optimizer.h File Reference

#include "nodes/parsenodes.h"

Include dependency graph for optimizer.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	HAVE_PLANNERINFO_TYPEDEF   1
#define	HAVE_INDEXOPTINFO_TYPEDEF   1
#define	HAVE_SPECIALJOININFO_TYPEDEF   1
#define	PVC_INCLUDE_AGGREGATES   0x0001 /* include Aggrefs in output list */
#define	PVC_RECURSE_AGGREGATES   0x0002 /* recurse into Aggref arguments */
#define	PVC_INCLUDE_WINDOWFUNCS   0x0004 /* include WindowFuncs in output list */
#define	PVC_RECURSE_WINDOWFUNCS   0x0008 /* recurse into WindowFunc arguments */
#define	PVC_INCLUDE_PLACEHOLDERS
#define	PVC_RECURSE_PLACEHOLDERS
#define	PVC_INCLUDE_CONVERTROWTYPES

Typedefs
typedef struct PlannerInfo	PlannerInfo
typedef struct IndexOptInfo	IndexOptInfo
typedef struct SpecialJoinInfo	SpecialJoinInfo

Enumerations
enum	DebugParallelMode { DEBUG_PARALLEL_OFF , DEBUG_PARALLEL_ON , DEBUG_PARALLEL_REGRESS }

Functions
Selectivity	clause_selectivity (PlannerInfo *root, Node *clause, int varRelid, JoinType jointype, SpecialJoinInfo *sjinfo)
Selectivity	clause_selectivity_ext (PlannerInfo *root, Node *clause, int varRelid, JoinType jointype, SpecialJoinInfo *sjinfo, bool use_extended_stats)
Selectivity	clauselist_selectivity (PlannerInfo *root, List *clauses, int varRelid, JoinType jointype, SpecialJoinInfo *sjinfo)
Selectivity	clauselist_selectivity_ext (PlannerInfo *root, List *clauses, int varRelid, JoinType jointype, SpecialJoinInfo *sjinfo, bool use_extended_stats)
double	clamp_row_est (double nrows)
int32	clamp_width_est (int64 tuple_width)
long	clamp_cardinality_to_long (Cardinality x)
bool	is_pseudo_constant_for_index (PlannerInfo *root, Node *expr, IndexOptInfo *index)
struct PlannedStmt *	planner (Query *parse, const char *query_string, int cursorOptions, struct ParamListInfoData *boundParams)
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)
void	extract_query_dependencies (Node *query, List **relationOids, List **invalItems, bool *hasRowSecurity)
Node *	negate_clause (Node *node)
Expr *	canonicalize_qual (Expr *qual, bool is_check)
bool	contain_mutable_functions (Node *clause)
bool	contain_mutable_functions_after_planning (Expr *expr)
bool	contain_volatile_functions (Node *clause)
bool	contain_volatile_functions_after_planning (Expr *expr)
bool	contain_volatile_functions_not_nextval (Node *clause)
Node *	eval_const_expressions (PlannerInfo *root, Node *node)
void	convert_saop_to_hashed_saop (Node *node)
Node *	estimate_expression_value (PlannerInfo *root, Node *node)
Expr *	evaluate_expr (Expr *expr, Oid result_type, int32 result_typmod, Oid result_collation)
List *	expand_function_arguments (List *args, bool include_out_arguments, Oid result_type, struct HeapTupleData *func_tuple)
ScalarArrayOpExpr *	make_SAOP_expr (Oid oper, Node *leftexpr, Oid coltype, Oid arraycollid, Oid inputcollid, List *exprs, bool haveNonConst)
bool	predicate_implied_by (List *predicate_list, List *clause_list, bool weak)
bool	predicate_refuted_by (List *predicate_list, List *clause_list, bool weak)
int	count_nonjunk_tlist_entries (List *tlist)
TargetEntry *	get_sortgroupref_tle (Index sortref, List *targetList)
TargetEntry *	get_sortgroupclause_tle (SortGroupClause *sgClause, List *targetList)
Node *	get_sortgroupclause_expr (SortGroupClause *sgClause, List *targetList)
List *	get_sortgrouplist_exprs (List *sgClauses, List *targetList)
SortGroupClause *	get_sortgroupref_clause (Index sortref, List *clauses)
SortGroupClause *	get_sortgroupref_clause_noerr (Index sortref, List *clauses)
Bitmapset *	pull_varnos (PlannerInfo *root, Node *node)
Bitmapset *	pull_varnos_of_level (PlannerInfo *root, Node *node, int levelsup)
void	pull_varattnos (Node *node, Index varno, Bitmapset **varattnos)
List *	pull_vars_of_level (Node *node, int levelsup)
bool	contain_var_clause (Node *node)
bool	contain_vars_of_level (Node *node, int levelsup)
bool	contain_vars_returning_old_or_new (Node *node)
int	locate_var_of_level (Node *node, int levelsup)
List *	pull_var_clause (Node *node, int flags)
Node *	flatten_join_alias_vars (PlannerInfo *root, Query *query, Node *node)
Node *	flatten_group_exprs (PlannerInfo *root, Query *query, Node *node)

Variables
PGDLLIMPORT double	seq_page_cost
PGDLLIMPORT double	random_page_cost
PGDLLIMPORT double	cpu_tuple_cost
PGDLLIMPORT double	cpu_index_tuple_cost
PGDLLIMPORT double	cpu_operator_cost
PGDLLIMPORT double	parallel_tuple_cost
PGDLLIMPORT double	parallel_setup_cost
PGDLLIMPORT double	recursive_worktable_factor
PGDLLIMPORT int	effective_cache_size
PGDLLIMPORT int	debug_parallel_query
PGDLLIMPORT bool	parallel_leader_participation
PGDLLIMPORT bool	enable_distinct_reordering

Macro Definition Documentation

HAVE_INDEXOPTINFO_TYPEDEF

#define HAVE_INDEXOPTINFO_TYPEDEF   1

Definition at line 41 of file optimizer.h.

HAVE_PLANNERINFO_TYPEDEF

#define HAVE_PLANNERINFO_TYPEDEF   1

Definition at line 35 of file optimizer.h.

HAVE_SPECIALJOININFO_TYPEDEF

#define HAVE_SPECIALJOININFO_TYPEDEF   1

Definition at line 45 of file optimizer.h.

PVC_INCLUDE_AGGREGATES

#define PVC_INCLUDE_AGGREGATES   0x0001 /* include Aggrefs in output list */

Definition at line 192 of file optimizer.h.

PVC_INCLUDE_CONVERTROWTYPES

#define PVC_INCLUDE_CONVERTROWTYPES

Value:

                                             0x0040 /* include ConvertRowtypeExprs in
                                             * output list */

Definition at line 198 of file optimizer.h.

PVC_INCLUDE_PLACEHOLDERS

#define PVC_INCLUDE_PLACEHOLDERS

Value:

                                             0x0010 /* include PlaceHolderVars in
                                             * output list */

Definition at line 196 of file optimizer.h.

PVC_INCLUDE_WINDOWFUNCS

#define PVC_INCLUDE_WINDOWFUNCS   0x0004 /* include WindowFuncs in output list */

Definition at line 194 of file optimizer.h.

PVC_RECURSE_AGGREGATES

#define PVC_RECURSE_AGGREGATES   0x0002 /* recurse into Aggref arguments */

Definition at line 193 of file optimizer.h.

PVC_RECURSE_PLACEHOLDERS

#define PVC_RECURSE_PLACEHOLDERS

Value:

                                             0x0020 /* recurse into PlaceHolderVar
                                             * arguments */

Definition at line 197 of file optimizer.h.

PVC_RECURSE_WINDOWFUNCS

#define PVC_RECURSE_WINDOWFUNCS   0x0008 /* recurse into WindowFunc arguments */

Definition at line 195 of file optimizer.h.

Typedef Documentation

IndexOptInfo

typedef struct IndexOptInfo IndexOptInfo

Definition at line 40 of file optimizer.h.

PlannerInfo

typedef struct PlannerInfo PlannerInfo

Definition at line 34 of file optimizer.h.

SpecialJoinInfo

typedef struct SpecialJoinInfo SpecialJoinInfo

Definition at line 44 of file optimizer.h.

Enumeration Type Documentation

DebugParallelMode

enum DebugParallelMode

Enumerator
DEBUG_PARALLEL_OFF
DEBUG_PARALLEL_ON
DEBUG_PARALLEL_REGRESS

Definition at line 104 of file optimizer.h.

{
    DEBUG_PARALLEL_OFF,
    DEBUG_PARALLEL_ON,
    DEBUG_PARALLEL_REGRESS,
}           DebugParallelMode;

Function Documentation

canonicalize_qual()

Expr * canonicalize_qual	(	Expr *	qual,
		bool	is_check
	)

Definition at line 293 of file prepqual.c.

{
    Expr       *newqual;
 
    /* Quick exit for empty qual */
    if (qual == NULL)
        return NULL;
 
    /* This should not be invoked on quals in implicit-AND format */
    Assert(!IsA(qual, List));
 
    /*
     * Pull up redundant subclauses in OR-of-AND trees.  We do this only
     * within the top-level AND/OR structure; there's no point in looking
     * deeper.  Also remove any NULL constants in the top-level structure.
     */
    newqual = find_duplicate_ors(qual, is_check);
 
    return newqual;
}

References Assert(), find_duplicate_ors(), and IsA.

Referenced by ConstraintImpliedByRelConstraint(), convert_EXISTS_to_ANY(), DoCopy(), get_proposed_default_constraint(), get_relation_constraints(), preprocess_expression(), and RelationGetIndexPredicate().

clamp_cardinality_to_long()

long clamp_cardinality_to_long

(

Cardinality

x

)

Definition at line 265 of file costsize.c.

{
    /*
     * Just for paranoia's sake, ensure we do something sane with negative or
     * NaN values.
     */
    if (isnan(x))
        return LONG_MAX;
    if (x <= 0)
        return 0;
 
    /*
     * If "long" is 64 bits, then LONG_MAX cannot be represented exactly as a
     * double.  Casting it to double and back may well result in overflow due
     * to rounding, so avoid doing that.  We trust that any double value that
     * compares strictly less than "(double) LONG_MAX" will cast to a
     * representable "long" value.
     */
    return (x < (double) LONG_MAX) ? (long) x : LONG_MAX;
}

References x.

Referenced by buildSubPlanHash(), create_recursiveunion_plan(), create_setop_plan(), and make_agg().

clamp_row_est()

double clamp_row_est

(

double

nrows

)

