/*------------------------------------------------------------------------- * stat_utils.c * * PostgreSQL statistics manipulation utilities. * * Code supporting the direct manipulation of statistics. * * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group * Portions Copyright (c) 1994, Regents of the University of California * * IDENTIFICATION * src/backend/statistics/stat_utils.c * * Ported from PostgreSQL REL_18_STABLE at commit * 780900dcfab (2026-11-09). * Source: src/backend/statistics/stat_utils.c * * Local modifications are listed in README.md in this directory. * *------------------------------------------------------------------------- */ #include "postgres.h" #if PG_VERSION_NUM >= 160000 && PG_VERSION_NUM < 190000 #include "access/htup_details.h" #include "access/relation.h" #include "catalog/index.h" #include "catalog/namespace.h" #include "catalog/objectaddress.h" #include "catalog/pg_class.h" #include "catalog/pg_collation.h" #include "catalog/pg_database.h" #include "catalog/pg_statistic.h" #include "catalog/pg_type.h" #include "funcapi.h" #include "miscadmin.h" #include "nodes/miscnodes.h" #include "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 "utils/typcache.h" /* Default values assigned to new pg_statistic tuples. */ #define DEFAULT_STATATT_NULL_FRAC Float4GetDatum(0.0) /* stanullfrac */ #define DEFAULT_STATATT_AVG_WIDTH Int32GetDatum(0) /* stawidth, same as * unknown */ #define DEFAULT_STATATT_N_DISTINCT Float4GetDatum(0.0) /* stadistinct, same as * unknown */ /* * Ensure that a given argument is not null. */ void regresql_stats_check_required_arg(FunctionCallInfo fcinfo, struct StatsArgInfo *arginfo, int argnum) { if (PG_ARGISNULL(argnum)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("argument \"%s\" must not be null", arginfo[argnum].argname))); } /* * Check that argument is either NULL or a one dimensional array with no * NULLs. * * If a problem is found, emit a WARNING, and return false. Otherwise return * true. */ bool regresql_stats_check_arg_array(FunctionCallInfo fcinfo, struct StatsArgInfo *arginfo, int argnum) { 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; } return true; } /* * Enforce parameter pairs that must be specified together (or not at all) for * a particular stakind, such as most_common_vals and most_common_freqs for * STATISTIC_KIND_MCV. * * If a problem is found, emit a WARNING, and return false. Otherwise return * true. */ bool regresql_stats_check_arg_pair(FunctionCallInfo fcinfo, struct StatsArgInfo *arginfo, int argnum1, int argnum2) { 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; } return true; } /* * A role has privileges to set statistics on the relation if any of the * following are true: * - the role owns the current database and the relation is not shared * - the role has the MAINTAIN privilege on the relation */ void regresql_RangeVarCallbackForStats(const RangeVar *relation, Oid relId, Oid oldRelId, void *arg) { 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())) { #if PG_VERSION_NUM >= 170000 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)); #else if (!object_ownercheck(RelationRelationId, table_oid, GetUserId())) aclcheck_error(ACLCHECK_NOT_OWNER, get_relkind_objtype(form->relkind), NameStr(form->relname)); #endif } ReleaseSysCache(tuple); /* Lock heap before index to avoid deadlock. */ if (relId != oldRelId && table_oid != relId) { LockRelationOid(table_oid, ShareUpdateExclusiveLock); *locked_oid = table_oid; } } /* * Find the argument number for the given argument name, returning -1 if not * found. */ static int get_arg_by_name(const char *argname, struct StatsArgInfo *arginfo) { 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))); return -1; } /* * Ensure that a given argument matched the expected type. * * Local addition: n_distinct and dependencies may also be given as text, * stats_text_to_bytea() converts those before the type check is reached. */ static bool stats_check_arg_type(const char *argname, Oid argtype, Oid expectedtype) { 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; } return true; } /* * Local addition. Parse a text value for a pg_ndistinct or pg_dependencies * argument with the PG19 input routines. An error is thrown as a WARNING, * the same way the other conversion failures of the restore functions are. */ static bool stats_text_to_bytea(const char *argname, Datum value, Oid argtype, Datum *result) { ErrorSaveContext escontext = {T_ErrorSaveContext}; char *s = TextDatumGetCString(value); bool ok; escontext.details_wanted = true; ok = DirectInputFunctionCallSafe(argtype == PG_NDISTINCTOID ? regresql_pg_ndistinct_in : regresql_pg_dependencies_in, s, InvalidOid, -1, (Node *) &escontext, result); if (!ok) { escontext.error_data->elevel = WARNING; ThrowErrorData(escontext.error_data); } pfree(s); return ok; } /* * Translate variadic argument pairs from 'pairs_fcinfo' into a * 'positional_fcinfo' appropriate for calling relation_statistics_update() or * attribute_statistics_update() with positional arguments. * * Caller should have already initialized positional_fcinfo with a size * appropriate for calling the intended positional function, and arginfo * should also match the intended positional function. */ bool regresql_stats_fill_fcinfo_from_arg_pairs(FunctionCallInfo pairs_fcinfo, FunctionCallInfo positional_fcinfo, struct StatsArgInfo *arginfo) { 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 && types[i + 1] == TEXTOID && (arginfo[argnum].argtype == PG_NDISTINCTOID || arginfo[argnum].argtype == PG_DEPENDENCIESOID)) { if (!stats_text_to_bytea(argname, args[i + 1], arginfo[argnum].argtype, &args[i + 1])) { result = false; continue; } types[i + 1] = arginfo[argnum].argtype; } 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; } return result; } /* * Derive element type information from the base type of an attribute. This * information is needed when the given type is one that contains elements of * other types. * * The type cache entry should be derived from a previous call to * the attribute type lookup. */ bool regresql_statatt_get_elem_type(TypeCacheEntry *basetypcache, Oid *elemtypid, Oid *elem_eq_opr) { TypeCacheEntry *elemtypcache; if (basetypcache->type_id == TSVECTOROID) { /* * Special case: element type for tsvector is text. See * compute_tsvector_stats(). */ *elemtypid = TEXTOID; } else { /* find the underlying element type */ *elemtypid = get_element_type(basetypcache->type_id); } 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; return true; } /* * Derive the range type to use from the attribute type, returning false if * the attribute cannot have range statistics at all. * * For a multirange type, we step down to its range type, because * compute_range_stats() stores range bounds even when analyzing a multirange * column (see also range_typanalyze() and multirange_typanalyze()). * * The type cache entry should be derived from a previous call to * the attribute type lookup, so that any domain has already been looked through. */ bool regresql_statatt_get_range_type(TypeCacheEntry *basetypcache, Oid *rangetypid) { if (basetypcache->typtype == TYPTYPE_MULTIRANGE) *rangetypid = get_multirange_range(basetypcache->type_id); else if (basetypcache->typtype == TYPTYPE_RANGE) *rangetypid = basetypcache->type_id; else { *rangetypid = InvalidOid; return false; } return true; } /* * Find and update the slot of a stakind, or use the first empty slot. * * Core statistics types expect the stakind value to be one of the * STATISTIC_KIND_* constants defined in pg_statistic.h, but types defined * by extensions are not restricted to those values. * * In the case of core statistics, the required staop is determined by the * stakind given and will either be a hardcoded oid, or the eq/lt operator * derived from the attribute type lookup. Likewise, types defined by extensions * have no such restriction. * * The stacoll value should be either the atttypcoll derived from * the attribute type lookup, or a hardcoded value required by that particular * stakind. * * The value/null pairs for stanumbers and stavalues should be calculated * based on the stakind, using the array input routines or constructed arrays. */ void regresql_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) { 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, (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED), 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; } } /* * Initialize values and nulls for a new pg_statistic tuple. * * The caller is responsible for allocating the arrays where the results are * stored, which should be of size Natts_pg_statistic. * * When using this routine for a tuple inserted into pg_statistic, reloid, * attnum and inherited flags should all be set. * * When using this routine for a tuple that is an element of a stxdexpr * array inserted into pg_statistic_ext_data, reloid, attnum and inherited * should be respectively set to InvalidOid, InvalidAttrNumber and false. */ void regresql_statatt_init_empty_tuple(Oid reloid, int16 attnum, bool inherited, Datum *values, bool *nulls, bool *replaces) { 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; } } #endif /* PG_VERSION_NUM >= 160000 && PG_VERSION_NUM < 190000 */