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	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 ExplainState	ExplainState
typedef struct PlannerInfo	PlannerInfo
typedef struct IndexOptInfo	IndexOptInfo
typedef struct SpecialJoinInfo	SpecialJoinInfo
typedef struct PlannedStmt	PlannedStmt
typedef struct ParamListInfoData *	ParamListInfo
typedef struct HeapTupleData *	HeapTuple

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)
bool	is_pseudo_constant_for_index (PlannerInfo *root, Node *expr, IndexOptInfo *index)
PlannedStmt *	planner (Query *parse, const char *query_string, int cursorOptions, ParamListInfo boundParams, ExplainState *es)
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)
bool	var_is_nonnullable (PlannerInfo *root, Var *var, bool use_rel_info)
bool	expr_is_nonnullable (PlannerInfo *root, Expr *expr, bool use_rel_info)
List *	expand_function_arguments (List *args, bool include_out_arguments, Oid result_type, HeapTuple 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

PVC_INCLUDE_AGGREGATES

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

Definition at line 188 of file optimizer.h.

PVC_INCLUDE_PLACEHOLDERS

#define PVC_INCLUDE_PLACEHOLDERS

Value:

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

Definition at line 192 of file optimizer.h.

PVC_INCLUDE_WINDOWFUNCS

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

Definition at line 190 of file optimizer.h.

PVC_RECURSE_AGGREGATES

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

Definition at line 189 of file optimizer.h.

PVC_RECURSE_PLACEHOLDERS

#define PVC_RECURSE_PLACEHOLDERS

Value:

                                             0x0020 /* recurse into PlaceHolderVar
                                             * arguments */

Definition at line 193 of file optimizer.h.

PVC_RECURSE_WINDOWFUNCS

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

Definition at line 191 of file optimizer.h.

Typedef Documentation

ExplainState

typedef struct ExplainState ExplainState

Definition at line 27 of file optimizer.h.

HeapTuple

typedef struct HeapTupleData* HeapTuple

Definition at line 42 of file optimizer.h.

IndexOptInfo

typedef struct IndexOptInfo IndexOptInfo

Definition at line 36 of file optimizer.h.

ParamListInfo

typedef struct ParamListInfoData* ParamListInfo

Definition at line 41 of file optimizer.h.

PlannedStmt

typedef struct PlannedStmt PlannedStmt

Definition at line 40 of file optimizer.h.

PlannerInfo

typedef struct PlannerInfo PlannerInfo

Definition at line 35 of file optimizer.h.

SpecialJoinInfo

typedef struct SpecialJoinInfo SpecialJoinInfo

Definition at line 37 of file optimizer.h.

Enumeration Type Documentation

DebugParallelMode

enum DebugParallelMode

Enumerator
DEBUG_PARALLEL_OFF
DEBUG_PARALLEL_ON
DEBUG_PARALLEL_REGRESS

Definition at line 94 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  )

extern

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, fb(), 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_row_est()

double clamp_row_est ( double  nrows )

extern

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 fb(), and 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(), cost_tidrangescan(), 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 )

extern

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, fb(), 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  )

extern

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  )

extern

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);
 
        /* If no support, fall back on boolvarsel */
        if (s1 < 0)
            s1 = boolvarsel(root, clause, varRelid);
    }
    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, bms_is_member(), booltestsel(), boolvarsel(), RestrictInfo::clause, clause_selectivity_ext(), clauselist_selectivity_ext(), clauselist_selectivity_or(), CurrentOfExpr::cvarno, DatumGetBool(), DEBUG4, elog, estimate_expression_value(), fb(), find_base_rel(), function_selectivity(), get_notclausearg(), is_andclause(), is_funcclause(), is_notclause(), is_opclause(), is_orclause(), IsA, JOIN_INNER, join_selectivity(), nulltestsel(), restriction_selectivity(), root, rowcomparesel(), s1, scalararraysel(), treat_as_join_clause(), 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  )

extern

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  )