Definition at line 213 of file costsize.c.

{
    /*
     * Avoid infinite and NaN row estimates.  Costs derived from such values
     * are going to be useless.  Also force the estimate to be at least one
     * row, to make explain output look better and to avoid possible
     * divide-by-zero when interpolating costs.  Make it an integer, too.
     */
    if (nrows > MAXIMUM_ROWCOUNT || isnan(nrows))
        nrows = MAXIMUM_ROWCOUNT;
    else if (nrows <= 1.0)
        nrows = 1.0;
    else
        nrows = rint(nrows);
 
    return nrows;
}

References MAXIMUM_ROWCOUNT.

Referenced by adjust_limit_rows_costs(), approx_tuple_count(), bernoulli_samplescangetsamplesize(), calc_joinrel_size_estimate(), compute_bitmap_pages(), compute_gather_rows(), cost_agg(), cost_append(), cost_bitmap_heap_scan(), cost_group(), cost_index(), cost_seqscan(), cost_subplan(), cost_subqueryscan(), create_bitmap_subplan(), create_memoize_path(), estimate_array_length(), estimate_hash_bucket_stats(), estimate_num_groups(), estimate_path_cost_size(), estimate_size(), expression_returns_set_rows(), final_cost_hashjoin(), final_cost_mergejoin(), final_cost_nestloop(), get_parameterized_baserel_size(), get_variable_numdistinct(), get_windowclause_startup_tuples(), initial_cost_mergejoin(), set_baserel_size_estimates(), set_cte_size_estimates(), set_foreign_size(), system_rows_samplescangetsamplesize(), system_samplescangetsamplesize(), system_time_samplescangetsamplesize(), and table_block_relation_estimate_size().

clamp_width_est()

int32 clamp_width_est

(

int64

tuple_width

)

Definition at line 242 of file costsize.c.

{
    /*
     * Anything more than MaxAllocSize is clearly bogus, since we could not
     * create a tuple that large.
     */
    if (tuple_width > MaxAllocSize)
        return (int32) MaxAllocSize;
 
    /*
     * Unlike clamp_row_est, we just Assert that the value isn't negative,
     * rather than masking such errors.
     */
    Assert(tuple_width >= 0);
 
    return (int32) tuple_width;
}

References Assert(), and MaxAllocSize.

Referenced by add_placeholders_to_joinrel(), build_joinrel_tlist(), create_one_window_path(), get_rel_data_width(), set_pathtarget_cost_width(), and set_rel_width().

clause_selectivity()

Selectivity clause_selectivity	(	PlannerInfo *	root,
		Node *	clause,
		int	varRelid,
		JoinType	jointype,
		SpecialJoinInfo *	sjinfo
	)

Definition at line 667 of file clausesel.c.

{
    return clause_selectivity_ext(root, clause, varRelid,
                                  jointype, sjinfo, true);
}

References clause_selectivity_ext(), and root.

Referenced by approx_tuple_count(), booltestsel(), consider_new_or_clause(), and get_foreign_key_join_selectivity().

clause_selectivity_ext()

Selectivity clause_selectivity_ext	(	PlannerInfo *	root,
		Node *	clause,
		int	varRelid,
		JoinType	jointype,
		SpecialJoinInfo *	sjinfo,
		bool	use_extended_stats
	)

Definition at line 684 of file clausesel.c.

{
    Selectivity s1 = 0.5;       /* default for any unhandled clause type */
    RestrictInfo *rinfo = NULL;
    bool        cacheable = false;
 
    if (clause == NULL)         /* can this still happen? */
        return s1;
 
    if (IsA(clause, RestrictInfo))
    {
        rinfo = (RestrictInfo *) clause;
 
        /*
         * If the clause is marked pseudoconstant, then it will be used as a
         * gating qual and should not affect selectivity estimates; hence
         * return 1.0.  The only exception is that a constant FALSE may be
         * taken as having selectivity 0.0, since it will surely mean no rows
         * out of the plan.  This case is simple enough that we need not
         * bother caching the result.
         */
        if (rinfo->pseudoconstant)
        {
            if (!IsA(rinfo->clause, Const))
                return (Selectivity) 1.0;
        }
 
        /*
         * If possible, cache the result of the selectivity calculation for
         * the clause.  We can cache if varRelid is zero or the clause
         * contains only vars of that relid --- otherwise varRelid will affect
         * the result, so mustn't cache.  Outer join quals might be examined
         * with either their join's actual jointype or JOIN_INNER, so we need
         * two cache variables to remember both cases.  Note: we assume the
         * result won't change if we are switching the input relations or
         * considering a unique-ified case, so we only need one cache variable
         * for all non-JOIN_INNER cases.
         */
        if (varRelid == 0 ||
            rinfo->num_base_rels == 0 ||
            (rinfo->num_base_rels == 1 &&
             bms_is_member(varRelid, rinfo->clause_relids)))
        {
            /* Cacheable --- do we already have the result? */
            if (jointype == JOIN_INNER)
            {
                if (rinfo->norm_selec >= 0)
                    return rinfo->norm_selec;
            }
            else
            {
                if (rinfo->outer_selec >= 0)
                    return rinfo->outer_selec;
            }
            cacheable = true;
        }
 
        /*
         * Proceed with examination of contained clause.  If the clause is an
         * OR-clause, we want to look at the variant with sub-RestrictInfos,
         * so that per-subclause selectivities can be cached.
         */
        if (rinfo->orclause)
            clause = (Node *) rinfo->orclause;
        else
            clause = (Node *) rinfo->clause;
    }
 
    if (IsA(clause, Var))
    {
        Var        *var = (Var *) clause;
 
        /*
         * We probably shouldn't ever see an uplevel Var here, but if we do,
         * return the default selectivity...
         */
        if (var->varlevelsup == 0 &&
            (varRelid == 0 || varRelid == (int) var->varno))
        {
            /* Use the restriction selectivity function for a bool Var */
            s1 = boolvarsel(root, (Node *) var, varRelid);
        }
    }
    else if (IsA(clause, Const))
    {
        /* bool constant is pretty easy... */
        Const      *con = (Const *) clause;
 
        s1 = con->constisnull ? 0.0 :
            DatumGetBool(con->constvalue) ? 1.0 : 0.0;
    }
    else if (IsA(clause, Param))
    {
        /* see if we can replace the Param */
        Node       *subst = estimate_expression_value(root, clause);
 
        if (IsA(subst, Const))
        {
            /* bool constant is pretty easy... */
            Const      *con = (Const *) subst;
 
            s1 = con->constisnull ? 0.0 :
                DatumGetBool(con->constvalue) ? 1.0 : 0.0;
        }
        else
        {
            /* XXX any way to do better than default? */
        }
    }
    else if (is_notclause(clause))
    {
        /* inverse of the selectivity of the underlying clause */
        s1 = 1.0 - clause_selectivity_ext(root,
                                          (Node *) get_notclausearg((Expr *) clause),
                                          varRelid,
                                          jointype,
                                          sjinfo,
                                          use_extended_stats);
    }
    else if (is_andclause(clause))
    {
        /* share code with clauselist_selectivity() */
        s1 = clauselist_selectivity_ext(root,
                                        ((BoolExpr *) clause)->args,
                                        varRelid,
                                        jointype,
                                        sjinfo,
                                        use_extended_stats);
    }
    else if (is_orclause(clause))
    {
        /*
         * Almost the same thing as clauselist_selectivity, but with the
         * clauses connected by OR.
         */
        s1 = clauselist_selectivity_or(root,
                                       ((BoolExpr *) clause)->args,
                                       varRelid,
                                       jointype,
                                       sjinfo,
                                       use_extended_stats);
    }
    else if (is_opclause(clause) || IsA(clause, DistinctExpr))
    {
        OpExpr     *opclause = (OpExpr *) clause;
        Oid         opno = opclause->opno;
 
        if (treat_as_join_clause(root, clause, rinfo, varRelid, sjinfo))
        {
            /* Estimate selectivity for a join clause. */
            s1 = join_selectivity(root, opno,
                                  opclause->args,
                                  opclause->inputcollid,
                                  jointype,
                                  sjinfo);
        }
        else
        {
            /* Estimate selectivity for a restriction clause. */
            s1 = restriction_selectivity(root, opno,
                                         opclause->args,
                                         opclause->inputcollid,
                                         varRelid);
        }
 
        /*
         * DistinctExpr has the same representation as OpExpr, but the
         * contained operator is "=" not "<>", so we must negate the result.
         * This estimation method doesn't give the right behavior for nulls,
         * but it's better than doing nothing.
         */
        if (IsA(clause, DistinctExpr))
            s1 = 1.0 - s1;
    }
    else if (is_funcclause(clause))
    {
        FuncExpr   *funcclause = (FuncExpr *) clause;
 
        /* Try to get an estimate from the support function, if any */
        s1 = function_selectivity(root,
                                  funcclause->funcid,
                                  funcclause->args,
                                  funcclause->inputcollid,
                                  treat_as_join_clause(root, clause, rinfo,
                                                       varRelid, sjinfo),
                                  varRelid,
                                  jointype,
                                  sjinfo);
    }
    else if (IsA(clause, ScalarArrayOpExpr))
    {
        /* Use node specific selectivity calculation function */
        s1 = scalararraysel(root,
                            (ScalarArrayOpExpr *) clause,
                            treat_as_join_clause(root, clause, rinfo,
                                                 varRelid, sjinfo),
                            varRelid,
                            jointype,
                            sjinfo);
    }
    else if (IsA(clause, RowCompareExpr))
    {
        /* Use node specific selectivity calculation function */
        s1 = rowcomparesel(root,
                           (RowCompareExpr *) clause,
                           varRelid,
                           jointype,
                           sjinfo);
    }
    else if (IsA(clause, NullTest))
    {
        /* Use node specific selectivity calculation function */
        s1 = nulltestsel(root,
                         ((NullTest *) clause)->nulltesttype,
                         (Node *) ((NullTest *) clause)->arg,
                         varRelid,
                         jointype,
                         sjinfo);
    }
    else if (IsA(clause, BooleanTest))
    {
        /* Use node specific selectivity calculation function */
        s1 = booltestsel(root,
                         ((BooleanTest *) clause)->booltesttype,
                         (Node *) ((BooleanTest *) clause)->arg,
                         varRelid,
                         jointype,
                         sjinfo);
    }
    else if (IsA(clause, CurrentOfExpr))
    {
        /* CURRENT OF selects at most one row of its table */
        CurrentOfExpr *cexpr = (CurrentOfExpr *) clause;
        RelOptInfo *crel = find_base_rel(root, cexpr->cvarno);
 
        if (crel->tuples > 0)
            s1 = 1.0 / crel->tuples;
    }
    else if (IsA(clause, RelabelType))
    {
        /* Not sure this case is needed, but it can't hurt */
        s1 = clause_selectivity_ext(root,
                                    (Node *) ((RelabelType *) clause)->arg,
                                    varRelid,
                                    jointype,
                                    sjinfo,
                                    use_extended_stats);
    }
    else if (IsA(clause, CoerceToDomain))
    {
        /* Not sure this case is needed, but it can't hurt */
        s1 = clause_selectivity_ext(root,
                                    (Node *) ((CoerceToDomain *) clause)->arg,
                                    varRelid,
                                    jointype,
                                    sjinfo,
                                    use_extended_stats);
    }
    else
    {
        /*
         * For anything else, see if we can consider it as a boolean variable.
         * This only works if it's an immutable expression in Vars of a single
         * relation; but there's no point in us checking that here because
         * boolvarsel() will do it internally, and return a suitable default
         * selectivity if not.
         */
        s1 = boolvarsel(root, clause, varRelid);
    }
 
    /* Cache the result if possible */
    if (cacheable)
    {
        if (jointype == JOIN_INNER)
            rinfo->norm_selec = s1;
        else
            rinfo->outer_selec = s1;
    }
 
#ifdef SELECTIVITY_DEBUG
    elog(DEBUG4, "clause_selectivity: s1 %f", s1);
#endif                          /* SELECTIVITY_DEBUG */
 
    return s1;
}

