extended_stats.c File Reference

#include "postgres.h"
#include "access/detoast.h"
#include "access/genam.h"
#include "access/htup_details.h"
#include "access/table.h"
#include "catalog/indexing.h"
#include "catalog/pg_statistic_ext.h"
#include "catalog/pg_statistic_ext_data.h"
#include "commands/defrem.h"
#include "commands/progress.h"
#include "executor/executor.h"
#include "miscadmin.h"
#include "nodes/nodeFuncs.h"
#include "optimizer/optimizer.h"
#include "parser/parsetree.h"
#include "pgstat.h"
#include "postmaster/autovacuum.h"
#include "statistics/extended_stats_internal.h"
#include "statistics/statistics.h"
#include "utils/acl.h"
#include "utils/array.h"
#include "utils/attoptcache.h"
#include "utils/builtins.h"
#include "utils/datum.h"
#include "utils/fmgroids.h"
#include "utils/lsyscache.h"
#include "utils/memutils.h"
#include "utils/rel.h"
#include "utils/selfuncs.h"
#include "utils/syscache.h"

Include dependency graph for extended_stats.c:

Go to the source code of this file.

Data Structures
struct	StatExtEntry
struct	AnlExprData

Macros
#define	WIDTH_THRESHOLD   1024

Typedefs
typedef struct StatExtEntry	StatExtEntry
typedef struct AnlExprData	AnlExprData

Functions
static List *	fetch_statentries_for_relation (Relation pg_statext, Oid relid)
static VacAttrStats **	lookup_var_attr_stats (Bitmapset *attrs, List *exprs, int nvacatts, VacAttrStats **vacatts)
static void	statext_store (Oid statOid, bool inh, MVNDistinct *ndistinct, MVDependencies *dependencies, MCVList *mcv, Datum exprs, VacAttrStats **stats)
static int	statext_compute_stattarget (int stattarget, int nattrs, VacAttrStats **stats)
static void	compute_expr_stats (Relation onerel, AnlExprData *exprdata, int nexprs, HeapTuple *rows, int numrows)
static Datum	serialize_expr_stats (AnlExprData *exprdata, int nexprs)
static Datum	expr_fetch_func (VacAttrStatsP stats, int rownum, bool *isNull)
static AnlExprData *	build_expr_data (List *exprs, int stattarget)
static StatsBuildData *	make_build_data (Relation rel, StatExtEntry *stat, int numrows, HeapTuple *rows, VacAttrStats **stats, int stattarget)
void	BuildRelationExtStatistics (Relation onerel, bool inh, double totalrows, int numrows, HeapTuple *rows, int natts, VacAttrStats **vacattrstats)
int	ComputeExtStatisticsRows (Relation onerel, int natts, VacAttrStats **vacattrstats)
bool	statext_is_kind_built (HeapTuple htup, char type)
static VacAttrStats *	examine_attribute (Node *expr)
static VacAttrStats *	examine_expression (Node *expr, int stattarget)
MultiSortSupport	multi_sort_init (int ndims)
void	multi_sort_add_dimension (MultiSortSupport mss, int sortdim, Oid oper, Oid collation)
int	multi_sort_compare (const void *a, const void *b, void *arg)
int	multi_sort_compare_dim (int dim, const SortItem *a, const SortItem *b, MultiSortSupport mss)
int	multi_sort_compare_dims (int start, int end, const SortItem *a, const SortItem *b, MultiSortSupport mss)
int	compare_scalars_simple (const void *a, const void *b, void *arg)
int	compare_datums_simple (Datum a, Datum b, SortSupport ssup)
AttrNumber *	build_attnums_array (Bitmapset *attrs, int nexprs, int *numattrs)
SortItem *	build_sorted_items (StatsBuildData *data, int *nitems, MultiSortSupport mss, int numattrs, AttrNumber *attnums)
bool	has_stats_of_kind (List *stats, char requiredkind)
static int	stat_find_expression (StatisticExtInfo *stat, Node *expr)
static bool	stat_covers_expressions (StatisticExtInfo *stat, List *exprs, Bitmapset **expr_idxs)
StatisticExtInfo *	choose_best_statistics (List *stats, char requiredkind, bool inh, Bitmapset **clause_attnums, List **clause_exprs, int nclauses)
static bool	statext_is_compatible_clause_internal (PlannerInfo *root, Node *clause, Index relid, Bitmapset **attnums, List **exprs)
static bool	statext_is_compatible_clause (PlannerInfo *root, Node *clause, Index relid, Bitmapset **attnums, List **exprs)
static Selectivity	statext_mcv_clauselist_selectivity (PlannerInfo *root, List *clauses, int varRelid, JoinType jointype, SpecialJoinInfo *sjinfo, RelOptInfo *rel, Bitmapset **estimatedclauses, bool is_or)
Selectivity	statext_clauselist_selectivity (PlannerInfo *root, List *clauses, int varRelid, JoinType jointype, SpecialJoinInfo *sjinfo, RelOptInfo *rel, Bitmapset **estimatedclauses, bool is_or)
bool	examine_opclause_args (List *args, Node **exprp, Const **cstp, bool *expronleftp)
HeapTuple	statext_expressions_load (Oid stxoid, bool inh, int idx)

Macro Definition Documentation

WIDTH_THRESHOLD

#define WIDTH_THRESHOLD   1024

Definition at line 58 of file extended_stats.c.

Typedef Documentation

AnlExprData

typedef struct AnlExprData AnlExprData

StatExtEntry

typedef struct StatExtEntry StatExtEntry

Function Documentation

build_attnums_array()

AttrNumber * build_attnums_array	(	Bitmapset *	attrs,
		int	nexprs,
		int *	numattrs
	)

Definition at line 938 of file extended_stats.c.

{
    int         i,
                j;
    AttrNumber *attnums;
    int         num = bms_num_members(attrs);
 
    if (numattrs)
        *numattrs = num;
 
    /* build attnums from the bitmapset */
    attnums = (AttrNumber *) palloc(sizeof(AttrNumber) * num);
    i = 0;
    j = -1;
    while ((j = bms_next_member(attrs, j)) >= 0)
    {
        int         attnum = (j - nexprs);
 
        /*
         * Make sure the bitmap contains only user-defined attributes. As
         * bitmaps can't contain negative values, this can be violated in two
         * ways. Firstly, the bitmap might contain 0 as a member, and secondly
         * the integer value might be larger than MaxAttrNumber.
         */
        Assert(AttributeNumberIsValid(attnum));
        Assert(attnum <= MaxAttrNumber);
        Assert(attnum >= (-nexprs));
 
        attnums[i++] = (AttrNumber) attnum;
 
        /* protect against overflows */
        Assert(i <= num);
    }
 
    return attnums;
}

References Assert(), attnum, AttributeNumberIsValid, bms_next_member(), bms_num_members(), i, j, MaxAttrNumber, and palloc().

build_expr_data()

static AnlExprData * build_expr_data ( List *  exprs, int  stattarget  )

static

Definition at line 2266 of file extended_stats.c.

{
    int         idx;
    int         nexprs = list_length(exprs);
    AnlExprData *exprdata;
    ListCell   *lc;
 
    exprdata = (AnlExprData *) palloc0(nexprs * sizeof(AnlExprData));
 
    idx = 0;
    foreach(lc, exprs)
    {
        Node       *expr = (Node *) lfirst(lc);
        AnlExprData *thisdata = &exprdata[idx];
 
        thisdata->expr = expr;
        thisdata->vacattrstat = examine_expression(expr, stattarget);
        idx++;
    }
 
    return exprdata;
}

References examine_expression(), AnlExprData::expr, idx(), lfirst, list_length(), palloc0(), and AnlExprData::vacattrstat.

Referenced by BuildRelationExtStatistics().

build_sorted_items()

SortItem * build_sorted_items	(	StatsBuildData *	data,
		int *	nitems,
		MultiSortSupport	mss,
		int	numattrs,
		AttrNumber *	attnums
	)

Definition at line 983 of file extended_stats.c.

{
    int         i,
                j,
                len,
                nrows;
    int         nvalues = data->numrows * numattrs;
 
    SortItem   *items;
    Datum      *values;
    bool       *isnull;
    char       *ptr;
    int        *typlen;
 
    /* Compute the total amount of memory we need (both items and values). */
    len = data->numrows * sizeof(SortItem) + nvalues * (sizeof(Datum) + sizeof(bool));
 
    /* Allocate the memory and split it into the pieces. */
    ptr = palloc0(len);
 
    /* items to sort */
    items = (SortItem *) ptr;
    ptr += data->numrows * sizeof(SortItem);
 
    /* values and null flags */
    values = (Datum *) ptr;
    ptr += nvalues * sizeof(Datum);
 
    isnull = (bool *) ptr;
    ptr += nvalues * sizeof(bool);
 
    /* make sure we consumed the whole buffer exactly */
    Assert((ptr - (char *) items) == len);
 
    /* fix the pointers to Datum and bool arrays */
    nrows = 0;
    for (i = 0; i < data->numrows; i++)
    {
        items[nrows].values = &values[nrows * numattrs];
        items[nrows].isnull = &isnull[nrows * numattrs];
 
        nrows++;
    }
 
    /* build a local cache of typlen for all attributes */
    typlen = (int *) palloc(sizeof(int) * data->nattnums);
    for (i = 0; i < data->nattnums; i++)
        typlen[i] = get_typlen(data->stats[i]->attrtypid);
 
    nrows = 0;
    for (i = 0; i < data->numrows; i++)
    {
        bool        toowide = false;
 
        /* load the values/null flags from sample rows */
        for (j = 0; j < numattrs; j++)
        {
            Datum       value;
            bool        isnull;
            int         attlen;
            AttrNumber  attnum = attnums[j];
 
            int         idx;
 
            /* match attnum to the pre-calculated data */
            for (idx = 0; idx < data->nattnums; idx++)
            {
                if (attnum == data->attnums[idx])
                    break;
            }
 
            Assert(idx < data->nattnums);
 
            value = data->values[idx][i];
            isnull = data->nulls[idx][i];
            attlen = typlen[idx];
 
            /*
             * If this is a varlena value, check if it's too wide and if yes
             * then skip the whole item. Otherwise detoast the value.
             *
             * XXX It may happen that we've already detoasted some preceding
             * values for the current item. We don't bother to cleanup those
             * on the assumption that those are small (below WIDTH_THRESHOLD)
             * and will be discarded at the end of analyze.
             */
            if ((!isnull) && (attlen == -1))
            {
                if (toast_raw_datum_size(value) > WIDTH_THRESHOLD)
                {
                    toowide = true;
                    break;
                }
 
                value = PointerGetDatum(PG_DETOAST_DATUM(value));
            }
 
            items[nrows].values[j] = value;
            items[nrows].isnull[j] = isnull;
        }
 
        if (toowide)
            continue;
 
        nrows++;
    }
 
    /* store the actual number of items (ignoring the too-wide ones) */
    *nitems = nrows;
 
    /* all items were too wide */
    if (nrows == 0)
    {
        /* everything is allocated as a single chunk */
        pfree(items);
        return NULL;
    }
 
    /* do the sort, using the multi-sort */
    qsort_interruptible(items, nrows, sizeof(SortItem),
                        multi_sort_compare, mss);
 
    return items;
}

References Assert(), attlen, attnum, data, get_typlen(), i, idx(), items, j, len, multi_sort_compare(), nitems, palloc(), palloc0(), pfree(), PG_DETOAST_DATUM, PointerGetDatum(), qsort_interruptible(), toast_raw_datum_size(), value, values, and WIDTH_THRESHOLD.

Referenced by dependency_degree(), and statext_mcv_build().

BuildRelationExtStatistics()