extern

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(), OpExpr::args, bms_is_member(), RestrictInfo::clause, clause_selectivity_ext(), DEFAULT_INEQ_SEL, DEFAULT_RANGE_INEQ_SEL, fb(), find_single_rel_for_clauses(), get_oprrest(), RangeQueryClause::hibound, IS_NULL, is_opclause(), is_pseudo_constant_clause(), is_pseudo_constant_clause_relids(), IsA, lfirst, linitial, list_length(), lsecond, NIL, nulltestsel(), NumRelids(), OpExpr::opno, pfree(), root, RTE_RELATION, RelOptInfo::rtekind, s1, s2, statext_clauselist_selectivity(), and RelOptInfo::statlist.

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

contain_mutable_functions()

bool contain_mutable_functions ( Node *  clause )

extern

Definition at line 379 of file clauses.c.

{
    return contain_mutable_functions_walker(clause, NULL);
}

References contain_mutable_functions_walker(), and fb().

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 )

extern

Definition at line 499 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 )

extern

Definition at line 406 of file var.c.

{
    return contain_var_clause_walker(node, NULL);
}

References contain_var_clause_walker(), and fb().

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  )

extern

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(), transformInsertStmt(), transformJsonTable(), transformRangeFunction(), transformRangeTableFunc(), transformSetOperationTree(), and transformValuesClause().

contain_vars_returning_old_or_new()

bool contain_vars_returning_old_or_new ( Node *  node )

extern

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

Referenced by make_modifytable().

contain_volatile_functions()

bool contain_volatile_functions ( Node *  clause )

extern

Definition at line 547 of file clauses.c.

{
    return contain_volatile_functions_walker(clause, NULL);
}

References contain_volatile_functions_walker(), and fb().

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_function_in_from(), 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 )

extern

Definition at line 668 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 )

extern

Definition at line 682 of file clauses.c.

{
    return contain_volatile_functions_not_nextval_walker(clause, NULL);
}

References contain_volatile_functions_not_nextval_walker(), and fb().

Referenced by BeginCopyFrom().

convert_saop_to_hashed_saop()

void convert_saop_to_hashed_saop ( Node *  node )

extern

Definition at line 2300 of file clauses.c.

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

References convert_saop_to_hashed_saop_walker(), and fb().

Referenced by preprocess_expression().

count_nonjunk_tlist_entries()

int count_nonjunk_tlist_entries ( List *  tlist )

extern

Definition at line 195 of file tlist.c.

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

References fb(), 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  )

extern

Definition at line 2408 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(), fb(), 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  )

extern

Definition at line 2267 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(), fb(), NIL, eval_const_expressions_context::root, and root.

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

evaluate_expr()

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

extern

Definition at line 5395 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(), fb(), 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, HeapTuple  func_tuple  )

extern

Definition at line 4598 of file clauses.c.

{
    Form_pg_proc funcform = (Form_pg_proc) GETSTRUCT(func_tuple);
    Oid        *proargtypes = funcform->proargtypes.values;
    int         pronargs = funcform->pronargs;
    bool        has_named_args = false;
    ListCell   *lc;
 
    /*
     * If we are asked to match to OUT arguments, then use the proallargtypes
     * array (which includes those); otherwise use proargtypes (which
     * doesn't).  Of course, if proallargtypes is null, we always use
     * proargtypes.  (Fetching proallargtypes is annoyingly expensive
     * considering that we may have nothing to do here, but fortunately the
     * common case is include_out_arguments == false.)
     */
    if (include_out_arguments)
    {
        Datum       proallargtypes;
        bool        isNull;
 
        proallargtypes = SysCacheGetAttr(PROCOID, func_tuple,
                                         Anum_pg_proc_proallargtypes,
                                         &isNull);
        if (!isNull)
        {
            ArrayType  *arr = DatumGetArrayTypeP(proallargtypes);
 
            pronargs = ARR_DIMS(arr)[0];
            if (ARR_NDIM(arr) != 1 ||
                pronargs < 0 ||
                ARR_HASNULL(arr) ||
                ARR_ELEMTYPE(arr) != OIDOID)
                elog(ERROR, "proallargtypes is not a 1-D Oid array or it contains nulls");
            Assert(pronargs >= funcform->pronargs);
            proargtypes = (Oid *) ARR_DATA_PTR(arr);
        }
    }
 
    /* Do we have any named arguments? */
    foreach(lc, args)
    {
        Node       *arg = (Node *) lfirst(lc);
 
        if (IsA(arg, NamedArgExpr))
        {
            has_named_args = true;
            break;
        }
    }
 
    /* If so, we must apply reorder_function_arguments */
    if (has_named_args)
    {
        args = reorder_function_arguments(args, pronargs, func_tuple);
        /* Recheck argument types and add casts if needed */
        recheck_cast_function_args(args, result_type,
                                   proargtypes, pronargs,
                                   func_tuple);
    }
    else if (list_length(args) < pronargs)
    {
        /* No named args, but we seem to be short some defaults */
        args = add_function_defaults(args, pronargs, func_tuple);
        /* Recheck argument types and add casts if needed */
        recheck_cast_function_args(args, result_type,
                                   proargtypes, pronargs,
                                   func_tuple);
    }
 
    return args;
}