References arg, generate_unaccent_rules::args, FuncExpr::args, OpExpr::args, bms_is_member(), booltestsel(), boolvarsel(), RestrictInfo::clause, clause_selectivity_ext(), clauselist_selectivity_ext(), clauselist_selectivity_or(), CurrentOfExpr::cvarno, DatumGetBool(), DEBUG4, elog, estimate_expression_value(), find_base_rel(), FuncExpr::funcid, function_selectivity(), get_notclausearg(), is_andclause(), is_funcclause(), is_notclause(), is_opclause(), is_orclause(), IsA, JOIN_INNER, join_selectivity(), nulltestsel(), OpExpr::opno, restriction_selectivity(), root, rowcomparesel(), s1, scalararraysel(), treat_as_join_clause(), RelOptInfo::tuples, and RangeQueryClause::var.

Referenced by clause_selectivity(), clause_selectivity_ext(), clauselist_selectivity_ext(), clauselist_selectivity_or(), and statext_mcv_clauselist_selectivity().

clauselist_selectivity()

Selectivity clauselist_selectivity	(	PlannerInfo *	root,
		List *	clauses,
		int	varRelid,
		JoinType	jointype,
		SpecialJoinInfo *	sjinfo
	)

Definition at line 100 of file clausesel.c.

{
    return clauselist_selectivity_ext(root, clauses, varRelid,
                                      jointype, sjinfo, true);
}

References clauselist_selectivity_ext(), and root.

Referenced by add_foreign_grouping_paths(), brincostestimate(), btcostestimate(), calc_joinrel_size_estimate(), compute_semi_anti_join_factors(), cost_agg(), cost_group(), cost_subqueryscan(), cost_tidrangescan(), estimate_path_cost_size(), estimate_size(), genericcostestimate(), get_parameterized_baserel_size(), gincostestimate(), postgresGetForeignJoinPaths(), postgresGetForeignRelSize(), and set_baserel_size_estimates().

clauselist_selectivity_ext()

Selectivity clauselist_selectivity_ext	(	PlannerInfo *	root,
		List *	clauses,
		int	varRelid,
		JoinType	jointype,
		SpecialJoinInfo *	sjinfo,
		bool	use_extended_stats
	)

Definition at line 117 of file clausesel.c.

{
    Selectivity s1 = 1.0;
    RelOptInfo *rel;
    Bitmapset  *estimatedclauses = NULL;
    RangeQueryClause *rqlist = NULL;
    ListCell   *l;
    int         listidx;
 
    /*
     * If there's exactly one clause, just go directly to
     * clause_selectivity_ext(). None of what we might do below is relevant.
     */
    if (list_length(clauses) == 1)
        return clause_selectivity_ext(root, (Node *) linitial(clauses),
                                      varRelid, jointype, sjinfo,
                                      use_extended_stats);
 
    /*
     * Determine if these clauses reference a single relation.  If so, and if
     * it has extended statistics, try to apply those.
     */
    rel = find_single_rel_for_clauses(root, clauses);
    if (use_extended_stats && rel && rel->rtekind == RTE_RELATION && rel->statlist != NIL)
    {
        /*
         * Estimate as many clauses as possible using extended statistics.
         *
         * 'estimatedclauses' is populated with the 0-based list position
         * index of clauses estimated here, and that should be ignored below.
         */
        s1 = statext_clauselist_selectivity(root, clauses, varRelid,
                                            jointype, sjinfo, rel,
                                            &estimatedclauses, false);
    }
 
    /*
     * Apply normal selectivity estimates for remaining clauses. We'll be
     * careful to skip any clauses which were already estimated above.
     *
     * Anything that doesn't look like a potential rangequery clause gets
     * multiplied into s1 and forgotten. Anything that does gets inserted into
     * an rqlist entry.
     */
    listidx = -1;
    foreach(l, clauses)
    {
        Node       *clause = (Node *) lfirst(l);
        RestrictInfo *rinfo;
        Selectivity s2;
 
        listidx++;
 
        /*
         * Skip this clause if it's already been estimated by some other
         * statistics above.
         */
        if (bms_is_member(listidx, estimatedclauses))
            continue;
 
        /* Compute the selectivity of this clause in isolation */
        s2 = clause_selectivity_ext(root, clause, varRelid, jointype, sjinfo,
                                    use_extended_stats);
 
        /*
         * Check for being passed a RestrictInfo.
         *
         * If it's a pseudoconstant RestrictInfo, then s2 is either 1.0 or
         * 0.0; just use that rather than looking for range pairs.
         */
        if (IsA(clause, RestrictInfo))
        {
            rinfo = (RestrictInfo *) clause;
            if (rinfo->pseudoconstant)
            {
                s1 = s1 * s2;
                continue;
            }
            clause = (Node *) rinfo->clause;
        }
        else
            rinfo = NULL;
 
        /*
         * See if it looks like a restriction clause with a pseudoconstant on
         * one side.  (Anything more complicated than that might not behave in
         * the simple way we are expecting.)  Most of the tests here can be
         * done more efficiently with rinfo than without.
         */
        if (is_opclause(clause) && list_length(((OpExpr *) clause)->args) == 2)
        {
            OpExpr     *expr = (OpExpr *) clause;
            bool        varonleft = true;
            bool        ok;
 
            if (rinfo)
            {
                ok = (rinfo->num_base_rels == 1) &&
                    (is_pseudo_constant_clause_relids(lsecond(expr->args),
                                                      rinfo->right_relids) ||
                     (varonleft = false,
                      is_pseudo_constant_clause_relids(linitial(expr->args),
                                                       rinfo->left_relids)));
            }
            else
            {
                ok = (NumRelids(root, clause) == 1) &&
                    (is_pseudo_constant_clause(lsecond(expr->args)) ||
                     (varonleft = false,
                      is_pseudo_constant_clause(linitial(expr->args))));
            }
 
            if (ok)
            {
                /*
                 * If it's not a "<"/"<="/">"/">=" operator, just merge the
                 * selectivity in generically.  But if it's the right oprrest,
                 * add the clause to rqlist for later processing.
                 */
                switch (get_oprrest(expr->opno))
                {
                    case F_SCALARLTSEL:
                    case F_SCALARLESEL:
                        addRangeClause(&rqlist, clause,
                                       varonleft, true, s2);
                        break;
                    case F_SCALARGTSEL:
                    case F_SCALARGESEL:
                        addRangeClause(&rqlist, clause,
                                       varonleft, false, s2);
                        break;
                    default:
                        /* Just merge the selectivity in generically */
                        s1 = s1 * s2;
                        break;
                }
                continue;       /* drop to loop bottom */
            }
        }
 
        /* Not the right form, so treat it generically. */
        s1 = s1 * s2;
    }
 
    /*
     * Now scan the rangequery pair list.
     */
    while (rqlist != NULL)
    {
        RangeQueryClause *rqnext;
 
        if (rqlist->have_lobound && rqlist->have_hibound)
        {
            /* Successfully matched a pair of range clauses */
            Selectivity s2;
 
            /*
             * Exact equality to the default value probably means the
             * selectivity function punted.  This is not airtight but should
             * be good enough.
             */
            if (rqlist->hibound == DEFAULT_INEQ_SEL ||
                rqlist->lobound == DEFAULT_INEQ_SEL)
            {
                s2 = DEFAULT_RANGE_INEQ_SEL;
            }
            else
            {
                s2 = rqlist->hibound + rqlist->lobound - 1.0;
 
                /* Adjust for double-exclusion of NULLs */
                s2 += nulltestsel(root, IS_NULL, rqlist->var,
                                  varRelid, jointype, sjinfo);
 
                /*
                 * A zero or slightly negative s2 should be converted into a
                 * small positive value; we probably are dealing with a very
                 * tight range and got a bogus result due to roundoff errors.
                 * However, if s2 is very negative, then we probably have
                 * default selectivity estimates on one or both sides of the
                 * range that we failed to recognize above for some reason.
                 */
                if (s2 <= 0.0)
                {
                    if (s2 < -0.01)
                    {
                        /*
                         * No data available --- use a default estimate that
                         * is small, but not real small.
                         */
                        s2 = DEFAULT_RANGE_INEQ_SEL;
                    }
                    else
                    {
                        /*
                         * It's just roundoff error; use a small positive
                         * value
                         */
                        s2 = 1.0e-10;
                    }
                }
            }
            /* Merge in the selectivity of the pair of clauses */
            s1 *= s2;
        }
        else
        {
            /* Only found one of a pair, merge it in generically */
            if (rqlist->have_lobound)
                s1 *= rqlist->lobound;
            else
                s1 *= rqlist->hibound;
        }
        /* release storage and advance */
        rqnext = rqlist->next;
        pfree(rqlist);
        rqlist = rqnext;
    }
 
    return s1;
}

