planner.c File Reference

#include "postgres.h"
#include <limits.h>
#include <math.h>
#include "access/genam.h"
#include "access/htup_details.h"
#include "access/parallel.h"
#include "access/sysattr.h"
#include "access/table.h"
#include "access/xact.h"
#include "catalog/pg_aggregate.h"
#include "catalog/pg_constraint.h"
#include "catalog/pg_inherits.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_type.h"
#include "executor/executor.h"
#include "executor/nodeAgg.h"
#include "foreign/fdwapi.h"
#include "jit/jit.h"
#include "lib/bipartite_match.h"
#include "lib/knapsack.h"
#include "miscadmin.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
#include "nodes/supportnodes.h"
#include "optimizer/appendinfo.h"
#include "optimizer/clauses.h"
#include "optimizer/cost.h"
#include "optimizer/inherit.h"
#include "optimizer/optimizer.h"
#include "optimizer/paramassign.h"
#include "optimizer/pathnode.h"
#include "optimizer/paths.h"
#include "optimizer/plancat.h"
#include "optimizer/planmain.h"
#include "optimizer/planner.h"
#include "optimizer/prep.h"
#include "optimizer/subselect.h"
#include "optimizer/tlist.h"
#include "parser/analyze.h"
#include "parser/parse_agg.h"
#include "parser/parse_relation.h"
#include "parser/parsetree.h"
#include "partitioning/partdesc.h"
#include "rewrite/rewriteManip.h"
#include "storage/dsm_impl.h"
#include "utils/lsyscache.h"
#include "utils/rel.h"
#include "utils/selfuncs.h"
#include "utils/syscache.h"

Include dependency graph for planner.c:

Go to the source code of this file.

Data Structures
struct	grouping_sets_data
struct	WindowClauseSortData
struct	standard_qp_extra

Macros
#define	EXPRKIND_QUAL   0
#define	EXPRKIND_TARGET   1
#define	EXPRKIND_RTFUNC   2
#define	EXPRKIND_RTFUNC_LATERAL   3
#define	EXPRKIND_VALUES   4
#define	EXPRKIND_VALUES_LATERAL   5
#define	EXPRKIND_LIMIT   6
#define	EXPRKIND_APPINFO   7
#define	EXPRKIND_PHV   8
#define	EXPRKIND_TABLESAMPLE   9
#define	EXPRKIND_ARBITER_ELEM   10
#define	EXPRKIND_TABLEFUNC   11
#define	EXPRKIND_TABLEFUNC_LATERAL   12

Functions
static Node *	preprocess_expression (PlannerInfo *root, Node *expr, int kind)
static void	preprocess_qual_conditions (PlannerInfo *root, Node *jtnode)
static void	grouping_planner (PlannerInfo *root, double tuple_fraction)
static grouping_sets_data *	preprocess_grouping_sets (PlannerInfo *root)
static List *	remap_to_groupclause_idx (List *groupClause, List *gsets, int *tleref_to_colnum_map)
static void	preprocess_rowmarks (PlannerInfo *root)
static double	preprocess_limit (PlannerInfo *root, double tuple_fraction, int64 *offset_est, int64 *count_est)
static void	remove_useless_groupby_columns (PlannerInfo *root)
static List *	preprocess_groupclause (PlannerInfo *root, List *force)
static List *	extract_rollup_sets (List *groupingSets)
static List *	reorder_grouping_sets (List *groupingSets, List *sortclause)
static void	standard_qp_callback (PlannerInfo *root, void *extra)
static double	get_number_of_groups (PlannerInfo *root, double path_rows, grouping_sets_data *gd, List *target_list)
static RelOptInfo *	create_grouping_paths (PlannerInfo *root, RelOptInfo *input_rel, PathTarget *target, bool target_parallel_safe, grouping_sets_data *gd)
static bool	is_degenerate_grouping (PlannerInfo *root)
static void	create_degenerate_grouping_paths (PlannerInfo *root, RelOptInfo *input_rel, RelOptInfo *grouped_rel)
static RelOptInfo *	make_grouping_rel (PlannerInfo *root, RelOptInfo *input_rel, PathTarget *target, bool target_parallel_safe, Node *havingQual)
static void	create_ordinary_grouping_paths (PlannerInfo *root, RelOptInfo *input_rel, RelOptInfo *grouped_rel, const AggClauseCosts *agg_costs, grouping_sets_data *gd, GroupPathExtraData *extra, RelOptInfo **partially_grouped_rel_p)
static void	consider_groupingsets_paths (PlannerInfo *root, RelOptInfo *grouped_rel, Path *path, bool is_sorted, bool can_hash, grouping_sets_data *gd, const AggClauseCosts *agg_costs, double dNumGroups)
static RelOptInfo *	create_window_paths (PlannerInfo *root, RelOptInfo *input_rel, PathTarget *input_target, PathTarget *output_target, bool output_target_parallel_safe, WindowFuncLists *wflists, List *activeWindows)
static void	create_one_window_path (PlannerInfo *root, RelOptInfo *window_rel, Path *path, PathTarget *input_target, PathTarget *output_target, WindowFuncLists *wflists, List *activeWindows)
static RelOptInfo *	create_distinct_paths (PlannerInfo *root, RelOptInfo *input_rel)
static void	create_partial_distinct_paths (PlannerInfo *root, RelOptInfo *input_rel, RelOptInfo *final_distinct_rel)
static RelOptInfo *	create_final_distinct_paths (PlannerInfo *root, RelOptInfo *input_rel, RelOptInfo *distinct_rel)
static RelOptInfo *	create_ordered_paths (PlannerInfo *root, RelOptInfo *input_rel, PathTarget *target, bool target_parallel_safe, double limit_tuples)
static PathTarget *	make_group_input_target (PlannerInfo *root, PathTarget *final_target)
static PathTarget *	make_partial_grouping_target (PlannerInfo *root, PathTarget *grouping_target, Node *havingQual)
static List *	postprocess_setop_tlist (List *new_tlist, List *orig_tlist)
static void	optimize_window_clauses (PlannerInfo *root, WindowFuncLists *wflists)
static List *	select_active_windows (PlannerInfo *root, WindowFuncLists *wflists)
static PathTarget *	make_window_input_target (PlannerInfo *root, PathTarget *final_target, List *activeWindows)
static List *	make_pathkeys_for_window (PlannerInfo *root, WindowClause *wc, List *tlist)
static PathTarget *	make_sort_input_target (PlannerInfo *root, PathTarget *final_target, bool *have_postponed_srfs)
static void	adjust_paths_for_srfs (PlannerInfo *root, RelOptInfo *rel, List *targets, List *targets_contain_srfs)
static void	add_paths_to_grouping_rel (PlannerInfo *root, RelOptInfo *input_rel, RelOptInfo *grouped_rel, RelOptInfo *partially_grouped_rel, const AggClauseCosts *agg_costs, grouping_sets_data *gd, double dNumGroups, GroupPathExtraData *extra)
static RelOptInfo *	create_partial_grouping_paths (PlannerInfo *root, RelOptInfo *grouped_rel, RelOptInfo *input_rel, grouping_sets_data *gd, GroupPathExtraData *extra, bool force_rel_creation)
static void	gather_grouping_paths (PlannerInfo *root, RelOptInfo *rel)
static bool	can_partial_agg (PlannerInfo *root)
static void	apply_scanjoin_target_to_paths (PlannerInfo *root, RelOptInfo *rel, List *scanjoin_targets, List *scanjoin_targets_contain_srfs, bool scanjoin_target_parallel_safe, bool tlist_same_exprs)
static void	create_partitionwise_grouping_paths (PlannerInfo *root, RelOptInfo *input_rel, RelOptInfo *grouped_rel, RelOptInfo *partially_grouped_rel, const AggClauseCosts *agg_costs, grouping_sets_data *gd, PartitionwiseAggregateType patype, GroupPathExtraData *extra)
static bool	group_by_has_partkey (RelOptInfo *input_rel, List *targetList, List *groupClause)
static int	common_prefix_cmp (const void *a, const void *b)
PlannedStmt *	planner (Query *parse, const char *query_string, int cursorOptions, ParamListInfo boundParams)
PlannedStmt *	standard_planner (Query *parse, const char *query_string, int cursorOptions, ParamListInfo boundParams)
PlannerInfo *	subquery_planner (PlannerGlobal *glob, Query *parse, PlannerInfo *parent_root, bool hasRecursion, double tuple_fraction)
Expr *	preprocess_phv_expression (PlannerInfo *root, Expr *expr)
RowMarkType	select_rowmark_type (RangeTblEntry *rte, LockClauseStrength strength)
bool	limit_needed (Query *parse)
static bool	has_volatile_pathkey (List *keys)
static void	adjust_group_pathkeys_for_groupagg (PlannerInfo *root)
void	mark_partial_aggref (Aggref *agg, AggSplit aggsplit)
Path *	get_cheapest_fractional_path (RelOptInfo *rel, double tuple_fraction)
Expr *	expression_planner (Expr *expr)
Expr *	expression_planner_with_deps (Expr *expr, List **relationOids, List **invalItems)
bool	plan_cluster_use_sort (Oid tableOid, Oid indexOid)
int	plan_create_index_workers (Oid tableOid, Oid indexOid)

Variables
double	cursor_tuple_fraction = DEFAULT_CURSOR_TUPLE_FRACTION
int	debug_parallel_query = DEBUG_PARALLEL_OFF
bool	parallel_leader_participation = true
planner_hook_type	planner_hook = NULL
create_upper_paths_hook_type	create_upper_paths_hook = NULL

Macro Definition Documentation

EXPRKIND_APPINFO

#define EXPRKIND_APPINFO   7

Definition at line 91 of file planner.c.

EXPRKIND_ARBITER_ELEM

#define EXPRKIND_ARBITER_ELEM   10

Definition at line 94 of file planner.c.

EXPRKIND_LIMIT

#define EXPRKIND_LIMIT   6

Definition at line 90 of file planner.c.

EXPRKIND_PHV

#define EXPRKIND_PHV   8

Definition at line 92 of file planner.c.

EXPRKIND_QUAL

#define EXPRKIND_QUAL   0

Definition at line 84 of file planner.c.

EXPRKIND_RTFUNC

#define EXPRKIND_RTFUNC   2

Definition at line 86 of file planner.c.

EXPRKIND_RTFUNC_LATERAL

#define EXPRKIND_RTFUNC_LATERAL   3

Definition at line 87 of file planner.c.

EXPRKIND_TABLEFUNC

#define EXPRKIND_TABLEFUNC   11

Definition at line 95 of file planner.c.

EXPRKIND_TABLEFUNC_LATERAL

#define EXPRKIND_TABLEFUNC_LATERAL   12

Definition at line 96 of file planner.c.

EXPRKIND_TABLESAMPLE

#define EXPRKIND_TABLESAMPLE   9

Definition at line 93 of file planner.c.

EXPRKIND_TARGET

#define EXPRKIND_TARGET   1

Definition at line 85 of file planner.c.

EXPRKIND_VALUES

#define EXPRKIND_VALUES   4

Definition at line 88 of file planner.c.

EXPRKIND_VALUES_LATERAL

#define EXPRKIND_VALUES_LATERAL   5

Definition at line 89 of file planner.c.

Function Documentation

add_paths_to_grouping_rel()

static void add_paths_to_grouping_rel ( PlannerInfo *  root, RelOptInfo *  input_rel, RelOptInfo *  grouped_rel, RelOptInfo *  partially_grouped_rel, const AggClauseCosts *  agg_costs, grouping_sets_data *  gd, double  dNumGroups, GroupPathExtraData *  extra  )

static

Definition at line 6767 of file planner.c.

{
    Query      *parse = root->parse;
    Path       *cheapest_path = input_rel->cheapest_total_path;
    ListCell   *lc;
    bool        can_hash = (extra->flags & GROUPING_CAN_USE_HASH) != 0;
    bool        can_sort = (extra->flags & GROUPING_CAN_USE_SORT) != 0;
    List       *havingQual = (List *) extra->havingQual;
    AggClauseCosts *agg_final_costs = &extra->agg_final_costs;
 
    if (can_sort)
    {
        /*
         * Use any available suitably-sorted path as input, and also consider
         * sorting the cheapest-total path and incremental sort on any paths
         * with presorted keys.
         */
        foreach(lc, input_rel->pathlist)
        {
            Path       *path = (Path *) lfirst(lc);
            bool        is_sorted;
            int         presorted_keys;
 
            is_sorted = pathkeys_count_contained_in(root->group_pathkeys,
                                                    path->pathkeys,
                                                    &presorted_keys);
 
            if (!is_sorted)
            {
                /*
                 * Try at least sorting the cheapest path and also try
                 * incrementally sorting any path which is partially sorted
                 * already (no need to deal with paths which have presorted
                 * keys when incremental sort is disabled unless it's the
                 * cheapest input path).
                 */
                if (path != cheapest_path &&
                    (presorted_keys == 0 || !enable_incremental_sort))
                    continue;
 
                /*
                 * We've no need to consider both a sort and incremental sort.
                 * We'll just do a sort if there are no presorted keys and an
                 * incremental sort when there are presorted keys.
                 */
                if (presorted_keys == 0 || !enable_incremental_sort)
                    path = (Path *) create_sort_path(root,
                                                     grouped_rel,
                                                     path,
                                                     root->group_pathkeys,
                                                     -1.0);
                else
                    path = (Path *) create_incremental_sort_path(root,
                                                                 grouped_rel,
                                                                 path,
                                                                 root->group_pathkeys,
                                                                 presorted_keys,
                                                                 -1.0);
            }
 
            /* Now decide what to stick atop it */
            if (parse->groupingSets)
            {
                consider_groupingsets_paths(root, grouped_rel,
                                            path, true, can_hash,
                                            gd, agg_costs, dNumGroups);
            }
            else if (parse->hasAggs)
            {
                /*
                 * We have aggregation, possibly with plain GROUP BY. Make an
                 * AggPath.
                 */
                add_path(grouped_rel, (Path *)
                         create_agg_path(root,
                                         grouped_rel,
                                         path,
                                         grouped_rel->reltarget,
                                         parse->groupClause ? AGG_SORTED : AGG_PLAIN,
                                         AGGSPLIT_SIMPLE,
                                         root->processed_groupClause,
                                         havingQual,
                                         agg_costs,
                                         dNumGroups));
            }
            else if (parse->groupClause)
            {
                /*
                 * We have GROUP BY without aggregation or grouping sets. Make
                 * a GroupPath.
                 */
                add_path(grouped_rel, (Path *)
                         create_group_path(root,
                                           grouped_rel,
                                           path,
                                           root->processed_groupClause,
                                           havingQual,
                                           dNumGroups));
            }
            else
            {
                /* Other cases should have been handled above */
                Assert(false);
            }
        }
 
        /*
         * Instead of operating directly on the input relation, we can
         * consider finalizing a partially aggregated path.
         */
        if (partially_grouped_rel != NULL)
        {
            foreach(lc, partially_grouped_rel->pathlist)
            {
                Path       *path = (Path *) lfirst(lc);
                bool        is_sorted;
                int         presorted_keys;
 
                is_sorted = pathkeys_count_contained_in(root->group_pathkeys,
                                                        path->pathkeys,
                                                        &presorted_keys);
 
                if (!is_sorted)
                {
                    /*
                     * Try at least sorting the cheapest path and also try
                     * incrementally sorting any path which is partially
                     * sorted already (no need to deal with paths which have
                     * presorted keys when incremental sort is disabled unless
                     * it's the cheapest input path).
                     */
                    if (path != partially_grouped_rel->cheapest_total_path &&
                        (presorted_keys == 0 || !enable_incremental_sort))
                        continue;
 
                    /*
                     * We've no need to consider both a sort and incremental
                     * sort.  We'll just do a sort if there are no pre-sorted
                     * keys and an incremental sort when there are presorted
                     * keys.
                     */
                    if (presorted_keys == 0 || !enable_incremental_sort)
                        path = (Path *) create_sort_path(root,
                                                         grouped_rel,
                                                         path,
                                                         root->group_pathkeys,
                                                         -1.0);
                    else
                        path = (Path *) create_incremental_sort_path(root,
                                                                     grouped_rel,
                                                                     path,
                                                                     root->group_pathkeys,
                                                                     presorted_keys,
                                                                     -1.0);
                }
 
                if (parse->hasAggs)
                    add_path(grouped_rel, (Path *)
                             create_agg_path(root,
                                             grouped_rel,
                                             path,
                                             grouped_rel->reltarget,
                                             parse->groupClause ? AGG_SORTED : AGG_PLAIN,
                                             AGGSPLIT_FINAL_DESERIAL,
                                             root->processed_groupClause,
                                             havingQual,
                                             agg_final_costs,
                                             dNumGroups));
                else
                    add_path(grouped_rel, (Path *)
                             create_group_path(root,
                                               grouped_rel,
                                               path,
                                               root->processed_groupClause,
                                               havingQual,
                                               dNumGroups));
 
            }
        }
    }
 
    if (can_hash)
    {
        if (parse->groupingSets)
        {
            /*
             * Try for a hash-only groupingsets path over unsorted input.
             */
            consider_groupingsets_paths(root, grouped_rel,
                                        cheapest_path, false, true,
                                        gd, agg_costs, dNumGroups);
        }
        else
        {
            /*
             * Generate a HashAgg Path.  We just need an Agg over the
             * cheapest-total input path, since input order won't matter.
             */
            add_path(grouped_rel, (Path *)
                     create_agg_path(root, grouped_rel,
                                     cheapest_path,
                                     grouped_rel->reltarget,
                                     AGG_HASHED,
                                     AGGSPLIT_SIMPLE,
                                     root->processed_groupClause,
                                     havingQual,
                                     agg_costs,
                                     dNumGroups));
        }
 
        /*
         * Generate a Finalize HashAgg Path atop of the cheapest partially
         * grouped path, assuming there is one
         */
        if (partially_grouped_rel && partially_grouped_rel->pathlist)
        {
            Path       *path = partially_grouped_rel->cheapest_total_path;
 
            add_path(grouped_rel, (Path *)
                     create_agg_path(root,
                                     grouped_rel,
                                     path,
                                     grouped_rel->reltarget,
                                     AGG_HASHED,
                                     AGGSPLIT_FINAL_DESERIAL,
                                     root->processed_groupClause,
                                     havingQual,
                                     agg_final_costs,
                                     dNumGroups));
        }
    }
 
    /*
     * When partitionwise aggregate is used, we might have fully aggregated
     * paths in the partial pathlist, because add_paths_to_append_rel() will
     * consider a path for grouped_rel consisting of a Parallel Append of
     * non-partial paths from each child.
     */
    if (grouped_rel->partial_pathlist != NIL)
        gather_grouping_paths(root, grouped_rel);
}

References add_path(), GroupPathExtraData::agg_final_costs, AGG_HASHED, AGG_PLAIN, AGG_SORTED, AGGSPLIT_FINAL_DESERIAL, AGGSPLIT_SIMPLE, Assert(), RelOptInfo::cheapest_total_path, consider_groupingsets_paths(), create_agg_path(), create_group_path(), create_incremental_sort_path(), create_sort_path(), enable_incremental_sort, GroupPathExtraData::flags, gather_grouping_paths(), PlannerInfo::group_pathkeys, GROUPING_CAN_USE_HASH, GROUPING_CAN_USE_SORT, GroupPathExtraData::havingQual, if(), lfirst, NIL, parse(), PlannerInfo::parse, RelOptInfo::partial_pathlist, Path::pathkeys, pathkeys_count_contained_in(), RelOptInfo::pathlist, PlannerInfo::processed_groupClause, and RelOptInfo::reltarget.

Referenced by create_ordinary_grouping_paths().

adjust_group_pathkeys_for_groupagg()

static void adjust_group_pathkeys_for_groupagg ( PlannerInfo *  root )

static

Definition at line 3218 of file planner.c.