References add_function_defaults(), arg, ARR_DATA_PTR, ARR_DIMS, ARR_ELEMTYPE, ARR_HASNULL, ARR_NDIM, Assert, DatumGetArrayTypeP, elog, ERROR, fb(), Form_pg_proc, GETSTRUCT(), IsA, lfirst, list_length(), pronargs, recheck_cast_function_args(), reorder_function_arguments(), and SysCacheGetAttr().

Referenced by eval_const_expressions_mutator(), simplify_function(), and transformCallStmt().

expr_is_nonnullable()

bool expr_is_nonnullable ( PlannerInfo *  root, Expr *  expr, bool  use_rel_info  )

extern

Definition at line 4456 of file clauses.c.

{
    /* since this function recurses, it could be driven to stack overflow */
    check_stack_depth();
 
    switch (nodeTag(expr))
    {
        case T_Var:
            {
                if (root)
                    return var_is_nonnullable(root, (Var *) expr, use_rel_info);
            }
            break;
        case T_Const:
            return !((Const *) expr)->constisnull;
        case T_CoalesceExpr:
            {
                /*
                 * A CoalesceExpr returns NULL if and only if all its
                 * arguments are NULL.  Therefore, we can determine that a
                 * CoalesceExpr cannot be NULL if at least one of its
                 * arguments can be proven non-nullable.
                 */
                CoalesceExpr *coalesceexpr = (CoalesceExpr *) expr;
 
                foreach_ptr(Expr, arg, coalesceexpr->args)
                {
                    if (expr_is_nonnullable(root, arg, use_rel_info))
                        return true;
                }
            }
            break;
        case T_MinMaxExpr:
            {
                /*
                 * Like CoalesceExpr, a MinMaxExpr returns NULL only if all
                 * its arguments evaluate to NULL.
                 */
                MinMaxExpr *minmaxexpr = (MinMaxExpr *) expr;
 
                foreach_ptr(Expr, arg, minmaxexpr->args)
                {
                    if (expr_is_nonnullable(root, arg, use_rel_info))
                        return true;
                }
            }
            break;
        case T_CaseExpr:
            {
                /*
                 * A CASE expression is non-nullable if all branch results are
                 * non-nullable.  We must also verify that the default result
                 * (ELSE) exists and is non-nullable.
                 */
                CaseExpr   *caseexpr = (CaseExpr *) expr;
 
                /* The default result must be present and non-nullable */
                if (caseexpr->defresult == NULL ||
                    !expr_is_nonnullable(root, caseexpr->defresult, use_rel_info))
                    return false;
 
                /* All branch results must be non-nullable */
                foreach_ptr(CaseWhen, casewhen, caseexpr->args)
                {
                    if (!expr_is_nonnullable(root, casewhen->result, use_rel_info))
                        return false;
                }
 
                return true;
            }
            break;
        case T_ArrayExpr:
            {
                /*
                 * An ARRAY[] expression always returns a valid Array object,
                 * even if it is empty (ARRAY[]) or contains NULLs
                 * (ARRAY[NULL]).  It never evaluates to a SQL NULL.
                 */
                return true;
            }
        case T_NullTest:
            {
                /*
                 * An IS NULL / IS NOT NULL expression always returns a
                 * boolean value.  It never returns SQL NULL.
                 */
                return true;
            }
        case T_BooleanTest:
            {
                /*
                 * A BooleanTest expression always evaluates to a boolean
                 * value.  It never returns SQL NULL.
                 */
                return true;
            }
        case T_DistinctExpr:
            {
                /*
                 * IS DISTINCT FROM never returns NULL, effectively acting as
                 * though NULL were a normal data value.
                 */
                return true;
            }
        case T_RelabelType:
            {
                /*
                 * RelabelType does not change the nullability of the data.
                 * The result is non-nullable if and only if the argument is
                 * non-nullable.
                 */
                return expr_is_nonnullable(root, ((RelabelType *) expr)->arg,
                                           use_rel_info);
            }
        default:
            break;
    }
 
    return false;
}