References addRangeClause(), generate_unaccent_rules::args, OpExpr::args, bms_is_member(), RestrictInfo::clause, clause_selectivity_ext(), DEFAULT_INEQ_SEL, DEFAULT_RANGE_INEQ_SEL, find_single_rel_for_clauses(), get_oprrest(), RangeQueryClause::have_hibound, RangeQueryClause::have_lobound, RangeQueryClause::hibound, IS_NULL, is_opclause(), is_pseudo_constant_clause(), is_pseudo_constant_clause_relids(), IsA, lfirst, linitial, list_length(), RangeQueryClause::lobound, lsecond, RangeQueryClause::next, NIL, nulltestsel(), NumRelids(), OpExpr::opno, pfree(), root, RTE_RELATION, RelOptInfo::rtekind, s1, s2, statext_clauselist_selectivity(), RelOptInfo::statlist, and RangeQueryClause::var.

Referenced by clause_selectivity_ext(), clauselist_apply_dependencies(), clauselist_selectivity(), and statext_mcv_clauselist_selectivity().

contain_mutable_functions()

bool contain_mutable_functions

(

Node *

clause

)

Definition at line 371 of file clauses.c.

{
    return contain_mutable_functions_walker(clause, NULL);
}

References contain_mutable_functions_walker().

Referenced by can_minmax_aggs(), check_index_predicates(), ComputePartitionAttrs(), contain_mutable_functions_after_planning(), create_bitmap_scan_plan(), create_indexscan_plan(), eval_const_expressions_mutator(), exec_save_simple_expr(), inline_function(), is_foreign_expr(), and relation_excluded_by_constraints().

contain_mutable_functions_after_planning()

bool contain_mutable_functions_after_planning

(

Expr *

expr

)

Definition at line 491 of file clauses.c.

{
    /* We assume here that expression_planner() won't scribble on its input */
    expr = expression_planner(expr);
 
    /* Now we can search for non-immutable functions */
    return contain_mutable_functions((Node *) expr);
}

References contain_mutable_functions(), and expression_planner().

Referenced by CheckPredicate(), ComputeIndexAttrs(), and cookDefault().

contain_var_clause()

bool contain_var_clause

(

Node *

node

)

Definition at line 406 of file var.c.

{
    return contain_var_clause_walker(node, NULL);
}

References contain_var_clause_walker().

Referenced by contain_leaked_vars_walker(), cookDefault(), domainAddCheckConstraint(), interpret_function_parameter_list(), is_pseudo_constant_clause(), match_clause_to_ordering_op(), match_clause_to_partition_key(), test_opexpr_is_hashable(), transformJsonBehavior(), and transformPartitionBoundValue().

contain_vars_of_level()

bool contain_vars_of_level	(	Node *	node,
		int	levelsup
	)

Definition at line 444 of file var.c.

{
    int         sublevels_up = levelsup;
 
    return query_or_expression_tree_walker(node,
                                           contain_vars_of_level_walker,
                                           &sublevels_up,
                                           0);
}

References contain_vars_of_level_walker(), and query_or_expression_tree_walker.

Referenced by apply_child_basequals(), checkExprIsVarFree(), convert_EXISTS_sublink_to_join(), convert_EXISTS_to_ANY(), pull_up_simple_values(), pullup_replace_vars_callback(), rewriteRuleAction(), transformAExprIn(), transformJsonTable(), transformRangeFunction(), transformRangeTableFunc(), transformSetOperationTree(), and transformValuesClause().

contain_vars_returning_old_or_new()

bool contain_vars_returning_old_or_new

(

Node *

node

)

Definition at line 511 of file var.c.

{
    return contain_vars_returning_old_or_new_walker(node, NULL);
}

References contain_vars_returning_old_or_new_walker().

Referenced by make_modifytable().

contain_volatile_functions()

bool contain_volatile_functions

(

Node *

clause

)

Definition at line 539 of file clauses.c.

{
    return contain_volatile_functions_walker(clause, NULL);
}

References contain_volatile_functions_walker().

Referenced by apply_child_basequals(), ATExecAddColumn(), check_hashjoinable(), check_mergejoinable(), check_output_expressions(), compute_semijoin_info(), contain_volatile_functions_after_planning(), convert_ANY_sublink_to_join(), convert_EXISTS_sublink_to_join(), convert_EXISTS_to_ANY(), convert_VALUES_to_ANY(), CopyFrom(), distribute_qual_to_rels(), estimate_num_groups(), ExecInitWindowAgg(), expand_indexqual_rowcompare(), find_compatible_agg(), find_simplified_clause(), get_eclass_for_sort_expr(), get_memoize_path(), group_similar_or_args(), initialize_peragg(), inline_function(), inline_set_returning_function(), is_pseudo_constant_clause(), is_pseudo_constant_clause_relids(), is_pseudo_constant_for_index(), is_safe_restriction_clause_for(), is_simple_subquery(), is_simple_values(), IsBinaryTidClause(), IsTidEqualAnyClause(), make_sort_input_target(), mark_nullable_by_grouping(), match_clause_to_ordering_op(), match_clause_to_partition_key(), match_opclause_to_indexcol(), match_orclause_to_indexcol(), match_rowcompare_to_indexcol(), match_saopclause_to_indexcol(), paraminfo_get_equal_hashops(), qual_is_pushdown_safe(), remove_unused_subquery_outputs(), SS_process_ctes(), and subquery_planner().

contain_volatile_functions_after_planning()

bool contain_volatile_functions_after_planning

(

Expr *

expr

)

Definition at line 660 of file clauses.c.

{
    /* We assume here that expression_planner() won't scribble on its input */
    expr = expression_planner(expr);
 
    /* Now we can search for volatile functions */
    return contain_volatile_functions((Node *) expr);
}

References contain_volatile_functions(), and expression_planner().

contain_volatile_functions_not_nextval()

bool contain_volatile_functions_not_nextval

(

Node *

clause

)

Definition at line 674 of file clauses.c.

{
    return contain_volatile_functions_not_nextval_walker(clause, NULL);
}

References contain_volatile_functions_not_nextval_walker().

Referenced by BeginCopyFrom().

convert_saop_to_hashed_saop()

void convert_saop_to_hashed_saop

(

Node *

node

)

Definition at line 2289 of file clauses.c.

{
    (void) convert_saop_to_hashed_saop_walker(node, NULL);
}

References convert_saop_to_hashed_saop_walker().

Referenced by preprocess_expression().

count_nonjunk_tlist_entries()

int count_nonjunk_tlist_entries

(

List *

tlist

)

Definition at line 186 of file tlist.c.

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

References len, and lfirst.

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

estimate_expression_value()

Node * estimate_expression_value	(	PlannerInfo *	root,
		Node *	node
	)

Definition at line 2397 of file clauses.c.

{
    eval_const_expressions_context context;
 
    context.boundParams = root->glob->boundParams;  /* bound Params */
    /* we do not need to mark the plan as depending on inlined functions */
    context.root = NULL;
    context.active_fns = NIL;   /* nothing being recursively simplified */
    context.case_val = NULL;    /* no CASE being examined */
    context.estimate = true;    /* unsafe transformations OK */
    return eval_const_expressions_mutator(node, &context);
}

References eval_const_expressions_context::active_fns, eval_const_expressions_context::boundParams, eval_const_expressions_context::case_val, eval_const_expressions_context::estimate, eval_const_expressions_mutator(), NIL, eval_const_expressions_context::root, and root.

Referenced by array_unnest_support(), bernoulli_samplescangetsamplesize(), clause_selectivity_ext(), generate_series_int4_support(), generate_series_int8_support(), generate_series_numeric_support(), generate_series_timestamp_support(), get_restriction_variable(), gincost_opexpr(), gincost_scalararrayopexpr(), preprocess_limit(), scalararraysel(), system_rows_samplescangetsamplesize(), system_samplescangetsamplesize(), and system_time_samplescangetsamplesize().

eval_const_expressions()

Node * eval_const_expressions	(	PlannerInfo *	root,
		Node *	node
	)

Definition at line 2256 of file clauses.c.

{
    eval_const_expressions_context context;
 
    if (root)
        context.boundParams = root->glob->boundParams;  /* bound Params */
    else
        context.boundParams = NULL;
    context.root = root;        /* for inlined-function dependencies */
    context.active_fns = NIL;   /* nothing being recursively simplified */
    context.case_val = NULL;    /* no CASE being examined */
    context.estimate = false;   /* safe transformations only */
    return eval_const_expressions_mutator(node, &context);
}

References eval_const_expressions_context::active_fns, eval_const_expressions_context::boundParams, eval_const_expressions_context::case_val, eval_const_expressions_context::estimate, eval_const_expressions_mutator(), NIL, eval_const_expressions_context::root, and root.

Referenced by apply_child_basequals(), ATExecAttachPartition(), ConstraintImpliedByRelConstraint(), convert_EXISTS_to_ANY(), convert_VALUES_to_ANY(), DetachAddConstraintIfNeeded(), DoCopy(), expand_insert_targetlist(), expression_planner(), expression_planner_with_deps(), fetch_statentries_for_relation(), get_proposed_default_constraint(), get_relation_constraints(), get_relation_statistics(), preprocess_expression(), preprocess_function_rtes(), process_implied_equality(), RelationBuildPartitionKey(), RelationGetIndexExpressions(), RelationGetIndexPredicate(), and simplify_EXISTS_query().

evaluate_expr()

Expr * evaluate_expr	(	Expr *	expr,
		Oid	result_type,
		int32	result_typmod,
		Oid	result_collation
	)

Definition at line 4976 of file clauses.c.

{
    EState     *estate;
    ExprState  *exprstate;
    MemoryContext oldcontext;
    Datum       const_val;
    bool        const_is_null;
    int16       resultTypLen;
    bool        resultTypByVal;
 
    /*
     * To use the executor, we need an EState.
     */
    estate = CreateExecutorState();
 
    /* We can use the estate's working context to avoid memory leaks. */
    oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
 
    /* Make sure any opfuncids are filled in. */
    fix_opfuncids((Node *) expr);
 
    /*
     * Prepare expr for execution.  (Note: we can't use ExecPrepareExpr
     * because it'd result in recursively invoking eval_const_expressions.)
     */
    exprstate = ExecInitExpr(expr, NULL);
 
    /*
     * And evaluate it.
     *
     * It is OK to use a default econtext because none of the ExecEvalExpr()
     * code used in this situation will use econtext.  That might seem
     * fortuitous, but it's not so unreasonable --- a constant expression does
     * not depend on context, by definition, n'est ce pas?
     */
    const_val = ExecEvalExprSwitchContext(exprstate,
                                          GetPerTupleExprContext(estate),
                                          &const_is_null);
 
    /* Get info needed about result datatype */
    get_typlenbyval(result_type, &resultTypLen, &resultTypByVal);
 
    /* Get back to outer memory context */
    MemoryContextSwitchTo(oldcontext);
 
    /*
     * Must copy result out of sub-context used by expression eval.
     *
     * Also, if it's varlena, forcibly detoast it.  This protects us against
     * storing TOAST pointers into plans that might outlive the referenced
     * data.  (makeConst would handle detoasting anyway, but it's worth a few
     * extra lines here so that we can do the copy and detoast in one step.)
     */
    if (!const_is_null)
    {
        if (resultTypLen == -1)
            const_val = PointerGetDatum(PG_DETOAST_DATUM_COPY(const_val));
        else
            const_val = datumCopy(const_val, resultTypByVal, resultTypLen);
    }
 
    /* Release all the junk we just created */
    FreeExecutorState(estate);
 
    /*
     * Make the constant result node.
     */
    return (Expr *) makeConst(result_type, result_typmod, result_collation,
                              resultTypLen,
                              const_val, const_is_null,
                              resultTypByVal);
}

