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

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)
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_volatile_functions (Node *clause)
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)
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)
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)

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

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 183 of file optimizer.h.

PVC_INCLUDE_PLACEHOLDERS

#define PVC_INCLUDE_PLACEHOLDERS

Value:

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

Definition at line 187 of file optimizer.h.

PVC_INCLUDE_WINDOWFUNCS

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

Definition at line 185 of file optimizer.h.

PVC_RECURSE_AGGREGATES

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

Definition at line 184 of file optimizer.h.

PVC_RECURSE_PLACEHOLDERS

#define PVC_RECURSE_PLACEHOLDERS

Value:

                                             0x0020 /* recurse into PlaceHolderVar
                                             * arguments */

Definition at line 188 of file optimizer.h.

PVC_RECURSE_WINDOWFUNCS

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

Definition at line 186 of file optimizer.h.

Typedef Documentation

IndexOptInfo

typedef struct IndexOptInfo IndexOptInfo

Definition at line 1 of file optimizer.h.

PlannerInfo

typedef struct PlannerInfo PlannerInfo

Definition at line 1 of file optimizer.h.

SpecialJoinInfo

typedef struct SpecialJoinInfo SpecialJoinInfo

Definition at line 1 of file optimizer.h.

Enumeration Type Documentation

DebugParallelMode

enum DebugParallelMode

Enumerator
DEBUG_PARALLEL_OFF
DEBUG_PARALLEL_ON
DEBUG_PARALLEL_REGRESS

Definition at line 103 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 294 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 226 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 203 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(), cost_agg(), cost_append(), cost_bitmap_heap_scan(), cost_group(), cost_index(), cost_seqscan(), cost_subplan(), cost_subqueryscan(), create_bitmap_subplan(), 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(), initial_cost_mergejoin(), set_baserel_size_estimates(), set_cte_size_estimates(), set_foreign_size(), system_rows_samplescangetsamplesize(), system_samplescangetsamplesize(), and system_time_samplescangetsamplesize().

clause_selectivity()

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

Definition at line 669 of file clausesel.c.

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

References clause_selectivity_ext().

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 686 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, 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(), rowcomparesel(), s1, scalararraysel(), treat_as_join_clause(), RelOptInfo::tuples, and RangeQueryClause::var.

Referenced by clause_selectivity(), 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 102 of file clausesel.c.

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

References clauselist_selectivity_ext().

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 119 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(), 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 367 of file clauses.c.

{
    return contain_mutable_functions_walker(clause, NULL);
}

References contain_mutable_functions_walker().

Referenced by can_minmax_aggs(), check_index_predicates(), CheckMutability(), ComputePartitionAttrs(), cookDefault(), 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_var_clause()

bool contain_var_clause

(

Node *

node

)

Definition at line 403 of file var.c.

{
    return contain_var_clause_walker(node, NULL);
}

References contain_var_clause_walker().

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

contain_vars_of_level()

bool contain_vars_of_level	(	Node *	node,
		int	levelsup
	)

Definition at line 441 of file var.c.

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

References contain_vars_of_level_walker(), and query_or_expression_tree_walker.

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

contain_volatile_functions()

bool contain_volatile_functions

(

Node *

clause

)

Definition at line 483 of file clauses.c.

{
    return contain_volatile_functions_walker(clause, NULL);
}

References contain_volatile_functions_walker().

Referenced by AddRelationNewConstraints(), apply_child_basequals(), check_hashjoinable(), check_mergejoinable(), check_output_expressions(), compute_semijoin_info(), convert_ANY_sublink_to_join(), convert_EXISTS_sublink_to_join(), convert_EXISTS_to_ANY(), CopyFrom(), distribute_qual_to_rels(), estimate_num_groups(), ExecInitWindowAgg(), expand_indexqual_rowcompare(), find_compatible_agg(), get_eclass_for_sort_expr(), get_memoize_path(), 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(), match_clause_to_ordering_op(), match_clause_to_partition_key(), match_opclause_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_not_nextval()

bool contain_volatile_functions_not_nextval

(

Node *

clause

)

Definition at line 590 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 2204 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 2312 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(), PlannerInfo::glob, NIL, and eval_const_expressions_context::root.

Referenced by array_unnest_support(), bernoulli_samplescangetsamplesize(), clause_selectivity_ext(), generate_series_int4_support(), generate_series_int8_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 2171 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(), PlannerInfo::glob, NIL, and eval_const_expressions_context::root.

Referenced by apply_child_basequals(), ATExecAttachPartition(), ConstraintImpliedByRelConstraint(), convert_EXISTS_to_ANY(), DetachAddConstraintIfNeeded(), DoCopy(), 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 4879 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 6431 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 6458 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_query_dependencies()

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

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

Referenced by CompleteCachedPlan(), and RevalidateCachedQuery().

flatten_join_alias_vars()

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

Definition at line 744 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, 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(), and group_by_has_partkey().

get_sortgroupref_clause()

