stat_utils.c File Reference

#include "postgres.h"
#include "access/htup_details.h"
#include "access/relation.h"
#include "catalog/index.h"
#include "catalog/namespace.h"
#include "catalog/pg_class.h"
#include "catalog/pg_collation.h"
#include "catalog/pg_database.h"
#include "catalog/pg_statistic.h"
#include "funcapi.h"
#include "miscadmin.h"
#include "nodes/nodeFuncs.h"
#include "statistics/stat_utils.h"
#include "storage/lmgr.h"
#include "utils/acl.h"
#include "utils/array.h"
#include "utils/builtins.h"
#include "utils/lsyscache.h"
#include "utils/rel.h"
#include "utils/syscache.h"

Include dependency graph for stat_utils.c:

Go to the source code of this file.

Macros
#define	DEFAULT_STATATT_NULL_FRAC   Float4GetDatum(0.0) /* stanullfrac */
#define	DEFAULT_STATATT_AVG_WIDTH
#define	DEFAULT_STATATT_N_DISTINCT

Functions
static Node *	statatt_get_index_expr (Relation rel, int attnum)
void	stats_check_required_arg (FunctionCallInfo fcinfo, struct StatsArgInfo *arginfo, int argnum)
bool	stats_check_arg_array (FunctionCallInfo fcinfo, struct StatsArgInfo *arginfo, int argnum)
bool	stats_check_arg_pair (FunctionCallInfo fcinfo, struct StatsArgInfo *arginfo, int argnum1, int argnum2)
void	RangeVarCallbackForStats (const RangeVar *relation, Oid relId, Oid oldRelId, void *arg)
static int	get_arg_by_name (const char *argname, struct StatsArgInfo *arginfo)
static bool	stats_check_arg_type (const char *argname, Oid argtype, Oid expectedtype)
bool	stats_fill_fcinfo_from_arg_pairs (FunctionCallInfo pairs_fcinfo, FunctionCallInfo positional_fcinfo, struct StatsArgInfo *arginfo)
void	statatt_get_type (Oid reloid, AttrNumber attnum, Oid *atttypid, int32 *atttypmod, char *atttyptype, Oid *atttypcoll, Oid *eq_opr, Oid *lt_opr)
bool	statatt_get_elem_type (Oid atttypid, char atttyptype, Oid *elemtypid, Oid *elem_eq_opr)
Datum	statatt_build_stavalues (const char *staname, FmgrInfo *array_in, Datum d, Oid typid, int32 typmod, bool *ok)
void	statatt_set_slot (Datum *values, bool *nulls, bool *replaces, int16 stakind, Oid staop, Oid stacoll, Datum stanumbers, bool stanumbers_isnull, Datum stavalues, bool stavalues_isnull)
void	statatt_init_empty_tuple (Oid reloid, int16 attnum, bool inherited, Datum *values, bool *nulls, bool *replaces)

Macro Definition Documentation

DEFAULT_STATATT_AVG_WIDTH

#define DEFAULT_STATATT_AVG_WIDTH

Value:

                                                         Int32GetDatum(0) /* stawidth, same as
                                                         * unknown */

Definition at line 41 of file stat_utils.c.

DEFAULT_STATATT_N_DISTINCT

#define DEFAULT_STATATT_N_DISTINCT

Value:

                                                             Float4GetDatum(0.0)    /* stadistinct, same as
                                                             * unknown */

Definition at line 42 of file stat_utils.c.

DEFAULT_STATATT_NULL_FRAC

#define DEFAULT_STATATT_NULL_FRAC   Float4GetDatum(0.0) /* stanullfrac */

Definition at line 40 of file stat_utils.c.

Function Documentation

get_arg_by_name()

static int get_arg_by_name ( const char *  argname, struct StatsArgInfo *  arginfo  )

static

Definition at line 261 of file stat_utils.c.