References CreateExecutorState(), datumCopy(), EState::es_query_cxt, ExecEvalExprSwitchContext(), ExecInitExpr(), fix_opfuncids(), FreeExecutorState(), get_typlenbyval(), GetPerTupleExprContext, makeConst(), MemoryContextSwitchTo(), PG_DETOAST_DATUM_COPY, and PointerGetDatum().

Referenced by eval_const_expressions_mutator(), evaluate_function(), and transformPartitionBoundValue().

expand_function_arguments()

List * expand_function_arguments	(	List *	args,
		bool	include_out_arguments,
		Oid	result_type,
		struct HeapTupleData *	func_tuple
	)

expression_planner()

Expr * expression_planner

(

Expr *

expr

)

Definition at line 6645 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(), ATExecSetExpression(), ATPrepAlterColumnType(), BeginCopyFrom(), ComputePartitionAttrs(), contain_mutable_functions_after_planning(), contain_volatile_functions_after_planning(), ExecPrepareCheck(), ExecPrepareExpr(), ExecPrepareQual(), load_domaintype_info(), set_baserel_partition_constraint(), slot_fill_defaults(), and transformPartitionBoundValue().

expression_planner_with_deps()

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

Definition at line 6672 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(), PlannerGlobal::invalItems, MemSet, NIL, PlannerGlobal::relationOids, and root.

Referenced by GetCachedExpression().

extract_query_dependencies()

void extract_query_dependencies	(	Node *	query,
		List **	relationOids,
		List **	invalItems,
		bool *	hasRowSecurity
	)

Definition at line 3633 of file setrefs.c.

{
    PlannerGlobal glob;
    PlannerInfo root;
 
    /* Make up dummy planner state so we can use this module's machinery */
    MemSet(&glob, 0, sizeof(glob));
    glob.type = T_PlannerGlobal;
    glob.relationOids = NIL;
    glob.invalItems = NIL;
    /* Hack: we use glob.dependsOnRole to collect hasRowSecurity flags */
    glob.dependsOnRole = false;
 
    MemSet(&root, 0, sizeof(root));
    root.type = T_PlannerInfo;
    root.glob = &glob;
 
    (void) extract_query_dependencies_walker(query, &root);
 
    *relationOids = glob.relationOids;
    *invalItems = glob.invalItems;
    *hasRowSecurity = glob.dependsOnRole;
}

References PlannerGlobal::dependsOnRole, extract_query_dependencies_walker(), PlannerGlobal::invalItems, MemSet, NIL, PlannerGlobal::relationOids, and root.

Referenced by CompleteCachedPlan(), and RevalidateCachedQuery().

flatten_group_exprs()

Node * flatten_group_exprs	(	PlannerInfo *	root,
		Query *	query,
		Node *	node
	)

Definition at line 968 of file var.c.

{
    flatten_join_alias_vars_context context;
 
    /*
     * We do not expect this to be applied to the whole Query, only to
     * expressions or LATERAL subqueries.  Hence, if the top node is a Query,
     * it's okay to immediately increment sublevels_up.
     */
    Assert(node != (Node *) query);
 
    context.root = root;
    context.query = query;
    context.sublevels_up = 0;
    /* flag whether grouping expressions could possibly contain SubLinks */
    context.possible_sublink = query->hasSubLinks;
    /* if hasSubLinks is already true, no need to work hard */
    context.inserted_sublink = query->hasSubLinks;
 
    return flatten_group_exprs_mutator(node, &context);
}

References Assert(), flatten_group_exprs_mutator(), flatten_join_alias_vars_context::inserted_sublink, flatten_join_alias_vars_context::possible_sublink, flatten_join_alias_vars_context::query, flatten_join_alias_vars_context::root, root, and flatten_join_alias_vars_context::sublevels_up.

Referenced by get_query_def(), and subquery_planner().

flatten_join_alias_vars()

Node * flatten_join_alias_vars	(	PlannerInfo *	root,
		Query *	query,
		Node *	node
	)

Definition at line 789 of file var.c.

{
    flatten_join_alias_vars_context context;
 
    /*
     * We do not expect this to be applied to the whole Query, only to
     * expressions or LATERAL subqueries.  Hence, if the top node is a Query,
     * it's okay to immediately increment sublevels_up.
     */
    Assert(node != (Node *) query);
 
    context.root = root;
    context.query = query;
    context.sublevels_up = 0;
    /* flag whether join aliases could possibly contain SubLinks */
    context.possible_sublink = query->hasSubLinks;
    /* if hasSubLinks is already true, no need to work hard */
    context.inserted_sublink = query->hasSubLinks;
 
    return flatten_join_alias_vars_mutator(node, &context);
}

References Assert(), flatten_join_alias_vars_mutator(), flatten_join_alias_vars_context::inserted_sublink, flatten_join_alias_vars_context::possible_sublink, flatten_join_alias_vars_context::query, flatten_join_alias_vars_context::root, root, and flatten_join_alias_vars_context::sublevels_up.

Referenced by finalize_grouping_exprs_walker(), parseCheckAggregates(), preprocess_expression(), pull_up_simple_subquery(), and subquery_planner().

get_sortgroupclause_expr()

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

Definition at line 379 of file tlist.c.

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

References TargetEntry::expr, and get_sortgroupclause_tle().

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

get_sortgroupclause_tle()

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

Definition at line 367 of file tlist.c.

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

References get_sortgroupref_tle(), and SortGroupClause::tleSortGroupRef.

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

get_sortgrouplist_exprs()

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

Definition at line 392 of file tlist.c.

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

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

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

get_sortgroupref_clause()

SortGroupClause * get_sortgroupref_clause	(	Index	sortref,
		List *	clauses
	)

Definition at line 422 of file tlist.c.

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

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

Referenced by preprocess_groupclause().

get_sortgroupref_clause_noerr()

SortGroupClause * get_sortgroupref_clause_noerr	(	Index	sortref,
		List *	clauses
	)

Definition at line 443 of file tlist.c.

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

References lfirst, and SortGroupClause::tleSortGroupRef.

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

get_sortgroupref_tle()

TargetEntry * get_sortgroupref_tle	(	Index	sortref,
		List *	targetList
	)

Definition at line 345 of file tlist.c.

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

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

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

is_pseudo_constant_for_index()

bool is_pseudo_constant_for_index	(	PlannerInfo *	root,
		Node *	expr,
		IndexOptInfo *	index
	)

Definition at line 4512 of file indxpath.c.

{
    /* pull_varnos is cheaper than volatility check, so do that first */
    if (bms_is_member(index->rel->relid, pull_varnos(root, expr)))
        return false;           /* no good, contains Var of table */
    if (contain_volatile_functions(expr))
        return false;           /* no good, volatile comparison value */
    return true;
}

References bms_is_member(), contain_volatile_functions(), pull_varnos(), and root.

locate_var_of_level()

int locate_var_of_level	(	Node *	node,
		int	levelsup
	)

Definition at line 555 of file var.c.

{
    locate_var_of_level_context context;
 
    context.var_location = -1;  /* in case we find nothing */
    context.sublevels_up = levelsup;
 
    (void) query_or_expression_tree_walker(node,
                                           locate_var_of_level_walker,
                                           &context,
                                           0);
 
    return context.var_location;
}

References locate_var_of_level_walker(), query_or_expression_tree_walker, locate_var_of_level_context::sublevels_up, and locate_var_of_level_context::var_location.

Referenced by check_agg_arguments(), checkExprIsVarFree(), and transformSetOperationTree().

make_SAOP_expr()

ScalarArrayOpExpr * make_SAOP_expr	(	Oid	oper,
		Node *	leftexpr,
		Oid	coltype,
		Oid	arraycollid,
		Oid	inputcollid,
		List *	exprs,
		bool	haveNonConst
	)

Definition at line 5453 of file clauses.c.

{
    Node       *arrayNode = NULL;
    ScalarArrayOpExpr *saopexpr = NULL;
    Oid         arraytype = get_array_type(coltype);
 
    if (!OidIsValid(arraytype))
        return NULL;
 
    /*
     * Assemble an array from the list of constants.  It seems more profitable
     * to build a const array.  But in the presence of other nodes, we don't
     * have a specific value here and must employ an ArrayExpr instead.
     */
    if (haveNonConst)
    {
        ArrayExpr  *arrayExpr = makeNode(ArrayExpr);
 
        /* array_collid will be set by parse_collate.c */
        arrayExpr->element_typeid = coltype;
        arrayExpr->array_typeid = arraytype;
        arrayExpr->multidims = false;
        arrayExpr->elements = exprs;
        arrayExpr->location = -1;
 
        arrayNode = (Node *) arrayExpr;
    }
    else
    {
        int16       typlen;
        bool        typbyval;
        char        typalign;
        Datum      *elems;
        bool       *nulls;
        int         i = 0;
        ArrayType  *arrayConst;
        int         dims[1] = {list_length(exprs)};
        int         lbs[1] = {1};
 
        get_typlenbyvalalign(coltype, &typlen, &typbyval, &typalign);
 
        elems = (Datum *) palloc(sizeof(Datum) * list_length(exprs));
        nulls = (bool *) palloc(sizeof(bool) * list_length(exprs));
        foreach_node(Const, value, exprs)
        {
            elems[i] = value->constvalue;
            nulls[i++] = value->constisnull;
        }
 
        arrayConst = construct_md_array(elems, nulls, 1, dims, lbs,
                                        coltype, typlen, typbyval, typalign);
        arrayNode = (Node *) makeConst(arraytype, -1, arraycollid,
                                       -1, PointerGetDatum(arrayConst),
                                       false, false);
 
        pfree(elems);
        pfree(nulls);
        list_free(exprs);
    }
 
    /* Build the SAOP expression node */
    saopexpr = makeNode(ScalarArrayOpExpr);
    saopexpr->opno = oper;
    saopexpr->opfuncid = get_opcode(oper);
    saopexpr->hashfuncid = InvalidOid;
    saopexpr->negfuncid = InvalidOid;
    saopexpr->useOr = true;
    saopexpr->inputcollid = inputcollid;
    saopexpr->args = list_make2(leftexpr, arrayNode);
    saopexpr->location = -1;
 
    return saopexpr;
}