SortGroupClause* get_sortgroupref_clause	(	Index	sortref,
		List *	clauses
	)

Definition at line 422 of file tlist.c.

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

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

Referenced by preprocess_groupclause().

get_sortgroupref_clause_noerr()

SortGroupClause* get_sortgroupref_clause_noerr	(	Index	sortref,
		List *	clauses
	)

Definition at line 443 of file tlist.c.

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

References lfirst, and SortGroupClause::tleSortGroupRef.

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

get_sortgroupref_tle()

TargetEntry* get_sortgroupref_tle	(	Index	sortref,
		List *	targetList
	)

Definition at line 345 of file tlist.c.

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

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

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

is_pseudo_constant_for_index()

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

Definition at line 3799 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(), and pull_varnos().

locate_var_of_level()

int locate_var_of_level	(	Node *	node,
		int	levelsup
	)

Definition at line 509 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,
                                           (void *) &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().

negate_clause()

Node* negate_clause

(

Node *

node

)

Definition at line 74 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, 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(), and simplify_boolean_equality().

plan_cluster_use_sort()

bool plan_cluster_use_sort	(	Oid	tableOid,
		Oid	indexOid
	)

Definition at line 6511 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->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, enable_indexscan, ForwardScanDirection, get_relation_data_width(), PlannerInfo::glob, RelOptInfo::indexlist, IndexOptInfo::indexoid, RangeTblEntry::inFromCl, RangeTblEntry::inh, PlannerInfo::join_domains, RangeTblEntry::lateral, lfirst_node, list_make1, maintenance_work_mem, makeNode, NIL, RelOptInfo::pages, PlannerInfo::parse, IndexPath::path, QualCost::per_tuple, PlannerInfo::query_level, RangeTblEntry::relid, RangeTblEntry::relkind, RangeTblEntry::rellockmode, RelOptInfo::reltarget, RelOptInfo::rows, Query::rtable, RTE_RELATION, RangeTblEntry::rtekind, setup_simple_rel_arrays(), QualCost::startup, Path::total_cost, PlannerInfo::total_table_pages, RelOptInfo::tuples, PathTarget::width, and PlannerInfo::wt_param_id.

Referenced by copy_table_data().

plan_create_index_workers()

int plan_create_index_workers	(	Oid	tableOid,
		Oid	indexOid
	)

Definition at line 6631 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) < 32768L)
        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(), PlannerInfo::glob, index_close(), index_open(), RangeTblEntry::inFromCl, RangeTblEntry::inh, is_parallel_safe(), IsUnderPostmaster, PlannerInfo::join_domains, RangeTblEntry::lateral, list_make1, maintenance_work_mem, makeNode, max_parallel_maintenance_workers, Min, NoLock, PlannerInfo::parse, PlannerInfo::query_level, RelationData::rd_rel, RelOptInfo::rel_parallel_workers, RelationGetIndexExpressions(), RelationGetIndexPredicate(), RangeTblEntry::relid, RangeTblEntry::relkind, RangeTblEntry::rellockmode, Query::rtable, RTE_RELATION, RangeTblEntry::rtekind, setup_simple_rel_arrays(), table_close(), table_open(), and PlannerInfo::wt_param_id.

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 607 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(), and StoreRelCheck().

pull_varattnos()

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

Definition at line 291 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(), ExecInitStoredGenerated(), 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 108 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,
                                    (void *) &context,
                                    0);
 
    return context.varnos;
}

References pull_varnos_walker(), query_or_expression_tree_walker, pull_varnos_context::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(), find_placeholder_info(), get_eclass_for_sort_expr(), is_pseudo_constant_for_index(), IsTidEqualAnyClause(), join_is_removable(), make_outerjoininfo(), make_restrictinfo_internal(), match_rowcompare_to_indexcol(), match_saopclause_to_indexcol(), NumRelids(), pg_get_expr_worker(), process_implied_equality(), and remove_rel_from_query().

pull_varnos_of_level()

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

Definition at line 134 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,
                                    (void *) &context,
                                    0);
 
    return context.varnos;
}

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

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

pull_vars_of_level()

List* pull_vars_of_level	(	Node *	node,
		int	levelsup
	)

Definition at line 335 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,
                                    (void *) &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().

Variable Documentation

cpu_index_tuple_cost

PGDLLIMPORT double cpu_index_tuple_cost

extern

Definition at line 123 of file costsize.c.

Referenced by genericcostestimate(), and gincostestimate().

cpu_operator_cost

PGDLLIMPORT double cpu_operator_cost

extern

Definition at line 124 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(), 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 122 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 73 of file planner.c.

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

effective_cache_size

PGDLLIMPORT int effective_cache_size

extern

Definition at line 129 of file costsize.c.

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

parallel_leader_participation

PGDLLIMPORT bool parallel_leader_participation

extern

Definition at line 74 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 126 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 125 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 121 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 127 of file costsize.c.

Referenced by set_cte_size_estimates().

seq_page_cost

PGDLLIMPORT double seq_page_cost

extern

Definition at line 120 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().