{
    List       *grouppathkeys = root->group_pathkeys;
    List       *bestpathkeys;
    Bitmapset  *bestaggs;
    Bitmapset  *unprocessed_aggs;
    ListCell   *lc;
    int         i;
 
    /* Shouldn't be here if there are grouping sets */
    Assert(root->parse->groupingSets == NIL);
    /* Shouldn't be here unless there are some ordered aggregates */
    Assert(root->numOrderedAggs > 0);
 
    /* Do nothing if disabled */
    if (!enable_presorted_aggregate)
        return;
 
    /*
     * Make a first pass over all AggInfos to collect a Bitmapset containing
     * the indexes of all AggInfos to be processed below.
     */
    unprocessed_aggs = NULL;
    foreach(lc, root->agginfos)
    {
        AggInfo    *agginfo = lfirst_node(AggInfo, lc);
        Aggref     *aggref = linitial_node(Aggref, agginfo->aggrefs);
 
        if (AGGKIND_IS_ORDERED_SET(aggref->aggkind))
            continue;
 
        /* only add aggregates with a DISTINCT or ORDER BY */
        if (aggref->aggdistinct != NIL || aggref->aggorder != NIL)
            unprocessed_aggs = bms_add_member(unprocessed_aggs,
                                              foreach_current_index(lc));
    }
 
    /*
     * Now process all the unprocessed_aggs to find the best set of pathkeys
     * for the given set of aggregates.
     *
     * On the first outer loop here 'bestaggs' will be empty.   We'll populate
     * this during the first loop using the pathkeys for the very first
     * AggInfo then taking any stronger pathkeys from any other AggInfos with
     * a more strict set of compatible pathkeys.  Once the outer loop is
     * complete, we mark off all the aggregates with compatible pathkeys then
     * remove those from the unprocessed_aggs and repeat the process to try to
     * find another set of pathkeys that are suitable for a larger number of
     * aggregates.  The outer loop will stop when there are not enough
     * unprocessed aggregates for it to be possible to find a set of pathkeys
     * to suit a larger number of aggregates.
     */
    bestpathkeys = NIL;
    bestaggs = NULL;
    while (bms_num_members(unprocessed_aggs) > bms_num_members(bestaggs))
    {
        Bitmapset  *aggindexes = NULL;
        List       *currpathkeys = NIL;
 
        i = -1;
        while ((i = bms_next_member(unprocessed_aggs, i)) >= 0)
        {
            AggInfo    *agginfo = list_nth_node(AggInfo, root->agginfos, i);
            Aggref     *aggref = linitial_node(Aggref, agginfo->aggrefs);
            List       *sortlist;
            List       *pathkeys;
 
            if (aggref->aggdistinct != NIL)
                sortlist = aggref->aggdistinct;
            else
                sortlist = aggref->aggorder;
 
            pathkeys = make_pathkeys_for_sortclauses(root, sortlist,
                                                     aggref->args);
 
            /*
             * Ignore Aggrefs which have volatile functions in their ORDER BY
             * or DISTINCT clause.
             */
            if (has_volatile_pathkey(pathkeys))
            {
                unprocessed_aggs = bms_del_member(unprocessed_aggs, i);
                continue;
            }
 
            /*
             * When not set yet, take the pathkeys from the first unprocessed
             * aggregate.
             */
            if (currpathkeys == NIL)
            {
                currpathkeys = pathkeys;
 
                /* include the GROUP BY pathkeys, if they exist */
                if (grouppathkeys != NIL)
                    currpathkeys = append_pathkeys(list_copy(grouppathkeys),
                                                   currpathkeys);
 
                /* record that we found pathkeys for this aggregate */
                aggindexes = bms_add_member(aggindexes, i);
            }
            else
            {
                /* now look for a stronger set of matching pathkeys */
 
                /* include the GROUP BY pathkeys, if they exist */
                if (grouppathkeys != NIL)
                    pathkeys = append_pathkeys(list_copy(grouppathkeys),
                                               pathkeys);
 
                /* are 'pathkeys' compatible or better than 'currpathkeys'? */
                switch (compare_pathkeys(currpathkeys, pathkeys))
                {
                    case PATHKEYS_BETTER2:
                        /* 'pathkeys' are stronger, use these ones instead */
                        currpathkeys = pathkeys;
                        /* FALLTHROUGH */
 
                    case PATHKEYS_BETTER1:
                        /* 'pathkeys' are less strict */
                        /* FALLTHROUGH */
 
                    case PATHKEYS_EQUAL:
                        /* mark this aggregate as covered by 'currpathkeys' */
                        aggindexes = bms_add_member(aggindexes, i);
                        break;
 
                    case PATHKEYS_DIFFERENT:
                        break;
                }
            }
        }
 
        /* remove the aggregates that we've just processed */
        unprocessed_aggs = bms_del_members(unprocessed_aggs, aggindexes);
 
        /*
         * If this pass included more aggregates than the previous best then
         * use these ones as the best set.
         */
        if (bms_num_members(aggindexes) > bms_num_members(bestaggs))
        {
            bestaggs = aggindexes;
            bestpathkeys = currpathkeys;
        }
    }
 
    /*
     * If we found any ordered aggregates, update root->group_pathkeys to add
     * the best set of aggregate pathkeys.  Note that bestpathkeys includes
     * the original GROUP BY pathkeys already.
     */
    if (bestpathkeys != NIL)
        root->group_pathkeys = bestpathkeys;
 
    /*
     * Now that we've found the best set of aggregates we can set the
     * presorted flag to indicate to the executor that it needn't bother
     * performing a sort for these Aggrefs.  We're able to do this now as
     * there's no chance of a Hash Aggregate plan as create_grouping_paths
     * will not mark the GROUP BY as GROUPING_CAN_USE_HASH due to the presence
     * of ordered aggregates.
     */
    i = -1;
    while ((i = bms_next_member(bestaggs, i)) >= 0)
    {
        AggInfo    *agginfo = list_nth_node(AggInfo, root->agginfos, i);
 
        foreach(lc, agginfo->aggrefs)
        {
            Aggref     *aggref = lfirst_node(Aggref, lc);
 
            aggref->aggpresorted = true;
        }
    }
}

References Aggref::aggdistinct, PlannerInfo::agginfos, Aggref::aggorder, AggInfo::aggrefs, append_pathkeys(), Aggref::args, Assert(), bms_add_member(), bms_del_member(), bms_del_members(), bms_next_member(), bms_num_members(), compare_pathkeys(), enable_presorted_aggregate, foreach_current_index, PlannerInfo::group_pathkeys, Query::groupingSets, has_volatile_pathkey(), i, lfirst_node, linitial_node, list_copy(), list_nth_node, make_pathkeys_for_sortclauses(), NIL, PlannerInfo::numOrderedAggs, PlannerInfo::parse, PATHKEYS_BETTER1, PATHKEYS_BETTER2, PATHKEYS_DIFFERENT, and PATHKEYS_EQUAL.

Referenced by standard_qp_callback().

adjust_paths_for_srfs()

static void adjust_paths_for_srfs ( PlannerInfo *  root, RelOptInfo *  rel, List *  targets, List *  targets_contain_srfs  )

static

Definition at line 6318 of file planner.c.

{
    ListCell   *lc;
 
    Assert(list_length(targets) == list_length(targets_contain_srfs));
    Assert(!linitial_int(targets_contain_srfs));
 
    /* If no SRFs appear at this plan level, nothing to do */
    if (list_length(targets) == 1)
        return;
 
    /*
     * Stack SRF-evaluation nodes atop each path for the rel.
     *
     * In principle we should re-run set_cheapest() here to identify the
     * cheapest path, but it seems unlikely that adding the same tlist eval
     * costs to all the paths would change that, so we don't bother. Instead,
     * just assume that the cheapest-startup and cheapest-total paths remain
     * so.  (There should be no parameterized paths anymore, so we needn't
     * worry about updating cheapest_parameterized_paths.)
     */
    foreach(lc, rel->pathlist)
    {
        Path       *subpath = (Path *) lfirst(lc);
        Path       *newpath = subpath;
        ListCell   *lc1,
                   *lc2;
 
        Assert(subpath->param_info == NULL);
        forboth(lc1, targets, lc2, targets_contain_srfs)
        {
            PathTarget *thistarget = lfirst_node(PathTarget, lc1);
            bool        contains_srfs = (bool) lfirst_int(lc2);
 
            /* If this level doesn't contain SRFs, do regular projection */
            if (contains_srfs)
                newpath = (Path *) create_set_projection_path(root,
                                                              rel,
                                                              newpath,
                                                              thistarget);
            else
                newpath = (Path *) apply_projection_to_path(root,
                                                            rel,
                                                            newpath,
                                                            thistarget);
        }
        lfirst(lc) = newpath;
        if (subpath == rel->cheapest_startup_path)
            rel->cheapest_startup_path = newpath;
        if (subpath == rel->cheapest_total_path)
            rel->cheapest_total_path = newpath;
    }
 
    /* Likewise for partial paths, if any */
    foreach(lc, rel->partial_pathlist)
    {
        Path       *subpath = (Path *) lfirst(lc);
        Path       *newpath = subpath;
        ListCell   *lc1,
                   *lc2;
 
        Assert(subpath->param_info == NULL);
        forboth(lc1, targets, lc2, targets_contain_srfs)
        {
            PathTarget *thistarget = lfirst_node(PathTarget, lc1);
            bool        contains_srfs = (bool) lfirst_int(lc2);
 
            /* If this level doesn't contain SRFs, do regular projection */
            if (contains_srfs)
                newpath = (Path *) create_set_projection_path(root,
                                                              rel,
                                                              newpath,
                                                              thistarget);
            else
            {
                /* avoid apply_projection_to_path, in case of multiple refs */
                newpath = (Path *) create_projection_path(root,
                                                          rel,
                                                          newpath,
                                                          thistarget);
            }
        }
        lfirst(lc) = newpath;
    }
}

References apply_projection_to_path(), Assert(), RelOptInfo::cheapest_startup_path, RelOptInfo::cheapest_total_path, create_projection_path(), create_set_projection_path(), forboth, lfirst, lfirst_int, lfirst_node, linitial_int, list_length(), RelOptInfo::partial_pathlist, RelOptInfo::pathlist, and subpath().

Referenced by apply_scanjoin_target_to_paths(), and grouping_planner().

apply_scanjoin_target_to_paths()

static void apply_scanjoin_target_to_paths ( PlannerInfo *  root, RelOptInfo *  rel, List *  scanjoin_targets, List *  scanjoin_targets_contain_srfs, bool  scanjoin_target_parallel_safe, bool  tlist_same_exprs  )

static

Definition at line 7484 of file planner.c.

{
    bool        rel_is_partitioned = IS_PARTITIONED_REL(rel);
    PathTarget *scanjoin_target;
    ListCell   *lc;
 
    /* This recurses, so be paranoid. */
    check_stack_depth();
 
    /*
     * If the rel is partitioned, we want to drop its existing paths and
     * generate new ones.  This function would still be correct if we kept the
     * existing paths: we'd modify them to generate the correct target above
     * the partitioning Append, and then they'd compete on cost with paths
     * generating the target below the Append.  However, in our current cost
     * model the latter way is always the same or cheaper cost, so modifying
     * the existing paths would just be useless work.  Moreover, when the cost
     * is the same, varying roundoff errors might sometimes allow an existing
     * path to be picked, resulting in undesirable cross-platform plan
     * variations.  So we drop old paths and thereby force the work to be done
     * below the Append, except in the case of a non-parallel-safe target.
     *
     * Some care is needed, because we have to allow
     * generate_useful_gather_paths to see the old partial paths in the next
     * stanza.  Hence, zap the main pathlist here, then allow
     * generate_useful_gather_paths to add path(s) to the main list, and
     * finally zap the partial pathlist.
     */
    if (rel_is_partitioned)
        rel->pathlist = NIL;
 
    /*
     * If the scan/join target is not parallel-safe, partial paths cannot
     * generate it.
     */
    if (!scanjoin_target_parallel_safe)
    {
        /*
         * Since we can't generate the final scan/join target in parallel
         * workers, this is our last opportunity to use any partial paths that
         * exist; so build Gather path(s) that use them and emit whatever the
         * current reltarget is.  We don't do this in the case where the
         * target is parallel-safe, since we will be able to generate superior
         * paths by doing it after the final scan/join target has been
         * applied.
         */
        generate_useful_gather_paths(root, rel, false);
 
        /* Can't use parallel query above this level. */
        rel->partial_pathlist = NIL;
        rel->consider_parallel = false;
    }
 
    /* Finish dropping old paths for a partitioned rel, per comment above */
    if (rel_is_partitioned)
        rel->partial_pathlist = NIL;
 
    /* Extract SRF-free scan/join target. */
    scanjoin_target = linitial_node(PathTarget, scanjoin_targets);
 
    /*
     * Apply the SRF-free scan/join target to each existing path.
     *
     * If the tlist exprs are the same, we can just inject the sortgroupref
     * information into the existing pathtargets.  Otherwise, replace each
     * path with a projection path that generates the SRF-free scan/join
     * target.  This can't change the ordering of paths within rel->pathlist,
     * so we just modify the list in place.
     */
    foreach(lc, rel->pathlist)
    {
        Path       *subpath = (Path *) lfirst(lc);
 
        /* Shouldn't have any parameterized paths anymore */
        Assert(subpath->param_info == NULL);
 
        if (tlist_same_exprs)
            subpath->pathtarget->sortgrouprefs =
                scanjoin_target->sortgrouprefs;
        else
        {
            Path       *newpath;
 
            newpath = (Path *) create_projection_path(root, rel, subpath,
                                                      scanjoin_target);
            lfirst(lc) = newpath;
        }
    }
 
    /* Likewise adjust the targets for any partial paths. */
    foreach(lc, rel->partial_pathlist)
    {
        Path       *subpath = (Path *) lfirst(lc);
 
        /* Shouldn't have any parameterized paths anymore */
        Assert(subpath->param_info == NULL);
 
        if (tlist_same_exprs)
            subpath->pathtarget->sortgrouprefs =
                scanjoin_target->sortgrouprefs;
        else
        {
            Path       *newpath;
 
            newpath = (Path *) create_projection_path(root, rel, subpath,
                                                      scanjoin_target);
            lfirst(lc) = newpath;
        }
    }
 
    /*
     * Now, if final scan/join target contains SRFs, insert ProjectSetPath(s)
     * atop each existing path.  (Note that this function doesn't look at the
     * cheapest-path fields, which is a good thing because they're bogus right
     * now.)
     */
    if (root->parse->hasTargetSRFs)
        adjust_paths_for_srfs(root, rel,
                              scanjoin_targets,
                              scanjoin_targets_contain_srfs);
 
    /*
     * Update the rel's target to be the final (with SRFs) scan/join target.
     * This now matches the actual output of all the paths, and we might get
     * confused in createplan.c if they don't agree.  We must do this now so
     * that any append paths made in the next part will use the correct
     * pathtarget (cf. create_append_path).
     *
     * Note that this is also necessary if GetForeignUpperPaths() gets called
     * on the final scan/join relation or on any of its children, since the
     * FDW might look at the rel's target to create ForeignPaths.
     */
    rel->reltarget = llast_node(PathTarget, scanjoin_targets);
 
    /*
     * If the relation is partitioned, recursively apply the scan/join target
     * to all partitions, and generate brand-new Append paths in which the
     * scan/join target is computed below the Append rather than above it.
     * Since Append is not projection-capable, that might save a separate
     * Result node, and it also is important for partitionwise aggregate.
     */
    if (rel_is_partitioned)
    {
        List       *live_children = NIL;
        int         i;
 
        /* Adjust each partition. */
        i = -1;
        while ((i = bms_next_member(rel->live_parts, i)) >= 0)
        {
            RelOptInfo *child_rel = rel->part_rels[i];
            AppendRelInfo **appinfos;
            int         nappinfos;
            List       *child_scanjoin_targets = NIL;
 
            Assert(child_rel != NULL);
 
            /* Dummy children can be ignored. */
            if (IS_DUMMY_REL(child_rel))
                continue;
 
            /* Translate scan/join targets for this child. */
            appinfos = find_appinfos_by_relids(root, child_rel->relids,
                                               &nappinfos);
            foreach(lc, scanjoin_targets)
            {
                PathTarget *target = lfirst_node(PathTarget, lc);
 
                target = copy_pathtarget(target);
                target->exprs = (List *)
                    adjust_appendrel_attrs(root,
                                           (Node *) target->exprs,
                                           nappinfos, appinfos);
                child_scanjoin_targets = lappend(child_scanjoin_targets,
                                                 target);
            }
            pfree(appinfos);
 
            /* Recursion does the real work. */
            apply_scanjoin_target_to_paths(root, child_rel,
                                           child_scanjoin_targets,
                                           scanjoin_targets_contain_srfs,
                                           scanjoin_target_parallel_safe,
                                           tlist_same_exprs);
 
            /* Save non-dummy children for Append paths. */
            if (!IS_DUMMY_REL(child_rel))
                live_children = lappend(live_children, child_rel);
        }
 
        /* Build new paths for this relation by appending child paths. */
        add_paths_to_append_rel(root, rel, live_children);
    }
 
    /*
     * Consider generating Gather or Gather Merge paths.  We must only do this
     * if the relation is parallel safe, and we don't do it for child rels to
     * avoid creating multiple Gather nodes within the same plan. We must do
     * this after all paths have been generated and before set_cheapest, since
     * one of the generated paths may turn out to be the cheapest one.
     */
    if (rel->consider_parallel && !IS_OTHER_REL(rel))
        generate_useful_gather_paths(root, rel, false);
 
    /*
     * Reassess which paths are the cheapest, now that we've potentially added
     * new Gather (or Gather Merge) and/or Append (or MergeAppend) paths to
     * this relation.
     */
    set_cheapest(rel);
}

References add_paths_to_append_rel(), adjust_appendrel_attrs(), adjust_paths_for_srfs(), Assert(), bms_next_member(), check_stack_depth(), RelOptInfo::consider_parallel, copy_pathtarget(), create_projection_path(), PathTarget::exprs, find_appinfos_by_relids(), generate_useful_gather_paths(), i, IS_DUMMY_REL, IS_OTHER_REL, IS_PARTITIONED_REL, lappend(), lfirst, lfirst_node, linitial_node, RelOptInfo::live_parts, llast_node, NIL, PlannerInfo::parse, RelOptInfo::partial_pathlist, RelOptInfo::pathlist, pfree(), RelOptInfo::relids, RelOptInfo::reltarget, set_cheapest(), subpath(), and tlist_same_exprs().

Referenced by grouping_planner().

can_partial_agg()

static bool can_partial_agg ( PlannerInfo *  root )

static

Definition at line 7442 of file planner.c.

{
    Query      *parse = root->parse;
 
    if (!parse->hasAggs && parse->groupClause == NIL)
    {
        /*
         * We don't know how to do parallel aggregation unless we have either
         * some aggregates or a grouping clause.
         */
        return false;
    }
    else if (parse->groupingSets)
    {
        /* We don't know how to do grouping sets in parallel. */
        return false;
    }
    else if (root->hasNonPartialAggs || root->hasNonSerialAggs)
    {
        /* Insufficient support for partial mode. */
        return false;
    }
 
    /* Everything looks good. */
    return true;
}

References PlannerInfo::hasNonPartialAggs, PlannerInfo::hasNonSerialAggs, NIL, parse(), and PlannerInfo::parse.

Referenced by create_grouping_paths().

common_prefix_cmp()

static int common_prefix_cmp ( const void *  a, const void *  b  )

static

Definition at line 5824 of file planner.c.

{
    const WindowClauseSortData *wcsa = a;
    const WindowClauseSortData *wcsb = b;
    ListCell   *item_a;
    ListCell   *item_b;
 
    forboth(item_a, wcsa->uniqueOrder, item_b, wcsb->uniqueOrder)
    {
        SortGroupClause *sca = lfirst_node(SortGroupClause, item_a);
        SortGroupClause *scb = lfirst_node(SortGroupClause, item_b);
 
        if (sca->tleSortGroupRef > scb->tleSortGroupRef)
            return -1;
        else if (sca->tleSortGroupRef < scb->tleSortGroupRef)
            return 1;
        else if (sca->sortop > scb->sortop)
            return -1;
        else if (sca->sortop < scb->sortop)
            return 1;
        else if (sca->nulls_first && !scb->nulls_first)
            return -1;
        else if (!sca->nulls_first && scb->nulls_first)
            return 1;
        /* no need to compare eqop, since it is fully determined by sortop */
    }
 
    if (list_length(wcsa->uniqueOrder) > list_length(wcsb->uniqueOrder))
        return -1;
    else if (list_length(wcsa->uniqueOrder) < list_length(wcsb->uniqueOrder))
        return 1;
 
    return 0;
}

References a, b, forboth, lfirst_node, list_length(), SortGroupClause::nulls_first, SortGroupClause::sortop, SortGroupClause::tleSortGroupRef, and WindowClauseSortData::uniqueOrder.

Referenced by select_active_windows().

consider_groupingsets_paths()

static void consider_groupingsets_paths ( PlannerInfo *  root, RelOptInfo *  grouped_rel, Path *  path, bool  is_sorted, bool  can_hash, grouping_sets_data *  gd, const AggClauseCosts *  agg_costs, double  dNumGroups  )

static

Definition at line 4068 of file planner.c.