References ScalarArrayOpExpr::args, construct_md_array(), foreach_node, get_array_type(), get_opcode(), get_typlenbyvalalign(), i, InvalidOid, list_free(), list_length(), list_make2, ScalarArrayOpExpr::location, ArrayExpr::location, makeConst(), makeNode, OidIsValid, oper(), ScalarArrayOpExpr::opno, palloc(), pfree(), PointerGetDatum(), typalign, ScalarArrayOpExpr::useOr, and value.

Referenced by convert_VALUES_to_ANY(), and match_orclause_to_indexcol().

negate_clause()

Node * negate_clause

(

Node *

node

)

Definition at line 73 of file prepqual.c.

{
    if (node == NULL)           /* should not happen */
        elog(ERROR, "can't negate an empty subexpression");
    switch (nodeTag(node))
    {
        case T_Const:
            {
                Const      *c = (Const *) node;
 
                /* NOT NULL is still NULL */
                if (c->constisnull)
                    return makeBoolConst(false, true);
                /* otherwise pretty easy */
                return makeBoolConst(!DatumGetBool(c->constvalue), false);
            }
            break;
        case T_OpExpr:
            {
                /*
                 * Negate operator if possible: (NOT (< A B)) => (>= A B)
                 */
                OpExpr     *opexpr = (OpExpr *) node;
                Oid         negator = get_negator(opexpr->opno);
 
                if (negator)
                {
                    OpExpr     *newopexpr = makeNode(OpExpr);
 
                    newopexpr->opno = negator;
                    newopexpr->opfuncid = InvalidOid;
                    newopexpr->opresulttype = opexpr->opresulttype;
                    newopexpr->opretset = opexpr->opretset;
                    newopexpr->opcollid = opexpr->opcollid;
                    newopexpr->inputcollid = opexpr->inputcollid;
                    newopexpr->args = opexpr->args;
                    newopexpr->location = opexpr->location;
                    return (Node *) newopexpr;
                }
            }
            break;
        case T_ScalarArrayOpExpr:
            {
                /*
                 * Negate a ScalarArrayOpExpr if its operator has a negator;
                 * for example x = ANY (list) becomes x <> ALL (list)
                 */
                ScalarArrayOpExpr *saopexpr = (ScalarArrayOpExpr *) node;
                Oid         negator = get_negator(saopexpr->opno);
 
                if (negator)
                {
                    ScalarArrayOpExpr *newopexpr = makeNode(ScalarArrayOpExpr);
 
                    newopexpr->opno = negator;
                    newopexpr->opfuncid = InvalidOid;
                    newopexpr->hashfuncid = InvalidOid;
                    newopexpr->negfuncid = InvalidOid;
                    newopexpr->useOr = !saopexpr->useOr;
                    newopexpr->inputcollid = saopexpr->inputcollid;
                    newopexpr->args = saopexpr->args;
                    newopexpr->location = saopexpr->location;
                    return (Node *) newopexpr;
                }
            }
            break;
        case T_BoolExpr:
            {
                BoolExpr   *expr = (BoolExpr *) node;
 
                switch (expr->boolop)
                {
                        /*--------------------
                         * Apply DeMorgan's Laws:
                         *      (NOT (AND A B)) => (OR (NOT A) (NOT B))
                         *      (NOT (OR A B))  => (AND (NOT A) (NOT B))
                         * i.e., swap AND for OR and negate each subclause.
                         *
                         * If the input is already AND/OR flat and has no NOT
                         * directly above AND or OR, this transformation preserves
                         * those properties.  For example, if no direct child of
                         * the given AND clause is an AND or a NOT-above-OR, then
                         * the recursive calls of negate_clause() can't return any
                         * OR clauses.  So we needn't call pull_ors() before
                         * building a new OR clause.  Similarly for the OR case.
                         *--------------------
                         */
                    case AND_EXPR:
                        {
                            List       *nargs = NIL;
                            ListCell   *lc;
 
                            foreach(lc, expr->args)
                            {
                                nargs = lappend(nargs,
                                                negate_clause(lfirst(lc)));
                            }
                            return (Node *) make_orclause(nargs);
                        }
                        break;
                    case OR_EXPR:
                        {
                            List       *nargs = NIL;
                            ListCell   *lc;
 
                            foreach(lc, expr->args)
                            {
                                nargs = lappend(nargs,
                                                negate_clause(lfirst(lc)));
                            }
                            return (Node *) make_andclause(nargs);
                        }
                        break;
                    case NOT_EXPR:
 
                        /*
                         * NOT underneath NOT: they cancel.  We assume the
                         * input is already simplified, so no need to recurse.
                         */
                        return (Node *) linitial(expr->args);
                    default:
                        elog(ERROR, "unrecognized boolop: %d",
                             (int) expr->boolop);
                        break;
                }
            }
            break;
        case T_NullTest:
            {
                NullTest   *expr = (NullTest *) node;
 
                /*
                 * In the rowtype case, the two flavors of NullTest are *not*
                 * logical inverses, so we can't simplify.  But it does work
                 * for scalar datatypes.
                 */
                if (!expr->argisrow)
                {
                    NullTest   *newexpr = makeNode(NullTest);
 
                    newexpr->arg = expr->arg;
                    newexpr->nulltesttype = (expr->nulltesttype == IS_NULL ?
                                             IS_NOT_NULL : IS_NULL);
                    newexpr->argisrow = expr->argisrow;
                    newexpr->location = expr->location;
                    return (Node *) newexpr;
                }
            }
            break;
        case T_BooleanTest:
            {
                BooleanTest *expr = (BooleanTest *) node;
                BooleanTest *newexpr = makeNode(BooleanTest);
 
                newexpr->arg = expr->arg;
                switch (expr->booltesttype)
                {
                    case IS_TRUE:
                        newexpr->booltesttype = IS_NOT_TRUE;
                        break;
                    case IS_NOT_TRUE:
                        newexpr->booltesttype = IS_TRUE;
                        break;
                    case IS_FALSE:
                        newexpr->booltesttype = IS_NOT_FALSE;
                        break;
                    case IS_NOT_FALSE:
                        newexpr->booltesttype = IS_FALSE;
                        break;
                    case IS_UNKNOWN:
                        newexpr->booltesttype = IS_NOT_UNKNOWN;
                        break;
                    case IS_NOT_UNKNOWN:
                        newexpr->booltesttype = IS_UNKNOWN;
                        break;
                    default:
                        elog(ERROR, "unrecognized booltesttype: %d",
                             (int) expr->booltesttype);
                        break;
                }
                newexpr->location = expr->location;
                return (Node *) newexpr;
            }
            break;
        default:
            /* else fall through */
            break;
    }
 
    /*
     * Otherwise we don't know how to simplify this, so just tack on an
     * explicit NOT node.
     */
    return (Node *) make_notclause((Expr *) node);
}

References AND_EXPR, NullTest::arg, BooleanTest::arg, OpExpr::args, ScalarArrayOpExpr::args, BoolExpr::args, BoolExpr::boolop, BooleanTest::booltesttype, DatumGetBool(), elog, ERROR, get_negator(), InvalidOid, IS_FALSE, IS_NOT_FALSE, IS_NOT_NULL, IS_NOT_TRUE, IS_NOT_UNKNOWN, IS_NULL, IS_TRUE, IS_UNKNOWN, lappend(), lfirst, linitial, OpExpr::location, ScalarArrayOpExpr::location, NullTest::location, BooleanTest::location, make_andclause(), make_notclause(), make_orclause(), makeBoolConst(), makeNode, negate_clause(), NIL, nodeTag, NOT_EXPR, NullTest::nulltesttype, OpExpr::opno, ScalarArrayOpExpr::opno, OR_EXPR, and ScalarArrayOpExpr::useOr.

Referenced by eval_const_expressions_mutator(), match_boolean_partition_clause(), negate_clause(), and simplify_boolean_equality().

plan_cluster_use_sort()

bool plan_cluster_use_sort	(	Oid	tableOid,
		Oid	indexOid
	)

Definition at line 6725 of file planner.c.