{
    int         argnum;
 
    for (argnum = 0; arginfo[argnum].argname != NULL; argnum++)
        if (pg_strcasecmp(argname, arginfo[argnum].argname) == 0)
            return argnum;
 
    ereport(WARNING,
            (errmsg("unrecognized argument name: \"%s\"", argname)));
 

References StatsArgInfo::argname, ereport, errmsg(), pg_strcasecmp(), and WARNING.

Referenced by stats_fill_fcinfo_from_arg_pairs().

RangeVarCallbackForStats()

void RangeVarCallbackForStats	(	const RangeVar *	relation,
		Oid	relId,
		Oid	oldRelId,
		void *	arg
	)

Definition at line 141 of file stat_utils.c.

{
    Oid        *locked_oid = (Oid *) arg;
    Oid         table_oid = relId;
    HeapTuple   tuple;
    Form_pg_class form;
    char        relkind;
 
    /*
     * If we previously locked some other index's heap, and the name we're
     * looking up no longer refers to that relation, release the now-useless
     * lock.
     */
    if (relId != oldRelId && OidIsValid(*locked_oid))
    {
        UnlockRelationOid(*locked_oid, ShareUpdateExclusiveLock);
        *locked_oid = InvalidOid;
    }
 
    /* If the relation does not exist, there's nothing more to do. */
    if (!OidIsValid(relId))
        return;
 
    /* If the relation does exist, check whether it's an index. */
    relkind = get_rel_relkind(relId);
    if (relkind == RELKIND_INDEX ||
        relkind == RELKIND_PARTITIONED_INDEX)
        table_oid = IndexGetRelation(relId, false);
 
    /*
     * If retrying yields the same OID, there are a couple of extremely
     * unlikely scenarios we need to handle.
     */
    if (relId == oldRelId)
    {
        /*
         * If a previous lookup found an index, but the current lookup did
         * not, the index was dropped and the OID was reused for something
         * else between lookups.  In theory, we could simply drop our lock on
         * the index's parent table and proceed, but in the interest of
         * avoiding complexity, we just error.
         */
        if (table_oid == relId && OidIsValid(*locked_oid))
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_OBJECT),
                     errmsg("index \"%s\" was concurrently dropped",
                            relation->relname)));
 
        /*
         * If the current lookup found an index but a previous lookup either
         * did not find an index or found one with a different parent
         * relation, the relation was dropped and the OID was reused for an
         * index between lookups.  RangeVarGetRelidExtended() will have
         * already locked the index at this point, so we can't just lock the
         * newly discovered parent table OID without risking deadlock.  As
         * above, we just error in this case.
         */
        if (table_oid != relId && table_oid != *locked_oid)
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_OBJECT),
                     errmsg("index \"%s\" was concurrently created",
                            relation->relname)));
    }
 
    tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(table_oid));
    if (!HeapTupleIsValid(tuple))
        elog(ERROR, "cache lookup failed for OID %u", table_oid);
    form = (Form_pg_class) GETSTRUCT(tuple);
 
    /* the relkinds that can be used with ANALYZE */
    switch (form->relkind)
    {
        case RELKIND_RELATION:
        case RELKIND_MATVIEW:
        case RELKIND_FOREIGN_TABLE:
        case RELKIND_PARTITIONED_TABLE:
            break;
        default:
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("cannot modify statistics for relation \"%s\"",
                            NameStr(form->relname)),
                     errdetail_relkind_not_supported(form->relkind)));
    }
 
    if (form->relisshared)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot modify statistics for shared relation")));
 
    /* Check permissions */
    if (!object_ownercheck(DatabaseRelationId, MyDatabaseId, GetUserId()))
    {
        AclResult   aclresult = pg_class_aclcheck(table_oid,
                                                  GetUserId(),
                                                  ACL_MAINTAIN);
 
        if (aclresult != ACLCHECK_OK)
            aclcheck_error(aclresult,
                           get_relkind_objtype(form->relkind),
                           NameStr(form->relname));
    }
 
    ReleaseSysCache(tuple);
 
    /* Lock heap before index to avoid deadlock. */
    if (relId != oldRelId && table_oid != relId)
    {
        LockRelationOid(table_oid, ShareUpdateExclusiveLock);
        *locked_oid = table_oid;

References ACL_MAINTAIN, aclcheck_error(), ACLCHECK_OK, arg, elog, ereport, errcode(), errdetail_relkind_not_supported(), errmsg(), ERROR, get_rel_relkind(), get_relkind_objtype(), GETSTRUCT(), GetUserId(), HeapTupleIsValid, IndexGetRelation(), InvalidOid, LockRelationOid(), MyDatabaseId, NameStr, object_ownercheck(), ObjectIdGetDatum(), OidIsValid, pg_class_aclcheck(), ReleaseSysCache(), RangeVar::relname, SearchSysCache1(), ShareUpdateExclusiveLock, and UnlockRelationOid().

Referenced by attribute_statistics_update(), pg_clear_attribute_stats(), and relation_statistics_update().

statatt_build_stavalues()

Datum statatt_build_stavalues	(	const char *	staname,
		FmgrInfo *	array_in,
		Datum	d,
		Oid	typid,
		int32	typmod,
		bool *	ok
	)

Definition at line 566 of file stat_utils.c.

{
    LOCAL_FCINFO(fcinfo, 8);
    char       *s;
    Datum       result;
    ErrorSaveContext escontext = {T_ErrorSaveContext};
 
    escontext.details_wanted = true;
 
    s = TextDatumGetCString(d);
 
    InitFunctionCallInfoData(*fcinfo, array_in, 3, InvalidOid,
                             (Node *) &escontext, NULL);
 
    fcinfo->args[0].value = CStringGetDatum(s);
    fcinfo->args[0].isnull = false;
    fcinfo->args[1].value = ObjectIdGetDatum(typid);
    fcinfo->args[1].isnull = false;
    fcinfo->args[2].value = Int32GetDatum(typmod);
    fcinfo->args[2].isnull = false;
 
    result = FunctionCallInvoke(fcinfo);
 
    pfree(s);
 
    if (escontext.error_occurred)
    {
        escontext.error_data->elevel = WARNING;
        ThrowErrorData(escontext.error_data);
        *ok = false;
        return (Datum) 0;
    }
 
    if (array_contains_nulls(DatumGetArrayTypeP(result)))
    {
        ereport(WARNING,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("\"%s\" array must not contain null values", staname)));
        *ok = false;
        return (Datum) 0;
    }
 
    *ok = true;
 

References array_contains_nulls(), array_in(), CStringGetDatum(), DatumGetArrayTypeP, ErrorSaveContext::details_wanted, ErrorData::elevel, ereport, errcode(), errmsg(), ErrorSaveContext::error_data, ErrorSaveContext::error_occurred, FunctionCallInvoke, InitFunctionCallInfoData, Int32GetDatum(), InvalidOid, LOCAL_FCINFO, ObjectIdGetDatum(), pfree(), TextDatumGetCString, ThrowErrorData(), and WARNING.

Referenced by attribute_statistics_update().

statatt_get_elem_type()

bool statatt_get_elem_type	(	Oid	atttypid,
		char	atttyptype,
		Oid *	elemtypid,
		Oid *	elem_eq_opr
	)

Definition at line 522 of file stat_utils.c.

{
    TypeCacheEntry *elemtypcache;
 
    if (atttypid == TSVECTOROID)
    {
        /*
         * Special case: element type for tsvector is text. See
         * compute_tsvector_stats().
         */
        *elemtypid = TEXTOID;
    }
    else
    {
        /* find underlying element type through any domain */
        *elemtypid = get_base_element_type(atttypid);
    }
 
    if (!OidIsValid(*elemtypid))
        return false;
 
    /* finds the right operator even if elemtypid is a domain */
    elemtypcache = lookup_type_cache(*elemtypid, TYPECACHE_EQ_OPR);
    if (!OidIsValid(elemtypcache->eq_opr))
        return false;
 
    *elem_eq_opr = elemtypcache->eq_opr;
 

References TypeCacheEntry::eq_opr, get_base_element_type(), lookup_type_cache(), OidIsValid, and TYPECACHE_EQ_OPR.

Referenced by attribute_statistics_update().

statatt_get_index_expr()

static Node * statatt_get_index_expr ( Relation  rel, int  attnum  )

static

Definition at line 302 of file stat_utils.c.

{
    List       *index_exprs;
    ListCell   *indexpr_item;
 
    /* relation is not an index */
    if (rel->rd_rel->relkind != RELKIND_INDEX &&
        rel->rd_rel->relkind != RELKIND_PARTITIONED_INDEX)
        return NULL;
 
    index_exprs = RelationGetIndexExpressions(rel);
 
    /* index has no expressions to give */
    if (index_exprs == NIL)
        return NULL;
 
    /*
     * The index's attnum points directly to a relation attnum, hence it is
     * not an expression attribute.
     */
    if (rel->rd_index->indkey.values[attnum - 1] != 0)
        return NULL;
 
    indexpr_item = list_head(rel->rd_indexprs);
 
    for (int i = 0; i < attnum - 1; i++)
        if (rel->rd_index->indkey.values[i] == 0)
            indexpr_item = lnext(rel->rd_indexprs, indexpr_item);
 
    if (indexpr_item == NULL)   /* shouldn't happen */
        elog(ERROR, "too few entries in indexprs list");
 

References attnum, elog, ERROR, i, lfirst, list_head(), lnext(), NIL, RelationData::rd_index, RelationData::rd_indexprs, RelationData::rd_rel, and RelationGetIndexExpressions().

Referenced by statatt_get_type().

statatt_get_type()

void statatt_get_type	(	Oid	reloid,
		AttrNumber	attnum,
		Oid *	atttypid,
		int32 *	atttypmod,
		char *	atttyptype,
		Oid *	atttypcoll,
		Oid *	eq_opr,
		Oid *	lt_opr
	)

Definition at line 436 of file stat_utils.c.

{
    Relation    rel = relation_open(reloid, AccessShareLock);
    Form_pg_attribute attr;
    HeapTuple   atup;
    Node       *expr;
    TypeCacheEntry *typcache;
 
    atup = SearchSysCache2(ATTNUM, ObjectIdGetDatum(reloid),
                           Int16GetDatum(attnum));
 
    /* Attribute not found */
    if (!HeapTupleIsValid(atup))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_COLUMN),
                 errmsg("column %d of relation \"%s\" does not exist",
                        attnum, RelationGetRelationName(rel))));
 
    attr = (Form_pg_attribute) GETSTRUCT(atup);
 
    if (attr->attisdropped)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_COLUMN),
                 errmsg("column %d of relation \"%s\" does not exist",
                        attnum, RelationGetRelationName(rel))));
 
    expr = statatt_get_index_expr(rel, attr->attnum);
 
    /*
     * When analyzing an expression index, 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.  This
     * mimics the behavior of examine_attribute().
     */
    if (expr == NULL)
    {
        *atttypid = attr->atttypid;
        *atttypmod = attr->atttypmod;
        *atttypcoll = attr->attcollation;
    }
    else
    {
        *atttypid = exprType(expr);
        *atttypmod = exprTypmod(expr);
 
        if (OidIsValid(attr->attcollation))
            *atttypcoll = attr->attcollation;
        else
            *atttypcoll = exprCollation(expr);
    }
    ReleaseSysCache(atup);
 
    /*
     * If it's a multirange, step down to the range type, as is done by
     * multirange_typanalyze().
     */
    if (type_is_multirange(*atttypid))
        *atttypid = get_multirange_range(*atttypid);
 
    /* finds the right operators even if atttypid is a domain */
    typcache = lookup_type_cache(*atttypid, TYPECACHE_LT_OPR | TYPECACHE_EQ_OPR);
    *atttyptype = typcache->typtype;
    *eq_opr = typcache->eq_opr;
    *lt_opr = typcache->lt_opr;
 
    /*
     * Special case: collation for tsvector is DEFAULT_COLLATION_OID. See
     * compute_tsvector_stats().
     */
    if (*atttypid == TSVECTOROID)
        *atttypcoll = DEFAULT_COLLATION_OID;
 