{
    Query      *parse = root->parse;
    Size        hash_mem_limit = get_hash_memory_limit();
 
    /*
     * If we're not being offered sorted input, then only consider plans that
     * can be done entirely by hashing.
     *
     * We can hash everything if it looks like it'll fit in hash_mem. But if
     * the input is actually sorted despite not being advertised as such, we
     * prefer to make use of that in order to use less memory.
     *
     * If none of the grouping sets are sortable, then ignore the hash_mem
     * limit and generate a path anyway, since otherwise we'll just fail.
     */
    if (!is_sorted)
    {
        List       *new_rollups = NIL;
        RollupData *unhashed_rollup = NULL;
        List       *sets_data;
        List       *empty_sets_data = NIL;
        List       *empty_sets = NIL;
        ListCell   *lc;
        ListCell   *l_start = list_head(gd->rollups);
        AggStrategy strat = AGG_HASHED;
        double      hashsize;
        double      exclude_groups = 0.0;
 
        Assert(can_hash);
 
        /*
         * If the input is coincidentally sorted usefully (which can happen
         * even if is_sorted is false, since that only means that our caller
         * has set up the sorting for us), then save some hashtable space by
         * making use of that. But we need to watch out for degenerate cases:
         *
         * 1) If there are any empty grouping sets, then group_pathkeys might
         * be NIL if all non-empty grouping sets are unsortable. In this case,
         * there will be a rollup containing only empty groups, and the
         * pathkeys_contained_in test is vacuously true; this is ok.
         *
         * XXX: the above relies on the fact that group_pathkeys is generated
         * from the first rollup. If we add the ability to consider multiple
         * sort orders for grouping input, this assumption might fail.
         *
         * 2) If there are no empty sets and only unsortable sets, then the
         * rollups list will be empty (and thus l_start == NULL), and
         * group_pathkeys will be NIL; we must ensure that the vacuously-true
         * pathkeys_contained_in test doesn't cause us to crash.
         */
        if (l_start != NULL &&
            pathkeys_contained_in(root->group_pathkeys, path->pathkeys))
        {
            unhashed_rollup = lfirst_node(RollupData, l_start);
            exclude_groups = unhashed_rollup->numGroups;
            l_start = lnext(gd->rollups, l_start);
        }
 
        hashsize = estimate_hashagg_tablesize(root,
                                              path,
                                              agg_costs,
                                              dNumGroups - exclude_groups);
 
        /*
         * gd->rollups is empty if we have only unsortable columns to work
         * with.  Override hash_mem in that case; otherwise, we'll rely on the
         * sorted-input case to generate usable mixed paths.
         */
        if (hashsize > hash_mem_limit && gd->rollups)
            return;             /* nope, won't fit */
 
        /*
         * We need to burst the existing rollups list into individual grouping
         * sets and recompute a groupClause for each set.
         */
        sets_data = list_copy(gd->unsortable_sets);
 
        for_each_cell(lc, gd->rollups, l_start)
        {
            RollupData *rollup = lfirst_node(RollupData, lc);
 
            /*
             * If we find an unhashable rollup that's not been skipped by the
             * "actually sorted" check above, we can't cope; we'd need sorted
             * input (with a different sort order) but we can't get that here.
             * So bail out; we'll get a valid path from the is_sorted case
             * instead.
             *
             * The mere presence of empty grouping sets doesn't make a rollup
             * unhashable (see preprocess_grouping_sets), we handle those
             * specially below.
             */
            if (!rollup->hashable)
                return;
 
            sets_data = list_concat(sets_data, rollup->gsets_data);
        }
        foreach(lc, sets_data)
        {
            GroupingSetData *gs = lfirst_node(GroupingSetData, lc);
            List       *gset = gs->set;
            RollupData *rollup;
 
            if (gset == NIL)
            {
                /* Empty grouping sets can't be hashed. */
                empty_sets_data = lappend(empty_sets_data, gs);
                empty_sets = lappend(empty_sets, NIL);
            }
            else
            {
                rollup = makeNode(RollupData);
 
                rollup->groupClause = preprocess_groupclause(root, gset);
                rollup->gsets_data = list_make1(gs);
                rollup->gsets = remap_to_groupclause_idx(rollup->groupClause,
                                                         rollup->gsets_data,
                                                         gd->tleref_to_colnum_map);
                rollup->numGroups = gs->numGroups;
                rollup->hashable = true;
                rollup->is_hashed = true;
                new_rollups = lappend(new_rollups, rollup);
            }
        }
 
        /*
         * If we didn't find anything nonempty to hash, then bail.  We'll
         * generate a path from the is_sorted case.
         */
        if (new_rollups == NIL)
            return;
 
        /*
         * If there were empty grouping sets they should have been in the
         * first rollup.
         */
        Assert(!unhashed_rollup || !empty_sets);
 
        if (unhashed_rollup)
        {
            new_rollups = lappend(new_rollups, unhashed_rollup);
            strat = AGG_MIXED;
        }
        else if (empty_sets)
        {
            RollupData *rollup = makeNode(RollupData);
 
            rollup->groupClause = NIL;
            rollup->gsets_data = empty_sets_data;
            rollup->gsets = empty_sets;
            rollup->numGroups = list_length(empty_sets);
            rollup->hashable = false;
            rollup->is_hashed = false;
            new_rollups = lappend(new_rollups, rollup);
            strat = AGG_MIXED;
        }
 
        add_path(grouped_rel, (Path *)
                 create_groupingsets_path(root,
                                          grouped_rel,
                                          path,
                                          (List *) parse->havingQual,
                                          strat,
                                          new_rollups,
                                          agg_costs));
        return;
    }
 
    /*
     * If we have sorted input but nothing we can do with it, bail.
     */
    if (gd->rollups == NIL)
        return;
 
    /*
     * Given sorted input, we try and make two paths: one sorted and one mixed
     * sort/hash. (We need to try both because hashagg might be disabled, or
     * some columns might not be sortable.)
     *
     * can_hash is passed in as false if some obstacle elsewhere (such as
     * ordered aggs) means that we shouldn't consider hashing at all.
     */
    if (can_hash && gd->any_hashable)
    {
        List       *rollups = NIL;
        List       *hash_sets = list_copy(gd->unsortable_sets);
        double      availspace = hash_mem_limit;
        ListCell   *lc;
 
        /*
         * Account first for space needed for groups we can't sort at all.
         */
        availspace -= estimate_hashagg_tablesize(root,
                                                 path,
                                                 agg_costs,
                                                 gd->dNumHashGroups);
 
        if (availspace > 0 && list_length(gd->rollups) > 1)
        {
            double      scale;
            int         num_rollups = list_length(gd->rollups);
            int         k_capacity;
            int        *k_weights = palloc(num_rollups * sizeof(int));
            Bitmapset  *hash_items = NULL;
            int         i;
 
            /*
             * We treat this as a knapsack problem: the knapsack capacity
             * represents hash_mem, the item weights are the estimated memory
             * usage of the hashtables needed to implement a single rollup,
             * and we really ought to use the cost saving as the item value;
             * however, currently the costs assigned to sort nodes don't
             * reflect the comparison costs well, and so we treat all items as
             * of equal value (each rollup we hash instead saves us one sort).
             *
             * To use the discrete knapsack, we need to scale the values to a
             * reasonably small bounded range.  We choose to allow a 5% error
             * margin; we have no more than 4096 rollups in the worst possible
             * case, which with a 5% error margin will require a bit over 42MB
             * of workspace. (Anyone wanting to plan queries that complex had
             * better have the memory for it.  In more reasonable cases, with
             * no more than a couple of dozen rollups, the memory usage will
             * be negligible.)
             *
             * k_capacity is naturally bounded, but we clamp the values for
             * scale and weight (below) to avoid overflows or underflows (or
             * uselessly trying to use a scale factor less than 1 byte).
             */
            scale = Max(availspace / (20.0 * num_rollups), 1.0);
            k_capacity = (int) floor(availspace / scale);
 
            /*
             * We leave the first rollup out of consideration since it's the
             * one that matches the input sort order.  We assign indexes "i"
             * to only those entries considered for hashing; the second loop,
             * below, must use the same condition.
             */
            i = 0;
            for_each_from(lc, gd->rollups, 1)
            {
                RollupData *rollup = lfirst_node(RollupData, lc);
 
                if (rollup->hashable)
                {
                    double      sz = estimate_hashagg_tablesize(root,
                                                                path,
                                                                agg_costs,
                                                                rollup->numGroups);
 
                    /*
                     * If sz is enormous, but hash_mem (and hence scale) is
                     * small, avoid integer overflow here.
                     */
                    k_weights[i] = (int) Min(floor(sz / scale),
                                             k_capacity + 1.0);
                    ++i;
                }
            }
 
            /*
             * Apply knapsack algorithm; compute the set of items which
             * maximizes the value stored (in this case the number of sorts
             * saved) while keeping the total size (approximately) within
             * capacity.
             */
            if (i > 0)
                hash_items = DiscreteKnapsack(k_capacity, i, k_weights, NULL);
 
            if (!bms_is_empty(hash_items))
            {
                rollups = list_make1(linitial(gd->rollups));
 
                i = 0;
                for_each_from(lc, gd->rollups, 1)
                {
                    RollupData *rollup = lfirst_node(RollupData, lc);
 
                    if (rollup->hashable)
                    {
                        if (bms_is_member(i, hash_items))
                            hash_sets = list_concat(hash_sets,
                                                    rollup->gsets_data);
                        else
                            rollups = lappend(rollups, rollup);
                        ++i;
                    }
                    else
                        rollups = lappend(rollups, rollup);
                }
            }
        }
 
        if (!rollups && hash_sets)
            rollups = list_copy(gd->rollups);
 
        foreach(lc, hash_sets)
        {
            GroupingSetData *gs = lfirst_node(GroupingSetData, lc);
            RollupData *rollup = makeNode(RollupData);
 
            Assert(gs->set != NIL);
 
            rollup->groupClause = preprocess_groupclause(root, gs->set);
            rollup->gsets_data = list_make1(gs);
            rollup->gsets = remap_to_groupclause_idx(rollup->groupClause,
                                                     rollup->gsets_data,
                                                     gd->tleref_to_colnum_map);
            rollup->numGroups = gs->numGroups;
            rollup->hashable = true;
            rollup->is_hashed = true;
            rollups = lcons(rollup, rollups);
        }
 
        if (rollups)
        {
            add_path(grouped_rel, (Path *)
                     create_groupingsets_path(root,
                                              grouped_rel,
                                              path,
                                              (List *) parse->havingQual,
                                              AGG_MIXED,
                                              rollups,
                                              agg_costs));
        }
    }
 
    /*
     * Now try the simple sorted case.
     */
    if (!gd->unsortable_sets)
        add_path(grouped_rel, (Path *)
                 create_groupingsets_path(root,
                                          grouped_rel,
                                          path,
                                          (List *) parse->havingQual,
                                          AGG_SORTED,
                                          gd->rollups,
                                          agg_costs));
}

References add_path(), AGG_HASHED, AGG_MIXED, AGG_SORTED, grouping_sets_data::any_hashable, Assert(), bms_is_empty, bms_is_member(), create_groupingsets_path(), DiscreteKnapsack(), grouping_sets_data::dNumHashGroups, estimate_hashagg_tablesize(), for_each_cell, for_each_from, get_hash_memory_limit(), PlannerInfo::group_pathkeys, RollupData::groupClause, RollupData::gsets, RollupData::gsets_data, RollupData::hashable, i, RollupData::is_hashed, lappend(), lcons(), lfirst_node, linitial, list_concat(), list_copy(), list_head(), list_length(), list_make1, lnext(), makeNode, Max, Min, NIL, GroupingSetData::numGroups, RollupData::numGroups, palloc(), parse(), PlannerInfo::parse, Path::pathkeys, pathkeys_contained_in(), preprocess_groupclause(), remap_to_groupclause_idx(), grouping_sets_data::rollups, scale, GroupingSetData::set, grouping_sets_data::tleref_to_colnum_map, and grouping_sets_data::unsortable_sets.

Referenced by add_paths_to_grouping_rel().

create_degenerate_grouping_paths()

static void create_degenerate_grouping_paths ( PlannerInfo *  root, RelOptInfo *  input_rel, RelOptInfo *  grouped_rel  )

static

Definition at line 3865 of file planner.c.

{
    Query      *parse = root->parse;
    int         nrows;
    Path       *path;
 
    nrows = list_length(parse->groupingSets);
    if (nrows > 1)
    {
        /*
         * Doesn't seem worthwhile writing code to cons up a generate_series
         * or a values scan to emit multiple rows. Instead just make N clones
         * and append them.  (With a volatile HAVING clause, this means you
         * might get between 0 and N output rows. Offhand I think that's
         * desired.)
         */
        List       *paths = NIL;
 
        while (--nrows >= 0)
        {
            path = (Path *)
                create_group_result_path(root, grouped_rel,
                                         grouped_rel->reltarget,
                                         (List *) parse->havingQual);
            paths = lappend(paths, path);
        }
        path = (Path *)
            create_append_path(root,
                               grouped_rel,
                               paths,
                               NIL,
                               NIL,
                               NULL,
                               0,
                               false,
                               -1);
    }
    else
    {
        /* No grouping sets, or just one, so one output row */
        path = (Path *)
            create_group_result_path(root, grouped_rel,
                                     grouped_rel->reltarget,
                                     (List *) parse->havingQual);
    }
 
    add_path(grouped_rel, path);
}

References add_path(), create_append_path(), create_group_result_path(), lappend(), list_length(), NIL, parse(), PlannerInfo::parse, and RelOptInfo::reltarget.

Referenced by create_grouping_paths().

create_distinct_paths()

static RelOptInfo * create_distinct_paths ( PlannerInfo *  root, RelOptInfo *  input_rel  )

static

Definition at line 4647 of file planner.c.

{
    RelOptInfo *distinct_rel;
 
    /* For now, do all work in the (DISTINCT, NULL) upperrel */
    distinct_rel = fetch_upper_rel(root, UPPERREL_DISTINCT, NULL);
 
    /*
     * We don't compute anything at this level, so distinct_rel will be
     * parallel-safe if the input rel is parallel-safe.  In particular, if
     * there is a DISTINCT ON (...) clause, any path for the input_rel will
     * output those expressions, and will not be parallel-safe unless those
     * expressions are parallel-safe.
     */
    distinct_rel->consider_parallel = input_rel->consider_parallel;
 
    /*
     * If the input rel belongs to a single FDW, so does the distinct_rel.
     */
    distinct_rel->serverid = input_rel->serverid;
    distinct_rel->userid = input_rel->userid;
    distinct_rel->useridiscurrent = input_rel->useridiscurrent;
    distinct_rel->fdwroutine = input_rel->fdwroutine;
 
    /* build distinct paths based on input_rel's pathlist */
    create_final_distinct_paths(root, input_rel, distinct_rel);
 
    /* now build distinct paths based on input_rel's partial_pathlist */
    create_partial_distinct_paths(root, input_rel, distinct_rel);
 
    /* Give a helpful error if we failed to create any paths */
    if (distinct_rel->pathlist == NIL)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("could not implement DISTINCT"),
                 errdetail("Some of the datatypes only support hashing, while others only support sorting.")));
 
    /*
     * If there is an FDW that's responsible for all baserels of the query,
     * let it consider adding ForeignPaths.
     */
    if (distinct_rel->fdwroutine &&
        distinct_rel->fdwroutine->GetForeignUpperPaths)
        distinct_rel->fdwroutine->GetForeignUpperPaths(root,
                                                       UPPERREL_DISTINCT,
                                                       input_rel,
                                                       distinct_rel,
                                                       NULL);
 
    /* Let extensions possibly add some more paths */
    if (create_upper_paths_hook)
        (*create_upper_paths_hook) (root, UPPERREL_DISTINCT, input_rel,
                                    distinct_rel, NULL);
 
    /* Now choose the best path(s) */
    set_cheapest(distinct_rel);
 
    return distinct_rel;
}

References RelOptInfo::consider_parallel, create_final_distinct_paths(), create_partial_distinct_paths(), create_upper_paths_hook, ereport, errcode(), errdetail(), errmsg(), ERROR, fetch_upper_rel(), NIL, RelOptInfo::pathlist, RelOptInfo::serverid, set_cheapest(), UPPERREL_DISTINCT, RelOptInfo::userid, and RelOptInfo::useridiscurrent.

Referenced by grouping_planner().

create_final_distinct_paths()

static RelOptInfo * create_final_distinct_paths ( PlannerInfo *  root, RelOptInfo *  input_rel, RelOptInfo *  distinct_rel  )

static

Definition at line 4880 of file planner.c.

{
    Query      *parse = root->parse;
    Path       *cheapest_input_path = input_rel->cheapest_total_path;
    double      numDistinctRows;
    bool        allow_hash;
 
    /* Estimate number of distinct rows there will be */
    if (parse->groupClause || parse->groupingSets || parse->hasAggs ||
        root->hasHavingQual)
    {
        /*
         * If there was grouping or aggregation, use the number of input rows
         * as the estimated number of DISTINCT rows (ie, assume the input is
         * already mostly unique).
         */
        numDistinctRows = cheapest_input_path->rows;
    }
    else
    {
        /*
         * Otherwise, the UNIQUE filter has effects comparable to GROUP BY.
         */
        List       *distinctExprs;
 
        distinctExprs = get_sortgrouplist_exprs(root->processed_distinctClause,
                                                parse->targetList);
        numDistinctRows = estimate_num_groups(root, distinctExprs,
                                              cheapest_input_path->rows,
                                              NULL, NULL);
    }
 
    /*
     * Consider sort-based implementations of DISTINCT, if possible.
     */
    if (grouping_is_sortable(root->processed_distinctClause))
    {
        /*
         * Firstly, if we have any adequately-presorted paths, just stick a
         * Unique node on those.  We also, consider doing an explicit sort of
         * the cheapest input path and Unique'ing that.  If any paths have
         * presorted keys then we'll create an incremental sort atop of those
         * before adding a unique node on the top.
         *
         * When we have DISTINCT ON, we must sort by the more rigorous of
         * DISTINCT and ORDER BY, else it won't have the desired behavior.
         * Also, if we do have to do an explicit sort, we might as well use
         * the more rigorous ordering to avoid a second sort later.  (Note
         * that the parser will have ensured that one clause is a prefix of
         * the other.)
         */
        List       *needed_pathkeys;
        ListCell   *lc;
        double      limittuples = root->distinct_pathkeys == NIL ? 1.0 : -1.0;
 
        if (parse->hasDistinctOn &&
            list_length(root->distinct_pathkeys) <
            list_length(root->sort_pathkeys))
            needed_pathkeys = root->sort_pathkeys;
        else
            needed_pathkeys = root->distinct_pathkeys;
 
        foreach(lc, input_rel->pathlist)
        {
            Path       *input_path = (Path *) lfirst(lc);
            Path       *sorted_path;
            bool        is_sorted;
            int         presorted_keys;
 
            is_sorted = pathkeys_count_contained_in(needed_pathkeys,
                                                    input_path->pathkeys,
                                                    &presorted_keys);
 
            if (is_sorted)
                sorted_path = input_path;
            else
            {
                /*
                 * Try at least sorting the cheapest path and also try
                 * incrementally sorting any path which is partially sorted
                 * already (no need to deal with paths which have presorted
                 * keys when incremental sort is disabled unless it's the
                 * cheapest input path).
                 */
                if (input_path != cheapest_input_path &&
                    (presorted_keys == 0 || !enable_incremental_sort))
                    continue;
 
                /*
                 * We've no need to consider both a sort and incremental sort.
                 * We'll just do a sort if there are no presorted keys and an
                 * incremental sort when there are presorted keys.
                 */
                if (presorted_keys == 0 || !enable_incremental_sort)
                    sorted_path = (Path *) create_sort_path(root,
                                                            distinct_rel,
                                                            input_path,
                                                            needed_pathkeys,
                                                            limittuples);
                else
                    sorted_path = (Path *) create_incremental_sort_path(root,
                                                                        distinct_rel,
                                                                        input_path,
                                                                        needed_pathkeys,
                                                                        presorted_keys,
                                                                        limittuples);
            }
 
            /*
             * distinct_pathkeys may have become empty if all of the pathkeys
             * were determined to be redundant.  If all of the pathkeys are
             * redundant then each DISTINCT target must only allow a single
             * value, therefore all resulting tuples must be identical (or at
             * least indistinguishable by an equality check).  We can uniquify
             * these tuples simply by just taking the first tuple.  All we do
             * here is add a path to do "LIMIT 1" atop of 'sorted_path'.  When
             * doing a DISTINCT ON we may still have a non-NIL sort_pathkeys
             * list, so we must still only do this with paths which are
             * correctly sorted by sort_pathkeys.
             */
            if (root->distinct_pathkeys == NIL)
            {
                Node       *limitCount;
 
                limitCount = (Node *) makeConst(INT8OID, -1, InvalidOid,
                                                sizeof(int64),
                                                Int64GetDatum(1), false,
                                                FLOAT8PASSBYVAL);
 
                /*
                 * If the query already has a LIMIT clause, then we could end
                 * up with a duplicate LimitPath in the final plan. That does
                 * not seem worth troubling over too much.
                 */
                add_path(distinct_rel, (Path *)
                         create_limit_path(root, distinct_rel, sorted_path,
                                           NULL, limitCount,
                                           LIMIT_OPTION_COUNT, 0, 1));
            }
            else
            {
                add_path(distinct_rel, (Path *)
                         create_upper_unique_path(root, distinct_rel,
                                                  sorted_path,
                                                  list_length(root->distinct_pathkeys),
                                                  numDistinctRows));
            }
        }
    }
 
    /*
     * Consider hash-based implementations of DISTINCT, if possible.
     *
     * If we were not able to make any other types of path, we *must* hash or
     * die trying.  If we do have other choices, there are two things that
     * should prevent selection of hashing: if the query uses DISTINCT ON
     * (because it won't really have the expected behavior if we hash), or if
     * enable_hashagg is off.
     *
     * Note: grouping_is_hashable() is much more expensive to check than the
     * other gating conditions, so we want to do it last.
     */
    if (distinct_rel->pathlist == NIL)
        allow_hash = true;      /* we have no alternatives */
    else if (parse->hasDistinctOn || !enable_hashagg)
        allow_hash = false;     /* policy-based decision not to hash */
    else
        allow_hash = true;      /* default */
 
    if (allow_hash && grouping_is_hashable(root->processed_distinctClause))
    {
        /* Generate hashed aggregate path --- no sort needed */
        add_path(distinct_rel, (Path *)
                 create_agg_path(root,
                                 distinct_rel,
                                 cheapest_input_path,
                                 cheapest_input_path->pathtarget,
                                 AGG_HASHED,
                                 AGGSPLIT_SIMPLE,
                                 root->processed_distinctClause,
                                 NIL,
                                 NULL,
                                 numDistinctRows));
    }
 
    return distinct_rel;
}

References add_path(), AGG_HASHED, AGGSPLIT_SIMPLE, RelOptInfo::cheapest_total_path, create_agg_path(), create_incremental_sort_path(), create_limit_path(), create_sort_path(), create_upper_unique_path(), PlannerInfo::distinct_pathkeys, enable_hashagg, enable_incremental_sort, estimate_num_groups(), FLOAT8PASSBYVAL, get_sortgrouplist_exprs(), grouping_is_hashable(), grouping_is_sortable(), PlannerInfo::hasHavingQual, Int64GetDatum(), InvalidOid, lfirst, LIMIT_OPTION_COUNT, list_length(), makeConst(), NIL, parse(), PlannerInfo::parse, Path::pathkeys, pathkeys_count_contained_in(), RelOptInfo::pathlist, PlannerInfo::processed_distinctClause, Path::rows, and PlannerInfo::sort_pathkeys.

Referenced by create_distinct_paths(), and create_partial_distinct_paths().

create_grouping_paths()

static RelOptInfo * create_grouping_paths ( PlannerInfo *  root, RelOptInfo *  input_rel, PathTarget *  target, bool  target_parallel_safe, grouping_sets_data *  gd  )

static

Definition at line 3678 of file planner.c.