void BuildRelationExtStatistics	(	Relation	onerel,
		bool	inh,
		double	totalrows,
		int	numrows,
		HeapTuple *	rows,
		int	natts,
		VacAttrStats **	vacattrstats
	)

Definition at line 111 of file extended_stats.c.

{
    Relation    pg_stext;
    ListCell   *lc;
    List       *statslist;
    MemoryContext cxt;
    MemoryContext oldcxt;
    int64       ext_cnt;
 
    /* Do nothing if there are no columns to analyze. */
    if (!natts)
        return;
 
    /* the list of stats has to be allocated outside the memory context */
    pg_stext = table_open(StatisticExtRelationId, RowExclusiveLock);
    statslist = fetch_statentries_for_relation(pg_stext, RelationGetRelid(onerel));
 
    /* memory context for building each statistics object */
    cxt = AllocSetContextCreate(CurrentMemoryContext,
                                "BuildRelationExtStatistics",
                                ALLOCSET_DEFAULT_SIZES);
    oldcxt = MemoryContextSwitchTo(cxt);
 
    /* report this phase */
    if (statslist != NIL)
    {
        const int   index[] = {
            PROGRESS_ANALYZE_PHASE,
            PROGRESS_ANALYZE_EXT_STATS_TOTAL
        };
        const int64 val[] = {
            PROGRESS_ANALYZE_PHASE_COMPUTE_EXT_STATS,
            list_length(statslist)
        };
 
        pgstat_progress_update_multi_param(2, index, val);
    }
 
    ext_cnt = 0;
    foreach(lc, statslist)
    {
        StatExtEntry *stat = (StatExtEntry *) lfirst(lc);
        MVNDistinct *ndistinct = NULL;
        MVDependencies *dependencies = NULL;
        MCVList    *mcv = NULL;
        Datum       exprstats = (Datum) 0;
        VacAttrStats **stats;
        ListCell   *lc2;
        int         stattarget;
        StatsBuildData *data;
 
        /*
         * Check if we can build these stats based on the column analyzed. If
         * not, report this fact (except in autovacuum) and move on.
         */
        stats = lookup_var_attr_stats(stat->columns, stat->exprs,
                                      natts, vacattrstats);
        if (!stats)
        {
            if (!AmAutoVacuumWorkerProcess())
                ereport(WARNING,
                        (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                         errmsg("statistics object \"%s.%s\" could not be computed for relation \"%s.%s\"",
                                stat->schema, stat->name,
                                get_namespace_name(onerel->rd_rel->relnamespace),
                                RelationGetRelationName(onerel)),
                         errtable(onerel)));
            continue;
        }
 
        /* compute statistics target for this statistics object */
        stattarget = statext_compute_stattarget(stat->stattarget,
                                                bms_num_members(stat->columns),
                                                stats);
 
        /*
         * Don't rebuild statistics objects with statistics target set to 0
         * (we just leave the existing values around, just like we do for
         * regular per-column statistics).
         */
        if (stattarget == 0)
            continue;
 
        /* evaluate expressions (if the statistics object has any) */
        data = make_build_data(onerel, stat, numrows, rows, stats, stattarget);
 
        /* compute statistic of each requested type */
        foreach(lc2, stat->types)
        {
            char        t = (char) lfirst_int(lc2);
 
            if (t == STATS_EXT_NDISTINCT)
                ndistinct = statext_ndistinct_build(totalrows, data);
            else if (t == STATS_EXT_DEPENDENCIES)
                dependencies = statext_dependencies_build(data);
            else if (t == STATS_EXT_MCV)
                mcv = statext_mcv_build(data, totalrows, stattarget);
            else if (t == STATS_EXT_EXPRESSIONS)
            {
                AnlExprData *exprdata;
                int         nexprs;
 
                /* should not happen, thanks to checks when defining stats */
                if (!stat->exprs)
                    elog(ERROR, "requested expression stats, but there are no expressions");
 
                exprdata = build_expr_data(stat->exprs, stattarget);
                nexprs = list_length(stat->exprs);
 
                compute_expr_stats(onerel, exprdata, nexprs, rows, numrows);
 
                exprstats = serialize_expr_stats(exprdata, nexprs);
            }
        }
 
        /* store the statistics in the catalog */
        statext_store(stat->statOid, inh,
                      ndistinct, dependencies, mcv, exprstats, stats);
 
        /* for reporting progress */
        pgstat_progress_update_param(PROGRESS_ANALYZE_EXT_STATS_COMPUTED,
                                     ++ext_cnt);
 
        /* free the data used for building this statistics object */
        MemoryContextReset(cxt);
    }
 
    MemoryContextSwitchTo(oldcxt);
    MemoryContextDelete(cxt);
 
    list_free(statslist);
 
    table_close(pg_stext, RowExclusiveLock);
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, AmAutoVacuumWorkerProcess, bms_num_members(), build_expr_data(), compute_expr_stats(), CurrentMemoryContext, data, elog, ereport, errcode(), errmsg(), ERROR, errtable(), fetch_statentries_for_relation(), get_namespace_name(), lfirst, lfirst_int, list_free(), list_length(), lookup_var_attr_stats(), make_build_data(), MemoryContextDelete(), MemoryContextReset(), MemoryContextSwitchTo(), NIL, pgstat_progress_update_multi_param(), pgstat_progress_update_param(), PROGRESS_ANALYZE_EXT_STATS_COMPUTED, PROGRESS_ANALYZE_EXT_STATS_TOTAL, PROGRESS_ANALYZE_PHASE, PROGRESS_ANALYZE_PHASE_COMPUTE_EXT_STATS, RelationData::rd_rel, RelationGetRelationName, RelationGetRelid, RowExclusiveLock, serialize_expr_stats(), statext_compute_stattarget(), statext_dependencies_build(), statext_mcv_build(), statext_ndistinct_build(), statext_store(), table_close(), table_open(), val, and WARNING.

Referenced by do_analyze_rel().

choose_best_statistics()

StatisticExtInfo * choose_best_statistics	(	List *	stats,
		char	requiredkind,
		bool	inh,
		Bitmapset **	clause_attnums,
		List **	clause_exprs,
		int	nclauses
	)

Definition at line 1206 of file extended_stats.c.

{
    ListCell   *lc;
    StatisticExtInfo *best_match = NULL;
    int         best_num_matched = 2;   /* goal #1: maximize */
    int         best_match_keys = (STATS_MAX_DIMENSIONS + 1);   /* goal #2: minimize */
 
    foreach(lc, stats)
    {
        int         i;
        StatisticExtInfo *info = (StatisticExtInfo *) lfirst(lc);
        Bitmapset  *matched_attnums = NULL;
        Bitmapset  *matched_exprs = NULL;
        int         num_matched;
        int         numkeys;
 
        /* skip statistics that are not of the correct type */
        if (info->kind != requiredkind)
            continue;
 
        /* skip statistics with mismatching inheritance flag */
        if (info->inherit != inh)
            continue;
 
        /*
         * Collect attributes and expressions in remaining (unestimated)
         * clauses fully covered by this statistic object.
         *
         * We know already estimated clauses have both clause_attnums and
         * clause_exprs set to NULL. We leave the pointers NULL if already
         * estimated, or we reset them to NULL after estimating the clause.
         */
        for (i = 0; i < nclauses; i++)
        {
            Bitmapset  *expr_idxs = NULL;
 
            /* ignore incompatible/estimated clauses */
            if (!clause_attnums[i] && !clause_exprs[i])
                continue;
 
            /* ignore clauses that are not covered by this object */
            if (!bms_is_subset(clause_attnums[i], info->keys) ||
                !stat_covers_expressions(info, clause_exprs[i], &expr_idxs))
                continue;
 
            /* record attnums and indexes of expressions covered */
            matched_attnums = bms_add_members(matched_attnums, clause_attnums[i]);
            matched_exprs = bms_add_members(matched_exprs, expr_idxs);
        }
 
        num_matched = bms_num_members(matched_attnums) + bms_num_members(matched_exprs);
 
        bms_free(matched_attnums);
        bms_free(matched_exprs);
 
        /*
         * save the actual number of keys in the stats so that we can choose
         * the narrowest stats with the most matching keys.
         */
        numkeys = bms_num_members(info->keys) + list_length(info->exprs);
 
        /*
         * Use this object when it increases the number of matched attributes
         * and expressions or when it matches the same number of attributes
         * and expressions but these stats have fewer keys than any previous
         * match.
         */
        if (num_matched > best_num_matched ||
            (num_matched == best_num_matched && numkeys < best_match_keys))
        {
            best_match = info;
            best_num_matched = num_matched;
            best_match_keys = numkeys;
        }
    }
 
    return best_match;
}

References bms_add_members(), bms_free(), bms_is_subset(), bms_num_members(), StatisticExtInfo::exprs, i, StatisticExtInfo::inherit, StatisticExtInfo::keys, StatisticExtInfo::kind, lfirst, list_length(), stat_covers_expressions(), and STATS_MAX_DIMENSIONS.

Referenced by statext_mcv_clauselist_selectivity().

compare_datums_simple()

int compare_datums_simple	(	Datum	a,
		Datum	b,
		SortSupport	ssup
	)

Definition at line 924 of file extended_stats.c.

{
    return ApplySortComparator(a, false, b, false, ssup);
}

References a, ApplySortComparator(), and b.

Referenced by compare_scalars_simple(), and statext_mcv_serialize().

compare_scalars_simple()

int compare_scalars_simple	(	const void *	a,
		const void *	b,
		void *	arg
	)

Definition at line 916 of file extended_stats.c.

{
    return compare_datums_simple(*(Datum *) a,
                                 *(Datum *) b,
                                 (SortSupport) arg);
}

References a, arg, b, and compare_datums_simple().

Referenced by statext_mcv_serialize().

compute_expr_stats()

static void compute_expr_stats ( Relation  onerel, AnlExprData *  exprdata, int  nexprs, HeapTuple *  rows, int  numrows  )

static

Definition at line 2107 of file extended_stats.c.

{
    MemoryContext expr_context,
                old_context;
    int         ind,
                i;
 
    expr_context = AllocSetContextCreate(CurrentMemoryContext,
                                         "Analyze Expression",
                                         ALLOCSET_DEFAULT_SIZES);
    old_context = MemoryContextSwitchTo(expr_context);
 
    for (ind = 0; ind < nexprs; ind++)
    {
        AnlExprData *thisdata = &exprdata[ind];
        VacAttrStats *stats = thisdata->vacattrstat;
        Node       *expr = thisdata->expr;
        TupleTableSlot *slot;
        EState     *estate;
        ExprContext *econtext;
        Datum      *exprvals;
        bool       *exprnulls;
        ExprState  *exprstate;
        int         tcnt;
 
        /* Are we still in the main context? */
        Assert(CurrentMemoryContext == expr_context);
 
        /*
         * Need an EState for evaluation of expressions.  Create it in the
         * per-expression context to be sure it gets cleaned up at the bottom
         * of the loop.
         */
        estate = CreateExecutorState();
        econtext = GetPerTupleExprContext(estate);
 
        /* Set up expression evaluation state */
        exprstate = ExecPrepareExpr((Expr *) expr, estate);
 
        /* Need a slot to hold the current heap tuple, too */
        slot = MakeSingleTupleTableSlot(RelationGetDescr(onerel),
                                        &TTSOpsHeapTuple);
 
        /* Arrange for econtext's scan tuple to be the tuple under test */
        econtext->ecxt_scantuple = slot;
 
        /* Compute and save expression values */
        exprvals = (Datum *) palloc(numrows * sizeof(Datum));
        exprnulls = (bool *) palloc(numrows * sizeof(bool));
 
        tcnt = 0;
        for (i = 0; i < numrows; i++)
        {
            Datum       datum;
            bool        isnull;
 
            /*
             * Reset the per-tuple context each time, to reclaim any cruft
             * left behind by evaluating the statistics expressions.
             */
            ResetExprContext(econtext);
 
            /* Set up for expression evaluation */
            ExecStoreHeapTuple(rows[i], slot, false);
 
            /*
             * Evaluate the expression. We do this in the per-tuple context so
             * as not to leak memory, and then copy the result into the
             * context created at the beginning of this function.
             */
            datum = ExecEvalExprSwitchContext(exprstate,
                                              GetPerTupleExprContext(estate),
                                              &isnull);
            if (isnull)
            {
                exprvals[tcnt] = (Datum) 0;
                exprnulls[tcnt] = true;
            }
            else
            {
                /* Make sure we copy the data into the context. */
                Assert(CurrentMemoryContext == expr_context);
 
                exprvals[tcnt] = datumCopy(datum,
                                           stats->attrtype->typbyval,
                                           stats->attrtype->typlen);
                exprnulls[tcnt] = false;
            }
 
            tcnt++;
        }
 
        /*
         * Now we can compute the statistics for the expression columns.
         *
         * XXX Unlike compute_index_stats we don't need to switch and reset
         * memory contexts here, because we're only computing stats for a
         * single expression (and not iterating over many indexes), so we just
         * do it in expr_context. Note that compute_stats copies the result
         * into stats->anl_context, so it does not disappear.
         */
        if (tcnt > 0)
        {
            AttributeOpts *aopt =
                get_attribute_options(onerel->rd_id, stats->tupattnum);
 
            stats->exprvals = exprvals;
            stats->exprnulls = exprnulls;
            stats->rowstride = 1;
            stats->compute_stats(stats,
                                 expr_fetch_func,
                                 tcnt,
                                 tcnt);
 
            /*
             * If the n_distinct option is specified, it overrides the above
             * computation.
             */
            if (aopt != NULL && aopt->n_distinct != 0.0)
                stats->stadistinct = aopt->n_distinct;
        }
 
        /* And clean up */
        MemoryContextSwitchTo(expr_context);
 
        ExecDropSingleTupleTableSlot(slot);
        FreeExecutorState(estate);
        MemoryContextReset(expr_context);
    }
 
    MemoryContextSwitchTo(old_context);
    MemoryContextDelete(expr_context);
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert(), VacAttrStats::attrtype, VacAttrStats::compute_stats, CreateExecutorState(), CurrentMemoryContext, datumCopy(), ExprContext::ecxt_scantuple, ExecDropSingleTupleTableSlot(), ExecEvalExprSwitchContext(), ExecPrepareExpr(), ExecStoreHeapTuple(), AnlExprData::expr, expr_fetch_func(), VacAttrStats::exprnulls, VacAttrStats::exprvals, FreeExecutorState(), get_attribute_options(), GetPerTupleExprContext, i, MakeSingleTupleTableSlot(), MemoryContextDelete(), MemoryContextReset(), MemoryContextSwitchTo(), AttributeOpts::n_distinct, palloc(), RelationData::rd_id, RelationGetDescr, ResetExprContext, VacAttrStats::rowstride, VacAttrStats::stadistinct, TTSOpsHeapTuple, VacAttrStats::tupattnum, and AnlExprData::vacattrstat.

Referenced by BuildRelationExtStatistics().

ComputeExtStatisticsRows()

int ComputeExtStatisticsRows	(	Relation	onerel,
		int	natts,
		VacAttrStats **	vacattrstats
	)

Definition at line 262 of file extended_stats.c.

{
    Relation    pg_stext;
    ListCell   *lc;
    List       *lstats;
    MemoryContext cxt;
    MemoryContext oldcxt;
    int         result = 0;
 
    /* If there are no columns to analyze, just return 0. */
    if (!natts)
        return 0;
 
    cxt = AllocSetContextCreate(CurrentMemoryContext,
                                "ComputeExtStatisticsRows",
                                ALLOCSET_DEFAULT_SIZES);
    oldcxt = MemoryContextSwitchTo(cxt);
 
    pg_stext = table_open(StatisticExtRelationId, RowExclusiveLock);
    lstats = fetch_statentries_for_relation(pg_stext, RelationGetRelid(onerel));
 
    foreach(lc, lstats)
    {
        StatExtEntry *stat = (StatExtEntry *) lfirst(lc);
        int         stattarget;
        VacAttrStats **stats;
        int         nattrs = bms_num_members(stat->columns);
 
        /*
         * Check if we can build this statistics object based on the columns
         * analyzed. If not, ignore it (don't report anything, we'll do that
         * during the actual build BuildRelationExtStatistics).
         */
        stats = lookup_var_attr_stats(stat->columns, stat->exprs,
                                      natts, vacattrstats);
 
        if (!stats)
            continue;
 
        /*
         * Compute statistics target, based on what's set for the statistic
         * object itself, and for its attributes.
         */
        stattarget = statext_compute_stattarget(stat->stattarget,
                                                nattrs, stats);
 
        /* Use the largest value for all statistics objects. */
        if (stattarget > result)
            result = stattarget;
    }
 
    table_close(pg_stext, RowExclusiveLock);
 
    MemoryContextSwitchTo(oldcxt);
    MemoryContextDelete(cxt);
 
    /* compute sample size based on the statistics target */
    return (300 * result);
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, bms_num_members(), CurrentMemoryContext, fetch_statentries_for_relation(), lfirst, lookup_var_attr_stats(), MemoryContextDelete(), MemoryContextSwitchTo(), RelationGetRelid, RowExclusiveLock, statext_compute_stattarget(), table_close(), and table_open().

Referenced by do_analyze_rel().

examine_attribute()

static VacAttrStats * examine_attribute ( Node *  expr )

static

Definition at line 525 of file extended_stats.c.

{
    HeapTuple   typtuple;
    VacAttrStats *stats;
    int         i;
    bool        ok;
 
    /*
     * Create the VacAttrStats struct.
     */
    stats = (VacAttrStats *) palloc0(sizeof(VacAttrStats));
    stats->attstattarget = -1;
 
    /*
     * When analyzing an expression, believe the expression tree's type not
     * the column datatype --- the latter might be the opckeytype storage type
     * of the opclass, which is not interesting for our purposes.  (Note: if
     * we did anything with non-expression statistics columns, we'd need to
     * figure out where to get the correct type info from, but for now that's
     * not a problem.)  It's not clear whether anyone will care about the
     * typmod, but we store that too just in case.
     */
    stats->attrtypid = exprType(expr);
    stats->attrtypmod = exprTypmod(expr);
    stats->attrcollid = exprCollation(expr);
 
    typtuple = SearchSysCacheCopy1(TYPEOID,
                                   ObjectIdGetDatum(stats->attrtypid));
    if (!HeapTupleIsValid(typtuple))
        elog(ERROR, "cache lookup failed for type %u", stats->attrtypid);
    stats->attrtype = (Form_pg_type) GETSTRUCT(typtuple);
 
    /*
     * We don't actually analyze individual attributes, so no need to set the
     * memory context.
     */
    stats->anl_context = NULL;
    stats->tupattnum = InvalidAttrNumber;
 
    /*
     * The fields describing the stats->stavalues[n] element types default to
     * the type of the data being analyzed, but the type-specific typanalyze
     * function can change them if it wants to store something else.
     */
    for (i = 0; i < STATISTIC_NUM_SLOTS; i++)
    {
        stats->statypid[i] = stats->attrtypid;
        stats->statyplen[i] = stats->attrtype->typlen;
        stats->statypbyval[i] = stats->attrtype->typbyval;
        stats->statypalign[i] = stats->attrtype->typalign;
    }
 
    /*
     * Call the type-specific typanalyze function.  If none is specified, use
     * std_typanalyze().
     */
    if (OidIsValid(stats->attrtype->typanalyze))
        ok = DatumGetBool(OidFunctionCall1(stats->attrtype->typanalyze,
                                           PointerGetDatum(stats)));
    else
        ok = std_typanalyze(stats);
 
    if (!ok || stats->compute_stats == NULL || stats->minrows <= 0)
    {
        heap_freetuple(typtuple);
        pfree(stats);
        return NULL;
    }
 
    return stats;
}

References VacAttrStats::anl_context, VacAttrStats::attrcollid, VacAttrStats::attrtype, VacAttrStats::attrtypid, VacAttrStats::attrtypmod, VacAttrStats::attstattarget, VacAttrStats::compute_stats, DatumGetBool(), elog, ERROR, exprCollation(), exprType(), exprTypmod(), GETSTRUCT(), heap_freetuple(), HeapTupleIsValid, i, InvalidAttrNumber, VacAttrStats::minrows, ObjectIdGetDatum(), OidFunctionCall1, OidIsValid, palloc0(), pfree(), PointerGetDatum(), SearchSysCacheCopy1, STATISTIC_NUM_SLOTS, VacAttrStats::statypalign, VacAttrStats::statypbyval, VacAttrStats::statypid, VacAttrStats::statyplen, std_typanalyze(), and VacAttrStats::tupattnum.

Referenced by lookup_var_attr_stats().

examine_expression()

static VacAttrStats * examine_expression ( Node *  expr, int  stattarget  )

static

Definition at line 604 of file extended_stats.c.

{
    HeapTuple   typtuple;
    VacAttrStats *stats;
    int         i;
    bool        ok;
 
    Assert(expr != NULL);
 
    /*
     * Create the VacAttrStats struct.
     */
    stats = (VacAttrStats *) palloc0(sizeof(VacAttrStats));
 
    /*
     * We can't have statistics target specified for the expression, so we
     * could use either the default_statistics_target, or the target computed
     * for the extended statistics. The second option seems more reasonable.
     */
    stats->attstattarget = stattarget;
 
    /*
     * When analyzing an expression, believe the expression tree's type.
     */
    stats->attrtypid = exprType(expr);
    stats->attrtypmod = exprTypmod(expr);
 
    /*
     * We don't allow collation to be specified in CREATE STATISTICS, so we
     * have to use the collation specified for the expression. It's possible
     * to specify the collation in the expression "(col COLLATE "en_US")" in
     * which case exprCollation() does the right thing.
     */
    stats->attrcollid = exprCollation(expr);
 
    typtuple = SearchSysCacheCopy1(TYPEOID,
                                   ObjectIdGetDatum(stats->attrtypid));
    if (!HeapTupleIsValid(typtuple))
        elog(ERROR, "cache lookup failed for type %u", stats->attrtypid);
 
    stats->attrtype = (Form_pg_type) GETSTRUCT(typtuple);
    stats->anl_context = CurrentMemoryContext;  /* XXX should be using
                                                 * something else? */
    stats->tupattnum = InvalidAttrNumber;
 
    /*
     * The fields describing the stats->stavalues[n] element types default to
     * the type of the data being analyzed, but the type-specific typanalyze
     * function can change them if it wants to store something else.
     */
    for (i = 0; i < STATISTIC_NUM_SLOTS; i++)
    {
        stats->statypid[i] = stats->attrtypid;
        stats->statyplen[i] = stats->attrtype->typlen;
        stats->statypbyval[i] = stats->attrtype->typbyval;
        stats->statypalign[i] = stats->attrtype->typalign;
    }
 
    /*
     * Call the type-specific typanalyze function.  If none is specified, use
     * std_typanalyze().
     */
    if (OidIsValid(stats->attrtype->typanalyze))
        ok = DatumGetBool(OidFunctionCall1(stats->attrtype->typanalyze,
                                           PointerGetDatum(stats)));
    else
        ok = std_typanalyze(stats);
 
    if (!ok || stats->compute_stats == NULL || stats->minrows <= 0)
    {
        heap_freetuple(typtuple);
        pfree(stats);
        return NULL;
    }
 
    return stats;
}

References VacAttrStats::anl_context, Assert(), VacAttrStats::attrcollid, VacAttrStats::attrtype, VacAttrStats::attrtypid, VacAttrStats::attrtypmod, VacAttrStats::attstattarget, VacAttrStats::compute_stats, CurrentMemoryContext, DatumGetBool(), elog, ERROR, exprCollation(), exprType(), exprTypmod(), GETSTRUCT(), heap_freetuple(), HeapTupleIsValid, i, InvalidAttrNumber, VacAttrStats::minrows, ObjectIdGetDatum(), OidFunctionCall1, OidIsValid, palloc0(), pfree(), PointerGetDatum(), SearchSysCacheCopy1, STATISTIC_NUM_SLOTS, VacAttrStats::statypalign, VacAttrStats::statypbyval, VacAttrStats::statypid, VacAttrStats::statyplen, std_typanalyze(), and VacAttrStats::tupattnum.

Referenced by build_expr_data(), and make_build_data().

examine_opclause_args()

bool examine_opclause_args	(	List *	args,
		Node **	exprp,
		Const **	cstp,
		bool *	expronleftp
	)

Definition at line 2052 of file extended_stats.c.

{
    Node       *expr;
    Const      *cst;
    bool        expronleft;
    Node       *leftop,
               *rightop;
 
    /* enforced by statext_is_compatible_clause_internal */
    Assert(list_length(args) == 2);
 
    leftop = linitial(args);
    rightop = lsecond(args);
 
    /* strip RelabelType from either side of the expression */
    if (IsA(leftop, RelabelType))
        leftop = (Node *) ((RelabelType *) leftop)->arg;
 
    if (IsA(rightop, RelabelType))
        rightop = (Node *) ((RelabelType *) rightop)->arg;
 
    if (IsA(rightop, Const))
    {
        expr = (Node *) leftop;
        cst = (Const *) rightop;
        expronleft = true;
    }
    else if (IsA(leftop, Const))
    {
        expr = (Node *) rightop;
        cst = (Const *) leftop;
        expronleft = false;
    }
    else
        return false;
 
    /* return pointers to the extracted parts if requested */
    if (exprp)
        *exprp = expr;
 
    if (cstp)
        *cstp = cst;
 
    if (expronleftp)
        *expronleftp = expronleft;
 
    return true;
}

References arg, generate_unaccent_rules::args, Assert(), IsA, linitial, list_length(), and lsecond.

Referenced by mcv_get_match_bitmap(), and statext_is_compatible_clause_internal().

expr_fetch_func()

static Datum expr_fetch_func ( VacAttrStatsP  stats, int  rownum, bool *  isNull  )

static

Definition at line 2250 of file extended_stats.c.

{
    int         i;
 
    /* exprvals and exprnulls are already offset for proper column */
    i = rownum * stats->rowstride;
    *isNull = stats->exprnulls[i];
    return stats->exprvals[i];
}

References VacAttrStats::exprnulls, VacAttrStats::exprvals, i, and VacAttrStats::rowstride.

Referenced by compute_expr_stats().

fetch_statentries_for_relation()

static List * fetch_statentries_for_relation ( Relation  pg_statext, Oid  relid  )

static

Definition at line 419 of file extended_stats.c.

{
    SysScanDesc scan;
    ScanKeyData skey;
    HeapTuple   htup;
    List       *result = NIL;
 
    /*
     * Prepare to scan pg_statistic_ext for entries having stxrelid = this
     * rel.
     */
    ScanKeyInit(&skey,
                Anum_pg_statistic_ext_stxrelid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(relid));
 
    scan = systable_beginscan(pg_statext, StatisticExtRelidIndexId, true,
                              NULL, 1, &skey);
 
    while (HeapTupleIsValid(htup = systable_getnext(scan)))
    {
        StatExtEntry *entry;
        Datum       datum;
        bool        isnull;
        int         i;
        ArrayType  *arr;
        char       *enabled;
        Form_pg_statistic_ext staForm;
        List       *exprs = NIL;
 
        entry = palloc0(sizeof(StatExtEntry));
        staForm = (Form_pg_statistic_ext) GETSTRUCT(htup);
        entry->statOid = staForm->oid;
        entry->schema = get_namespace_name(staForm->stxnamespace);
        entry->name = pstrdup(NameStr(staForm->stxname));
        for (i = 0; i < staForm->stxkeys.dim1; i++)
        {
            entry->columns = bms_add_member(entry->columns,
                                            staForm->stxkeys.values[i]);
        }
 
        datum = SysCacheGetAttr(STATEXTOID, htup, Anum_pg_statistic_ext_stxstattarget, &isnull);
        entry->stattarget = isnull ? -1 : DatumGetInt16(datum);
 
        /* decode the stxkind char array into a list of chars */
        datum = SysCacheGetAttrNotNull(STATEXTOID, htup,
                                       Anum_pg_statistic_ext_stxkind);
        arr = DatumGetArrayTypeP(datum);
        if (ARR_NDIM(arr) != 1 ||
            ARR_HASNULL(arr) ||
            ARR_ELEMTYPE(arr) != CHAROID)
            elog(ERROR, "stxkind is not a 1-D char array");
        enabled = (char *) ARR_DATA_PTR(arr);
        for (i = 0; i < ARR_DIMS(arr)[0]; i++)
        {
            Assert((enabled[i] == STATS_EXT_NDISTINCT) ||
                   (enabled[i] == STATS_EXT_DEPENDENCIES) ||
                   (enabled[i] == STATS_EXT_MCV) ||
                   (enabled[i] == STATS_EXT_EXPRESSIONS));
            entry->types = lappend_int(entry->types, (int) enabled[i]);
        }
 
        /* decode expression (if any) */
        datum = SysCacheGetAttr(STATEXTOID, htup,
                                Anum_pg_statistic_ext_stxexprs, &isnull);
 
        if (!isnull)
        {
            char       *exprsString;
 
            exprsString = TextDatumGetCString(datum);
            exprs = (List *) stringToNode(exprsString);
 
            pfree(exprsString);
 
            /*
             * Run the expressions through eval_const_expressions. This is not
             * just an optimization, but is necessary, because the planner
             * will be comparing them to similarly-processed qual clauses, and
             * may fail to detect valid matches without this.  We must not use
             * canonicalize_qual, however, since these aren't qual
             * expressions.
             */
            exprs = (List *) eval_const_expressions(NULL, (Node *) exprs);
 
            /* May as well fix opfuncids too */
            fix_opfuncids((Node *) exprs);
        }
 
        entry->exprs = exprs;
 
        result = lappend(result, entry);
    }
 
    systable_endscan(scan);
 
    return result;
}

References ARR_DATA_PTR, ARR_DIMS, ARR_ELEMTYPE, ARR_HASNULL, ARR_NDIM, Assert(), bms_add_member(), BTEqualStrategyNumber, StatExtEntry::columns, DatumGetArrayTypeP, DatumGetInt16(), elog, ERROR, eval_const_expressions(), StatExtEntry::exprs, fix_opfuncids(), get_namespace_name(), GETSTRUCT(), HeapTupleIsValid, i, lappend(), lappend_int(), StatExtEntry::name, NameStr, NIL, ObjectIdGetDatum(), palloc0(), pfree(), pstrdup(), ScanKeyInit(), StatExtEntry::schema, StatExtEntry::statOid, StatExtEntry::stattarget, stringToNode(), SysCacheGetAttr(), SysCacheGetAttrNotNull(), systable_beginscan(), systable_endscan(), systable_getnext(), TextDatumGetCString, and StatExtEntry::types.

Referenced by BuildRelationExtStatistics(), and ComputeExtStatisticsRows().

has_stats_of_kind()

bool has_stats_of_kind	(	List *	stats,
		char	requiredkind
	)

Definition at line 1115 of file extended_stats.c.

{
    ListCell   *l;
 
    foreach(l, stats)
    {
        StatisticExtInfo *stat = (StatisticExtInfo *) lfirst(l);
 
        if (stat->kind == requiredkind)
            return true;
    }
 
    return false;
}

References lfirst.

Referenced by dependencies_clauselist_selectivity(), and statext_mcv_clauselist_selectivity().

lookup_var_attr_stats()

static VacAttrStats ** lookup_var_attr_stats ( Bitmapset *  attrs, List *  exprs, int  nvacatts, VacAttrStats **  vacatts  )

static

Definition at line 690 of file extended_stats.c.

{
    int         i = 0;
    int         x = -1;
    int         natts;
    VacAttrStats **stats;
    ListCell   *lc;
 
    natts = bms_num_members(attrs) + list_length(exprs);
 
    stats = (VacAttrStats **) palloc(natts * sizeof(VacAttrStats *));
 
    /* lookup VacAttrStats info for the requested columns (same attnum) */
    while ((x = bms_next_member(attrs, x)) >= 0)
    {
        int         j;
 
        stats[i] = NULL;
        for (j = 0; j < nvacatts; j++)
        {
            if (x == vacatts[j]->tupattnum)
            {
                stats[i] = vacatts[j];
                break;
            }
        }
 
        if (!stats[i])
        {
            /*
             * Looks like stats were not gathered for one of the columns
             * required. We'll be unable to build the extended stats without
             * this column.
             */
            pfree(stats);
            return NULL;
        }
 
        i++;
    }
 
    /* also add info for expressions */
    foreach(lc, exprs)
    {
        Node       *expr = (Node *) lfirst(lc);
 
        stats[i] = examine_attribute(expr);
 
        /*
         * XXX We need tuple descriptor later, and we just grab it from
         * stats[0]->tupDesc (see e.g. statext_mcv_build). But as coded
         * examine_attribute does not set that, so just grab it from the first
         * vacatts element.
         */
        stats[i]->tupDesc = vacatts[0]->tupDesc;
 
        i++;
    }
 
    return stats;
}

References bms_next_member(), bms_num_members(), examine_attribute(), i, j, lfirst, list_length(), palloc(), pfree(), VacAttrStats::tupDesc, and x.

Referenced by BuildRelationExtStatistics(), and ComputeExtStatisticsRows().

make_build_data()

static StatsBuildData * make_build_data ( Relation  rel, StatExtEntry *  stat, int  numrows, HeapTuple *  rows, VacAttrStats **  stats, int  stattarget  )

static

Definition at line 2468 of file extended_stats.c.

{
    /* evaluated expressions */
    StatsBuildData *result;
    char       *ptr;
    Size        len;
 
    int         i;
    int         k;
    int         idx;
    TupleTableSlot *slot;
    EState     *estate;
    ExprContext *econtext;
    List       *exprstates = NIL;
    int         nkeys = bms_num_members(stat->columns) + list_length(stat->exprs);
    ListCell   *lc;
 
    /* allocate everything as a single chunk, so we can free it easily */
    len = MAXALIGN(sizeof(StatsBuildData));
    len += MAXALIGN(sizeof(AttrNumber) * nkeys);    /* attnums */
    len += MAXALIGN(sizeof(VacAttrStats *) * nkeys);    /* stats */
 
    /* values */
    len += MAXALIGN(sizeof(Datum *) * nkeys);
    len += nkeys * MAXALIGN(sizeof(Datum) * numrows);
 
    /* nulls */
    len += MAXALIGN(sizeof(bool *) * nkeys);
    len += nkeys * MAXALIGN(sizeof(bool) * numrows);
 
    ptr = palloc(len);
 
    /* set the pointers */
    result = (StatsBuildData *) ptr;
    ptr += MAXALIGN(sizeof(StatsBuildData));
 
    /* attnums */
    result->attnums = (AttrNumber *) ptr;
    ptr += MAXALIGN(sizeof(AttrNumber) * nkeys);
 
    /* stats */
    result->stats = (VacAttrStats **) ptr;
    ptr += MAXALIGN(sizeof(VacAttrStats *) * nkeys);
 
    /* values */
    result->values = (Datum **) ptr;
    ptr += MAXALIGN(sizeof(Datum *) * nkeys);
 
    /* nulls */
    result->nulls = (bool **) ptr;
    ptr += MAXALIGN(sizeof(bool *) * nkeys);
 
    for (i = 0; i < nkeys; i++)
    {
        result->values[i] = (Datum *) ptr;
        ptr += MAXALIGN(sizeof(Datum) * numrows);
 
        result->nulls[i] = (bool *) ptr;
        ptr += MAXALIGN(sizeof(bool) * numrows);
    }
 
    Assert((ptr - (char *) result) == len);
 
    /* we have it allocated, so let's fill the values */
    result->nattnums = nkeys;
    result->numrows = numrows;
 
    /* fill the attribute info - first attributes, then expressions */
    idx = 0;
    k = -1;
    while ((k = bms_next_member(stat->columns, k)) >= 0)
    {
        result->attnums[idx] = k;
        result->stats[idx] = stats[idx];
 
        idx++;
    }
 
    k = -1;
    foreach(lc, stat->exprs)
    {
        Node       *expr = (Node *) lfirst(lc);
 
        result->attnums[idx] = k;
        result->stats[idx] = examine_expression(expr, stattarget);
 
        idx++;
        k--;
    }
 
    /* first extract values for all the regular attributes */
    for (i = 0; i < numrows; i++)
    {
        idx = 0;
        k = -1;
        while ((k = bms_next_member(stat->columns, k)) >= 0)
        {
            result->values[idx][i] = heap_getattr(rows[i], k,
                                                  result->stats[idx]->tupDesc,
                                                  &result->nulls[idx][i]);
 
            idx++;
        }
    }
 
    /* Need an EState for evaluation expressions. */
    estate = CreateExecutorState();
    econtext = GetPerTupleExprContext(estate);
 
    /* Need a slot to hold the current heap tuple, too */
    slot = MakeSingleTupleTableSlot(RelationGetDescr(rel),
                                    &TTSOpsHeapTuple);
 
    /* Arrange for econtext's scan tuple to be the tuple under test */
    econtext->ecxt_scantuple = slot;
 
    /* Set up expression evaluation state */
    exprstates = ExecPrepareExprList(stat->exprs, estate);
 
    for (i = 0; i < numrows; i++)
    {
        /*
         * Reset the per-tuple context each time, to reclaim any cruft left
         * behind by evaluating the statistics object expressions.
         */
        ResetExprContext(econtext);
 
        /* Set up for expression evaluation */
        ExecStoreHeapTuple(rows[i], slot, false);
 
        idx = bms_num_members(stat->columns);
        foreach(lc, exprstates)
        {
            Datum       datum;
            bool        isnull;
            ExprState  *exprstate = (ExprState *) lfirst(lc);
 
            /*
             * XXX This probably leaks memory. Maybe we should use
             * ExecEvalExprSwitchContext but then we need to copy the result
             * somewhere else.
             */
            datum = ExecEvalExpr(exprstate,
                                 GetPerTupleExprContext(estate),
                                 &isnull);
            if (isnull)
            {
                result->values[idx][i] = (Datum) 0;
                result->nulls[idx][i] = true;
            }
            else
            {
                result->values[idx][i] = (Datum) datum;
                result->nulls[idx][i] = false;
            }
 
            idx++;
        }
    }
 
    ExecDropSingleTupleTableSlot(slot);
    FreeExecutorState(estate);
 
    return result;
}

References Assert(), StatsBuildData::attnums, bms_next_member(), bms_num_members(), CreateExecutorState(), ExprContext::ecxt_scantuple, examine_expression(), ExecDropSingleTupleTableSlot(), ExecEvalExpr(), ExecPrepareExprList(), ExecStoreHeapTuple(), FreeExecutorState(), GetPerTupleExprContext, heap_getattr(), i, idx(), len, lfirst, list_length(), MakeSingleTupleTableSlot(), MAXALIGN, StatsBuildData::nattnums, NIL, StatsBuildData::nulls, StatsBuildData::numrows, palloc(), RelationGetDescr, ResetExprContext, StatsBuildData::stats, TTSOpsHeapTuple, VacAttrStats::tupDesc, and StatsBuildData::values.

Referenced by BuildRelationExtStatistics().

multi_sort_add_dimension()

void multi_sort_add_dimension	(	MultiSortSupport	mss,
		int	sortdim,
		Oid	oper,
		Oid	collation
	)

Definition at line 848 of file extended_stats.c.

{
    SortSupport ssup = &mss->ssup[sortdim];
 
    ssup->ssup_cxt = CurrentMemoryContext;
    ssup->ssup_collation = collation;
    ssup->ssup_nulls_first = false;
 
    PrepareSortSupportFromOrderingOp(oper, ssup);
}

References CurrentMemoryContext, oper(), PrepareSortSupportFromOrderingOp(), MultiSortSupportData::ssup, SortSupportData::ssup_collation, SortSupportData::ssup_cxt, and SortSupportData::ssup_nulls_first.

Referenced by build_mss(), dependency_degree(), and ndistinct_for_combination().

multi_sort_compare()

int multi_sort_compare	(	const void *	a,
		const void *	b,
		void *	arg
	)

Definition at line 862 of file extended_stats.c.

{
    MultiSortSupport mss = (MultiSortSupport) arg;
    SortItem   *ia = (SortItem *) a;
    SortItem   *ib = (SortItem *) b;
    int         i;
 
    for (i = 0; i < mss->ndims; i++)
    {
        int         compare;
 
        compare = ApplySortComparator(ia->values[i], ia->isnull[i],
                                      ib->values[i], ib->isnull[i],
                                      &mss->ssup[i]);
 
        if (compare != 0)
            return compare;
    }
 
    /* equal by default */
    return 0;
}

References a, ApplySortComparator(), arg, b, compare(), i, SortItem::isnull, MultiSortSupportData::ndims, MultiSortSupportData::ssup, and SortItem::values.

Referenced by build_distinct_groups(), build_sorted_items(), count_distinct_groups(), ndistinct_for_combination(), and statext_mcv_build().

multi_sort_compare_dim()

int multi_sort_compare_dim	(	int	dim,
		const SortItem *	a,
		const SortItem *	b,
		MultiSortSupport	mss
	)

Definition at line 887 of file extended_stats.c.

{
    return ApplySortComparator(a->values[dim], a->isnull[dim],
                               b->values[dim], b->isnull[dim],
                               &mss->ssup[dim]);
}

References a, ApplySortComparator(), b, and MultiSortSupportData::ssup.

Referenced by dependency_degree().

multi_sort_compare_dims()

int multi_sort_compare_dims	(	int	start,
		int	end,
		const SortItem *	a,
		const SortItem *	b,
		MultiSortSupport	mss
	)

Definition at line 896 of file extended_stats.c.

{
    int         dim;
 
    for (dim = start; dim <= end; dim++)
    {
        int         r = ApplySortComparator(a->values[dim], a->isnull[dim],
                                            b->values[dim], b->isnull[dim],
                                            &mss->ssup[dim]);
 
        if (r != 0)
            return r;
    }
 
    return 0;
}

References a, ApplySortComparator(), b, MultiSortSupportData::ssup, and start.

Referenced by dependency_degree().

multi_sort_init()

MultiSortSupport multi_sort_init

(

int

ndims

)

Definition at line 829 of file extended_stats.c.

{
    MultiSortSupport mss;
 
    Assert(ndims >= 2);
 
    mss = (MultiSortSupport) palloc0(offsetof(MultiSortSupportData, ssup)
                                     + sizeof(SortSupportData) * ndims);
 
    mss->ndims = ndims;
 
    return mss;
}

References Assert(), MultiSortSupportData::ndims, and palloc0().

Referenced by build_mss(), dependency_degree(), and ndistinct_for_combination().

serialize_expr_stats()

static Datum serialize_expr_stats ( AnlExprData *  exprdata, int  nexprs  )

static

Definition at line 2291 of file extended_stats.c.

{
    int         exprno;
    Oid         typOid;
    Relation    sd;
 
    ArrayBuildState *astate = NULL;
 
    sd = table_open(StatisticRelationId, RowExclusiveLock);
 
    /* lookup OID of composite type for pg_statistic */
    typOid = get_rel_type_id(StatisticRelationId);
    if (!OidIsValid(typOid))
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("relation \"%s\" does not have a composite type",
                        "pg_statistic")));
 
    for (exprno = 0; exprno < nexprs; exprno++)
    {
        int         i,
                    k;
        VacAttrStats *stats = exprdata[exprno].vacattrstat;
 
        Datum       values[Natts_pg_statistic];
        bool        nulls[Natts_pg_statistic];
        HeapTuple   stup;
 
        if (!stats->stats_valid)
        {
            astate = accumArrayResult(astate,
                                      (Datum) 0,
                                      true,
                                      typOid,
                                      CurrentMemoryContext);
            continue;
        }
 
        /*
         * Construct a new pg_statistic tuple
         */
        for (i = 0; i < Natts_pg_statistic; ++i)
        {
            nulls[i] = false;
        }
 
        values[Anum_pg_statistic_starelid - 1] = ObjectIdGetDatum(InvalidOid);
        values[Anum_pg_statistic_staattnum - 1] = Int16GetDatum(InvalidAttrNumber);
        values[Anum_pg_statistic_stainherit - 1] = BoolGetDatum(false);
        values[Anum_pg_statistic_stanullfrac - 1] = Float4GetDatum(stats->stanullfrac);
        values[Anum_pg_statistic_stawidth - 1] = Int32GetDatum(stats->stawidth);
        values[Anum_pg_statistic_stadistinct - 1] = Float4GetDatum(stats->stadistinct);
        i = Anum_pg_statistic_stakind1 - 1;
        for (k = 0; k < STATISTIC_NUM_SLOTS; k++)
        {
            values[i++] = Int16GetDatum(stats->stakind[k]); /* stakindN */
        }
        i = Anum_pg_statistic_staop1 - 1;
        for (k = 0; k < STATISTIC_NUM_SLOTS; k++)
        {
            values[i++] = ObjectIdGetDatum(stats->staop[k]);    /* staopN */
        }
        i = Anum_pg_statistic_stacoll1 - 1;
        for (k = 0; k < STATISTIC_NUM_SLOTS; k++)
        {
            values[i++] = ObjectIdGetDatum(stats->stacoll[k]);  /* stacollN */
        }
        i = Anum_pg_statistic_stanumbers1 - 1;
        for (k = 0; k < STATISTIC_NUM_SLOTS; k++)
        {
            int         nnum = stats->numnumbers[k];
 
            if (nnum > 0)
            {
                int         n;
                Datum      *numdatums = (Datum *) palloc(nnum * sizeof(Datum));
                ArrayType  *arry;
 
                for (n = 0; n < nnum; n++)
                    numdatums[n] = Float4GetDatum(stats->stanumbers[k][n]);
                arry = construct_array_builtin(numdatums, nnum, FLOAT4OID);
                values[i++] = PointerGetDatum(arry);    /* stanumbersN */
            }
            else
            {
                nulls[i] = true;
                values[i++] = (Datum) 0;
            }
        }
        i = Anum_pg_statistic_stavalues1 - 1;
        for (k = 0; k < STATISTIC_NUM_SLOTS; k++)
        {
            if (stats->numvalues[k] > 0)
            {
                ArrayType  *arry;
 
                arry = construct_array(stats->stavalues[k],
                                       stats->numvalues[k],
                                       stats->statypid[k],
                                       stats->statyplen[k],
                                       stats->statypbyval[k],
                                       stats->statypalign[k]);
                values[i++] = PointerGetDatum(arry);    /* stavaluesN */
            }
            else
            {
                nulls[i] = true;
                values[i++] = (Datum) 0;
            }
        }
 
        stup = heap_form_tuple(RelationGetDescr(sd), values, nulls);
 
        astate = accumArrayResult(astate,
                                  heap_copy_tuple_as_datum(stup, RelationGetDescr(sd)),
                                  false,
                                  typOid,
                                  CurrentMemoryContext);
    }
 
    table_close(sd, RowExclusiveLock);
 
    return makeArrayResult(astate, CurrentMemoryContext);
}

References accumArrayResult(), BoolGetDatum(), construct_array(), construct_array_builtin(), CurrentMemoryContext, ereport, errcode(), errmsg(), ERROR, Float4GetDatum(), get_rel_type_id(), heap_copy_tuple_as_datum(), heap_form_tuple(), i, Int16GetDatum(), Int32GetDatum(), InvalidAttrNumber, InvalidOid, makeArrayResult(), VacAttrStats::numnumbers, VacAttrStats::numvalues, ObjectIdGetDatum(), OidIsValid, palloc(), PointerGetDatum(), RelationGetDescr, RowExclusiveLock, VacAttrStats::stacoll, VacAttrStats::stadistinct, VacAttrStats::stakind, VacAttrStats::stanullfrac, VacAttrStats::stanumbers, VacAttrStats::staop, STATISTIC_NUM_SLOTS, VacAttrStats::stats_valid, VacAttrStats::statypalign, VacAttrStats::statypbyval, VacAttrStats::statypid, VacAttrStats::statyplen, VacAttrStats::stavalues, VacAttrStats::stawidth, table_close(), table_open(), AnlExprData::vacattrstat, and values.

Referenced by BuildRelationExtStatistics().

stat_covers_expressions()

static bool stat_covers_expressions ( StatisticExtInfo *  stat, List *  exprs, Bitmapset **  expr_idxs  )

static

Definition at line 1165 of file extended_stats.c.

{
    ListCell   *lc;
 
    foreach(lc, exprs)
    {
        Node       *expr = (Node *) lfirst(lc);
        int         expr_idx;
 
        expr_idx = stat_find_expression(stat, expr);
        if (expr_idx == -1)
            return false;
 
        if (expr_idxs != NULL)
            *expr_idxs = bms_add_member(*expr_idxs, expr_idx);
    }
 
    /* If we reach here, all expressions are covered */
    return true;
}

References bms_add_member(), lfirst, and stat_find_expression().

Referenced by choose_best_statistics(), and statext_mcv_clauselist_selectivity().

stat_find_expression()

static int stat_find_expression ( StatisticExtInfo *  stat, Node *  expr  )

static

Definition at line 1138 of file extended_stats.c.

{
    ListCell   *lc;
    int         idx;
 
    idx = 0;
    foreach(lc, stat->exprs)
    {
        Node       *stat_expr = (Node *) lfirst(lc);
 
        if (equal(stat_expr, expr))
            return idx;
        idx++;
    }
 
    /* Expression not found */
    return -1;
}

References equal(), idx(), and lfirst.

Referenced by stat_covers_expressions().

statext_clauselist_selectivity()

Selectivity statext_clauselist_selectivity	(	PlannerInfo *	root,
		List *	clauses,
		int	varRelid,
		JoinType	jointype,
		SpecialJoinInfo *	sjinfo,
		RelOptInfo *	rel,
		Bitmapset **	estimatedclauses,
		bool	is_or
	)

Definition at line 2001 of file extended_stats.c.

{
    Selectivity sel;
 
    /* First, try estimating clauses using a multivariate MCV list. */
    sel = statext_mcv_clauselist_selectivity(root, clauses, varRelid, jointype,
                                             sjinfo, rel, estimatedclauses, is_or);
 
    /*
     * Functional dependencies only work for clauses connected by AND, so for
     * OR clauses we're done.
     */
    if (is_or)
        return sel;
 
    /*
     * Then, apply functional dependencies on the remaining clauses by calling
     * dependencies_clauselist_selectivity.  Pass 'estimatedclauses' so the
     * function can properly skip clauses already estimated above.
     *
     * The reasoning for applying dependencies last is that the more complex
     * stats can track more complex correlations between the attributes, and
     * so may be considered more reliable.
     *
     * For example, MCV list can give us an exact selectivity for values in
     * two columns, while functional dependencies can only provide information
     * about the overall strength of the dependency.
     */
    sel *= dependencies_clauselist_selectivity(root, clauses, varRelid,
                                               jointype, sjinfo, rel,
                                               estimatedclauses);
 
    return sel;
}

References dependencies_clauselist_selectivity(), root, and statext_mcv_clauselist_selectivity().

Referenced by clauselist_selectivity_ext(), and clauselist_selectivity_or().

statext_compute_stattarget()

static int statext_compute_stattarget ( int  stattarget, int  nattrs, VacAttrStats **  stats  )

static

Definition at line 344 of file extended_stats.c.

{
    int         i;
 
    /*
     * If there's statistics target set for the statistics object, use it. It
     * may be set to 0 which disables building of that statistic.
     */
    if (stattarget >= 0)
        return stattarget;
 
    /*
     * The target for the statistics object is set to -1, in which case we
     * look at the maximum target set for any of the attributes the object is
     * defined on.
     */
    for (i = 0; i < nattrs; i++)
    {
        /* keep the maximum statistics target */
        if (stats[i]->attstattarget > stattarget)
            stattarget = stats[i]->attstattarget;
    }
 
    /*
     * If the value is still negative (so neither the statistics object nor
     * any of the columns have custom statistics target set), use the global
     * default target.
     */
    if (stattarget < 0)
        stattarget = default_statistics_target;
 
    /* As this point we should have a valid statistics target. */
    Assert((stattarget >= 0) && (stattarget <= MAX_STATISTICS_TARGET));
 
    return stattarget;
}

References Assert(), VacAttrStats::attstattarget, default_statistics_target, i, and MAX_STATISTICS_TARGET.

Referenced by BuildRelationExtStatistics(), and ComputeExtStatisticsRows().

statext_expressions_load()

HeapTuple statext_expressions_load	(	Oid	stxoid,
		bool	inh,
		int	idx
	)

Definition at line 2421 of file extended_stats.c.

{
    bool        isnull;
    Datum       value;
    HeapTuple   htup;
    ExpandedArrayHeader *eah;
    HeapTupleHeader td;
    HeapTupleData tmptup;
    HeapTuple   tup;
 
    htup = SearchSysCache2(STATEXTDATASTXOID,
                           ObjectIdGetDatum(stxoid), BoolGetDatum(inh));
    if (!HeapTupleIsValid(htup))
        elog(ERROR, "cache lookup failed for statistics object %u", stxoid);
 
    value = SysCacheGetAttr(STATEXTDATASTXOID, htup,
                            Anum_pg_statistic_ext_data_stxdexpr, &isnull);
    if (isnull)
        elog(ERROR,
             "requested statistics kind \"%c\" is not yet built for statistics object %u",
             STATS_EXT_EXPRESSIONS, stxoid);
 
    eah = DatumGetExpandedArray(value);
 
    deconstruct_expanded_array(eah);
 
    td = DatumGetHeapTupleHeader(eah->dvalues[idx]);
 
    /* Build a temporary HeapTuple control structure */
    tmptup.t_len = HeapTupleHeaderGetDatumLength(td);
    ItemPointerSetInvalid(&(tmptup.t_self));
    tmptup.t_tableOid = InvalidOid;
    tmptup.t_data = td;
 
    tup = heap_copytuple(&tmptup);
 
    ReleaseSysCache(htup);
 
    return tup;
}

References BoolGetDatum(), DatumGetExpandedArray(), DatumGetHeapTupleHeader, deconstruct_expanded_array(), ExpandedArrayHeader::dvalues, elog, ERROR, heap_copytuple(), HeapTupleHeaderGetDatumLength(), HeapTupleIsValid, idx(), InvalidOid, ItemPointerSetInvalid(), ObjectIdGetDatum(), ReleaseSysCache(), SearchSysCache2(), SysCacheGetAttr(), HeapTupleData::t_data, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, and value.

Referenced by examine_variable().

statext_is_compatible_clause()

static bool statext_is_compatible_clause ( PlannerInfo *  root, Node *  clause, Index  relid, Bitmapset **  attnums, List **  exprs  )

static

Definition at line 1569 of file extended_stats.c.

{
    RangeTblEntry *rte = root->simple_rte_array[relid];
    RelOptInfo *rel = root->simple_rel_array[relid];
    RestrictInfo *rinfo;
    int         clause_relid;
    Oid         userid;
 
    /*
     * Special-case handling for bare BoolExpr AND clauses, because the
     * restrictinfo machinery doesn't build RestrictInfos on top of AND
     * clauses.
     */
    if (is_andclause(clause))
    {
        BoolExpr   *expr = (BoolExpr *) clause;
        ListCell   *lc;
 
        /*
         * Check that each sub-clause is compatible.  We expect these to be
         * RestrictInfos.
         */
        foreach(lc, expr->args)
        {
            if (!statext_is_compatible_clause(root, (Node *) lfirst(lc),
                                              relid, attnums, exprs))
                return false;
        }
 
        return true;
    }
 
    /* Otherwise it must be a RestrictInfo. */
    if (!IsA(clause, RestrictInfo))
        return false;
    rinfo = (RestrictInfo *) clause;
 
    /* Pseudoconstants are not really interesting here. */
    if (rinfo->pseudoconstant)
        return false;
 
    /* Clauses referencing other varnos are incompatible. */
    if (!bms_get_singleton_member(rinfo->clause_relids, &clause_relid) ||
        clause_relid != relid)
        return false;
 
    /* Check the clause and determine what attributes it references. */
    if (!statext_is_compatible_clause_internal(root, (Node *) rinfo->clause,
                                               relid, attnums, exprs))
        return false;
 
    /*
     * Check that the user has permission to read all required attributes.
     */
    userid = OidIsValid(rel->userid) ? rel->userid : GetUserId();
 
    /* Table-level SELECT privilege is sufficient for all columns */
    if (pg_class_aclcheck(rte->relid, userid, ACL_SELECT) != ACLCHECK_OK)
    {
        Bitmapset  *clause_attnums = NULL;
        int         attnum = -1;
 
        /*
         * We have to check per-column privileges.  *attnums has the attnums
         * for individual Vars we saw, but there may also be Vars within
         * subexpressions in *exprs.  We can use pull_varattnos() to extract
         * those, but there's an impedance mismatch: attnums returned by
         * pull_varattnos() are offset by FirstLowInvalidHeapAttributeNumber,
         * while attnums within *attnums aren't.  Convert *attnums to the
         * offset style so we can combine the results.
         */
        while ((attnum = bms_next_member(*attnums, attnum)) >= 0)
        {
            clause_attnums =
                bms_add_member(clause_attnums,
                               attnum - FirstLowInvalidHeapAttributeNumber);
        }
 
        /* Now merge attnums from *exprs into clause_attnums */
        if (*exprs != NIL)
            pull_varattnos((Node *) *exprs, relid, &clause_attnums);
 
        attnum = -1;
        while ((attnum = bms_next_member(clause_attnums, attnum)) >= 0)
        {
            /* Undo the offset */
            AttrNumber  attno = attnum + FirstLowInvalidHeapAttributeNumber;
 
            if (attno == InvalidAttrNumber)
            {
                /* Whole-row reference, so must have access to all columns */
                if (pg_attribute_aclcheck_all(rte->relid, userid, ACL_SELECT,
                                              ACLMASK_ALL) != ACLCHECK_OK)
                    return false;
            }
            else
            {
                if (pg_attribute_aclcheck(rte->relid, attno, userid,
                                          ACL_SELECT) != ACLCHECK_OK)
                    return false;
            }
        }
    }
 
    /* If we reach here, the clause is OK */
    return true;
}

References ACL_SELECT, ACLCHECK_OK, ACLMASK_ALL, BoolExpr::args, attnum, bms_add_member(), bms_get_singleton_member(), bms_next_member(), RestrictInfo::clause, FirstLowInvalidHeapAttributeNumber, GetUserId(), InvalidAttrNumber, is_andclause(), IsA, lfirst, NIL, OidIsValid, pg_attribute_aclcheck(), pg_attribute_aclcheck_all(), pg_class_aclcheck(), pull_varattnos(), root, statext_is_compatible_clause(), statext_is_compatible_clause_internal(), and RelOptInfo::userid.

Referenced by statext_is_compatible_clause(), and statext_mcv_clauselist_selectivity().

statext_is_compatible_clause_internal()

static bool statext_is_compatible_clause_internal ( PlannerInfo *  root, Node *  clause, Index  relid, Bitmapset **  attnums, List **  exprs  )

static

Definition at line 1325 of file extended_stats.c.

{
    /* Look inside any binary-compatible relabeling (as in examine_variable) */
    if (IsA(clause, RelabelType))
        clause = (Node *) ((RelabelType *) clause)->arg;
 
    /* plain Var references (boolean Vars or recursive checks) */
    if (IsA(clause, Var))
    {
        Var        *var = (Var *) clause;
 
        /* Ensure var is from the correct relation */
        if (var->varno != relid)
            return false;
 
        /* we also better ensure the Var is from the current level */
        if (var->varlevelsup > 0)
            return false;
 
        /*
         * Also reject system attributes and whole-row Vars (we don't allow
         * stats on those).
         */
        if (!AttrNumberIsForUserDefinedAttr(var->varattno))
            return false;
 
        /* OK, record the attnum for later permissions checks. */
        *attnums = bms_add_member(*attnums, var->varattno);
 
        return true;
    }
 
    /* (Var/Expr op Const) or (Const op Var/Expr) */
    if (is_opclause(clause))
    {
        RangeTblEntry *rte = root->simple_rte_array[relid];
        OpExpr     *expr = (OpExpr *) clause;
        Node       *clause_expr;
 
        /* Only expressions with two arguments are considered compatible. */
        if (list_length(expr->args) != 2)
            return false;
 
        /* Check if the expression has the right shape */
        if (!examine_opclause_args(expr->args, &clause_expr, NULL, NULL))
            return false;
 
        /*
         * If it's not one of the supported operators ("=", "<", ">", etc.),
         * just ignore the clause, as it's not compatible with MCV lists.
         *
         * This uses the function for estimating selectivity, not the operator
         * directly (a bit awkward, but well ...).
         */
        switch (get_oprrest(expr->opno))
        {
            case F_EQSEL:
            case F_NEQSEL:
            case F_SCALARLTSEL:
            case F_SCALARLESEL:
            case F_SCALARGTSEL:
            case F_SCALARGESEL:
                /* supported, will continue with inspection of the Var/Expr */
                break;
 
            default:
                /* other estimators are considered unknown/unsupported */
                return false;
        }
 
        /*
         * If there are any securityQuals on the RTE from security barrier
         * views or RLS policies, then the user may not have access to all the
         * table's data, and we must check that the operator is leakproof.
         *
         * If the operator is leaky, then we must ignore this clause for the
         * purposes of estimating with MCV lists, otherwise the operator might
         * reveal values from the MCV list that the user doesn't have
         * permission to see.
         */
        if (rte->securityQuals != NIL &&
            !get_func_leakproof(get_opcode(expr->opno)))
            return false;
 
        /* Check (Var op Const) or (Const op Var) clauses by recursing. */
        if (IsA(clause_expr, Var))
            return statext_is_compatible_clause_internal(root, clause_expr,
                                                         relid, attnums, exprs);
 
        /* Otherwise we have (Expr op Const) or (Const op Expr). */
        *exprs = lappend(*exprs, clause_expr);
        return true;
    }
 
    /* Var/Expr IN Array */
    if (IsA(clause, ScalarArrayOpExpr))
    {
        RangeTblEntry *rte = root->simple_rte_array[relid];
        ScalarArrayOpExpr *expr = (ScalarArrayOpExpr *) clause;
        Node       *clause_expr;
        bool        expronleft;
 
        /* Only expressions with two arguments are considered compatible. */
        if (list_length(expr->args) != 2)
            return false;
 
        /* Check if the expression has the right shape (one Var, one Const) */
        if (!examine_opclause_args(expr->args, &clause_expr, NULL, &expronleft))
            return false;
 
        /* We only support Var on left, Const on right */
        if (!expronleft)
            return false;
 
        /*
         * If it's not one of the supported operators ("=", "<", ">", etc.),
         * just ignore the clause, as it's not compatible with MCV lists.
         *
         * This uses the function for estimating selectivity, not the operator
         * directly (a bit awkward, but well ...).
         */
        switch (get_oprrest(expr->opno))
        {
            case F_EQSEL:
            case F_NEQSEL:
            case F_SCALARLTSEL:
            case F_SCALARLESEL:
            case F_SCALARGTSEL:
            case F_SCALARGESEL:
                /* supported, will continue with inspection of the Var/Expr */
                break;
 
            default:
                /* other estimators are considered unknown/unsupported */
                return false;
        }
 
        /*
         * If there are any securityQuals on the RTE from security barrier
         * views or RLS policies, then the user may not have access to all the
         * table's data, and we must check that the operator is leakproof.
         *
         * If the operator is leaky, then we must ignore this clause for the
         * purposes of estimating with MCV lists, otherwise the operator might
         * reveal values from the MCV list that the user doesn't have
         * permission to see.
         */
        if (rte->securityQuals != NIL &&
            !get_func_leakproof(get_opcode(expr->opno)))
            return false;
 
        /* Check Var IN Array clauses by recursing. */
        if (IsA(clause_expr, Var))
            return statext_is_compatible_clause_internal(root, clause_expr,
                                                         relid, attnums, exprs);
 
        /* Otherwise we have Expr IN Array. */
        *exprs = lappend(*exprs, clause_expr);
        return true;
    }
 
    /* AND/OR/NOT clause */
    if (is_andclause(clause) ||
        is_orclause(clause) ||
        is_notclause(clause))
    {
        /*
         * AND/OR/NOT-clauses are supported if all sub-clauses are supported
         *
         * Perhaps we could improve this by handling mixed cases, when some of
         * the clauses are supported and some are not. Selectivity for the
         * supported subclauses would be computed using extended statistics,
         * and the remaining clauses would be estimated using the traditional
         * algorithm (product of selectivities).
         *
         * It however seems overly complex, and in a way we already do that
         * because if we reject the whole clause as unsupported here, it will
         * be eventually passed to clauselist_selectivity() which does exactly
         * this (split into supported/unsupported clauses etc).
         */
        BoolExpr   *expr = (BoolExpr *) clause;
        ListCell   *lc;
 
        foreach(lc, expr->args)
        {
            /*
             * If we find an incompatible clause in the arguments, treat the
             * whole clause as incompatible.
             */
            if (!statext_is_compatible_clause_internal(root,
                                                       (Node *) lfirst(lc),
                                                       relid, attnums, exprs))
                return false;
        }
 
        return true;
    }
 
    /* Var/Expr IS NULL */
    if (IsA(clause, NullTest))
    {
        NullTest   *nt = (NullTest *) clause;
 
        /* Check Var IS NULL clauses by recursing. */
        if (IsA(nt->arg, Var))
            return statext_is_compatible_clause_internal(root, (Node *) (nt->arg),
                                                         relid, attnums, exprs);
 
        /* Otherwise we have Expr IS NULL. */
        *exprs = lappend(*exprs, nt->arg);
        return true;
    }
 
    /*
     * Treat any other expressions as bare expressions to be matched against
     * expressions in statistics objects.
     */
    *exprs = lappend(*exprs, clause);
    return true;
}

References arg, NullTest::arg, OpExpr::args, ScalarArrayOpExpr::args, BoolExpr::args, AttrNumberIsForUserDefinedAttr, bms_add_member(), examine_opclause_args(), get_func_leakproof(), get_opcode(), get_oprrest(), is_andclause(), is_notclause(), is_opclause(), is_orclause(), IsA, lappend(), lfirst, list_length(), NIL, OpExpr::opno, ScalarArrayOpExpr::opno, root, statext_is_compatible_clause_internal(), Var::varattno, Var::varlevelsup, and Var::varno.

Referenced by statext_is_compatible_clause(), and statext_is_compatible_clause_internal().

statext_is_kind_built()

bool statext_is_kind_built	(	HeapTuple	htup,
		char	type
	)

Definition at line 386 of file extended_stats.c.

{
    AttrNumber  attnum;
 
    switch (type)
    {
        case STATS_EXT_NDISTINCT:
            attnum = Anum_pg_statistic_ext_data_stxdndistinct;
            break;
 
        case STATS_EXT_DEPENDENCIES:
            attnum = Anum_pg_statistic_ext_data_stxddependencies;
            break;
 
        case STATS_EXT_MCV:
            attnum = Anum_pg_statistic_ext_data_stxdmcv;
            break;
 
        case STATS_EXT_EXPRESSIONS:
            attnum = Anum_pg_statistic_ext_data_stxdexpr;
            break;
 
        default:
            elog(ERROR, "unexpected statistics type requested: %d", type);
    }
 
    return !heap_attisnull(htup, attnum, NULL);
}

References attnum, elog, ERROR, heap_attisnull(), and type.

Referenced by get_relation_statistics_worker().

statext_mcv_clauselist_selectivity()

static Selectivity statext_mcv_clauselist_selectivity ( PlannerInfo *  root, List *  clauses, int  varRelid, JoinType  jointype, SpecialJoinInfo *  sjinfo, RelOptInfo *  rel, Bitmapset **  estimatedclauses, bool  is_or  )

static

Definition at line 1713 of file extended_stats.c.

{
    ListCell   *l;
    Bitmapset **list_attnums;   /* attnums extracted from the clause */
    List      **list_exprs;     /* expressions matched to any statistic */
    int         listidx;
    Selectivity sel = (is_or) ? 0.0 : 1.0;
    RangeTblEntry *rte = planner_rt_fetch(rel->relid, root);
 
    /* check if there's any stats that might be useful for us. */
    if (!has_stats_of_kind(rel->statlist, STATS_EXT_MCV))
        return sel;
 
    list_attnums = (Bitmapset **) palloc(sizeof(Bitmapset *) *
                                         list_length(clauses));
 
    /* expressions extracted from complex expressions */
    list_exprs = (List **) palloc(sizeof(Node *) * list_length(clauses));
 
    /*
     * Pre-process the clauses list to extract the attnums and expressions
     * seen in each item.  We need to determine if there are any clauses which
     * will be useful for selectivity estimations with extended stats.  Along
     * the way we'll record all of the attnums and expressions for each clause
     * in lists which we'll reference later so we don't need to repeat the
     * same work again.
     *
     * We also skip clauses that we already estimated using different types of
     * statistics (we treat them as incompatible).
     */
    listidx = 0;
    foreach(l, clauses)
    {
        Node       *clause = (Node *) lfirst(l);
        Bitmapset  *attnums = NULL;
        List       *exprs = NIL;
 
        if (!bms_is_member(listidx, *estimatedclauses) &&
            statext_is_compatible_clause(root, clause, rel->relid, &attnums, &exprs))
        {
            list_attnums[listidx] = attnums;
            list_exprs[listidx] = exprs;
        }
        else
        {
            list_attnums[listidx] = NULL;
            list_exprs[listidx] = NIL;
        }
 
        listidx++;
    }
 
    /* apply as many extended statistics as possible */
    while (true)
    {
        StatisticExtInfo *stat;
        List       *stat_clauses;
        Bitmapset  *simple_clauses;
 
        /* find the best suited statistics object for these attnums */
        stat = choose_best_statistics(rel->statlist, STATS_EXT_MCV, rte->inh,
                                      list_attnums, list_exprs,
                                      list_length(clauses));
 
        /*
         * if no (additional) matching stats could be found then we've nothing
         * to do
         */
        if (!stat)
            break;
 
        /* Ensure choose_best_statistics produced an expected stats type. */
        Assert(stat->kind == STATS_EXT_MCV);
 
        /* now filter the clauses to be estimated using the selected MCV */
        stat_clauses = NIL;
 
        /* record which clauses are simple (single column or expression) */
        simple_clauses = NULL;
 
        listidx = -1;
        foreach(l, clauses)
        {
            /* Increment the index before we decide if to skip the clause. */
            listidx++;
 
            /*
             * Ignore clauses from which we did not extract any attnums or
             * expressions (this needs to be consistent with what we do in
             * choose_best_statistics).
             *
             * This also eliminates already estimated clauses - both those
             * estimated before and during applying extended statistics.
             *
             * XXX This check is needed because both bms_is_subset and
             * stat_covers_expressions return true for empty attnums and
             * expressions.
             */
            if (!list_attnums[listidx] && !list_exprs[listidx])
                continue;
 
            /*
             * The clause was not estimated yet, and we've extracted either
             * attnums or expressions from it. Ignore it if it's not fully
             * covered by the chosen statistics object.
             *
             * We need to check both attributes and expressions, and reject if
             * either is not covered.
             */
            if (!bms_is_subset(list_attnums[listidx], stat->keys) ||
                !stat_covers_expressions(stat, list_exprs[listidx], NULL))
                continue;
 
            /*
             * Now we know the clause is compatible (we have either attnums or
             * expressions extracted from it), and was not estimated yet.
             */
 
            /* record simple clauses (single column or expression) */
            if ((list_attnums[listidx] == NULL &&
                 list_length(list_exprs[listidx]) == 1) ||
                (list_exprs[listidx] == NIL &&
                 bms_membership(list_attnums[listidx]) == BMS_SINGLETON))
                simple_clauses = bms_add_member(simple_clauses,
                                                list_length(stat_clauses));
 
            /* add clause to list and mark it as estimated */
            stat_clauses = lappend(stat_clauses, (Node *) lfirst(l));
            *estimatedclauses = bms_add_member(*estimatedclauses, listidx);
 
            /*
             * Reset the pointers, so that choose_best_statistics knows this
             * clause was estimated and does not consider it again.
             */
            bms_free(list_attnums[listidx]);
            list_attnums[listidx] = NULL;
 
            list_free(list_exprs[listidx]);
            list_exprs[listidx] = NULL;
        }
 
        if (is_or)
        {
            bool       *or_matches = NULL;
            Selectivity simple_or_sel = 0.0,
                        stat_sel = 0.0;
            MCVList    *mcv_list;
 
            /* Load the MCV list stored in the statistics object */
            mcv_list = statext_mcv_load(stat->statOid, rte->inh);
 
            /*
             * Compute the selectivity of the ORed list of clauses covered by
             * this statistics object by estimating each in turn and combining
             * them using the formula P(A OR B) = P(A) + P(B) - P(A AND B).
             * This allows us to use the multivariate MCV stats to better
             * estimate the individual terms and their overlap.
             *
             * Each time we iterate this formula, the clause "A" above is
             * equal to all the clauses processed so far, combined with "OR".
             */
            listidx = 0;
            foreach(l, stat_clauses)
            {
                Node       *clause = (Node *) lfirst(l);
                Selectivity simple_sel,
                            overlap_simple_sel,
                            mcv_sel,
                            mcv_basesel,
                            overlap_mcvsel,
                            overlap_basesel,
                            mcv_totalsel,
                            clause_sel,
                            overlap_sel;
 
                /*
                 * "Simple" selectivity of the next clause and its overlap
                 * with any of the previous clauses.  These are our initial
                 * estimates of P(B) and P(A AND B), assuming independence of
                 * columns/clauses.
                 */
                simple_sel = clause_selectivity_ext(root, clause, varRelid,
                                                    jointype, sjinfo, false);
 
                overlap_simple_sel = simple_or_sel * simple_sel;
 
                /*
                 * New "simple" selectivity of all clauses seen so far,
                 * assuming independence.
                 */
                simple_or_sel += simple_sel - overlap_simple_sel;
                CLAMP_PROBABILITY(simple_or_sel);
 
                /*
                 * Multi-column estimate of this clause using MCV statistics,
                 * along with base and total selectivities, and corresponding
                 * selectivities for the overlap term P(A AND B).
                 */
                mcv_sel = mcv_clause_selectivity_or(root, stat, mcv_list,
                                                    clause, &or_matches,
                                                    &mcv_basesel,
                                                    &overlap_mcvsel,
                                                    &overlap_basesel,
                                                    &mcv_totalsel);
 
                /*
                 * Combine the simple and multi-column estimates.
                 *
                 * If this clause is a simple single-column clause, then we
                 * just use the simple selectivity estimate for it, since the
                 * multi-column statistics are unlikely to improve on that
                 * (and in fact could make it worse).  For the overlap, we
                 * always make use of the multi-column statistics.
                 */
                if (bms_is_member(listidx, simple_clauses))
                    clause_sel = simple_sel;
                else
                    clause_sel = mcv_combine_selectivities(simple_sel,
                                                           mcv_sel,
                                                           mcv_basesel,
                                                           mcv_totalsel);
 
                overlap_sel = mcv_combine_selectivities(overlap_simple_sel,
                                                        overlap_mcvsel,
                                                        overlap_basesel,
                                                        mcv_totalsel);
 
                /* Factor these into the result for this statistics object */
                stat_sel += clause_sel - overlap_sel;
                CLAMP_PROBABILITY(stat_sel);
 
                listidx++;
            }
 
            /*
             * Factor the result for this statistics object into the overall
             * result.  We treat the results from each separate statistics
             * object as independent of one another.
             */
            sel = sel + stat_sel - sel * stat_sel;
        }
        else                    /* Implicitly-ANDed list of clauses */
        {
            Selectivity simple_sel,
                        mcv_sel,
                        mcv_basesel,
                        mcv_totalsel,
                        stat_sel;
 
            /*
             * "Simple" selectivity, i.e. without any extended statistics,
             * essentially assuming independence of the columns/clauses.
             */
            simple_sel = clauselist_selectivity_ext(root, stat_clauses,
                                                    varRelid, jointype,
                                                    sjinfo, false);
 
            /*
             * Multi-column estimate using MCV statistics, along with base and
             * total selectivities.
             */
            mcv_sel = mcv_clauselist_selectivity(root, stat, stat_clauses,
                                                 varRelid, jointype, sjinfo,
                                                 rel, &mcv_basesel,
                                                 &mcv_totalsel);
 
            /* Combine the simple and multi-column estimates. */
            stat_sel = mcv_combine_selectivities(simple_sel,
                                                 mcv_sel,
                                                 mcv_basesel,
                                                 mcv_totalsel);
 
            /* Factor this into the overall result */
            sel *= stat_sel;
        }
    }
 
    return sel;
}

References Assert(), bms_add_member(), bms_free(), bms_is_member(), bms_is_subset(), bms_membership(), BMS_SINGLETON, choose_best_statistics(), CLAMP_PROBABILITY, clause_selectivity_ext(), clauselist_selectivity_ext(), has_stats_of_kind(), RangeTblEntry::inh, lappend(), lfirst, list_free(), list_length(), mcv_clause_selectivity_or(), mcv_clauselist_selectivity(), mcv_combine_selectivities(), NIL, palloc(), planner_rt_fetch, RelOptInfo::relid, root, stat, stat_covers_expressions(), statext_is_compatible_clause(), statext_mcv_load(), and RelOptInfo::statlist.

Referenced by statext_clauselist_selectivity().

statext_store()

static void statext_store ( Oid  statOid, bool  inh, MVNDistinct *  ndistinct, MVDependencies *  dependencies, MCVList *  mcv, Datum  exprs, VacAttrStats **  stats  )

static

Definition at line 759 of file extended_stats.c.

{
    Relation    pg_stextdata;
    HeapTuple   stup;
    Datum       values[Natts_pg_statistic_ext_data];
    bool        nulls[Natts_pg_statistic_ext_data];
 
    pg_stextdata = table_open(StatisticExtDataRelationId, RowExclusiveLock);
 
    memset(nulls, true, sizeof(nulls));
    memset(values, 0, sizeof(values));
 
    /* basic info */
    values[Anum_pg_statistic_ext_data_stxoid - 1] = ObjectIdGetDatum(statOid);
    nulls[Anum_pg_statistic_ext_data_stxoid - 1] = false;
 
    values[Anum_pg_statistic_ext_data_stxdinherit - 1] = BoolGetDatum(inh);
    nulls[Anum_pg_statistic_ext_data_stxdinherit - 1] = false;
 
    /*
     * Construct a new pg_statistic_ext_data tuple, replacing the calculated
     * stats.
     */
    if (ndistinct != NULL)
    {
        bytea      *data = statext_ndistinct_serialize(ndistinct);
 
        nulls[Anum_pg_statistic_ext_data_stxdndistinct - 1] = (data == NULL);
        values[Anum_pg_statistic_ext_data_stxdndistinct - 1] = PointerGetDatum(data);
    }
 
    if (dependencies != NULL)
    {
        bytea      *data = statext_dependencies_serialize(dependencies);
 
        nulls[Anum_pg_statistic_ext_data_stxddependencies - 1] = (data == NULL);
        values[Anum_pg_statistic_ext_data_stxddependencies - 1] = PointerGetDatum(data);
    }
    if (mcv != NULL)
    {
        bytea      *data = statext_mcv_serialize(mcv, stats);
 
        nulls[Anum_pg_statistic_ext_data_stxdmcv - 1] = (data == NULL);
        values[Anum_pg_statistic_ext_data_stxdmcv - 1] = PointerGetDatum(data);
    }
    if (exprs != (Datum) 0)
    {
        nulls[Anum_pg_statistic_ext_data_stxdexpr - 1] = false;
        values[Anum_pg_statistic_ext_data_stxdexpr - 1] = exprs;
    }
 
    /*
     * Delete the old tuple if it exists, and insert a new one. It's easier
     * than trying to update or insert, based on various conditions.
     */
    RemoveStatisticsDataById(statOid, inh);
 
    /* form and insert a new tuple */
    stup = heap_form_tuple(RelationGetDescr(pg_stextdata), values, nulls);
    CatalogTupleInsert(pg_stextdata, stup);
 
    heap_freetuple(stup);
 
    table_close(pg_stextdata, RowExclusiveLock);
}

References BoolGetDatum(), CatalogTupleInsert(), data, heap_form_tuple(), heap_freetuple(), ObjectIdGetDatum(), PointerGetDatum(), RelationGetDescr, RemoveStatisticsDataById(), RowExclusiveLock, statext_dependencies_serialize(), statext_mcv_serialize(), statext_ndistinct_serialize(), table_close(), table_open(), and values.

Referenced by BuildRelationExtStatistics().