References arg, check_stack_depth(), expr_is_nonnullable(), fb(), foreach_ptr, nodeTag, root, and var_is_nonnullable().

Referenced by eval_const_expressions_mutator(), expr_is_nonnullable(), int8inc_support(), restriction_is_always_false(), and restriction_is_always_true().

expression_planner()

Expr * expression_planner ( Expr *  expr )

extern

Definition at line 6819 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(), fb(), and fix_opfuncids().

Referenced by ATExecAddColumn(), ATExecSetExpression(), ATPrepAlterColumnType(), BeginCopyFrom(), ComputePartitionAttrs(), contain_mutable_functions_after_planning(), contain_volatile_functions_after_planning(), createTableConstraints(), 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  )

extern

Definition at line 6846 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(), fb(), 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  )

extern

Definition at line 3707 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(), fb(), 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  )

extern

Definition at line 972 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 check_output_expressions(), get_query_def(), and subquery_planner().

flatten_join_alias_vars()

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

extern

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  )

extern

Definition at line 388 of file tlist.c.

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

References fb(), 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  )

extern

Definition at line 376 of file tlist.c.

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

References fb(), and get_sortgroupref_tle().

Referenced by build_pertrans_for_aggref(), create_grouping_expr_infos(), 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(), 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  )

extern

Definition at line 401 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 fb(), 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  )

extern

Definition at line 431 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, fb(), and lfirst.

Referenced by init_grouping_targets(), and preprocess_groupclause().

get_sortgroupref_clause_noerr()

SortGroupClause * get_sortgroupref_clause_noerr ( Index  sortref, List *  clauses  )

extern

Definition at line 452 of file tlist.c.

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

References fb(), and lfirst.

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  )

extern

Definition at line 354 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, fb(), and lfirst.

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  )

extern

Definition at line 4537 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  )

extern

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 fb(), 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  )

extern

Definition at line 5943 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 = palloc_array(Datum, list_length(exprs));
        nulls = palloc_array(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 construct_md_array(), fb(), foreach_node, get_array_type(), get_opcode(), get_typlenbyvalalign(), i, InvalidOid, list_free(), list_length(), list_make2, makeConst(), makeNode, OidIsValid, oper(), palloc_array, pfree(), PointerGetDatum(), typalign, and value.

Referenced by convert_VALUES_to_ANY(), and match_orclause_to_indexcol().

negate_clause()

Node * negate_clause ( Node *  node )

extern

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, BoolExpr::args, BoolExpr::boolop, BooleanTest::booltesttype, DatumGetBool(), elog, ERROR, fb(), 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, NullTest::location, BooleanTest::location, make_andclause(), make_notclause(), make_orclause(), makeBoolConst(), makeNode, negate_clause(), NIL, nodeTag, NOT_EXPR, NullTest::nulltesttype, OpExpr::opno, and OR_EXPR.

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  )

extern