References AccessShareLock, attnum, TypeCacheEntry::eq_opr, ereport, errcode(), errmsg(), ERROR, exprCollation(), exprType(), exprTypmod(), get_multirange_range(), GETSTRUCT(), HeapTupleIsValid, Int16GetDatum(), lookup_type_cache(), TypeCacheEntry::lt_opr, NoLock, ObjectIdGetDatum(), OidIsValid, relation_close(), relation_open(), RelationGetRelationName, ReleaseSysCache(), SearchSysCache2(), statatt_get_index_expr(), type_is_multirange(), TYPECACHE_EQ_OPR, TYPECACHE_LT_OPR, and TypeCacheEntry::typtype.

Referenced by attribute_statistics_update().

statatt_init_empty_tuple()

void statatt_init_empty_tuple	(	Oid	reloid,
		int16	attnum,
		bool	inherited,
		Datum *	values,
		bool *	nulls,
		bool *	replaces
	)

Definition at line 712 of file stat_utils.c.

{
    memset(nulls, true, sizeof(bool) * Natts_pg_statistic);
    memset(replaces, true, sizeof(bool) * Natts_pg_statistic);
 
    /* This must initialize non-NULL attributes */
    values[Anum_pg_statistic_starelid - 1] = ObjectIdGetDatum(reloid);
    nulls[Anum_pg_statistic_starelid - 1] = false;
    values[Anum_pg_statistic_staattnum - 1] = Int16GetDatum(attnum);
    nulls[Anum_pg_statistic_staattnum - 1] = false;
    values[Anum_pg_statistic_stainherit - 1] = BoolGetDatum(inherited);
    nulls[Anum_pg_statistic_stainherit - 1] = false;
 
    values[Anum_pg_statistic_stanullfrac - 1] = DEFAULT_STATATT_NULL_FRAC;
    nulls[Anum_pg_statistic_stanullfrac - 1] = false;
    values[Anum_pg_statistic_stawidth - 1] = DEFAULT_STATATT_AVG_WIDTH;
    nulls[Anum_pg_statistic_stawidth - 1] = false;
    values[Anum_pg_statistic_stadistinct - 1] = DEFAULT_STATATT_N_DISTINCT;
    nulls[Anum_pg_statistic_stadistinct - 1] = false;
 
    /* initialize stakind, staop, and stacoll slots */
    for (int slotnum = 0; slotnum < STATISTIC_NUM_SLOTS; slotnum++)
    {
        values[Anum_pg_statistic_stakind1 + slotnum - 1] = (Datum) 0;
        nulls[Anum_pg_statistic_stakind1 + slotnum - 1] = false;
        values[Anum_pg_statistic_staop1 + slotnum - 1] = ObjectIdGetDatum(InvalidOid);
        nulls[Anum_pg_statistic_staop1 + slotnum - 1] = false;
        values[Anum_pg_statistic_stacoll1 + slotnum - 1] = ObjectIdGetDatum(InvalidOid);
        nulls[Anum_pg_statistic_stacoll1 + slotnum - 1] = false;

References attnum, BoolGetDatum(), DEFAULT_STATATT_AVG_WIDTH, DEFAULT_STATATT_N_DISTINCT, DEFAULT_STATATT_NULL_FRAC, Int16GetDatum(), InvalidOid, ObjectIdGetDatum(), STATISTIC_NUM_SLOTS, and values.

Referenced by attribute_statistics_update().

statatt_set_slot()

void statatt_set_slot	(	Datum *	values,
		bool *	nulls,
		bool *	replaces,
		int16	stakind,
		Oid	staop,
		Oid	stacoll,
		Datum	stanumbers,
		bool	stanumbers_isnull,
		Datum	stavalues,
		bool	stavalues_isnull
	)

Definition at line 634 of file stat_utils.c.

{
    int         slotidx;
    int         first_empty = -1;
    AttrNumber  stakind_attnum;
    AttrNumber  staop_attnum;
    AttrNumber  stacoll_attnum;
 
    /* find existing slot with given stakind */
    for (slotidx = 0; slotidx < STATISTIC_NUM_SLOTS; slotidx++)
    {
        stakind_attnum = Anum_pg_statistic_stakind1 - 1 + slotidx;
 
        if (first_empty < 0 &&
            DatumGetInt16(values[stakind_attnum]) == 0)
            first_empty = slotidx;
        if (DatumGetInt16(values[stakind_attnum]) == stakind)
            break;
    }
 
    if (slotidx >= STATISTIC_NUM_SLOTS && first_empty >= 0)
        slotidx = first_empty;
 
    if (slotidx >= STATISTIC_NUM_SLOTS)
        ereport(ERROR,
                (errmsg("maximum number of statistics slots exceeded: %d",
                        slotidx + 1)));
 
    stakind_attnum = Anum_pg_statistic_stakind1 - 1 + slotidx;
    staop_attnum = Anum_pg_statistic_staop1 - 1 + slotidx;
    stacoll_attnum = Anum_pg_statistic_stacoll1 - 1 + slotidx;
 
    if (DatumGetInt16(values[stakind_attnum]) != stakind)
    {
        values[stakind_attnum] = Int16GetDatum(stakind);
        replaces[stakind_attnum] = true;
    }
    if (DatumGetObjectId(values[staop_attnum]) != staop)
    {
        values[staop_attnum] = ObjectIdGetDatum(staop);
        replaces[staop_attnum] = true;
    }
    if (DatumGetObjectId(values[stacoll_attnum]) != stacoll)
    {
        values[stacoll_attnum] = ObjectIdGetDatum(stacoll);
        replaces[stacoll_attnum] = true;
    }
    if (!stanumbers_isnull)
    {
        values[Anum_pg_statistic_stanumbers1 - 1 + slotidx] = stanumbers;
        nulls[Anum_pg_statistic_stanumbers1 - 1 + slotidx] = false;
        replaces[Anum_pg_statistic_stanumbers1 - 1 + slotidx] = true;
    }
    if (!stavalues_isnull)
    {
        values[Anum_pg_statistic_stavalues1 - 1 + slotidx] = stavalues;
        nulls[Anum_pg_statistic_stavalues1 - 1 + slotidx] = false;
        replaces[Anum_pg_statistic_stavalues1 - 1 + slotidx] = true;

References DatumGetInt16(), DatumGetObjectId(), ereport, errmsg(), ERROR, Int16GetDatum(), ObjectIdGetDatum(), STATISTIC_NUM_SLOTS, and values.

Referenced by attribute_statistics_update().

stats_check_arg_array()

bool stats_check_arg_array	(	FunctionCallInfo	fcinfo,
		struct StatsArgInfo *	arginfo,
		int	argnum
	)

Definition at line 69 of file stat_utils.c.

{
    ArrayType  *arr;
 
    if (PG_ARGISNULL(argnum))
        return true;
 
    arr = DatumGetArrayTypeP(PG_GETARG_DATUM(argnum));
 
    if (ARR_NDIM(arr) != 1)
    {
        ereport(WARNING,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("argument \"%s\" must not be a multidimensional array",
                        arginfo[argnum].argname)));
        return false;
    }
 
    if (array_contains_nulls(arr))
    {
        ereport(WARNING,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("argument \"%s\" array must not contain null values",
                        arginfo[argnum].argname)));
        return false;
    }
 

References ARR_NDIM, array_contains_nulls(), DatumGetArrayTypeP, ereport, errcode(), errmsg(), PG_ARGISNULL, PG_GETARG_DATUM, and WARNING.

Referenced by attribute_statistics_update().

stats_check_arg_pair()

bool stats_check_arg_pair	(	FunctionCallInfo	fcinfo,
		struct StatsArgInfo *	arginfo,
		int	argnum1,
		int	argnum2
	)

Definition at line 110 of file stat_utils.c.

{
    if (PG_ARGISNULL(argnum1) && PG_ARGISNULL(argnum2))
        return true;
 
    if (PG_ARGISNULL(argnum1) || PG_ARGISNULL(argnum2))
    {
        int         nullarg = PG_ARGISNULL(argnum1) ? argnum1 : argnum2;
        int         otherarg = PG_ARGISNULL(argnum1) ? argnum2 : argnum1;
 
        ereport(WARNING,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("argument \"%s\" must be specified when argument \"%s\" is specified",
                        arginfo[nullarg].argname,
                        arginfo[otherarg].argname)));
 
        return false;
    }
 

References ereport, errcode(), errmsg(), PG_ARGISNULL, and WARNING.

Referenced by attribute_statistics_update().

stats_check_arg_type()

static bool stats_check_arg_type ( const char *  argname, Oid  argtype, Oid  expectedtype  )

static

Definition at line 279 of file stat_utils.c.

{
    if (argtype != expectedtype)
    {
        ereport(WARNING,
                (errmsg("argument \"%s\" has type %s, expected type %s",
                        argname, format_type_be(argtype),
                        format_type_be(expectedtype))));
        return false;
    }
 

References ereport, errmsg(), format_type_be(), and WARNING.

Referenced by stats_fill_fcinfo_from_arg_pairs().

stats_check_required_arg()

void stats_check_required_arg	(	FunctionCallInfo	fcinfo,
		struct StatsArgInfo *	arginfo,
		int	argnum
	)

Definition at line 50 of file stat_utils.c.

{
    if (PG_ARGISNULL(argnum))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("argument \"%s\" must not be null",

References ereport, errcode(), errmsg(), ERROR, and PG_ARGISNULL.

Referenced by attribute_statistics_update(), pg_clear_attribute_stats(), and relation_statistics_update().

stats_fill_fcinfo_from_arg_pairs()

bool stats_fill_fcinfo_from_arg_pairs	(	FunctionCallInfo	pairs_fcinfo,
		FunctionCallInfo	positional_fcinfo,
		struct StatsArgInfo *	arginfo
	)

Definition at line 347 of file stat_utils.c.

{
    Datum      *args;
    bool       *argnulls;
    Oid        *types;
    int         nargs;
    bool        result = true;
 
    /* clear positional args */
    for (int i = 0; arginfo[i].argname != NULL; i++)
    {
        positional_fcinfo->args[i].value = (Datum) 0;
        positional_fcinfo->args[i].isnull = true;
    }
 
    nargs = extract_variadic_args(pairs_fcinfo, 0, true,
                                  &args, &types, &argnulls);
 
    if (nargs % 2 != 0)
        ereport(ERROR,
                errmsg("variadic arguments must be name/value pairs"),
                errhint("Provide an even number of variadic arguments that can be divided into pairs."));
 
    /*
     * For each argument name/value pair, find corresponding positional
     * argument for the argument name, and assign the argument value to
     * positional_fcinfo.
     */
    for (int i = 0; i < nargs; i += 2)
    {
        int         argnum;
        char       *argname;
 
        if (argnulls[i])
            ereport(ERROR,
                    (errmsg("name at variadic position %d is null", i + 1)));
 
        if (types[i] != TEXTOID)
            ereport(ERROR,
                    (errmsg("name at variadic position %d has type %s, expected type %s",
                            i + 1, format_type_be(types[i]),
                            format_type_be(TEXTOID))));
 
        if (argnulls[i + 1])
            continue;
 
        argname = TextDatumGetCString(args[i]);
 
        /*
         * The 'version' argument is a special case, not handled by arginfo
         * because it's not a valid positional argument.
         *
         * For now, 'version' is accepted but ignored. In the future it can be
         * used to interpret older statistics properly.
         */
        if (pg_strcasecmp(argname, "version") == 0)
            continue;
 
        argnum = get_arg_by_name(argname, arginfo);
 
        if (argnum < 0 || !stats_check_arg_type(argname, types[i + 1],
                                                arginfo[argnum].argtype))
        {
            result = false;
            continue;
        }
 
        positional_fcinfo->args[argnum].value = args[i + 1];
        positional_fcinfo->args[argnum].isnull = false;
    }
 

References StatsArgInfo::argname, generate_unaccent_rules::args, FunctionCallInfoBaseData::args, ereport, errhint(), errmsg(), ERROR, extract_variadic_args(), format_type_be(), get_arg_by_name(), i, NullableDatum::isnull, pg_strcasecmp(), stats_check_arg_type(), TextDatumGetCString, types, and NullableDatum::value.

Referenced by pg_restore_attribute_stats(), and pg_restore_relation_stats().