{
    Query      *parse = root->parse;
    RelOptInfo *grouped_rel;
    RelOptInfo *partially_grouped_rel;
    AggClauseCosts agg_costs;
 
    MemSet(&agg_costs, 0, sizeof(AggClauseCosts));
    get_agg_clause_costs(root, AGGSPLIT_SIMPLE, &agg_costs);
 
    /*
     * Create grouping relation to hold fully aggregated grouping and/or
     * aggregation paths.
     */
    grouped_rel = make_grouping_rel(root, input_rel, target,
                                    target_parallel_safe, parse->havingQual);
 
    /*
     * Create either paths for a degenerate grouping or paths for ordinary
     * grouping, as appropriate.
     */
    if (is_degenerate_grouping(root))
        create_degenerate_grouping_paths(root, input_rel, grouped_rel);
    else
    {
        int         flags = 0;
        GroupPathExtraData extra;
 
        /*
         * Determine whether it's possible to perform sort-based
         * implementations of grouping.  (Note that if processed_groupClause
         * is empty, grouping_is_sortable() is trivially true, and all the
         * pathkeys_contained_in() tests will succeed too, so that we'll
         * consider every surviving input path.)
         *
         * If we have grouping sets, we might be able to sort some but not all
         * of them; in this case, we need can_sort to be true as long as we
         * must consider any sorted-input plan.
         */
        if ((gd && gd->rollups != NIL)
            || grouping_is_sortable(root->processed_groupClause))
            flags |= GROUPING_CAN_USE_SORT;
 
        /*
         * Determine whether we should consider hash-based implementations of
         * grouping.
         *
         * Hashed aggregation only applies if we're grouping. If we have
         * grouping sets, some groups might be hashable but others not; in
         * this case we set can_hash true as long as there is nothing globally
         * preventing us from hashing (and we should therefore consider plans
         * with hashes).
         *
         * Executor doesn't support hashed aggregation with DISTINCT or ORDER
         * BY aggregates.  (Doing so would imply storing *all* the input
         * values in the hash table, and/or running many sorts in parallel,
         * either of which seems like a certain loser.)  We similarly don't
         * support ordered-set aggregates in hashed aggregation, but that case
         * is also included in the numOrderedAggs count.
         *
         * Note: grouping_is_hashable() is much more expensive to check than
         * the other gating conditions, so we want to do it last.
         */
        if ((parse->groupClause != NIL &&
             root->numOrderedAggs == 0 &&
             (gd ? gd->any_hashable : grouping_is_hashable(root->processed_groupClause))))
            flags |= GROUPING_CAN_USE_HASH;
 
        /*
         * Determine whether partial aggregation is possible.
         */
        if (can_partial_agg(root))
            flags |= GROUPING_CAN_PARTIAL_AGG;
 
        extra.flags = flags;
        extra.target_parallel_safe = target_parallel_safe;
        extra.havingQual = parse->havingQual;
        extra.targetList = parse->targetList;
        extra.partial_costs_set = false;
 
        /*
         * Determine whether partitionwise aggregation is in theory possible.
         * It can be disabled by the user, and for now, we don't try to
         * support grouping sets.  create_ordinary_grouping_paths() will check
         * additional conditions, such as whether input_rel is partitioned.
         */
        if (enable_partitionwise_aggregate && !parse->groupingSets)
            extra.patype = PARTITIONWISE_AGGREGATE_FULL;
        else
            extra.patype = PARTITIONWISE_AGGREGATE_NONE;
 
        create_ordinary_grouping_paths(root, input_rel, grouped_rel,
                                       &agg_costs, gd, &extra,
                                       &partially_grouped_rel);
    }
 
    set_cheapest(grouped_rel);
    return grouped_rel;
}

References AGGSPLIT_SIMPLE, grouping_sets_data::any_hashable, can_partial_agg(), create_degenerate_grouping_paths(), create_ordinary_grouping_paths(), enable_partitionwise_aggregate, GroupPathExtraData::flags, get_agg_clause_costs(), GROUPING_CAN_PARTIAL_AGG, GROUPING_CAN_USE_HASH, GROUPING_CAN_USE_SORT, grouping_is_hashable(), grouping_is_sortable(), GroupPathExtraData::havingQual, is_degenerate_grouping(), make_grouping_rel(), MemSet, NIL, PlannerInfo::numOrderedAggs, parse(), PlannerInfo::parse, GroupPathExtraData::partial_costs_set, PARTITIONWISE_AGGREGATE_FULL, PARTITIONWISE_AGGREGATE_NONE, GroupPathExtraData::patype, PlannerInfo::processed_groupClause, grouping_sets_data::rollups, set_cheapest(), GroupPathExtraData::target_parallel_safe, and GroupPathExtraData::targetList.

Referenced by grouping_planner().

create_one_window_path()

static void create_one_window_path ( PlannerInfo *  root, RelOptInfo *  window_rel, Path *  path, PathTarget *  input_target, PathTarget *  output_target, WindowFuncLists *  wflists, List *  activeWindows  )

static

Definition at line 4517 of file planner.c.

{
    PathTarget *window_target;
    ListCell   *l;
    List       *topqual = NIL;
 
    /*
     * Since each window clause could require a different sort order, we stack
     * up a WindowAgg node for each clause, with sort steps between them as
     * needed.  (We assume that select_active_windows chose a good order for
     * executing the clauses in.)
     *
     * input_target should contain all Vars and Aggs needed for the result.
     * (In some cases we wouldn't need to propagate all of these all the way
     * to the top, since they might only be needed as inputs to WindowFuncs.
     * It's probably not worth trying to optimize that though.)  It must also
     * contain all window partitioning and sorting expressions, to ensure
     * they're computed only once at the bottom of the stack (that's critical
     * for volatile functions).  As we climb up the stack, we'll add outputs
     * for the WindowFuncs computed at each level.
     */
    window_target = input_target;
 
    foreach(l, activeWindows)
    {
        WindowClause *wc = lfirst_node(WindowClause, l);
        List       *window_pathkeys;
        int         presorted_keys;
        bool        is_sorted;
        bool        topwindow;
 
        window_pathkeys = make_pathkeys_for_window(root,
                                                   wc,
                                                   root->processed_tlist);
 
        is_sorted = pathkeys_count_contained_in(window_pathkeys,
                                                path->pathkeys,
                                                &presorted_keys);
 
        /* Sort if necessary */
        if (!is_sorted)
        {
            /*
             * No presorted keys or incremental sort disabled, just perform a
             * complete sort.
             */
            if (presorted_keys == 0 || !enable_incremental_sort)
                path = (Path *) create_sort_path(root, window_rel,
                                                 path,
                                                 window_pathkeys,
                                                 -1.0);
            else
            {
                /*
                 * Since we have presorted keys and incremental sort is
                 * enabled, just use incremental sort.
                 */
                path = (Path *) create_incremental_sort_path(root,
                                                             window_rel,
                                                             path,
                                                             window_pathkeys,
                                                             presorted_keys,
                                                             -1.0);
            }
        }
 
        if (lnext(activeWindows, l))
        {
            /*
             * Add the current WindowFuncs to the output target for this
             * intermediate WindowAggPath.  We must copy window_target to
             * avoid changing the previous path's target.
             *
             * Note: a WindowFunc adds nothing to the target's eval costs; but
             * we do need to account for the increase in tlist width.
             */
            ListCell   *lc2;
 
            window_target = copy_pathtarget(window_target);
            foreach(lc2, wflists->windowFuncs[wc->winref])
            {
                WindowFunc *wfunc = lfirst_node(WindowFunc, lc2);
 
                add_column_to_pathtarget(window_target, (Expr *) wfunc, 0);
                window_target->width += get_typavgwidth(wfunc->wintype, -1);
            }
        }
        else
        {
            /* Install the goal target in the topmost WindowAgg */
            window_target = output_target;
        }
 
        /* mark the final item in the list as the top-level window */
        topwindow = foreach_current_index(l) == list_length(activeWindows) - 1;
 
        /*
         * Accumulate all of the runConditions from each intermediate
         * WindowClause.  The top-level WindowAgg must pass these as a qual so
         * that it filters out unwanted tuples correctly.
         */
        if (!topwindow)
            topqual = list_concat(topqual, wc->runCondition);
 
        path = (Path *)
            create_windowagg_path(root, window_rel, path, window_target,
                                  wflists->windowFuncs[wc->winref],
                                  wc, topwindow ? topqual : NIL, topwindow);
    }
 
    add_path(window_rel, path);
}

References add_column_to_pathtarget(), add_path(), copy_pathtarget(), create_incremental_sort_path(), create_sort_path(), create_windowagg_path(), enable_incremental_sort, foreach_current_index, get_typavgwidth(), lfirst_node, list_concat(), list_length(), lnext(), make_pathkeys_for_window(), NIL, Path::pathkeys, pathkeys_count_contained_in(), PlannerInfo::processed_tlist, PathTarget::width, WindowFuncLists::windowFuncs, and WindowClause::winref.

Referenced by create_window_paths().

create_ordered_paths()

static RelOptInfo * create_ordered_paths ( PlannerInfo *  root, RelOptInfo *  input_rel, PathTarget *  target, bool  target_parallel_safe, double  limit_tuples  )

static

Definition at line 5087 of file planner.c.

{
    Path       *cheapest_input_path = input_rel->cheapest_total_path;
    RelOptInfo *ordered_rel;
    ListCell   *lc;
 
    /* For now, do all work in the (ORDERED, NULL) upperrel */
    ordered_rel = fetch_upper_rel(root, UPPERREL_ORDERED, NULL);
 
    /*
     * If the input relation is not parallel-safe, then the ordered relation
     * can't be parallel-safe, either.  Otherwise, it's parallel-safe if the
     * target list is parallel-safe.
     */
    if (input_rel->consider_parallel && target_parallel_safe)
        ordered_rel->consider_parallel = true;
 
    /*
     * If the input rel belongs to a single FDW, so does the ordered_rel.
     */
    ordered_rel->serverid = input_rel->serverid;
    ordered_rel->userid = input_rel->userid;
    ordered_rel->useridiscurrent = input_rel->useridiscurrent;
    ordered_rel->fdwroutine = input_rel->fdwroutine;
 
    foreach(lc, input_rel->pathlist)
    {
        Path       *input_path = (Path *) lfirst(lc);
        Path       *sorted_path;
        bool        is_sorted;
        int         presorted_keys;
 
        is_sorted = pathkeys_count_contained_in(root->sort_pathkeys,
                                                input_path->pathkeys, &presorted_keys);
 
        if (is_sorted)
            sorted_path = input_path;
        else
        {
            /*
             * Try at least sorting the cheapest path and also try
             * incrementally sorting any path which is partially sorted
             * already (no need to deal with paths which have presorted keys
             * when incremental sort is disabled unless it's the cheapest
             * input path).
             */
            if (input_path != cheapest_input_path &&
                (presorted_keys == 0 || !enable_incremental_sort))
                continue;
 
            /*
             * We've no need to consider both a sort and incremental sort.
             * We'll just do a sort if there are no presorted keys and an
             * incremental sort when there are presorted keys.
             */
            if (presorted_keys == 0 || !enable_incremental_sort)
                sorted_path = (Path *) create_sort_path(root,
                                                        ordered_rel,
                                                        input_path,
                                                        root->sort_pathkeys,
                                                        limit_tuples);
            else
                sorted_path = (Path *) create_incremental_sort_path(root,
                                                                    ordered_rel,
                                                                    input_path,
                                                                    root->sort_pathkeys,
                                                                    presorted_keys,
                                                                    limit_tuples);
        }
 
        /* Add projection step if needed */
        if (sorted_path->pathtarget != target)
            sorted_path = apply_projection_to_path(root, ordered_rel,
                                                   sorted_path, target);
 
        add_path(ordered_rel, sorted_path);
    }
 
    /*
     * generate_gather_paths() will have already generated a simple Gather
     * path for the best parallel path, if any, and the loop above will have
     * considered sorting it.  Similarly, generate_gather_paths() will also
     * have generated order-preserving Gather Merge plans which can be used
     * without sorting if they happen to match the sort_pathkeys, and the loop
     * above will have handled those as well.  However, there's one more
     * possibility: it may make sense to sort the cheapest partial path
     * according to the required output order and then use Gather Merge.
     */
    if (ordered_rel->consider_parallel && root->sort_pathkeys != NIL &&
        input_rel->partial_pathlist != NIL)
    {
        Path       *cheapest_partial_path;
 
        cheapest_partial_path = linitial(input_rel->partial_pathlist);
 
        /*
         * If cheapest partial path doesn't need a sort, this is redundant
         * with what's already been tried.
         */
        if (!pathkeys_contained_in(root->sort_pathkeys,
                                   cheapest_partial_path->pathkeys))
        {
            Path       *path;
            double      total_groups;
 
            path = (Path *) create_sort_path(root,
                                             ordered_rel,
                                             cheapest_partial_path,
                                             root->sort_pathkeys,
                                             limit_tuples);
 
            total_groups = cheapest_partial_path->rows *
                cheapest_partial_path->parallel_workers;
            path = (Path *)
                create_gather_merge_path(root, ordered_rel,
                                         path,
                                         path->pathtarget,
                                         root->sort_pathkeys, NULL,
                                         &total_groups);
 
            /* Add projection step if needed */
            if (path->pathtarget != target)
                path = apply_projection_to_path(root, ordered_rel,
                                                path, target);
 
            add_path(ordered_rel, path);
        }
 
        /*
         * Consider incremental sort with a gather merge on partial paths.
         *
         * We can also skip the entire loop when we only have a single-item
         * sort_pathkeys because then we can't possibly have a presorted
         * prefix of the list without having the list be fully sorted.
         */
        if (enable_incremental_sort && list_length(root->sort_pathkeys) > 1)
        {
            foreach(lc, input_rel->partial_pathlist)
            {
                Path       *input_path = (Path *) lfirst(lc);
                Path       *sorted_path;
                bool        is_sorted;
                int         presorted_keys;
                double      total_groups;
 
                /*
                 * We don't care if this is the cheapest partial path - we
                 * can't simply skip it, because it may be partially sorted in
                 * which case we want to consider adding incremental sort
                 * (instead of full sort, which is what happens above).
                 */
 
                is_sorted = pathkeys_count_contained_in(root->sort_pathkeys,
                                                        input_path->pathkeys,
                                                        &presorted_keys);
 
                /* No point in adding incremental sort on fully sorted paths. */
                if (is_sorted)
                    continue;
 
                if (presorted_keys == 0)
                    continue;
 
                /* Since we have presorted keys, consider incremental sort. */
                sorted_path = (Path *) create_incremental_sort_path(root,
                                                                    ordered_rel,
                                                                    input_path,
                                                                    root->sort_pathkeys,
                                                                    presorted_keys,
                                                                    limit_tuples);
                total_groups = input_path->rows *
                    input_path->parallel_workers;
                sorted_path = (Path *)
                    create_gather_merge_path(root, ordered_rel,
                                             sorted_path,
                                             sorted_path->pathtarget,
                                             root->sort_pathkeys, NULL,
                                             &total_groups);
 
                /* Add projection step if needed */
                if (sorted_path->pathtarget != target)
                    sorted_path = apply_projection_to_path(root, ordered_rel,
                                                           sorted_path, target);
 
                add_path(ordered_rel, sorted_path);
            }
        }
    }
 
    /*
     * If there is an FDW that's responsible for all baserels of the query,
     * let it consider adding ForeignPaths.
     */
    if (ordered_rel->fdwroutine &&
        ordered_rel->fdwroutine->GetForeignUpperPaths)
        ordered_rel->fdwroutine->GetForeignUpperPaths(root, UPPERREL_ORDERED,
                                                      input_rel, ordered_rel,
                                                      NULL);
 
    /* Let extensions possibly add some more paths */
    if (create_upper_paths_hook)
        (*create_upper_paths_hook) (root, UPPERREL_ORDERED,
                                    input_rel, ordered_rel, NULL);
 
    /*
     * No need to bother with set_cheapest here; grouping_planner does not
     * need us to do it.
     */
    Assert(ordered_rel->pathlist != NIL);
 
    return ordered_rel;
}

References add_path(), apply_projection_to_path(), Assert(), RelOptInfo::cheapest_total_path, RelOptInfo::consider_parallel, create_gather_merge_path(), create_incremental_sort_path(), create_sort_path(), create_upper_paths_hook, enable_incremental_sort, fetch_upper_rel(), lfirst, linitial, list_length(), NIL, Path::parallel_workers, RelOptInfo::partial_pathlist, Path::pathkeys, pathkeys_contained_in(), pathkeys_count_contained_in(), RelOptInfo::pathlist, Path::rows, RelOptInfo::serverid, PlannerInfo::sort_pathkeys, UPPERREL_ORDERED, RelOptInfo::userid, and RelOptInfo::useridiscurrent.

Referenced by grouping_planner().

create_ordinary_grouping_paths()

static void create_ordinary_grouping_paths ( PlannerInfo *  root, RelOptInfo *  input_rel, RelOptInfo *  grouped_rel, const AggClauseCosts *  agg_costs, grouping_sets_data *  gd, GroupPathExtraData *  extra, RelOptInfo **  partially_grouped_rel_p  )

static

Definition at line 3929 of file planner.c.

{
    Path       *cheapest_path = input_rel->cheapest_total_path;
    RelOptInfo *partially_grouped_rel = NULL;
    double      dNumGroups;
    PartitionwiseAggregateType patype = PARTITIONWISE_AGGREGATE_NONE;
 
    /*
     * If this is the topmost grouping relation or if the parent relation is
     * doing some form of partitionwise aggregation, then we may be able to do
     * it at this level also.  However, if the input relation is not
     * partitioned, partitionwise aggregate is impossible.
     */
    if (extra->patype != PARTITIONWISE_AGGREGATE_NONE &&
        IS_PARTITIONED_REL(input_rel))
    {
        /*
         * If this is the topmost relation or if the parent relation is doing
         * full partitionwise aggregation, then we can do full partitionwise
         * aggregation provided that the GROUP BY clause contains all of the
         * partitioning columns at this level.  Otherwise, we can do at most
         * partial partitionwise aggregation.  But if partial aggregation is
         * not supported in general then we can't use it for partitionwise
         * aggregation either.
         *
         * Check parse->groupClause not processed_groupClause, because it's
         * okay if some of the partitioning columns were proved redundant.
         */
        if (extra->patype == PARTITIONWISE_AGGREGATE_FULL &&
            group_by_has_partkey(input_rel, extra->targetList,
                                 root->parse->groupClause))
            patype = PARTITIONWISE_AGGREGATE_FULL;
        else if ((extra->flags & GROUPING_CAN_PARTIAL_AGG) != 0)
            patype = PARTITIONWISE_AGGREGATE_PARTIAL;
        else
            patype = PARTITIONWISE_AGGREGATE_NONE;
    }
 
    /*
     * Before generating paths for grouped_rel, we first generate any possible
     * partially grouped paths; that way, later code can easily consider both
     * parallel and non-parallel approaches to grouping.
     */
    if ((extra->flags & GROUPING_CAN_PARTIAL_AGG) != 0)
    {
        bool        force_rel_creation;
 
        /*
         * If we're doing partitionwise aggregation at this level, force
         * creation of a partially_grouped_rel so we can add partitionwise
         * paths to it.
         */
        force_rel_creation = (patype == PARTITIONWISE_AGGREGATE_PARTIAL);
 
        partially_grouped_rel =
            create_partial_grouping_paths(root,
                                          grouped_rel,
                                          input_rel,
                                          gd,
                                          extra,
                                          force_rel_creation);
    }
 
    /* Set out parameter. */
    *partially_grouped_rel_p = partially_grouped_rel;
 
    /* Apply partitionwise aggregation technique, if possible. */
    if (patype != PARTITIONWISE_AGGREGATE_NONE)
        create_partitionwise_grouping_paths(root, input_rel, grouped_rel,
                                            partially_grouped_rel, agg_costs,
                                            gd, patype, extra);
 
    /* If we are doing partial aggregation only, return. */
    if (extra->patype == PARTITIONWISE_AGGREGATE_PARTIAL)
    {
        Assert(partially_grouped_rel);
 
        if (partially_grouped_rel->pathlist)
            set_cheapest(partially_grouped_rel);
 
        return;
    }
 
    /* Gather any partially grouped partial paths. */
    if (partially_grouped_rel && partially_grouped_rel->partial_pathlist)
    {
        gather_grouping_paths(root, partially_grouped_rel);
        set_cheapest(partially_grouped_rel);
    }
 
    /*
     * Estimate number of groups.
     */
    dNumGroups = get_number_of_groups(root,
                                      cheapest_path->rows,
                                      gd,
                                      extra->targetList);
 
    /* Build final grouping paths */
    add_paths_to_grouping_rel(root, input_rel, grouped_rel,
                              partially_grouped_rel, agg_costs, gd,
                              dNumGroups, extra);
 
    /* Give a helpful error if we failed to find any implementation */
    if (grouped_rel->pathlist == NIL)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("could not implement GROUP BY"),
                 errdetail("Some of the datatypes only support hashing, while others only support sorting.")));
 
    /*
     * If there is an FDW that's responsible for all baserels of the query,
     * let it consider adding ForeignPaths.
     */
    if (grouped_rel->fdwroutine &&
        grouped_rel->fdwroutine->GetForeignUpperPaths)
        grouped_rel->fdwroutine->GetForeignUpperPaths(root, UPPERREL_GROUP_AGG,
                                                      input_rel, grouped_rel,
                                                      extra);
 
    /* Let extensions possibly add some more paths */
    if (create_upper_paths_hook)
        (*create_upper_paths_hook) (root, UPPERREL_GROUP_AGG,
                                    input_rel, grouped_rel,
                                    extra);
}

References add_paths_to_grouping_rel(), Assert(), RelOptInfo::cheapest_total_path, create_partial_grouping_paths(), create_partitionwise_grouping_paths(), create_upper_paths_hook, ereport, errcode(), errdetail(), errmsg(), ERROR, GroupPathExtraData::flags, gather_grouping_paths(), get_number_of_groups(), group_by_has_partkey(), Query::groupClause, GROUPING_CAN_PARTIAL_AGG, IS_PARTITIONED_REL, NIL, PlannerInfo::parse, RelOptInfo::partial_pathlist, PARTITIONWISE_AGGREGATE_FULL, PARTITIONWISE_AGGREGATE_NONE, PARTITIONWISE_AGGREGATE_PARTIAL, RelOptInfo::pathlist, GroupPathExtraData::patype, Path::rows, set_cheapest(), GroupPathExtraData::targetList, and UPPERREL_GROUP_AGG.

Referenced by create_grouping_paths(), and create_partitionwise_grouping_paths().

create_partial_distinct_paths()