{
    PlannerInfo *root;
    Query      *query;
    PlannerGlobal *glob;
    RangeTblEntry *rte;
    RelOptInfo *rel;
    IndexOptInfo *indexInfo;
    QualCost    indexExprCost;
    Cost        comparisonCost;
    Path       *seqScanPath;
    Path        seqScanAndSortPath;
    IndexPath  *indexScanPath;
    ListCell   *lc;
 
    /* We can short-circuit the cost comparison if indexscans are disabled */
    if (!enable_indexscan)
        return true;            /* use sort */
 
    /* Set up mostly-dummy planner state */
    query = makeNode(Query);
    query->commandType = CMD_SELECT;
 
    glob = makeNode(PlannerGlobal);
 
    root = makeNode(PlannerInfo);
    root->parse = query;
    root->glob = glob;
    root->query_level = 1;
    root->planner_cxt = CurrentMemoryContext;
    root->wt_param_id = -1;
    root->join_domains = list_make1(makeNode(JoinDomain));
 
    /* Build a minimal RTE for the rel */
    rte = makeNode(RangeTblEntry);
    rte->rtekind = RTE_RELATION;
    rte->relid = tableOid;
    rte->relkind = RELKIND_RELATION;    /* Don't be too picky. */
    rte->rellockmode = AccessShareLock;
    rte->lateral = false;
    rte->inh = false;
    rte->inFromCl = true;
    query->rtable = list_make1(rte);
    addRTEPermissionInfo(&query->rteperminfos, rte);
 
    /* Set up RTE/RelOptInfo arrays */
    setup_simple_rel_arrays(root);
 
    /* Build RelOptInfo */
    rel = build_simple_rel(root, 1, NULL);
 
    /* Locate IndexOptInfo for the target index */
    indexInfo = NULL;
    foreach(lc, rel->indexlist)
    {
        indexInfo = lfirst_node(IndexOptInfo, lc);
        if (indexInfo->indexoid == indexOid)
            break;
    }
 
    /*
     * It's possible that get_relation_info did not generate an IndexOptInfo
     * for the desired index; this could happen if it's not yet reached its
     * indcheckxmin usability horizon, or if it's a system index and we're
     * ignoring system indexes.  In such cases we should tell CLUSTER to not
     * trust the index contents but use seqscan-and-sort.
     */
    if (lc == NULL)             /* not in the list? */
        return true;            /* use sort */
 
    /*
     * Rather than doing all the pushups that would be needed to use
     * set_baserel_size_estimates, just do a quick hack for rows and width.
     */
    rel->rows = rel->tuples;
    rel->reltarget->width = get_relation_data_width(tableOid, NULL);
 
    root->total_table_pages = rel->pages;
 
    /*
     * Determine eval cost of the index expressions, if any.  We need to
     * charge twice that amount for each tuple comparison that happens during
     * the sort, since tuplesort.c will have to re-evaluate the index
     * expressions each time.  (XXX that's pretty inefficient...)
     */
    cost_qual_eval(&indexExprCost, indexInfo->indexprs, root);
    comparisonCost = 2.0 * (indexExprCost.startup + indexExprCost.per_tuple);
 
    /* Estimate the cost of seq scan + sort */
    seqScanPath = create_seqscan_path(root, rel, NULL, 0);
    cost_sort(&seqScanAndSortPath, root, NIL,
              seqScanPath->disabled_nodes,
              seqScanPath->total_cost, rel->tuples, rel->reltarget->width,
              comparisonCost, maintenance_work_mem, -1.0);
 
    /* Estimate the cost of index scan */
    indexScanPath = create_index_path(root, indexInfo,
                                      NIL, NIL, NIL, NIL,
                                      ForwardScanDirection, false,
                                      NULL, 1.0, false);
 
    return (seqScanAndSortPath.total_cost < indexScanPath->path.total_cost);
}

References AccessShareLock, addRTEPermissionInfo(), build_simple_rel(), CMD_SELECT, Query::commandType, cost_qual_eval(), cost_sort(), create_index_path(), create_seqscan_path(), CurrentMemoryContext, Path::disabled_nodes, enable_indexscan, ForwardScanDirection, get_relation_data_width(), RelOptInfo::indexlist, IndexOptInfo::indexoid, RangeTblEntry::inh, lfirst_node, list_make1, maintenance_work_mem, makeNode, NIL, RelOptInfo::pages, IndexPath::path, QualCost::per_tuple, RelOptInfo::reltarget, root, RelOptInfo::rows, Query::rtable, RTE_RELATION, RangeTblEntry::rtekind, setup_simple_rel_arrays(), QualCost::startup, Path::total_cost, RelOptInfo::tuples, and PathTarget::width.

Referenced by copy_table_data().

plan_create_index_workers()

int plan_create_index_workers	(	Oid	tableOid,
		Oid	indexOid
	)

Definition at line 6847 of file planner.c.

{
    PlannerInfo *root;
    Query      *query;
    PlannerGlobal *glob;
    RangeTblEntry *rte;
    Relation    heap;
    Relation    index;
    RelOptInfo *rel;
    int         parallel_workers;
    BlockNumber heap_blocks;
    double      reltuples;
    double      allvisfrac;
 
    /*
     * We don't allow performing parallel operation in standalone backend or
     * when parallelism is disabled.
     */
    if (!IsUnderPostmaster || max_parallel_maintenance_workers == 0)
        return 0;
 
    /* Set up largely-dummy planner state */
    query = makeNode(Query);
    query->commandType = CMD_SELECT;
 
    glob = makeNode(PlannerGlobal);
 
    root = makeNode(PlannerInfo);
    root->parse = query;
    root->glob = glob;
    root->query_level = 1;
    root->planner_cxt = CurrentMemoryContext;
    root->wt_param_id = -1;
    root->join_domains = list_make1(makeNode(JoinDomain));
 
    /*
     * Build a minimal RTE.
     *
     * Mark the RTE with inh = true.  This is a kludge to prevent
     * get_relation_info() from fetching index info, which is necessary
     * because it does not expect that any IndexOptInfo is currently
     * undergoing REINDEX.
     */
    rte = makeNode(RangeTblEntry);
    rte->rtekind = RTE_RELATION;
    rte->relid = tableOid;
    rte->relkind = RELKIND_RELATION;    /* Don't be too picky. */
    rte->rellockmode = AccessShareLock;
    rte->lateral = false;
    rte->inh = true;
    rte->inFromCl = true;
    query->rtable = list_make1(rte);
    addRTEPermissionInfo(&query->rteperminfos, rte);
 
    /* Set up RTE/RelOptInfo arrays */
    setup_simple_rel_arrays(root);
 
    /* Build RelOptInfo */
    rel = build_simple_rel(root, 1, NULL);
 
    /* Rels are assumed already locked by the caller */
    heap = table_open(tableOid, NoLock);
    index = index_open(indexOid, NoLock);
 
    /*
     * Determine if it's safe to proceed.
     *
     * Currently, parallel workers can't access the leader's temporary tables.
     * Furthermore, any index predicate or index expressions must be parallel
     * safe.
     */
    if (heap->rd_rel->relpersistence == RELPERSISTENCE_TEMP ||
        !is_parallel_safe(root, (Node *) RelationGetIndexExpressions(index)) ||
        !is_parallel_safe(root, (Node *) RelationGetIndexPredicate(index)))
    {
        parallel_workers = 0;
        goto done;
    }
 
    /*
     * If parallel_workers storage parameter is set for the table, accept that
     * as the number of parallel worker processes to launch (though still cap
     * at max_parallel_maintenance_workers).  Note that we deliberately do not
     * consider any other factor when parallel_workers is set. (e.g., memory
     * use by workers.)
     */
    if (rel->rel_parallel_workers != -1)
    {
        parallel_workers = Min(rel->rel_parallel_workers,
                               max_parallel_maintenance_workers);
        goto done;
    }
 
    /*
     * Estimate heap relation size ourselves, since rel->pages cannot be
     * trusted (heap RTE was marked as inheritance parent)
     */
    estimate_rel_size(heap, NULL, &heap_blocks, &reltuples, &allvisfrac);
 
    /*
     * Determine number of workers to scan the heap relation using generic
     * model
     */
    parallel_workers = compute_parallel_worker(rel, heap_blocks, -1,
                                               max_parallel_maintenance_workers);
 
    /*
     * Cap workers based on available maintenance_work_mem as needed.
     *
     * Note that each tuplesort participant receives an even share of the
     * total maintenance_work_mem budget.  Aim to leave participants
     * (including the leader as a participant) with no less than 32MB of
     * memory.  This leaves cases where maintenance_work_mem is set to 64MB
     * immediately past the threshold of being capable of launching a single
     * parallel worker to sort.
     */
    while (parallel_workers > 0 &&
           maintenance_work_mem / (parallel_workers + 1) < 32 * 1024)
        parallel_workers--;
 
done:
    index_close(index, NoLock);
    table_close(heap, NoLock);
 
    return parallel_workers;
}

References AccessShareLock, addRTEPermissionInfo(), build_simple_rel(), CMD_SELECT, Query::commandType, compute_parallel_worker(), CurrentMemoryContext, estimate_rel_size(), index_close(), index_open(), RangeTblEntry::inh, is_parallel_safe(), IsUnderPostmaster, list_make1, maintenance_work_mem, makeNode, max_parallel_maintenance_workers, Min, NoLock, RelationData::rd_rel, RelOptInfo::rel_parallel_workers, RelationGetIndexExpressions(), RelationGetIndexPredicate(), root, Query::rtable, RTE_RELATION, RangeTblEntry::rtekind, setup_simple_rel_arrays(), table_close(), and table_open().

Referenced by index_build().

planner()

struct PlannedStmt * planner	(	Query *	parse,
		const char *	query_string,
		int	cursorOptions,
		struct ParamListInfoData *	boundParams
	)

predicate_implied_by()

bool predicate_implied_by	(	List *	predicate_list,
		List *	clause_list,
		bool	weak
	)

Definition at line 152 of file predtest.c.

{
    Node       *p,
               *c;
 
    if (predicate_list == NIL)
        return true;            /* no predicate: implication is vacuous */
    if (clause_list == NIL)
        return false;           /* no restriction: implication must fail */
 
    /*
     * If either input is a single-element list, replace it with its lone
     * member; this avoids one useless level of AND-recursion.  We only need
     * to worry about this at top level, since eval_const_expressions should
     * have gotten rid of any trivial ANDs or ORs below that.
     */
    if (list_length(predicate_list) == 1)
        p = (Node *) linitial(predicate_list);
    else
        p = (Node *) predicate_list;
    if (list_length(clause_list) == 1)
        c = (Node *) linitial(clause_list);
    else
        c = (Node *) clause_list;
 
    /* And away we go ... */
    return predicate_implied_by_recurse(c, p, weak);
}

References linitial, list_length(), NIL, and predicate_implied_by_recurse().

Referenced by add_predicate_to_index_quals(), build_paths_for_OR(), check_index_predicates(), choose_bitmap_and(), ConstraintImpliedByRelConstraint(), create_bitmap_scan_plan(), create_bitmap_subplan(), create_indexscan_plan(), infer_arbiter_indexes(), and test_predtest().

predicate_refuted_by()

bool predicate_refuted_by	(	List *	predicate_list,
		List *	clause_list,
		bool	weak
	)

Definition at line 222 of file predtest.c.

{
    Node       *p,
               *c;
 
    if (predicate_list == NIL)
        return false;           /* no predicate: no refutation is possible */
    if (clause_list == NIL)
        return false;           /* no restriction: refutation must fail */
 
    /*
     * If either input is a single-element list, replace it with its lone
     * member; this avoids one useless level of AND-recursion.  We only need
     * to worry about this at top level, since eval_const_expressions should
     * have gotten rid of any trivial ANDs or ORs below that.
     */
    if (list_length(predicate_list) == 1)
        p = (Node *) linitial(predicate_list);
    else
        p = (Node *) predicate_list;
    if (list_length(clause_list) == 1)
        c = (Node *) linitial(clause_list);
    else
        c = (Node *) clause_list;
 
    /* And away we go ... */
    return predicate_refuted_by_recurse(c, p, weak);
}

References linitial, list_length(), NIL, and predicate_refuted_by_recurse().

Referenced by gen_partprune_steps_internal(), relation_excluded_by_constraints(), and test_predtest().