Definition at line 6899 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, enable_indexscan, fb(), ForwardScanDirection, get_relation_data_width(), RelOptInfo::indexlist, IndexOptInfo::indexoid, lfirst_node, list_make1, maintenance_work_mem, makeNode, NIL, RelOptInfo::pages, RelOptInfo::reltarget, root, RelOptInfo::rows, Query::rtable, RTE_RELATION, setup_simple_rel_arrays(), RelOptInfo::tuples, and PathTarget::width.

Referenced by copy_table_data().

plan_create_index_workers()

int plan_create_index_workers ( Oid  tableOid, Oid  indexOid  )

extern

Definition at line 7021 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(), fb(), index_close(), index_open(), 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, setup_simple_rel_arrays(), table_close(), and table_open().

Referenced by index_build().

planner()

PlannedStmt * planner ( Query *  parse, const char *  query_string, int  cursorOptions, ParamListInfo  boundParams, ExplainState *  es  )

extern

Definition at line 315 of file planner.c.

{
    PlannedStmt *result;
 
    if (planner_hook)
        result = (*planner_hook) (parse, query_string, cursorOptions,
                                  boundParams, es);
    else
        result = standard_planner(parse, query_string, cursorOptions,
                                  boundParams, es);
 
    pgstat_report_plan_id(result->planId, false);
 
    return result;
}

References parse(), pgstat_report_plan_id(), PlannedStmt::planId, planner_hook, and standard_planner().

Referenced by pg_plan_query().

predicate_implied_by()

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

extern

Definition at line 153 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 fb(), 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  )

extern

Definition at line 223 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 fb(), 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  )

extern

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(), create_agg_clause_infos(), 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(), is_var_in_aggref_only(), 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  )

extern

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 fb(), 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(), createTableConstraints(), DefineIndex(), deparseReturningList(), DoCopy(), 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  )

extern

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 fb(), 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(), create_agg_clause_infos(), 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  )

extern

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 fb(), 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  )

extern

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

var_is_nonnullable()

bool var_is_nonnullable ( PlannerInfo *  root, Var *  var, bool  use_rel_info  )

extern

Definition at line 4391 of file clauses.c.

{
    Bitmapset  *notnullattnums = NULL;
 
    Assert(IsA(var, Var));
 
    /* skip upper-level Vars */
    if (var->varlevelsup != 0)
        return false;
 
    /* could the Var be nulled by any outer joins or grouping sets? */
    if (!bms_is_empty(var->varnullingrels))
        return false;
 
    /* system columns cannot be NULL */
    if (var->varattno < 0)
        return true;
 
    /*
     * Check if the Var is defined as NOT NULL.  We retrieve the column NOT
     * NULL constraint information from the corresponding RelOptInfo if it is
     * available; otherwise, we search the hash table for this information.
     */
    if (use_rel_info)
    {
        RelOptInfo *rel = find_base_rel(root, var->varno);
 
        notnullattnums = rel->notnullattnums;
    }
    else
    {
        RangeTblEntry *rte = planner_rt_fetch(var->varno, root);
 
        /*
         * We must skip inheritance parent tables, as some child tables may
         * have a NOT NULL constraint for a column while others may not.  This
         * cannot happen with partitioned tables, though.
         */
        if (rte->inh && rte->relkind != RELKIND_PARTITIONED_TABLE)
            return false;
 
        notnullattnums = find_relation_notnullatts(root, rte->relid);
    }
 
    if (var->varattno > 0 &&
        bms_is_member(var->varattno, notnullattnums))
        return true;
 
    return false;
}

References Assert, bms_is_empty, bms_is_member(), fb(), find_base_rel(), find_relation_notnullatts(), IsA, RelOptInfo::notnullattnums, planner_rt_fetch, root, Var::varattno, Var::varlevelsup, and Var::varno.

Referenced by expr_is_nonnullable().

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(), 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 69 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 71 of file planner.c.

Referenced by get_useful_pathkeys_for_distinct().

parallel_leader_participation

PGDLLIMPORT bool parallel_leader_participation

extern

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