static void create_partial_distinct_paths ( PlannerInfo *  root, RelOptInfo *  input_rel, RelOptInfo *  final_distinct_rel  )

static

Definition at line 4716 of file planner.c.

{
    RelOptInfo *partial_distinct_rel;
    Query      *parse;
    List       *distinctExprs;
    double      numDistinctRows;
    Path       *cheapest_partial_path;
    ListCell   *lc;
 
    /* nothing to do when there are no partial paths in the input rel */
    if (!input_rel->consider_parallel || input_rel->partial_pathlist == NIL)
        return;
 
    parse = root->parse;
 
    /* can't do parallel DISTINCT ON */
    if (parse->hasDistinctOn)
        return;
 
    partial_distinct_rel = fetch_upper_rel(root, UPPERREL_PARTIAL_DISTINCT,
                                           NULL);
    partial_distinct_rel->reltarget = root->upper_targets[UPPERREL_PARTIAL_DISTINCT];
    partial_distinct_rel->consider_parallel = input_rel->consider_parallel;
 
    /*
     * If input_rel belongs to a single FDW, so does the partial_distinct_rel.
     */
    partial_distinct_rel->serverid = input_rel->serverid;
    partial_distinct_rel->userid = input_rel->userid;
    partial_distinct_rel->useridiscurrent = input_rel->useridiscurrent;
    partial_distinct_rel->fdwroutine = input_rel->fdwroutine;
 
    cheapest_partial_path = linitial(input_rel->partial_pathlist);
 
    distinctExprs = get_sortgrouplist_exprs(root->processed_distinctClause,
                                            parse->targetList);
 
    /* estimate how many distinct rows we'll get from each worker */
    numDistinctRows = estimate_num_groups(root, distinctExprs,
                                          cheapest_partial_path->rows,
                                          NULL, NULL);
 
    /*
     * Try sorting the cheapest path and incrementally sorting any paths with
     * presorted keys and put a unique paths atop of those.
     */
    if (grouping_is_sortable(root->processed_distinctClause))
    {
        foreach(lc, input_rel->partial_pathlist)
        {
            Path       *input_path = (Path *) lfirst(lc);
            Path       *sorted_path;
            bool        is_sorted;
            int         presorted_keys;
 
            is_sorted = pathkeys_count_contained_in(root->distinct_pathkeys,
                                                    input_path->pathkeys,
                                                    &presorted_keys);
 
            if (is_sorted)
                sorted_path = input_path;
            else
            {
                /*
                 * Try at least sorting the cheapest path and also try
                 * incrementally sorting any path which is partially sorted
                 * already (no need to deal with paths which have presorted
                 * keys when incremental sort is disabled unless it's the
                 * cheapest partial path).
                 */
                if (input_path != cheapest_partial_path &&
                    (presorted_keys == 0 || !enable_incremental_sort))
                    continue;
 
                /*
                 * We've no need to consider both a sort and incremental sort.
                 * We'll just do a sort if there are no presorted keys and an
                 * incremental sort when there are presorted keys.
                 */
                if (presorted_keys == 0 || !enable_incremental_sort)
                    sorted_path = (Path *) create_sort_path(root,
                                                            partial_distinct_rel,
                                                            input_path,
                                                            root->distinct_pathkeys,
                                                            -1.0);
                else
                    sorted_path = (Path *) create_incremental_sort_path(root,
                                                                        partial_distinct_rel,
                                                                        input_path,
                                                                        root->distinct_pathkeys,
                                                                        presorted_keys,
                                                                        -1.0);
            }
 
            add_partial_path(partial_distinct_rel, (Path *)
                             create_upper_unique_path(root, partial_distinct_rel,
                                                      sorted_path,
                                                      list_length(root->distinct_pathkeys),
                                                      numDistinctRows));
        }
    }
 
    /*
     * Now try hash aggregate paths, if enabled and hashing is possible. Since
     * we're not on the hook to ensure we do our best to create at least one
     * path here, we treat enable_hashagg as a hard off-switch rather than the
     * slightly softer variant in create_final_distinct_paths.
     */
    if (enable_hashagg && grouping_is_hashable(root->processed_distinctClause))
    {
        add_partial_path(partial_distinct_rel, (Path *)
                         create_agg_path(root,
                                         partial_distinct_rel,
                                         cheapest_partial_path,
                                         cheapest_partial_path->pathtarget,
                                         AGG_HASHED,
                                         AGGSPLIT_SIMPLE,
                                         root->processed_distinctClause,
                                         NIL,
                                         NULL,
                                         numDistinctRows));
    }
 
    /*
     * If there is an FDW that's responsible for all baserels of the query,
     * let it consider adding ForeignPaths.
     */
    if (partial_distinct_rel->fdwroutine &&
        partial_distinct_rel->fdwroutine->GetForeignUpperPaths)
        partial_distinct_rel->fdwroutine->GetForeignUpperPaths(root,
                                                               UPPERREL_PARTIAL_DISTINCT,
                                                               input_rel,
                                                               partial_distinct_rel,
                                                               NULL);
 
    /* Let extensions possibly add some more partial paths */
    if (create_upper_paths_hook)
        (*create_upper_paths_hook) (root, UPPERREL_PARTIAL_DISTINCT,
                                    input_rel, partial_distinct_rel, NULL);
 
    if (partial_distinct_rel->partial_pathlist != NIL)
    {
        generate_gather_paths(root, partial_distinct_rel, true);
        set_cheapest(partial_distinct_rel);
 
        /*
         * Finally, create paths to distinctify the final result.  This step
         * is needed to remove any duplicates due to combining rows from
         * parallel workers.
         */
        create_final_distinct_paths(root, partial_distinct_rel,
                                    final_distinct_rel);
    }
}

References add_partial_path(), AGG_HASHED, AGGSPLIT_SIMPLE, RelOptInfo::consider_parallel, create_agg_path(), create_final_distinct_paths(), create_incremental_sort_path(), create_sort_path(), create_upper_paths_hook, create_upper_unique_path(), PlannerInfo::distinct_pathkeys, enable_hashagg, enable_incremental_sort, estimate_num_groups(), fetch_upper_rel(), generate_gather_paths(), get_sortgrouplist_exprs(), grouping_is_hashable(), grouping_is_sortable(), lfirst, linitial, list_length(), NIL, parse(), PlannerInfo::parse, RelOptInfo::partial_pathlist, Path::pathkeys, pathkeys_count_contained_in(), PlannerInfo::processed_distinctClause, RelOptInfo::reltarget, Path::rows, RelOptInfo::serverid, set_cheapest(), UPPERREL_PARTIAL_DISTINCT, RelOptInfo::userid, and RelOptInfo::useridiscurrent.

Referenced by create_distinct_paths().

create_partial_grouping_paths()

static RelOptInfo * create_partial_grouping_paths ( PlannerInfo *  root, RelOptInfo *  grouped_rel, RelOptInfo *  input_rel, grouping_sets_data *  gd, GroupPathExtraData *  extra, bool  force_rel_creation  )

static

Definition at line 7031 of file planner.c.

{
    Query      *parse = root->parse;
    RelOptInfo *partially_grouped_rel;
    AggClauseCosts *agg_partial_costs = &extra->agg_partial_costs;
    AggClauseCosts *agg_final_costs = &extra->agg_final_costs;
    Path       *cheapest_partial_path = NULL;
    Path       *cheapest_total_path = NULL;
    double      dNumPartialGroups = 0;
    double      dNumPartialPartialGroups = 0;
    ListCell   *lc;
    bool        can_hash = (extra->flags & GROUPING_CAN_USE_HASH) != 0;
    bool        can_sort = (extra->flags & GROUPING_CAN_USE_SORT) != 0;
 
    /*
     * Consider whether we should generate partially aggregated non-partial
     * paths.  We can only do this if we have a non-partial path, and only if
     * the parent of the input rel is performing partial partitionwise
     * aggregation.  (Note that extra->patype is the type of partitionwise
     * aggregation being used at the parent level, not this level.)
     */
    if (input_rel->pathlist != NIL &&
        extra->patype == PARTITIONWISE_AGGREGATE_PARTIAL)
        cheapest_total_path = input_rel->cheapest_total_path;
 
    /*
     * If parallelism is possible for grouped_rel, then we should consider
     * generating partially-grouped partial paths.  However, if the input rel
     * has no partial paths, then we can't.
     */
    if (grouped_rel->consider_parallel && input_rel->partial_pathlist != NIL)
        cheapest_partial_path = linitial(input_rel->partial_pathlist);
 
    /*
     * If we can't partially aggregate partial paths, and we can't partially
     * aggregate non-partial paths, then don't bother creating the new
     * RelOptInfo at all, unless the caller specified force_rel_creation.
     */
    if (cheapest_total_path == NULL &&
        cheapest_partial_path == NULL &&
        !force_rel_creation)
        return NULL;
 
    /*
     * Build a new upper relation to represent the result of partially
     * aggregating the rows from the input relation.
     */
    partially_grouped_rel = fetch_upper_rel(root,
                                            UPPERREL_PARTIAL_GROUP_AGG,
                                            grouped_rel->relids);
    partially_grouped_rel->consider_parallel =
        grouped_rel->consider_parallel;
    partially_grouped_rel->reloptkind = grouped_rel->reloptkind;
    partially_grouped_rel->serverid = grouped_rel->serverid;
    partially_grouped_rel->userid = grouped_rel->userid;
    partially_grouped_rel->useridiscurrent = grouped_rel->useridiscurrent;
    partially_grouped_rel->fdwroutine = grouped_rel->fdwroutine;
 
    /*
     * Build target list for partial aggregate paths.  These paths cannot just
     * emit the same tlist as regular aggregate paths, because (1) we must
     * include Vars and Aggrefs needed in HAVING, which might not appear in
     * the result tlist, and (2) the Aggrefs must be set in partial mode.
     */
    partially_grouped_rel->reltarget =
        make_partial_grouping_target(root, grouped_rel->reltarget,
                                     extra->havingQual);
 
    if (!extra->partial_costs_set)
    {
        /*
         * Collect statistics about aggregates for estimating costs of
         * performing aggregation in parallel.
         */
        MemSet(agg_partial_costs, 0, sizeof(AggClauseCosts));
        MemSet(agg_final_costs, 0, sizeof(AggClauseCosts));
        if (parse->hasAggs)
        {
            /* partial phase */
            get_agg_clause_costs(root, AGGSPLIT_INITIAL_SERIAL,
                                 agg_partial_costs);
 
            /* final phase */
            get_agg_clause_costs(root, AGGSPLIT_FINAL_DESERIAL,
                                 agg_final_costs);
        }
 
        extra->partial_costs_set = true;
    }
 
    /* Estimate number of partial groups. */
    if (cheapest_total_path != NULL)
        dNumPartialGroups =
            get_number_of_groups(root,
                                 cheapest_total_path->rows,
                                 gd,
                                 extra->targetList);
    if (cheapest_partial_path != NULL)
        dNumPartialPartialGroups =
            get_number_of_groups(root,
                                 cheapest_partial_path->rows,
                                 gd,
                                 extra->targetList);
 
    if (can_sort && cheapest_total_path != NULL)
    {
        /* This should have been checked previously */
        Assert(parse->hasAggs || parse->groupClause);
 
        /*
         * Use any available suitably-sorted path as input, and also consider
         * sorting the cheapest partial path.
         */
        foreach(lc, input_rel->pathlist)
        {
            Path       *path = (Path *) lfirst(lc);
            bool        is_sorted;
            int         presorted_keys;
 
            is_sorted = pathkeys_count_contained_in(root->group_pathkeys,
                                                    path->pathkeys,
                                                    &presorted_keys);
            if (!is_sorted)
            {
                /*
                 * Try at least sorting the cheapest path and also try
                 * incrementally sorting any path which is partially sorted
                 * already (no need to deal with paths which have presorted
                 * keys when incremental sort is disabled unless it's the
                 * cheapest input path).
                 */
                if (path != cheapest_total_path &&
                    (presorted_keys == 0 || !enable_incremental_sort))
                    continue;
 
                /*
                 * We've no need to consider both a sort and incremental sort.
                 * We'll just do a sort if there are no presorted keys and an
                 * incremental sort when there are presorted keys.
                 */
                if (presorted_keys == 0 || !enable_incremental_sort)
                    path = (Path *) create_sort_path(root,
                                                     partially_grouped_rel,
                                                     path,
                                                     root->group_pathkeys,
                                                     -1.0);
                else
                    path = (Path *) create_incremental_sort_path(root,
                                                                 partially_grouped_rel,
                                                                 path,
                                                                 root->group_pathkeys,
                                                                 presorted_keys,
                                                                 -1.0);
            }
 
            if (parse->hasAggs)
                add_path(partially_grouped_rel, (Path *)
                         create_agg_path(root,
                                         partially_grouped_rel,
                                         path,
                                         partially_grouped_rel->reltarget,
                                         parse->groupClause ? AGG_SORTED : AGG_PLAIN,
                                         AGGSPLIT_INITIAL_SERIAL,
                                         root->processed_groupClause,
                                         NIL,
                                         agg_partial_costs,
                                         dNumPartialGroups));
            else
                add_path(partially_grouped_rel, (Path *)
                         create_group_path(root,
                                           partially_grouped_rel,
                                           path,
                                           root->processed_groupClause,
                                           NIL,
                                           dNumPartialGroups));
        }
    }
 
    if (can_sort && cheapest_partial_path != NULL)
    {
        /* Similar to above logic, but for partial paths. */
        foreach(lc, input_rel->partial_pathlist)
        {
            Path       *path = (Path *) lfirst(lc);
            bool        is_sorted;
            int         presorted_keys;
 
            is_sorted = pathkeys_count_contained_in(root->group_pathkeys,
                                                    path->pathkeys,
                                                    &presorted_keys);
 
            if (!is_sorted)
            {
                /*
                 * Try at least sorting the cheapest path and also try
                 * incrementally sorting any path which is partially sorted
                 * already (no need to deal with paths which have presorted
                 * keys when incremental sort is disabled unless it's the
                 * cheapest input path).
                 */
                if (path != cheapest_partial_path &&
                    (presorted_keys == 0 || !enable_incremental_sort))
                    continue;
 
                /*
                 * We've no need to consider both a sort and incremental sort.
                 * We'll just do a sort if there are no presorted keys and an
                 * incremental sort when there are presorted keys.
                 */
                if (presorted_keys == 0 || !enable_incremental_sort)
                    path = (Path *) create_sort_path(root,
                                                     partially_grouped_rel,
                                                     path,
                                                     root->group_pathkeys,
                                                     -1.0);
                else
                    path = (Path *) create_incremental_sort_path(root,
                                                                 partially_grouped_rel,
                                                                 path,
                                                                 root->group_pathkeys,
                                                                 presorted_keys,
                                                                 -1.0);
            }
 
            if (parse->hasAggs)
                add_partial_path(partially_grouped_rel, (Path *)
                                 create_agg_path(root,
                                                 partially_grouped_rel,
                                                 path,
                                                 partially_grouped_rel->reltarget,
                                                 parse->groupClause ? AGG_SORTED : AGG_PLAIN,
                                                 AGGSPLIT_INITIAL_SERIAL,
                                                 root->processed_groupClause,
                                                 NIL,
                                                 agg_partial_costs,
                                                 dNumPartialPartialGroups));
            else
                add_partial_path(partially_grouped_rel, (Path *)
                                 create_group_path(root,
                                                   partially_grouped_rel,
                                                   path,
                                                   root->processed_groupClause,
                                                   NIL,
                                                   dNumPartialPartialGroups));
        }
    }
 
    /*
     * Add a partially-grouped HashAgg Path where possible
     */
    if (can_hash && cheapest_total_path != NULL)
    {
        /* Checked above */
        Assert(parse->hasAggs || parse->groupClause);
 
        add_path(partially_grouped_rel, (Path *)
                 create_agg_path(root,
                                 partially_grouped_rel,
                                 cheapest_total_path,
                                 partially_grouped_rel->reltarget,
                                 AGG_HASHED,
                                 AGGSPLIT_INITIAL_SERIAL,
                                 root->processed_groupClause,
                                 NIL,
                                 agg_partial_costs,
                                 dNumPartialGroups));
    }
 
    /*
     * Now add a partially-grouped HashAgg partial Path where possible
     */
    if (can_hash && cheapest_partial_path != NULL)
    {
        add_partial_path(partially_grouped_rel, (Path *)
                         create_agg_path(root,
                                         partially_grouped_rel,
                                         cheapest_partial_path,
                                         partially_grouped_rel->reltarget,
                                         AGG_HASHED,
                                         AGGSPLIT_INITIAL_SERIAL,
                                         root->processed_groupClause,
                                         NIL,
                                         agg_partial_costs,
                                         dNumPartialPartialGroups));
    }
 
    /*
     * If there is an FDW that's responsible for all baserels of the query,
     * let it consider adding partially grouped ForeignPaths.
     */
    if (partially_grouped_rel->fdwroutine &&
        partially_grouped_rel->fdwroutine->GetForeignUpperPaths)
    {
        FdwRoutine *fdwroutine = partially_grouped_rel->fdwroutine;
 
        fdwroutine->GetForeignUpperPaths(root,
                                         UPPERREL_PARTIAL_GROUP_AGG,
                                         input_rel, partially_grouped_rel,
                                         extra);
    }
 
    return partially_grouped_rel;
}

References add_partial_path(), add_path(), GroupPathExtraData::agg_final_costs, AGG_HASHED, GroupPathExtraData::agg_partial_costs, AGG_PLAIN, AGG_SORTED, AGGSPLIT_FINAL_DESERIAL, AGGSPLIT_INITIAL_SERIAL, Assert(), RelOptInfo::cheapest_total_path, RelOptInfo::consider_parallel, create_agg_path(), create_group_path(), create_incremental_sort_path(), create_sort_path(), enable_incremental_sort, fetch_upper_rel(), GroupPathExtraData::flags, get_agg_clause_costs(), get_number_of_groups(), FdwRoutine::GetForeignUpperPaths, PlannerInfo::group_pathkeys, GROUPING_CAN_USE_HASH, GROUPING_CAN_USE_SORT, GroupPathExtraData::havingQual, lfirst, linitial, make_partial_grouping_target(), MemSet, NIL, parse(), PlannerInfo::parse, GroupPathExtraData::partial_costs_set, RelOptInfo::partial_pathlist, PARTITIONWISE_AGGREGATE_PARTIAL, Path::pathkeys, pathkeys_count_contained_in(), RelOptInfo::pathlist, GroupPathExtraData::patype, PlannerInfo::processed_groupClause, RelOptInfo::relids, RelOptInfo::reloptkind, RelOptInfo::reltarget, Path::rows, RelOptInfo::serverid, GroupPathExtraData::targetList, UPPERREL_PARTIAL_GROUP_AGG, RelOptInfo::userid, and RelOptInfo::useridiscurrent.

Referenced by create_ordinary_grouping_paths().

create_partitionwise_grouping_paths()

static void create_partitionwise_grouping_paths ( PlannerInfo *  root, RelOptInfo *  input_rel, RelOptInfo *  grouped_rel, RelOptInfo *  partially_grouped_rel, const AggClauseCosts *  agg_costs, grouping_sets_data *  gd, PartitionwiseAggregateType  patype, GroupPathExtraData *  extra  )

static

Definition at line 7719 of file planner.c.

{
    List       *grouped_live_children = NIL;
    List       *partially_grouped_live_children = NIL;
    PathTarget *target = grouped_rel->reltarget;
    bool        partial_grouping_valid = true;
    int         i;
 
    Assert(patype != PARTITIONWISE_AGGREGATE_NONE);
    Assert(patype != PARTITIONWISE_AGGREGATE_PARTIAL ||
           partially_grouped_rel != NULL);
 
    /* Add paths for partitionwise aggregation/grouping. */
    i = -1;
    while ((i = bms_next_member(input_rel->live_parts, i)) >= 0)
    {
        RelOptInfo *child_input_rel = input_rel->part_rels[i];
        PathTarget *child_target;
        AppendRelInfo **appinfos;
        int         nappinfos;
        GroupPathExtraData child_extra;
        RelOptInfo *child_grouped_rel;
        RelOptInfo *child_partially_grouped_rel;
 
        Assert(child_input_rel != NULL);
 
        /* Dummy children can be ignored. */
        if (IS_DUMMY_REL(child_input_rel))
            continue;
 
        child_target = copy_pathtarget(target);
 
        /*
         * Copy the given "extra" structure as is and then override the
         * members specific to this child.
         */
        memcpy(&child_extra, extra, sizeof(child_extra));
 
        appinfos = find_appinfos_by_relids(root, child_input_rel->relids,
                                           &nappinfos);
 
        child_target->exprs = (List *)
            adjust_appendrel_attrs(root,
                                   (Node *) target->exprs,
                                   nappinfos, appinfos);
 
        /* Translate havingQual and targetList. */
        child_extra.havingQual = (Node *)
            adjust_appendrel_attrs(root,
                                   extra->havingQual,
                                   nappinfos, appinfos);
        child_extra.targetList = (List *)
            adjust_appendrel_attrs(root,
                                   (Node *) extra->targetList,
                                   nappinfos, appinfos);
 
        /*
         * extra->patype was the value computed for our parent rel; patype is
         * the value for this relation.  For the child, our value is its
         * parent rel's value.
         */
        child_extra.patype = patype;
 
        /*
         * Create grouping relation to hold fully aggregated grouping and/or
         * aggregation paths for the child.
         */
        child_grouped_rel = make_grouping_rel(root, child_input_rel,
                                              child_target,
                                              extra->target_parallel_safe,
                                              child_extra.havingQual);
 
        /* Create grouping paths for this child relation. */
        create_ordinary_grouping_paths(root, child_input_rel,
                                       child_grouped_rel,
                                       agg_costs, gd, &child_extra,
                                       &child_partially_grouped_rel);
 
        if (child_partially_grouped_rel)
        {
            partially_grouped_live_children =
                lappend(partially_grouped_live_children,
                        child_partially_grouped_rel);
        }
        else
            partial_grouping_valid = false;
 
        if (patype == PARTITIONWISE_AGGREGATE_FULL)
        {
            set_cheapest(child_grouped_rel);
            grouped_live_children = lappend(grouped_live_children,
                                            child_grouped_rel);
        }
 
        pfree(appinfos);
    }
 
    /*
     * Try to create append paths for partially grouped children. For full
     * partitionwise aggregation, we might have paths in the partial_pathlist
     * if parallel aggregation is possible.  For partial partitionwise
     * aggregation, we may have paths in both pathlist and partial_pathlist.
     *
     * NB: We must have a partially grouped path for every child in order to
     * generate a partially grouped path for this relation.
     */
    if (partially_grouped_rel && partial_grouping_valid)
    {
        Assert(partially_grouped_live_children != NIL);
 
        add_paths_to_append_rel(root, partially_grouped_rel,
                                partially_grouped_live_children);
 
        /*
         * We need call set_cheapest, since the finalization step will use the
         * cheapest path from the rel.
         */
        if (partially_grouped_rel->pathlist)
            set_cheapest(partially_grouped_rel);
    }
 
    /* If possible, create append paths for fully grouped children. */
    if (patype == PARTITIONWISE_AGGREGATE_FULL)
    {
        Assert(grouped_live_children != NIL);
 
        add_paths_to_append_rel(root, grouped_rel, grouped_live_children);
    }
}