pull_var_clause()

List * pull_var_clause	(	Node *	node,
		int	flags
	)

Definition at line 653 of file var.c.

{
    pull_var_clause_context context;
 
    /* Assert that caller has not specified inconsistent flags */
    Assert((flags & (PVC_INCLUDE_AGGREGATES | PVC_RECURSE_AGGREGATES))
           != (PVC_INCLUDE_AGGREGATES | PVC_RECURSE_AGGREGATES));
    Assert((flags & (PVC_INCLUDE_WINDOWFUNCS | PVC_RECURSE_WINDOWFUNCS))
           != (PVC_INCLUDE_WINDOWFUNCS | PVC_RECURSE_WINDOWFUNCS));
    Assert((flags & (PVC_INCLUDE_PLACEHOLDERS | PVC_RECURSE_PLACEHOLDERS))
           != (PVC_INCLUDE_PLACEHOLDERS | PVC_RECURSE_PLACEHOLDERS));
 
    context.varlist = NIL;
    context.flags = flags;
 
    pull_var_clause_walker(node, &context);
    return context.varlist;
}

References Assert(), pull_var_clause_context::flags, NIL, pull_var_clause_walker(), PVC_INCLUDE_AGGREGATES, PVC_INCLUDE_PLACEHOLDERS, PVC_INCLUDE_WINDOWFUNCS, PVC_RECURSE_AGGREGATES, PVC_RECURSE_PLACEHOLDERS, PVC_RECURSE_WINDOWFUNCS, and pull_var_clause_context::varlist.

Referenced by add_paths_with_pathkeys_for_rel(), AddRelationNewConstraints(), build_base_rel_tlists(), build_remote_returning(), build_tlist_to_deparse(), CreateTriggerFiringOn(), distribute_qual_to_rels(), estimate_num_groups(), find_computable_ec_member(), find_placeholders_in_expr(), fix_placeholder_input_needed_levels(), foreign_grouping_ok(), generate_base_implied_equalities_no_const(), make_group_input_target(), make_partial_grouping_target(), make_sort_input_target(), make_window_input_target(), preprocess_targetlist(), process_implied_equality(), qual_is_pushdown_safe(), rebuild_eclass_attr_needed(), rebuild_joinclause_attr_needed(), rebuild_placeholder_attr_needed(), semijoin_target_ok(), and StoreRelCheck().

pull_varattnos()

void pull_varattnos	(	Node *	node,
		Index	varno,
		Bitmapset **	varattnos
	)

Definition at line 296 of file var.c.

{
    pull_varattnos_context context;
 
    context.varattnos = *varattnos;
    context.varno = varno;
 
    (void) pull_varattnos_walker(node, &context);
 
    *varattnos = context.varattnos;
}

References pull_varattnos_walker(), pull_varattnos_context::varattnos, and pull_varattnos_context::varno.

Referenced by check_index_only(), check_selective_binary_conversion(), ComputePartitionAttrs(), create_foreignscan_plan(), CreateStatistics(), DefineIndex(), deparseReturningList(), ExecInitGenerated(), get_dependent_generated_columns(), has_partition_attrs(), postgresGetForeignRelSize(), RelationGetIndexAttrBitmap(), remove_unused_subquery_outputs(), and statext_is_compatible_clause().

pull_varnos()

Bitmapset * pull_varnos	(	PlannerInfo *	root,
		Node *	node
	)

Definition at line 114 of file var.c.

{
    pull_varnos_context context;
 
    context.varnos = NULL;
    context.root = root;
    context.sublevels_up = 0;
 
    /*
     * Must be prepared to start with a Query or a bare expression tree; if
     * it's a Query, we don't want to increment sublevels_up.
     */
    query_or_expression_tree_walker(node,
                                    pull_varnos_walker,
                                    &context,
                                    0);
 
    return context.varnos;
}

References pull_varnos_walker(), query_or_expression_tree_walker, pull_varnos_context::root, root, pull_varnos_context::sublevels_up, and pull_varnos_context::varnos.

Referenced by compute_semijoin_info(), convert_ANY_sublink_to_join(), convert_EXISTS_sublink_to_join(), cost_incremental_sort(), distribute_qual_to_rels(), examine_variable(), expand_indexqual_rowcompare(), extract_lateral_vars_from_PHVs(), find_placeholder_info(), get_eclass_for_sort_expr(), is_pseudo_constant_for_index(), IsTidEqualAnyClause(), join_is_removable(), make_outerjoininfo(), make_plain_restrictinfo(), match_rowcompare_to_indexcol(), match_saopclause_to_indexcol(), NumRelids(), pg_get_expr_worker(), process_implied_equality(), pullup_replace_vars_callback(), remove_leftjoinrel_from_query(), and subquery_planner().

pull_varnos_of_level()

Bitmapset * pull_varnos_of_level	(	PlannerInfo *	root,
		Node *	node,
		int	levelsup
	)

Definition at line 140 of file var.c.

{
    pull_varnos_context context;
 
    context.varnos = NULL;
    context.root = root;
    context.sublevels_up = levelsup;
 
    /*
     * Must be prepared to start with a Query or a bare expression tree; if
     * it's a Query, we don't want to increment sublevels_up.
     */
    query_or_expression_tree_walker(node,
                                    pull_varnos_walker,
                                    &context,
                                    0);
 
    return context.varnos;
}

References pull_varnos_walker(), query_or_expression_tree_walker, pull_varnos_context::root, root, pull_varnos_context::sublevels_up, and pull_varnos_context::varnos.

Referenced by add_nullingrels_if_needed(), convert_ANY_sublink_to_join(), is_simple_subquery(), jointree_contains_lateral_outer_refs(), and mark_nullable_by_grouping().

pull_vars_of_level()

List * pull_vars_of_level	(	Node *	node,
		int	levelsup
	)

Definition at line 339 of file var.c.

{
    pull_vars_context context;
 
    context.vars = NIL;
    context.sublevels_up = levelsup;
 
    /*
     * Must be prepared to start with a Query or a bare expression tree; if
     * it's a Query, we don't want to increment sublevels_up.
     */
    query_or_expression_tree_walker(node,
                                    pull_vars_walker,
                                    &context,
                                    0);
 
    return context.vars;
}

References NIL, pull_vars_walker(), query_or_expression_tree_walker, pull_vars_context::sublevels_up, and pull_vars_context::vars.

Referenced by extract_lateral_references(), and extract_lateral_vars_from_PHVs().

Variable Documentation

cpu_index_tuple_cost

PGDLLIMPORT double cpu_index_tuple_cost

extern

Definition at line 133 of file costsize.c.

Referenced by genericcostestimate(), and gincostestimate().

cpu_operator_cost

PGDLLIMPORT double cpu_operator_cost

extern

Definition at line 134 of file costsize.c.

Referenced by add_function_cost(), brincostestimate(), btcostestimate(), cached_plan_cost(), cost_agg(), cost_bitmap_and_node(), cost_bitmap_or_node(), cost_bitmap_tree_node(), cost_gather_merge(), cost_group(), cost_material(), cost_memoize_rescan(), cost_merge_append(), cost_qual_eval_walker(), cost_rescan(), cost_subplan(), cost_tuplesort(), cost_valuesscan(), cost_windowagg(), create_mergejoin_plan(), create_setop_path(), create_unique_path(), create_upper_unique_path(), estimate_path_cost_size(), final_cost_mergejoin(), find_simplified_clause(), genericcostestimate(), gincostestimate(), gistcostestimate(), initial_cost_hashjoin(), inline_function(), make_sort_input_target(), order_qual_clauses(), spgcostestimate(), and test_support_func().

cpu_tuple_cost

PGDLLIMPORT double cpu_tuple_cost

extern

Definition at line 132 of file costsize.c.

Referenced by cost_agg(), cost_append(), cost_bitmap_heap_scan(), cost_ctescan(), cost_functionscan(), cost_incremental_sort(), cost_index(), cost_memoize_rescan(), cost_merge_append(), cost_namedtuplestorescan(), cost_recursive_union(), cost_rescan(), cost_resultscan(), cost_samplescan(), cost_seqscan(), cost_subqueryscan(), cost_tablefuncscan(), cost_tidrangescan(), cost_tidscan(), cost_valuesscan(), cost_windowagg(), create_group_result_path(), create_lockrows_path(), create_memoize_path(), create_minmaxagg_path(), create_projection_path(), create_set_projection_path(), estimate_costs(), estimate_path_cost_size(), final_cost_hashjoin(), final_cost_mergejoin(), final_cost_nestloop(), and initial_cost_hashjoin().

debug_parallel_query

PGDLLIMPORT int debug_parallel_query

extern

Definition at line 68 of file planner.c.

Referenced by ProcessParallelMessage(), query_planner(), and standard_planner().

effective_cache_size

PGDLLIMPORT int effective_cache_size

extern

Definition at line 139 of file costsize.c.

Referenced by gistBuildCallback(), gistInitBuffering(), and index_pages_fetched().

enable_distinct_reordering

PGDLLIMPORT bool enable_distinct_reordering

extern

Definition at line 70 of file planner.c.

Referenced by get_useful_pathkeys_for_distinct().

parallel_leader_participation

PGDLLIMPORT bool parallel_leader_participation

extern

Definition at line 69 of file planner.c.

Referenced by ExecGather(), ExecGatherMerge(), ExecInitGather(), and get_parallel_divisor().

parallel_setup_cost

PGDLLIMPORT double parallel_setup_cost

extern

Definition at line 136 of file costsize.c.

Referenced by cost_gather(), cost_gather_merge(), and standard_planner().

parallel_tuple_cost

PGDLLIMPORT double parallel_tuple_cost

extern

Definition at line 135 of file costsize.c.

Referenced by cost_gather(), cost_gather_merge(), and standard_planner().

random_page_cost

PGDLLIMPORT double random_page_cost

extern

Definition at line 131 of file costsize.c.

Referenced by cost_agg(), cost_tuplesort(), get_tablespace_page_costs(), and tablespace_reloptions().

recursive_worktable_factor

PGDLLIMPORT double recursive_worktable_factor

extern

Definition at line 137 of file costsize.c.

Referenced by set_cte_size_estimates().

seq_page_cost

PGDLLIMPORT double seq_page_cost

extern

Definition at line 130 of file costsize.c.

Referenced by cost_agg(), cost_material(), cost_rescan(), cost_tuplesort(), estimate_costs(), estimate_path_cost_size(), get_tablespace_page_costs(), initial_cost_hashjoin(), and tablespace_reloptions().