References add_paths_to_append_rel(), adjust_appendrel_attrs(), Assert(), bms_next_member(), copy_pathtarget(), create_ordinary_grouping_paths(), PathTarget::exprs, find_appinfos_by_relids(), GroupPathExtraData::havingQual, i, IS_DUMMY_REL, lappend(), RelOptInfo::live_parts, make_grouping_rel(), NIL, PARTITIONWISE_AGGREGATE_FULL, PARTITIONWISE_AGGREGATE_NONE, PARTITIONWISE_AGGREGATE_PARTIAL, RelOptInfo::pathlist, GroupPathExtraData::patype, pfree(), RelOptInfo::relids, RelOptInfo::reltarget, set_cheapest(), GroupPathExtraData::target_parallel_safe, and GroupPathExtraData::targetList.

Referenced by create_ordinary_grouping_paths().

create_window_paths()

static RelOptInfo * create_window_paths ( PlannerInfo *  root, RelOptInfo *  input_rel, PathTarget *  input_target, PathTarget *  output_target, bool  output_target_parallel_safe, WindowFuncLists *  wflists, List *  activeWindows  )

static

Definition at line 4430 of file planner.c.

{
    RelOptInfo *window_rel;
    ListCell   *lc;
 
    /* For now, do all work in the (WINDOW, NULL) upperrel */
    window_rel = fetch_upper_rel(root, UPPERREL_WINDOW, NULL);
 
    /*
     * If the input relation is not parallel-safe, then the window relation
     * can't be parallel-safe, either.  Otherwise, we need to examine the
     * target list and active windows for non-parallel-safe constructs.
     */
    if (input_rel->consider_parallel && output_target_parallel_safe &&
        is_parallel_safe(root, (Node *) activeWindows))
        window_rel->consider_parallel = true;
 
    /*
     * If the input rel belongs to a single FDW, so does the window rel.
     */
    window_rel->serverid = input_rel->serverid;
    window_rel->userid = input_rel->userid;
    window_rel->useridiscurrent = input_rel->useridiscurrent;
    window_rel->fdwroutine = input_rel->fdwroutine;
 
    /*
     * Consider computing window functions starting from the existing
     * cheapest-total path (which will likely require a sort) as well as any
     * existing paths that satisfy or partially satisfy root->window_pathkeys.
     */
    foreach(lc, input_rel->pathlist)
    {
        Path       *path = (Path *) lfirst(lc);
        int         presorted_keys;
 
        if (path == input_rel->cheapest_total_path ||
            pathkeys_count_contained_in(root->window_pathkeys, path->pathkeys,
                                        &presorted_keys) ||
            presorted_keys > 0)
            create_one_window_path(root,
                                   window_rel,
                                   path,
                                   input_target,
                                   output_target,
                                   wflists,
                                   activeWindows);
    }
 
    /*
     * If there is an FDW that's responsible for all baserels of the query,
     * let it consider adding ForeignPaths.
     */
    if (window_rel->fdwroutine &&
        window_rel->fdwroutine->GetForeignUpperPaths)
        window_rel->fdwroutine->GetForeignUpperPaths(root, UPPERREL_WINDOW,
                                                     input_rel, window_rel,
                                                     NULL);
 
    /* Let extensions possibly add some more paths */
    if (create_upper_paths_hook)
        (*create_upper_paths_hook) (root, UPPERREL_WINDOW,
                                    input_rel, window_rel, NULL);
 
    /* Now choose the best path(s) */
    set_cheapest(window_rel);
 
    return window_rel;
}

References RelOptInfo::cheapest_total_path, RelOptInfo::consider_parallel, create_one_window_path(), create_upper_paths_hook, fetch_upper_rel(), is_parallel_safe(), lfirst, Path::pathkeys, pathkeys_count_contained_in(), RelOptInfo::pathlist, RelOptInfo::serverid, set_cheapest(), UPPERREL_WINDOW, RelOptInfo::userid, RelOptInfo::useridiscurrent, and PlannerInfo::window_pathkeys.

Referenced by grouping_planner().

expression_planner()

Expr* expression_planner

(

Expr *

expr

)

Definition at line 6434 of file planner.c.

{
    Node       *result;
 
    /*
     * Convert named-argument function calls, insert default arguments and
     * simplify constant subexprs
     */
    result = eval_const_expressions(NULL, (Node *) expr);
 
    /* Fill in opfuncid values if missing */
    fix_opfuncids(result);
 
    return (Expr *) result;
}

References eval_const_expressions(), and fix_opfuncids().

Referenced by ATExecAddColumn(), ATPrepAlterColumnType(), BeginCopyFrom(), CheckMutability(), ComputePartitionAttrs(), ExecPrepareCheck(), ExecPrepareExpr(), ExecPrepareQual(), load_domaintype_info(), set_baserel_partition_constraint(), slot_fill_defaults(), StoreAttrDefault(), and transformPartitionBoundValue().

expression_planner_with_deps()

Expr* expression_planner_with_deps	(	Expr *	expr,
		List **	relationOids,
		List **	invalItems
	)

Definition at line 6461 of file planner.c.

{
    Node       *result;
    PlannerGlobal glob;
    PlannerInfo root;
 
    /* Make up dummy planner state so we can use setrefs machinery */
    MemSet(&glob, 0, sizeof(glob));
    glob.type = T_PlannerGlobal;
    glob.relationOids = NIL;
    glob.invalItems = NIL;
 
    MemSet(&root, 0, sizeof(root));
    root.type = T_PlannerInfo;
    root.glob = &glob;
 
    /*
     * Convert named-argument function calls, insert default arguments and
     * simplify constant subexprs.  Collect identities of inlined functions
     * and elided domains, too.
     */
    result = eval_const_expressions(&root, (Node *) expr);
 
    /* Fill in opfuncid values if missing */
    fix_opfuncids(result);
 
    /*
     * Now walk the finished expression to find anything else we ought to
     * record as an expression dependency.
     */
    (void) extract_query_dependencies_walker(result, &root);
 
    *relationOids = glob.relationOids;
    *invalItems = glob.invalItems;
 
    return (Expr *) result;
}

References eval_const_expressions(), extract_query_dependencies_walker(), fix_opfuncids(), PlannerInfo::glob, PlannerGlobal::invalItems, MemSet, NIL, and PlannerGlobal::relationOids.

Referenced by GetCachedExpression().

extract_rollup_sets()

static List * extract_rollup_sets ( List *  groupingSets )

static

Definition at line 2913 of file planner.c.

{
    int         num_sets_raw = list_length(groupingSets);
    int         num_empty = 0;
    int         num_sets = 0;   /* distinct sets */
    int         num_chains = 0;
    List       *result = NIL;
    List      **results;
    List      **orig_sets;
    Bitmapset **set_masks;
    int        *chains;
    short     **adjacency;
    short      *adjacency_buf;
    BipartiteMatchState *state;
    int         i;
    int         j;
    int         j_size;
    ListCell   *lc1 = list_head(groupingSets);
    ListCell   *lc;
 
    /*
     * Start by stripping out empty sets.  The algorithm doesn't require this,
     * but the planner currently needs all empty sets to be returned in the
     * first list, so we strip them here and add them back after.
     */
    while (lc1 && lfirst(lc1) == NIL)
    {
        ++num_empty;
        lc1 = lnext(groupingSets, lc1);
    }
 
    /* bail out now if it turns out that all we had were empty sets. */
    if (!lc1)
        return list_make1(groupingSets);
 
    /*----------
     * We don't strictly need to remove duplicate sets here, but if we don't,
     * they tend to become scattered through the result, which is a bit
     * confusing (and irritating if we ever decide to optimize them out).
     * So we remove them here and add them back after.
     *
     * For each non-duplicate set, we fill in the following:
     *
     * orig_sets[i] = list of the original set lists
     * set_masks[i] = bitmapset for testing inclusion
     * adjacency[i] = array [n, v1, v2, ... vn] of adjacency indices
     *
     * chains[i] will be the result group this set is assigned to.
     *
     * We index all of these from 1 rather than 0 because it is convenient
     * to leave 0 free for the NIL node in the graph algorithm.
     *----------
     */
    orig_sets = palloc0((num_sets_raw + 1) * sizeof(List *));
    set_masks = palloc0((num_sets_raw + 1) * sizeof(Bitmapset *));
    adjacency = palloc0((num_sets_raw + 1) * sizeof(short *));
    adjacency_buf = palloc((num_sets_raw + 1) * sizeof(short));
 
    j_size = 0;
    j = 0;
    i = 1;
 
    for_each_cell(lc, groupingSets, lc1)
    {
        List       *candidate = (List *) lfirst(lc);
        Bitmapset  *candidate_set = NULL;
        ListCell   *lc2;
        int         dup_of = 0;
 
        foreach(lc2, candidate)
        {
            candidate_set = bms_add_member(candidate_set, lfirst_int(lc2));
        }
 
        /* we can only be a dup if we're the same length as a previous set */
        if (j_size == list_length(candidate))
        {
            int         k;
 
            for (k = j; k < i; ++k)
            {
                if (bms_equal(set_masks[k], candidate_set))
                {
                    dup_of = k;
                    break;
                }
            }
        }
        else if (j_size < list_length(candidate))
        {
            j_size = list_length(candidate);
            j = i;
        }
 
        if (dup_of > 0)
        {
            orig_sets[dup_of] = lappend(orig_sets[dup_of], candidate);
            bms_free(candidate_set);
        }
        else
        {
            int         k;
            int         n_adj = 0;
 
            orig_sets[i] = list_make1(candidate);
            set_masks[i] = candidate_set;
 
            /* fill in adjacency list; no need to compare equal-size sets */
 
            for (k = j - 1; k > 0; --k)
            {
                if (bms_is_subset(set_masks[k], candidate_set))
                    adjacency_buf[++n_adj] = k;
            }
 
            if (n_adj > 0)
            {
                adjacency_buf[0] = n_adj;
                adjacency[i] = palloc((n_adj + 1) * sizeof(short));
                memcpy(adjacency[i], adjacency_buf, (n_adj + 1) * sizeof(short));
            }
            else
                adjacency[i] = NULL;
 
            ++i;
        }
    }
 
    num_sets = i - 1;
 
    /*
     * Apply the graph matching algorithm to do the work.
     */
    state = BipartiteMatch(num_sets, num_sets, adjacency);
 
    /*
     * Now, the state->pair* fields have the info we need to assign sets to
     * chains. Two sets (u,v) belong to the same chain if pair_uv[u] = v or
     * pair_vu[v] = u (both will be true, but we check both so that we can do
     * it in one pass)
     */
    chains = palloc0((num_sets + 1) * sizeof(int));
 
    for (i = 1; i <= num_sets; ++i)
    {
        int         u = state->pair_vu[i];
        int         v = state->pair_uv[i];
 
        if (u > 0 && u < i)
            chains[i] = chains[u];
        else if (v > 0 && v < i)
            chains[i] = chains[v];
        else
            chains[i] = ++num_chains;
    }
 
    /* build result lists. */
    results = palloc0((num_chains + 1) * sizeof(List *));
 
    for (i = 1; i <= num_sets; ++i)
    {
        int         c = chains[i];
 
        Assert(c > 0);
 
        results[c] = list_concat(results[c], orig_sets[i]);
    }
 
    /* push any empty sets back on the first list. */
    while (num_empty-- > 0)
        results[1] = lcons(NIL, results[1]);
 
    /* make result list */
    for (i = 1; i <= num_chains; ++i)
        result = lappend(result, results[i]);
 
    /*
     * Free all the things.
     *
     * (This is over-fussy for small sets but for large sets we could have
     * tied up a nontrivial amount of memory.)
     */
    BipartiteMatchFree(state);
    pfree(results);
    pfree(chains);
    for (i = 1; i <= num_sets; ++i)
        if (adjacency[i])
            pfree(adjacency[i]);
    pfree(adjacency);
    pfree(adjacency_buf);
    pfree(orig_sets);
    for (i = 1; i <= num_sets; ++i)
        bms_free(set_masks[i]);
    pfree(set_masks);
 
    return result;
}

References Assert(), BipartiteMatch(), BipartiteMatchFree(), bms_add_member(), bms_equal(), bms_free(), bms_is_subset(), for_each_cell, i, j, lappend(), lcons(), lfirst, lfirst_int, list_concat(), list_head(), list_length(), list_make1, lnext(), NIL, palloc(), palloc0(), and pfree().

Referenced by preprocess_grouping_sets().

gather_grouping_paths()

static void gather_grouping_paths ( PlannerInfo *  root, RelOptInfo *  rel  )

static

Definition at line 7354 of file planner.c.

{
    ListCell   *lc;
    Path       *cheapest_partial_path;
 
    /* Try Gather for unordered paths and Gather Merge for ordered ones. */
    generate_useful_gather_paths(root, rel, true);
 
    /* Try cheapest partial path + explicit Sort + Gather Merge. */
    cheapest_partial_path = linitial(rel->partial_pathlist);
    if (!pathkeys_contained_in(root->group_pathkeys,
                               cheapest_partial_path->pathkeys))
    {
        Path       *path;
        double      total_groups;
 
        total_groups =
            cheapest_partial_path->rows * cheapest_partial_path->parallel_workers;
        path = (Path *) create_sort_path(root, rel, cheapest_partial_path,
                                         root->group_pathkeys,
                                         -1.0);
        path = (Path *)
            create_gather_merge_path(root,
                                     rel,
                                     path,
                                     rel->reltarget,
                                     root->group_pathkeys,
                                     NULL,
                                     &total_groups);
 
        add_path(rel, path);
    }
 
    /*
     * Consider incremental sort on all partial paths, if enabled.
     *
     * We can also skip the entire loop when we only have a single-item
     * group_pathkeys because then we can't possibly have a presorted prefix
     * of the list without having the list be fully sorted.
     */
    if (!enable_incremental_sort || list_length(root->group_pathkeys) == 1)
        return;
 
    /* also consider incremental sort on partial paths, if enabled */
    foreach(lc, rel->partial_pathlist)
    {
        Path       *path = (Path *) lfirst(lc);
        bool        is_sorted;
        int         presorted_keys;
        double      total_groups;
 
        is_sorted = pathkeys_count_contained_in(root->group_pathkeys,
                                                path->pathkeys,
                                                &presorted_keys);
 
        if (is_sorted)
            continue;
 
        if (presorted_keys == 0)
            continue;
 
        path = (Path *) create_incremental_sort_path(root,
                                                     rel,
                                                     path,
                                                     root->group_pathkeys,
                                                     presorted_keys,
                                                     -1.0);
 
        path = (Path *)
            create_gather_merge_path(root,
                                     rel,
                                     path,
                                     rel->reltarget,
                                     root->group_pathkeys,
                                     NULL,
                                     &total_groups);
 
        add_path(rel, path);
    }
}

References add_path(), create_gather_merge_path(), create_incremental_sort_path(), create_sort_path(), enable_incremental_sort, generate_useful_gather_paths(), PlannerInfo::group_pathkeys, lfirst, linitial, list_length(), Path::parallel_workers, RelOptInfo::partial_pathlist, Path::pathkeys, pathkeys_contained_in(), pathkeys_count_contained_in(), RelOptInfo::reltarget, and Path::rows.

Referenced by add_paths_to_grouping_rel(), and create_ordinary_grouping_paths().

get_cheapest_fractional_path()

Path* get_cheapest_fractional_path	(	RelOptInfo *	rel,
		double	tuple_fraction
	)

Definition at line 6275 of file planner.c.

{
    Path       *best_path = rel->cheapest_total_path;
    ListCell   *l;
 
    /* If all tuples will be retrieved, just return the cheapest-total path */
    if (tuple_fraction <= 0.0)
        return best_path;
 
    /* Convert absolute # of tuples to a fraction; no need to clamp to 0..1 */
    if (tuple_fraction >= 1.0 && best_path->rows > 0)
        tuple_fraction /= best_path->rows;
 
    foreach(l, rel->pathlist)
    {
        Path       *path = (Path *) lfirst(l);
 
        if (path == rel->cheapest_total_path ||
            compare_fractional_path_costs(best_path, path, tuple_fraction) <= 0)
            continue;
 
        best_path = path;
    }
 
    return best_path;
}

References RelOptInfo::cheapest_total_path, compare_fractional_path_costs(), lfirst, RelOptInfo::pathlist, and Path::rows.

Referenced by make_subplan(), recurse_set_operations(), and standard_planner().

get_number_of_groups()

static double get_number_of_groups ( PlannerInfo *  root, double  path_rows, grouping_sets_data *  gd, List *  target_list  )

static

Definition at line 3556 of file planner.c.

{
    Query      *parse = root->parse;
    double      dNumGroups;
 
    if (parse->groupClause)
    {
        List       *groupExprs;
 
        if (parse->groupingSets)
        {
            /* Add up the estimates for each grouping set */
            ListCell   *lc;
 
            Assert(gd);         /* keep Coverity happy */
 
            dNumGroups = 0;
 
            foreach(lc, gd->rollups)
            {
                RollupData *rollup = lfirst_node(RollupData, lc);
                ListCell   *lc2;
                ListCell   *lc3;
 
                groupExprs = get_sortgrouplist_exprs(rollup->groupClause,
                                                     target_list);
 
                rollup->numGroups = 0.0;
 
                forboth(lc2, rollup->gsets, lc3, rollup->gsets_data)
                {
                    List       *gset = (List *) lfirst(lc2);
                    GroupingSetData *gs = lfirst_node(GroupingSetData, lc3);
                    double      numGroups = estimate_num_groups(root,
                                                                groupExprs,
                                                                path_rows,
                                                                &gset,
                                                                NULL);
 
                    gs->numGroups = numGroups;
                    rollup->numGroups += numGroups;
                }
 
                dNumGroups += rollup->numGroups;
            }
 
            if (gd->hash_sets_idx)
            {
                ListCell   *lc2;
 
                gd->dNumHashGroups = 0;
 
                groupExprs = get_sortgrouplist_exprs(parse->groupClause,
                                                     target_list);
 
                forboth(lc, gd->hash_sets_idx, lc2, gd->unsortable_sets)
                {
                    List       *gset = (List *) lfirst(lc);
                    GroupingSetData *gs = lfirst_node(GroupingSetData, lc2);
                    double      numGroups = estimate_num_groups(root,
                                                                groupExprs,
                                                                path_rows,
                                                                &gset,
                                                                NULL);
 
                    gs->numGroups = numGroups;
                    gd->dNumHashGroups += numGroups;
                }
 
                dNumGroups += gd->dNumHashGroups;
            }
        }
        else
        {
            /* Plain GROUP BY -- estimate based on optimized groupClause */
            groupExprs = get_sortgrouplist_exprs(root->processed_groupClause,
                                                 target_list);
 
            dNumGroups = estimate_num_groups(root, groupExprs, path_rows,
                                             NULL, NULL);
        }
    }
    else if (parse->groupingSets)
    {
        /* Empty grouping sets ... one result row for each one */
        dNumGroups = list_length(parse->groupingSets);
    }
    else if (parse->hasAggs || root->hasHavingQual)
    {
        /* Plain aggregation, one result row */
        dNumGroups = 1;
    }
    else
    {
        /* Not grouping */
        dNumGroups = 1;
    }
 
    return dNumGroups;
}

References Assert(), grouping_sets_data::dNumHashGroups, estimate_num_groups(), forboth, get_sortgrouplist_exprs(), RollupData::groupClause, RollupData::gsets, RollupData::gsets_data, grouping_sets_data::hash_sets_idx, PlannerInfo::hasHavingQual, lfirst, lfirst_node, list_length(), GroupingSetData::numGroups, RollupData::numGroups, parse(), PlannerInfo::parse, PlannerInfo::processed_groupClause, grouping_sets_data::rollups, and grouping_sets_data::unsortable_sets.

Referenced by create_ordinary_grouping_paths(), and create_partial_grouping_paths().

group_by_has_partkey()

static bool group_by_has_partkey ( RelOptInfo *  input_rel, List *  targetList, List *  groupClause  )

static

Definition at line 7863 of file planner.c.

{
    List       *groupexprs = get_sortgrouplist_exprs(groupClause, targetList);
    int         cnt = 0;
    int         partnatts;
 
    /* Input relation should be partitioned. */
    Assert(input_rel->part_scheme);
 
    /* Rule out early, if there are no partition keys present. */
    if (!input_rel->partexprs)
        return false;
 
    partnatts = input_rel->part_scheme->partnatts;
 
    for (cnt = 0; cnt < partnatts; cnt++)
    {
        List       *partexprs = input_rel->partexprs[cnt];
        ListCell   *lc;
        bool        found = false;
 
        foreach(lc, partexprs)
        {
            Expr       *partexpr = lfirst(lc);
 
            if (list_member(groupexprs, partexpr))
            {
                found = true;
                break;
            }
        }
 
        /*
         * If none of the partition key expressions match with any of the
         * GROUP BY expression, return false.
         */
        if (!found)
            return false;
    }
 
    return true;
}

References Assert(), get_sortgrouplist_exprs(), lfirst, and list_member().

Referenced by create_ordinary_grouping_paths().

grouping_planner()

static void grouping_planner ( PlannerInfo *  root, double  tuple_fraction  )

static

Definition at line 1274 of file planner.c.

{
    Query      *parse = root->parse;
    int64       offset_est = 0;
    int64       count_est = 0;
    double      limit_tuples = -1.0;
    bool        have_postponed_srfs = false;
    PathTarget *final_target;
    List       *final_targets;
    List       *final_targets_contain_srfs;
    bool        final_target_parallel_safe;
    RelOptInfo *current_rel;
    RelOptInfo *final_rel;
    FinalPathExtraData extra;
    ListCell   *lc;
 
    /* Tweak caller-supplied tuple_fraction if have LIMIT/OFFSET */
    if (parse->limitCount || parse->limitOffset)
    {
        tuple_fraction = preprocess_limit(root, tuple_fraction,
                                          &offset_est, &count_est);
 
        /*
         * If we have a known LIMIT, and don't have an unknown OFFSET, we can
         * estimate the effects of using a bounded sort.
         */
        if (count_est > 0 && offset_est >= 0)
            limit_tuples = (double) count_est + (double) offset_est;
    }
 
    /* Make tuple_fraction accessible to lower-level routines */
    root->tuple_fraction = tuple_fraction;
 
    if (parse->setOperations)
    {
        /*
         * If there's a top-level ORDER BY, assume we have to fetch all the
         * tuples.  This might be too simplistic given all the hackery below
         * to possibly avoid the sort; but the odds of accurate estimates here
         * are pretty low anyway.  XXX try to get rid of this in favor of
         * letting plan_set_operations generate both fast-start and
         * cheapest-total paths.
         */
        if (parse->sortClause)
            root->tuple_fraction = 0.0;
 
        /*
         * Construct Paths for set operations.  The results will not need any
         * work except perhaps a top-level sort and/or LIMIT.  Note that any
         * special work for recursive unions is the responsibility of
         * plan_set_operations.
         */
        current_rel = plan_set_operations(root);
 
        /*
         * We should not need to call preprocess_targetlist, since we must be
         * in a SELECT query node.  Instead, use the processed_tlist returned
         * by plan_set_operations (since this tells whether it returned any
         * resjunk columns!), and transfer any sort key information from the
         * original tlist.
         */
        Assert(parse->commandType == CMD_SELECT);
 
        /* for safety, copy processed_tlist instead of modifying in-place */
        root->processed_tlist =
            postprocess_setop_tlist(copyObject(root->processed_tlist),
                                    parse->targetList);
 
        /* Also extract the PathTarget form of the setop result tlist */
        final_target = current_rel->cheapest_total_path->pathtarget;
 
        /* And check whether it's parallel safe */
        final_target_parallel_safe =
            is_parallel_safe(root, (Node *) final_target->exprs);
 
        /* The setop result tlist couldn't contain any SRFs */
        Assert(!parse->hasTargetSRFs);
        final_targets = final_targets_contain_srfs = NIL;
 
        /*
         * Can't handle FOR [KEY] UPDATE/SHARE here (parser should have
         * checked already, but let's make sure).
         */
        if (parse->rowMarks)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
            /*------
              translator: %s is a SQL row locking clause such as FOR UPDATE */
                     errmsg("%s is not allowed with UNION/INTERSECT/EXCEPT",
                            LCS_asString(linitial_node(RowMarkClause,
                                                       parse->rowMarks)->strength))));
 
        /*
         * Calculate pathkeys that represent result ordering requirements
         */
        Assert(parse->distinctClause == NIL);
        root->sort_pathkeys = make_pathkeys_for_sortclauses(root,
                                                            parse->sortClause,
                                                            root->processed_tlist);
    }
    else
    {
        /* No set operations, do regular planning */
        PathTarget *sort_input_target;
        List       *sort_input_targets;
        List       *sort_input_targets_contain_srfs;
        bool        sort_input_target_parallel_safe;
        PathTarget *grouping_target;
        List       *grouping_targets;
        List       *grouping_targets_contain_srfs;
        bool        grouping_target_parallel_safe;
        PathTarget *scanjoin_target;
        List       *scanjoin_targets;
        List       *scanjoin_targets_contain_srfs;
        bool        scanjoin_target_parallel_safe;
        bool        scanjoin_target_same_exprs;
        bool        have_grouping;
        WindowFuncLists *wflists = NULL;
        List       *activeWindows = NIL;
        grouping_sets_data *gset_data = NULL;
        standard_qp_extra qp_extra;
 
        /* A recursive query should always have setOperations */
        Assert(!root->hasRecursion);
 
        /* Preprocess grouping sets and GROUP BY clause, if any */
        if (parse->groupingSets)
        {
            gset_data = preprocess_grouping_sets(root);
        }
        else if (parse->groupClause)
        {
            /* Preprocess regular GROUP BY clause, if any */
            root->processed_groupClause = preprocess_groupclause(root, NIL);
            /* Remove any redundant GROUP BY columns */
            remove_useless_groupby_columns(root);
        }
 
        /*
         * Preprocess targetlist.  Note that much of the remaining planning
         * work will be done with the PathTarget representation of tlists, but
         * we must also maintain the full representation of the final tlist so
         * that we can transfer its decoration (resnames etc) to the topmost
         * tlist of the finished Plan.  This is kept in processed_tlist.
         */
        preprocess_targetlist(root);
 
        /*
         * Mark all the aggregates with resolved aggtranstypes, and detect
         * aggregates that are duplicates or can share transition state.  We
         * must do this before slicing and dicing the tlist into various
         * pathtargets, else some copies of the Aggref nodes might escape
         * being marked.
         */
        if (parse->hasAggs)
        {
            preprocess_aggrefs(root, (Node *) root->processed_tlist);
            preprocess_aggrefs(root, (Node *) parse->havingQual);
        }
 
        /*
         * Locate any window functions in the tlist.  (We don't need to look
         * anywhere else, since expressions used in ORDER BY will be in there
         * too.)  Note that they could all have been eliminated by constant
         * folding, in which case we don't need to do any more work.
         */
        if (parse->hasWindowFuncs)
        {
            wflists = find_window_functions((Node *) root->processed_tlist,
                                            list_length(parse->windowClause));
            if (wflists->numWindowFuncs > 0)
            {
                /*
                 * See if any modifications can be made to each WindowClause
                 * to allow the executor to execute the WindowFuncs more
                 * quickly.
                 */
                optimize_window_clauses(root, wflists);
 
                activeWindows = select_active_windows(root, wflists);
            }
            else
                parse->hasWindowFuncs = false;
        }
 
        /*
         * Preprocess MIN/MAX aggregates, if any.  Note: be careful about
         * adding logic between here and the query_planner() call.  Anything
         * that is needed in MIN/MAX-optimizable cases will have to be
         * duplicated in planagg.c.
         */
        if (parse->hasAggs)
            preprocess_minmax_aggregates(root);
 
        /*
         * Figure out whether there's a hard limit on the number of rows that
         * query_planner's result subplan needs to return.  Even if we know a
         * hard limit overall, it doesn't apply if the query has any
         * grouping/aggregation operations, or SRFs in the tlist.
         */
        if (parse->groupClause ||
            parse->groupingSets ||
            parse->distinctClause ||
            parse->hasAggs ||
            parse->hasWindowFuncs ||
            parse->hasTargetSRFs ||
            root->hasHavingQual)
            root->limit_tuples = -1.0;
        else
            root->limit_tuples = limit_tuples;
 
        /* Set up data needed by standard_qp_callback */
        qp_extra.activeWindows = activeWindows;
        qp_extra.gset_data = gset_data;
 
        /*
         * Generate the best unsorted and presorted paths for the scan/join
         * portion of this Query, ie the processing represented by the
         * FROM/WHERE clauses.  (Note there may not be any presorted paths.)
         * We also generate (in standard_qp_callback) pathkey representations
         * of the query's sort clause, distinct clause, etc.
         */
        current_rel = query_planner(root, standard_qp_callback, &qp_extra);
 
        /*
         * Convert the query's result tlist into PathTarget format.
         *
         * Note: this cannot be done before query_planner() has performed
         * appendrel expansion, because that might add resjunk entries to
         * root->processed_tlist.  Waiting till afterwards is also helpful
         * because the target width estimates can use per-Var width numbers
         * that were obtained within query_planner().
         */
        final_target = create_pathtarget(root, root->processed_tlist);
        final_target_parallel_safe =
            is_parallel_safe(root, (Node *) final_target->exprs);
 
        /*
         * If ORDER BY was given, consider whether we should use a post-sort
         * projection, and compute the adjusted target for preceding steps if
         * so.
         */
        if (parse->sortClause)
        {
            sort_input_target = make_sort_input_target(root,
                                                       final_target,
                                                       &have_postponed_srfs);
            sort_input_target_parallel_safe =
                is_parallel_safe(root, (Node *) sort_input_target->exprs);
        }
        else
        {
            sort_input_target = final_target;
            sort_input_target_parallel_safe = final_target_parallel_safe;
        }
 
        /*
         * If we have window functions to deal with, the output from any
         * grouping step needs to be what the window functions want;
         * otherwise, it should be sort_input_target.
         */
        if (activeWindows)
        {
            grouping_target = make_window_input_target(root,
                                                       final_target,
                                                       activeWindows);
            grouping_target_parallel_safe =
                is_parallel_safe(root, (Node *) grouping_target->exprs);
        }
        else
        {
            grouping_target = sort_input_target;
            grouping_target_parallel_safe = sort_input_target_parallel_safe;
        }
 
        /*
         * If we have grouping or aggregation to do, the topmost scan/join
         * plan node must emit what the grouping step wants; otherwise, it
         * should emit grouping_target.
         */
        have_grouping = (parse->groupClause || parse->groupingSets ||
                         parse->hasAggs || root->hasHavingQual);
        if (have_grouping)
        {
            scanjoin_target = make_group_input_target(root, final_target);
            scanjoin_target_parallel_safe =
                is_parallel_safe(root, (Node *) scanjoin_target->exprs);
        }
        else
        {
            scanjoin_target = grouping_target;
            scanjoin_target_parallel_safe = grouping_target_parallel_safe;
        }
 
        /*
         * If there are any SRFs in the targetlist, we must separate each of
         * these PathTargets into SRF-computing and SRF-free targets.  Replace
         * each of the named targets with a SRF-free version, and remember the
         * list of additional projection steps we need to add afterwards.
         */
        if (parse->hasTargetSRFs)
        {
            /* final_target doesn't recompute any SRFs in sort_input_target */
            split_pathtarget_at_srfs(root, final_target, sort_input_target,
                                     &final_targets,
                                     &final_targets_contain_srfs);
            final_target = linitial_node(PathTarget, final_targets);
            Assert(!linitial_int(final_targets_contain_srfs));
            /* likewise for sort_input_target vs. grouping_target */
            split_pathtarget_at_srfs(root, sort_input_target, grouping_target,
                                     &sort_input_targets,
                                     &sort_input_targets_contain_srfs);
            sort_input_target = linitial_node(PathTarget, sort_input_targets);
            Assert(!linitial_int(sort_input_targets_contain_srfs));
            /* likewise for grouping_target vs. scanjoin_target */
            split_pathtarget_at_srfs(root, grouping_target, scanjoin_target,
                                     &grouping_targets,
                                     &grouping_targets_contain_srfs);
            grouping_target = linitial_node(PathTarget, grouping_targets);
            Assert(!linitial_int(grouping_targets_contain_srfs));
            /* scanjoin_target will not have any SRFs precomputed for it */
            split_pathtarget_at_srfs(root, scanjoin_target, NULL,
                                     &scanjoin_targets,
                                     &scanjoin_targets_contain_srfs);
            scanjoin_target = linitial_node(PathTarget, scanjoin_targets);
            Assert(!linitial_int(scanjoin_targets_contain_srfs));
        }
        else
        {
            /* initialize lists; for most of these, dummy values are OK */
            final_targets = final_targets_contain_srfs = NIL;
            sort_input_targets = sort_input_targets_contain_srfs = NIL;
            grouping_targets = grouping_targets_contain_srfs = NIL;
            scanjoin_targets = list_make1(scanjoin_target);
            scanjoin_targets_contain_srfs = NIL;
        }
 
        /* Apply scan/join target. */
        scanjoin_target_same_exprs = list_length(scanjoin_targets) == 1
            && equal(scanjoin_target->exprs, current_rel->reltarget->exprs);
        apply_scanjoin_target_to_paths(root, current_rel, scanjoin_targets,
                                       scanjoin_targets_contain_srfs,
                                       scanjoin_target_parallel_safe,
                                       scanjoin_target_same_exprs);
 
        /*
         * Save the various upper-rel PathTargets we just computed into
         * root->upper_targets[].  The core code doesn't use this, but it
         * provides a convenient place for extensions to get at the info.  For
         * consistency, we save all the intermediate targets, even though some
         * of the corresponding upperrels might not be needed for this query.
         */
        root->upper_targets[UPPERREL_FINAL] = final_target;
        root->upper_targets[UPPERREL_ORDERED] = final_target;
        root->upper_targets[UPPERREL_PARTIAL_DISTINCT] = sort_input_target;
        root->upper_targets[UPPERREL_DISTINCT] = sort_input_target;
        root->upper_targets[UPPERREL_WINDOW] = sort_input_target;
        root->upper_targets[UPPERREL_GROUP_AGG] = grouping_target;
 
        /*
         * If we have grouping and/or aggregation, consider ways to implement
         * that.  We build a new upperrel representing the output of this
         * phase.
         */
        if (have_grouping)
        {
            current_rel = create_grouping_paths(root,
                                                current_rel,
                                                grouping_target,
                                                grouping_target_parallel_safe,
                                                gset_data);
            /* Fix things up if grouping_target contains SRFs */
            if (parse->hasTargetSRFs)
                adjust_paths_for_srfs(root, current_rel,
                                      grouping_targets,
                                      grouping_targets_contain_srfs);
        }
 
        /*
         * If we have window functions, consider ways to implement those.  We
         * build a new upperrel representing the output of this phase.
         */
        if (activeWindows)
        {
            current_rel = create_window_paths(root,
                                              current_rel,
                                              grouping_target,
                                              sort_input_target,
                                              sort_input_target_parallel_safe,
                                              wflists,
                                              activeWindows);
            /* Fix things up if sort_input_target contains SRFs */
            if (parse->hasTargetSRFs)
                adjust_paths_for_srfs(root, current_rel,
                                      sort_input_targets,
                                      sort_input_targets_contain_srfs);
        }
 
        /*
         * If there is a DISTINCT clause, consider ways to implement that. We
         * build a new upperrel representing the output of this phase.
         */
        if (parse->distinctClause)
        {
            current_rel = create_distinct_paths(root,
                                                current_rel);
        }
    }                           /* end of if (setOperations) */
 
    /*
     * If ORDER BY was given, consider ways to implement that, and generate a
     * new upperrel containing only paths that emit the correct ordering and
     * project the correct final_target.  We can apply the original
     * limit_tuples limit in sort costing here, but only if there are no
     * postponed SRFs.
     */
    if (parse->sortClause)
    {
        current_rel = create_ordered_paths(root,
                                           current_rel,
                                           final_target,
                                           final_target_parallel_safe,
                                           have_postponed_srfs ? -1.0 :
                                           limit_tuples);
        /* Fix things up if final_target contains SRFs */
        if (parse->hasTargetSRFs)
            adjust_paths_for_srfs(root, current_rel,
                                  final_targets,
                                  final_targets_contain_srfs);
    }
 
    /*
     * Now we are prepared to build the final-output upperrel.
     */
    final_rel = fetch_upper_rel(root, UPPERREL_FINAL, NULL);
 
    /*
     * If the input rel is marked consider_parallel and there's nothing that's
     * not parallel-safe in the LIMIT clause, then the final_rel can be marked
     * consider_parallel as well.  Note that if the query has rowMarks or is
     * not a SELECT, consider_parallel will be false for every relation in the
     * query.
     */
    if (current_rel->consider_parallel &&
        is_parallel_safe(root, parse->limitOffset) &&
        is_parallel_safe(root, parse->limitCount))
        final_rel->consider_parallel = true;
 
    /*
     * If the current_rel belongs to a single FDW, so does the final_rel.
     */
    final_rel->serverid = current_rel->serverid;
    final_rel->userid = current_rel->userid;
    final_rel->useridiscurrent = current_rel->useridiscurrent;
    final_rel->fdwroutine = current_rel->fdwroutine;
 
    /*
     * Generate paths for the final_rel.  Insert all surviving paths, with
     * LockRows, Limit, and/or ModifyTable steps added if needed.
     */
    foreach(lc, current_rel->pathlist)
    {
        Path       *path = (Path *) lfirst(lc);
 
        /*
         * If there is a FOR [KEY] UPDATE/SHARE clause, add the LockRows node.
         * (Note: we intentionally test parse->rowMarks not root->rowMarks
         * here.  If there are only non-locking rowmarks, they should be
         * handled by the ModifyTable node instead.  However, root->rowMarks
         * is what goes into the LockRows node.)
         */
        if (parse->rowMarks)
        {
            path = (Path *) create_lockrows_path(root, final_rel, path,
                                                 root->rowMarks,
                                                 assign_special_exec_param(root));
        }
 
        /*
         * If there is a LIMIT/OFFSET clause, add the LIMIT node.
         */
        if (limit_needed(parse))
        {
            path = (Path *) create_limit_path(root, final_rel, path,
                                              parse->limitOffset,
                                              parse->limitCount,
                                              parse->limitOption,
                                              offset_est, count_est);
        }
 
        /*
         * If this is an INSERT/UPDATE/DELETE/MERGE, add the ModifyTable node.
         */
        if (parse->commandType != CMD_SELECT)
        {
            Index       rootRelation;
            List       *resultRelations = NIL;
            List       *updateColnosLists = NIL;
            List       *withCheckOptionLists = NIL;
            List       *returningLists = NIL;
            List       *mergeActionLists = NIL;
            List       *rowMarks;
 
            if (bms_membership(root->all_result_relids) == BMS_MULTIPLE)
            {
                /* Inherited UPDATE/DELETE/MERGE */
                RelOptInfo *top_result_rel = find_base_rel(root,
                                                           parse->resultRelation);
                int         resultRelation = -1;
 
                /* Add only leaf children to ModifyTable. */
                while ((resultRelation = bms_next_member(root->leaf_result_relids,
                                                         resultRelation)) >= 0)
                {
                    RelOptInfo *this_result_rel = find_base_rel(root,
                                                                resultRelation);
 
                    /*
                     * Also exclude any leaf rels that have turned dummy since
                     * being added to the list, for example, by being excluded
                     * by constraint exclusion.
                     */
                    if (IS_DUMMY_REL(this_result_rel))
                        continue;
 
                    /* Build per-target-rel lists needed by ModifyTable */
                    resultRelations = lappend_int(resultRelations,
                                                  resultRelation);
                    if (parse->commandType == CMD_UPDATE)
                    {
                        List       *update_colnos = root->update_colnos;
 
                        if (this_result_rel != top_result_rel)
                            update_colnos =
                                adjust_inherited_attnums_multilevel(root,
                                                                    update_colnos,
                                                                    this_result_rel->relid,
                                                                    top_result_rel->relid);
                        updateColnosLists = lappend(updateColnosLists,
                                                    update_colnos);
                    }
                    if (parse->withCheckOptions)
                    {
                        List       *withCheckOptions = parse->withCheckOptions;
 
                        if (this_result_rel != top_result_rel)
                            withCheckOptions = (List *)
                                adjust_appendrel_attrs_multilevel(root,
                                                                  (Node *) withCheckOptions,
                                                                  this_result_rel,
                                                                  top_result_rel);
                        withCheckOptionLists = lappend(withCheckOptionLists,
                                                       withCheckOptions);
                    }
                    if (parse->returningList)
                    {
                        List       *returningList = parse->returningList;
 
                        if (this_result_rel != top_result_rel)
                            returningList = (List *)
                                adjust_appendrel_attrs_multilevel(root,
                                                                  (Node *) returningList,
                                                                  this_result_rel,
                                                                  top_result_rel);
                        returningLists = lappend(returningLists,
                                                 returningList);
                    }
                    if (parse->mergeActionList)
                    {
                        ListCell   *l;
                        List       *mergeActionList = NIL;
 
                        /*
                         * Copy MergeActions and translate stuff that
                         * references attribute numbers.
                         */
                        foreach(l, parse->mergeActionList)
                        {
                            MergeAction *action = lfirst(l),
                                       *leaf_action = copyObject(action);
 
                            leaf_action->qual =
                                adjust_appendrel_attrs_multilevel(root,
                                                                  (Node *) action->qual,
                                                                  this_result_rel,
                                                                  top_result_rel);
                            leaf_action->targetList = (List *)
                                adjust_appendrel_attrs_multilevel(root,
                                                                  (Node *) action->targetList,
                                                                  this_result_rel,
                                                                  top_result_rel);
                            if (leaf_action->commandType == CMD_UPDATE)
                                leaf_action->updateColnos =
                                    adjust_inherited_attnums_multilevel(root,
                                                                        action->updateColnos,
                                                                        this_result_rel->relid,
                                                                        top_result_rel->relid);
                            mergeActionList = lappend(mergeActionList,
                                                      leaf_action);
                        }
 
                        mergeActionLists = lappend(mergeActionLists,
                                                   mergeActionList);
                    }
                }
 
                if (resultRelations == NIL)
                {
                    /*
                     * We managed to exclude every child rel, so generate a
                     * dummy one-relation plan using info for the top target
                     * rel (even though that may not be a leaf target).
                     * Although it's clear that no data will be updated or
                     * deleted, we still need to have a ModifyTable node so
                     * that any statement triggers will be executed.  (This
                     * could be cleaner if we fixed nodeModifyTable.c to allow
                     * zero target relations, but that probably wouldn't be a
                     * net win.)
                     */
                    resultRelations = list_make1_int(parse->resultRelation);
                    if (parse->commandType == CMD_UPDATE)
                        updateColnosLists = list_make1(root->update_colnos);
                    if (parse->withCheckOptions)
                        withCheckOptionLists = list_make1(parse->withCheckOptions);
                    if (parse->returningList)
                        returningLists = list_make1(parse->returningList);
                    if (parse->mergeActionList)
                        mergeActionLists = list_make1(parse->mergeActionList);
                }
            }
            else
            {
                /* Single-relation INSERT/UPDATE/DELETE/MERGE. */
                resultRelations = list_make1_int(parse->resultRelation);
                if (parse->commandType == CMD_UPDATE)
                    updateColnosLists = list_make1(root->update_colnos);
                if (parse->withCheckOptions)
                    withCheckOptionLists = list_make1(parse->withCheckOptions);
                if (parse->returningList)
                    returningLists = list_make1(parse->returningList);
                if (parse->mergeActionList)
                    mergeActionLists = list_make1(parse->mergeActionList);
            }
 
            /*
             * If target is a partition root table, we need to mark the
             * ModifyTable node appropriately for that.
             */
            if (rt_fetch(parse->resultRelation, parse->rtable)->relkind ==
                RELKIND_PARTITIONED_TABLE)
                rootRelation = parse->resultRelation;
            else
                rootRelation = 0;
 
            /*
             * If there was a FOR [KEY] UPDATE/SHARE clause, the LockRows node
             * will have dealt with fetching non-locked marked rows, else we
             * need to have ModifyTable do that.
             */
            if (parse->rowMarks)
                rowMarks = NIL;
            else
                rowMarks = root->rowMarks;
 
            path = (Path *)
                create_modifytable_path(root, final_rel,
                                        path,
                                        parse->commandType,
                                        parse->canSetTag,
                                        parse->resultRelation,
                                        rootRelation,
                                        root->partColsUpdated,
                                        resultRelations,
                                        updateColnosLists,
                                        withCheckOptionLists,
                                        returningLists,
                                        rowMarks,
                                        parse->onConflict,
                                        mergeActionLists,
                                        assign_special_exec_param(root));
        }
 
        /* And shove it into final_rel */
        add_path(final_rel, path);
    }
 
    /*
     * Generate partial paths for final_rel, too, if outer query levels might
     * be able to make use of them.
     */
    if (final_rel->consider_parallel && root->query_level > 1 &&
        !limit_needed(parse))
    {
        Assert(!parse->rowMarks && parse->commandType == CMD_SELECT);
        foreach(lc, current_rel->partial_pathlist)
        {
            Path       *partial_path = (Path *) lfirst(lc);
 
            add_partial_path(final_rel, partial_path);
        }
    }
 
    extra.limit_needed = limit_needed(parse);
    extra.limit_tuples = limit_tuples;
    extra.count_est = count_est;
    extra.offset_est = offset_est;
 
    /*
     * If there is an FDW that's responsible for all baserels of the query,
     * let it consider adding ForeignPaths.
     */
    if (final_rel->fdwroutine &&
        final_rel->fdwroutine->GetForeignUpperPaths)
        final_rel->fdwroutine->GetForeignUpperPaths(root, UPPERREL_FINAL,
                                                    current_rel, final_rel,
                                                    &extra);
 
    /* Let extensions possibly add some more paths */
    if (create_upper_paths_hook)
        (*create_upper_paths_hook) (root, UPPERREL_FINAL,
                                    current_rel, final_rel, &extra);
 
    /* Note: currently, we leave it to callers to do set_cheapest() */
}

References generate_unaccent_rules::action, standard_qp_extra::activeWindows, add_partial_path(), add_path(), adjust_appendrel_attrs_multilevel(), adjust_inherited_attnums_multilevel(), adjust_paths_for_srfs(), PlannerInfo::all_result_relids, apply_scanjoin_target_to_paths(), Assert(), assign_special_exec_param(), bms_membership(), BMS_MULTIPLE, bms_next_member(), RelOptInfo::cheapest_total_path, CMD_SELECT, CMD_UPDATE, RelOptInfo::consider_parallel, copyObject, FinalPathExtraData::count_est, create_distinct_paths(), create_grouping_paths(), create_limit_path(), create_lockrows_path(), create_modifytable_path(), create_ordered_paths(), create_pathtarget, create_upper_paths_hook, create_window_paths(), equal(), ereport, errcode(), errmsg(), ERROR, PathTarget::exprs, fetch_upper_rel(), find_base_rel(), find_window_functions(), standard_qp_extra::gset_data, PlannerInfo::hasHavingQual, PlannerInfo::hasRecursion, IS_DUMMY_REL, is_parallel_safe(), lappend(), lappend_int(), LCS_asString(), PlannerInfo::leaf_result_relids, lfirst, limit_needed(), FinalPathExtraData::limit_needed, PlannerInfo::limit_tuples, FinalPathExtraData::limit_tuples, linitial_int, linitial_node, list_length(), list_make1, list_make1_int, make_group_input_target(), make_pathkeys_for_sortclauses(), make_sort_input_target(), make_window_input_target(), NIL, WindowFuncLists::numWindowFuncs, FinalPathExtraData::offset_est, optimize_window_clauses(), parse(), PlannerInfo::parse, PlannerInfo::partColsUpdated, RelOptInfo::partial_pathlist, RelOptInfo::pathlist, plan_set_operations(), postprocess_setop_tlist(), preprocess_aggrefs(), preprocess_groupclause(), preprocess_grouping_sets(), preprocess_limit(), preprocess_minmax_aggregates(), preprocess_targetlist(), PlannerInfo::processed_groupClause, PlannerInfo::processed_tlist, PlannerInfo::query_level, query_planner(), RelOptInfo::relid, RelOptInfo::reltarget, remove_useless_groupby_columns(), PlannerInfo::rowMarks, rt_fetch, select_active_windows(), RelOptInfo::serverid, PlannerInfo::sort_pathkeys, split_pathtarget_at_srfs(), standard_qp_callback(), PlannerInfo::tuple_fraction, PlannerInfo::update_colnos, UPPERREL_DISTINCT, UPPERREL_FINAL, UPPERREL_GROUP_AGG, UPPERREL_ORDERED, UPPERREL_PARTIAL_DISTINCT, UPPERREL_WINDOW, RelOptInfo::userid, and RelOptInfo::useridiscurrent.

Referenced by subquery_planner().

has_volatile_pathkey()

static bool has_volatile_pathkey ( List *  keys )

static

Definition at line 3173 of file planner.c.

{
    ListCell   *lc;
 
    foreach(lc, keys)
    {
        PathKey    *pathkey = lfirst_node(PathKey, lc);
 
        if (pathkey->pk_eclass->ec_has_volatile)
            return true;
    }
 
    return false;
}

References lfirst_node.

Referenced by adjust_group_pathkeys_for_groupagg().

is_degenerate_grouping()

static bool is_degenerate_grouping ( PlannerInfo *  root )

static

Definition at line 3844 of file planner.c.

{
    Query      *parse = root->parse;
 
    return (root->hasHavingQual || parse->groupingSets) &&
        !parse->hasAggs && parse->groupClause == NIL;
}

References PlannerInfo::hasHavingQual, NIL, parse(), and PlannerInfo::parse.

Referenced by create_grouping_paths().

limit_needed()

bool limit_needed

(

Query *

parse

)

Definition at line 2586 of file planner.c.

{
    Node       *node;
 
    node = parse->limitCount;
    if (node)
    {
        if (IsA(node, Const))
        {
            /* NULL indicates LIMIT ALL, ie, no limit */
            if (!((Const *) node)->constisnull)
                return true;    /* LIMIT with a constant value */
        }
        else
            return true;        /* non-constant LIMIT */
    }
 
    node = parse->limitOffset;
    if (node)
    {
        if (IsA(node, Const))
        {
            /* Treat NULL as no offset; the executor would too */
            if (!((Const *) node)->constisnull)
            {
                int64       offset = DatumGetInt64(((Const *) node)->constvalue);
 
                if (offset != 0)
                    return true;    /* OFFSET with a nonzero value */
            }
        }
        else
            return true;        /* non-constant OFFSET */
    }
 
    return false;               /* don't need a Limit plan node */
}

References DatumGetInt64(), IsA, and parse().

Referenced by grouping_planner(), and set_rel_consider_parallel().

make_group_input_target()

static PathTarget * make_group_input_target ( PlannerInfo *  root, PathTarget *  final_target  )

static

Definition at line 5333 of file planner.c.

{
    Query      *parse = root->parse;
    PathTarget *input_target;
    List       *non_group_cols;
    List       *non_group_vars;
    int         i;
    ListCell   *lc;
 
    /*
     * We must build a target containing all grouping columns, plus any other
     * Vars mentioned in the query's targetlist and HAVING qual.
     */
    input_target = create_empty_pathtarget();
    non_group_cols = NIL;
 
    i = 0;
    foreach(lc, final_target->exprs)
    {
        Expr       *expr = (Expr *) lfirst(lc);
        Index       sgref = get_pathtarget_sortgroupref(final_target, i);
 
        if (sgref && root->processed_groupClause &&
            get_sortgroupref_clause_noerr(sgref,
                                          root->processed_groupClause) != NULL)
        {
            /*
             * It's a grouping column, so add it to the input target as-is.
             */
            add_column_to_pathtarget(input_target, expr, sgref);
        }
        else
        {
            /*
             * Non-grouping column, so just remember the expression for later
             * call to pull_var_clause.
             */
            non_group_cols = lappend(non_group_cols, expr);
        }
 
        i++;
    }
 
    /*
     * If there's a HAVING clause, we'll need the Vars it uses, too.
     */
    if (parse->havingQual)
        non_group_cols = lappend(non_group_cols, parse->havingQual);
 
    /*
     * Pull out all the Vars mentioned in non-group cols (plus HAVING), and
     * add them to the input target if not already present.  (A Var used
     * directly as a GROUP BY item will be present already.)  Note this
     * includes Vars used in resjunk items, so we are covering the needs of
     * ORDER BY and window specifications.  Vars used within Aggrefs and
     * WindowFuncs will be pulled out here, too.
     */
    non_group_vars = pull_var_clause((Node *) non_group_cols,
                                     PVC_RECURSE_AGGREGATES |
                                     PVC_RECURSE_WINDOWFUNCS |
                                     PVC_INCLUDE_PLACEHOLDERS);
    add_new_columns_to_pathtarget(input_target, non_group_vars);
 
    /* clean up cruft */
    list_free(non_group_vars);
    list_free(non_group_cols);
 
    /* XXX this causes some redundant cost calculation ... */
    return set_pathtarget_cost_width(root, input_target);
}

References add_column_to_pathtarget(), add_new_columns_to_pathtarget(), create_empty_pathtarget(), PathTarget::exprs, get_pathtarget_sortgroupref, get_sortgroupref_clause_noerr(), i, lappend(), lfirst, list_free(), NIL, parse(), PlannerInfo::parse, PlannerInfo::processed_groupClause, pull_var_clause(), PVC_INCLUDE_PLACEHOLDERS, PVC_RECURSE_AGGREGATES, PVC_RECURSE_WINDOWFUNCS, and set_pathtarget_cost_width().

Referenced by grouping_planner().

make_grouping_rel()

static RelOptInfo * make_grouping_rel ( PlannerInfo *  root, RelOptInfo *  input_rel, PathTarget *  target, bool  target_parallel_safe, Node *  havingQual  )

static

Definition at line 3791 of file planner.c.

{
    RelOptInfo *grouped_rel;
 
    if (IS_OTHER_REL(input_rel))
    {
        grouped_rel = fetch_upper_rel(root, UPPERREL_GROUP_AGG,
                                      input_rel->relids);
        grouped_rel->reloptkind = RELOPT_OTHER_UPPER_REL;
    }
    else
    {
        /*
         * By tradition, the relids set for the main grouping relation is
         * NULL.  (This could be changed, but might require adjustments
         * elsewhere.)
         */
        grouped_rel = fetch_upper_rel(root, UPPERREL_GROUP_AGG, NULL);
    }
 
    /* Set target. */
    grouped_rel->reltarget = target;
 
    /*
     * If the input relation is not parallel-safe, then the grouped relation
     * can't be parallel-safe, either.  Otherwise, it's parallel-safe if the
     * target list and HAVING quals are parallel-safe.
     */
    if (input_rel->consider_parallel && target_parallel_safe &&
        is_parallel_safe(root, (Node *) havingQual))
        grouped_rel->consider_parallel = true;
 
    /*
     * If the input rel belongs to a single FDW, so does the grouped rel.
     */
    grouped_rel->serverid = input_rel->serverid;
    grouped_rel->userid = input_rel->userid;
    grouped_rel->useridiscurrent = input_rel->useridiscurrent;
    grouped_rel->fdwroutine = input_rel->fdwroutine;
 
    return grouped_rel;
}

References RelOptInfo::consider_parallel, fetch_upper_rel(), IS_OTHER_REL, is_parallel_safe(), RelOptInfo::relids, RELOPT_OTHER_UPPER_REL, RelOptInfo::reloptkind, RelOptInfo::reltarget, RelOptInfo::serverid, UPPERREL_GROUP_AGG, RelOptInfo::userid, and RelOptInfo::useridiscurrent.

Referenced by create_grouping_paths(), and create_partitionwise_grouping_paths().

make_partial_grouping_target()

static PathTarget * make_partial_grouping_target ( PlannerInfo *  root, PathTarget *  grouping_target, Node *  havingQual  )

static

Definition at line 5421 of file planner.c.

{
    PathTarget *partial_target;
    List       *non_group_cols;
    List       *non_group_exprs;
    int         i;
    ListCell   *lc;
 
    partial_target = create_empty_pathtarget();
    non_group_cols = NIL;
 
    i = 0;
    foreach(lc, grouping_target->exprs)
    {
        Expr       *expr = (Expr *) lfirst(lc);
        Index       sgref = get_pathtarget_sortgroupref(grouping_target, i);
 
        if (sgref && root->processed_groupClause &&
            get_sortgroupref_clause_noerr(sgref,
                                          root->processed_groupClause) != NULL)
        {
            /*
             * It's a grouping column, so add it to the partial_target as-is.
             * (This allows the upper agg step to repeat the grouping calcs.)
             */
            add_column_to_pathtarget(partial_target, expr, sgref);
        }
        else
        {
            /*
             * Non-grouping column, so just remember the expression for later
             * call to pull_var_clause.
             */
            non_group_cols = lappend(non_group_cols, expr);
        }
 
        i++;
    }
 
    /*
     * If there's a HAVING clause, we'll need the Vars/Aggrefs it uses, too.
     */
    if (havingQual)
        non_group_cols = lappend(non_group_cols, havingQual);
 
    /*
     * Pull out all the Vars, PlaceHolderVars, and Aggrefs mentioned in
     * non-group cols (plus HAVING), and add them to the partial_target if not
     * already present.  (An expression used directly as a GROUP BY item will
     * be present already.)  Note this includes Vars used in resjunk items, so
     * we are covering the needs of ORDER BY and window specifications.
     */
    non_group_exprs = pull_var_clause((Node *) non_group_cols,
                                      PVC_INCLUDE_AGGREGATES |
                                      PVC_RECURSE_WINDOWFUNCS |
                                      PVC_INCLUDE_PLACEHOLDERS);
 
    add_new_columns_to_pathtarget(partial_target, non_group_exprs);
 
    /*
     * Adjust Aggrefs to put them in partial mode.  At this point all Aggrefs
     * are at the top level of the target list, so we can just scan the list
     * rather than recursing through the expression trees.
     */
    foreach(lc, partial_target->exprs)
    {
        Aggref     *aggref = (Aggref *) lfirst(lc);
 
        if (IsA(aggref, Aggref))
        {
            Aggref     *newaggref;
 
            /*
             * We shouldn't need to copy the substructure of the Aggref node,
             * but flat-copy the node itself to avoid damaging other trees.
             */
            newaggref = makeNode(Aggref);
            memcpy(newaggref, aggref, sizeof(Aggref));
 
            /* For now, assume serialization is required */
            mark_partial_aggref(newaggref, AGGSPLIT_INITIAL_SERIAL);
 
            lfirst(lc) = newaggref;
        }
    }
 
    /* clean up cruft */
    list_free(non_group_exprs);
    list_free(non_group_cols);
 
    /* XXX this causes some redundant cost calculation ... */
    return set_pathtarget_cost_width(root, partial_target);
}

References add_column_to_pathtarget(), add_new_columns_to_pathtarget(), AGGSPLIT_INITIAL_SERIAL, create_empty_pathtarget(), PathTarget::exprs, get_pathtarget_sortgroupref, get_sortgroupref_clause_noerr(), i, IsA, lappend(), lfirst, list_free(), makeNode, mark_partial_aggref(), NIL, PlannerInfo::processed_groupClause, pull_var_clause(), PVC_INCLUDE_AGGREGATES, PVC_INCLUDE_PLACEHOLDERS, PVC_RECURSE_WINDOWFUNCS, and set_pathtarget_cost_width().

Referenced by create_partial_grouping_paths().

make_pathkeys_for_window()

static List * make_pathkeys_for_window ( PlannerInfo *  root, WindowClause *  wc, List *  tlist  )

static

Definition at line 6010 of file planner.c.

{
    List       *window_pathkeys;
    List       *window_sortclauses;
 
    /* Throw error if can't sort */
    if (!grouping_is_sortable(wc->partitionClause))
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("could not implement window PARTITION BY"),
                 errdetail("Window partitioning columns must be of sortable datatypes.")));
    if (!grouping_is_sortable(wc->orderClause))
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("could not implement window ORDER BY"),
                 errdetail("Window ordering columns must be of sortable datatypes.")));
 
    /* Okay, make the combined pathkeys */
    window_sortclauses = list_concat_copy(wc->partitionClause, wc->orderClause);
    window_pathkeys = make_pathkeys_for_sortclauses(root,
                                                    window_sortclauses,
                                                    tlist);
    list_free(window_sortclauses);
    return window_pathkeys;
}

References ereport, errcode(), errdetail(), errmsg(), ERROR, grouping_is_sortable(), list_concat_copy(), list_free(), make_pathkeys_for_sortclauses(), WindowClause::orderClause, and WindowClause::partitionClause.

Referenced by create_one_window_path(), and standard_qp_callback().

make_sort_input_target()

static PathTarget * make_sort_input_target ( PlannerInfo *  root, PathTarget *  final_target, bool *  have_postponed_srfs  )

static

Definition at line 6104 of file planner.c.

{
    Query      *parse = root->parse;
    PathTarget *input_target;
    int         ncols;
    bool       *col_is_srf;
    bool       *postpone_col;
    bool        have_srf;
    bool        have_volatile;
    bool        have_expensive;
    bool        have_srf_sortcols;
    bool        postpone_srfs;
    List       *postponable_cols;
    List       *postponable_vars;
    int         i;
    ListCell   *lc;
 
    /* Shouldn't get here unless query has ORDER BY */
    Assert(parse->sortClause);
 
    *have_postponed_srfs = false;   /* default result */
 
    /* Inspect tlist and collect per-column information */
    ncols = list_length(final_target->exprs);
    col_is_srf = (bool *) palloc0(ncols * sizeof(bool));
    postpone_col = (bool *) palloc0(ncols * sizeof(bool));
    have_srf = have_volatile = have_expensive = have_srf_sortcols = false;
 
    i = 0;
    foreach(lc, final_target->exprs)
    {
        Expr       *expr = (Expr *) lfirst(lc);
 
        /*
         * If the column has a sortgroupref, assume it has to be evaluated
         * before sorting.  Generally such columns would be ORDER BY, GROUP
         * BY, etc targets.  One exception is columns that were removed from
         * GROUP BY by remove_useless_groupby_columns() ... but those would
         * only be Vars anyway.  There don't seem to be any cases where it
         * would be worth the trouble to double-check.
         */
        if (get_pathtarget_sortgroupref(final_target, i) == 0)
        {
            /*
             * Check for SRF or volatile functions.  Check the SRF case first
             * because we must know whether we have any postponed SRFs.
             */
            if (parse->hasTargetSRFs &&
                expression_returns_set((Node *) expr))
            {
                /* We'll decide below whether these are postponable */
                col_is_srf[i] = true;
                have_srf = true;
            }
            else if (contain_volatile_functions((Node *) expr))
            {
                /* Unconditionally postpone */
                postpone_col[i] = true;
                have_volatile = true;
            }
            else
            {
                /*
                 * Else check the cost.  XXX it's annoying to have to do this
                 * when set_pathtarget_cost_width() just did it.  Refactor to
                 * allow sharing the work?
                 */
                QualCost    cost;
 
                cost_qual_eval_node(&cost, (Node *) expr, root);
 
                /*
                 * We arbitrarily define "expensive" as "more than 10X
                 * cpu_operator_cost".  Note this will take in any PL function
                 * with default cost.
                 */
                if (cost.per_tuple > 10 * cpu_operator_cost)
                {
                    postpone_col[i] = true;
                    have_expensive = true;
                }
            }
        }
        else
        {
            /* For sortgroupref cols, just check if any contain SRFs */
            if (!have_srf_sortcols &&
                parse->hasTargetSRFs &&
                expression_returns_set((Node *) expr))
                have_srf_sortcols = true;
        }
 
        i++;
    }
 
    /*
     * We can postpone SRFs if we have some but none are in sortgroupref cols.
     */
    postpone_srfs = (have_srf && !have_srf_sortcols);
 
    /*
     * If we don't need a post-sort projection, just return final_target.
     */
    if (!(postpone_srfs || have_volatile ||
          (have_expensive &&
           (parse->limitCount || root->tuple_fraction > 0))))
        return final_target;
 
    /*
     * Report whether the post-sort projection will contain set-returning
     * functio