Branch data Line data Source code
1 : : /*-------------------------------------------------------------------------
2 : : * stat_utils.c
3 : : *
4 : : * PostgreSQL statistics manipulation utilities.
5 : : *
6 : : * Code supporting the direct manipulation of statistics.
7 : : *
8 : : * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
9 : : * Portions Copyright (c) 1994, Regents of the University of California
10 : : *
11 : : * IDENTIFICATION
12 : : * src/backend/statistics/stat_utils.c
13 : : *
14 : : *-------------------------------------------------------------------------
15 : : */
16 : :
17 : : #include "postgres.h"
18 : :
19 : : #include "access/htup_details.h"
20 : : #include "access/relation.h"
21 : : #include "catalog/index.h"
22 : : #include "catalog/namespace.h"
23 : : #include "catalog/pg_class.h"
24 : : #include "catalog/pg_collation.h"
25 : : #include "catalog/pg_database.h"
26 : : #include "catalog/pg_statistic.h"
27 : : #include "funcapi.h"
28 : : #include "miscadmin.h"
29 : : #include "nodes/nodeFuncs.h"
30 : : #include "statistics/stat_utils.h"
31 : : #include "storage/lmgr.h"
32 : : #include "utils/acl.h"
33 : : #include "utils/array.h"
34 : : #include "utils/builtins.h"
35 : : #include "utils/lsyscache.h"
36 : : #include "utils/rangetypes.h"
37 : : #include "utils/rel.h"
38 : : #include "utils/syscache.h"
39 : : #include "utils/typcache.h"
40 : :
41 : : /* Default values assigned to new pg_statistic tuples. */
42 : : #define DEFAULT_STATATT_NULL_FRAC Float4GetDatum(0.0) /* stanullfrac */
43 : : #define DEFAULT_STATATT_AVG_WIDTH Int32GetDatum(0) /* stawidth, same as
44 : : * unknown */
45 : : #define DEFAULT_STATATT_N_DISTINCT Float4GetDatum(0.0) /* stadistinct, same as
46 : : * unknown */
47 : :
48 : : static Node *statatt_get_index_expr(Relation rel, int attnum);
49 : :
50 : : /*
51 : : * Ensure that a given argument is not null.
52 : : */
53 : : void
54 : 7535 : stats_check_required_arg(FunctionCallInfo fcinfo,
55 : : struct StatsArgInfo *arginfo,
56 : : int argnum)
57 : : {
58 [ + + ]: 7535 : if (PG_ARGISNULL(argnum))
59 [ + - ]: 88 : ereport(ERROR,
60 : : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
61 : : errmsg("argument \"%s\" must not be null",
62 : : arginfo[argnum].argname)));
63 : 7447 : }
64 : :
65 : : /*
66 : : * Check that argument is either NULL or a one dimensional array with no
67 : : * NULLs.
68 : : *
69 : : * If a problem is found, emit a WARNING, and return false. Otherwise return
70 : : * true.
71 : : */
72 : : bool
73 : 2838 : stats_check_arg_array(FunctionCallInfo fcinfo,
74 : : struct StatsArgInfo *arginfo,
75 : : int argnum)
76 : : {
77 : : ArrayType *arr;
78 : :
79 [ + + ]: 2838 : if (PG_ARGISNULL(argnum))
80 : 2319 : return true;
81 : :
82 : 519 : arr = DatumGetArrayTypeP(PG_GETARG_DATUM(argnum));
83 : :
84 [ + + ]: 519 : if (ARR_NDIM(arr) != 1)
85 : : {
86 [ + - ]: 4 : ereport(WARNING,
87 : : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
88 : : errmsg("argument \"%s\" must be a non-empty one-dimensional array",
89 : : arginfo[argnum].argname)));
90 : 4 : return false;
91 : : }
92 : :
93 [ + + ]: 515 : if (array_contains_nulls(arr))
94 : : {
95 [ + - ]: 4 : ereport(WARNING,
96 : : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
97 : : errmsg("argument \"%s\" array must not contain null values",
98 : : arginfo[argnum].argname)));
99 : 4 : return false;
100 : : }
101 : :
102 : 511 : return true;
103 : : }
104 : :
105 : : /*
106 : : * Enforce parameter pairs that must be specified together (or not at all) for
107 : : * a particular stakind, such as most_common_vals and most_common_freqs for
108 : : * STATISTIC_KIND_MCV.
109 : : *
110 : : * If a problem is found, emit a WARNING, and return false. Otherwise return
111 : : * true.
112 : : */
113 : : bool
114 : 2838 : stats_check_arg_pair(FunctionCallInfo fcinfo,
115 : : struct StatsArgInfo *arginfo,
116 : : int argnum1, int argnum2)
117 : : {
118 [ + + + + ]: 2838 : if (PG_ARGISNULL(argnum1) && PG_ARGISNULL(argnum2))
119 : 2278 : return true;
120 : :
121 [ + + + + ]: 560 : if (PG_ARGISNULL(argnum1) || PG_ARGISNULL(argnum2))
122 : : {
123 [ + + ]: 28 : int nullarg = PG_ARGISNULL(argnum1) ? argnum1 : argnum2;
124 [ + + ]: 28 : int otherarg = PG_ARGISNULL(argnum1) ? argnum2 : argnum1;
125 : :
126 [ + - ]: 28 : ereport(WARNING,
127 : : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
128 : : errmsg("argument \"%s\" must be specified when argument \"%s\" is specified",
129 : : arginfo[nullarg].argname,
130 : : arginfo[otherarg].argname)));
131 : :
132 : 28 : return false;
133 : : }
134 : :
135 : 532 : return true;
136 : : }
137 : :
138 : : /*
139 : : * A role has privileges to set statistics on the relation if any of the
140 : : * following are true:
141 : : * - the role owns the current database and the relation is not shared
142 : : * - the role has the MAINTAIN privilege on the relation
143 : : */
144 : : void
145 : 2573 : RangeVarCallbackForStats(const RangeVar *relation,
146 : : Oid relId, Oid oldRelId, void *arg)
147 : : {
148 : 2573 : Oid *locked_oid = (Oid *) arg;
149 : 2573 : Oid table_oid = relId;
150 : : HeapTuple tuple;
151 : : Form_pg_class form;
152 : : char relkind;
153 : :
154 : : /*
155 : : * If we previously locked some other index's heap, and the name we're
156 : : * looking up no longer refers to that relation, release the now-useless
157 : : * lock.
158 : : */
159 [ + + - + ]: 2573 : if (relId != oldRelId && OidIsValid(*locked_oid))
160 : : {
161 : 0 : UnlockRelationOid(*locked_oid, ShareUpdateExclusiveLock);
162 : 0 : *locked_oid = InvalidOid;
163 : : }
164 : :
165 : : /* If the relation does not exist, there's nothing more to do. */
166 [ + + ]: 2573 : if (!OidIsValid(relId))
167 : 20 : return;
168 : :
169 : : /* If the relation does exist, check whether it's an index. */
170 : 2553 : relkind = get_rel_relkind(relId);
171 [ + + + + ]: 2553 : if (relkind == RELKIND_INDEX ||
172 : : relkind == RELKIND_PARTITIONED_INDEX)
173 : 323 : table_oid = IndexGetRelation(relId, false);
174 : :
175 : : /*
176 : : * If retrying yields the same OID, there are a couple of extremely
177 : : * unlikely scenarios we need to handle.
178 : : */
179 [ + + ]: 2553 : if (relId == oldRelId)
180 : : {
181 : : /*
182 : : * If a previous lookup found an index, but the current lookup did
183 : : * not, the index was dropped and the OID was reused for something
184 : : * else between lookups. In theory, we could simply drop our lock on
185 : : * the index's parent table and proceed, but in the interest of
186 : : * avoiding complexity, we just error.
187 : : */
188 [ + + - + ]: 4 : if (table_oid == relId && OidIsValid(*locked_oid))
189 [ # # ]: 0 : ereport(ERROR,
190 : : (errcode(ERRCODE_UNDEFINED_OBJECT),
191 : : errmsg("index \"%s\" was concurrently dropped",
192 : : relation->relname)));
193 : :
194 : : /*
195 : : * If the current lookup found an index but a previous lookup either
196 : : * did not find an index or found one with a different parent
197 : : * relation, the relation was dropped and the OID was reused for an
198 : : * index between lookups. RangeVarGetRelidExtended() will have
199 : : * already locked the index at this point, so we can't just lock the
200 : : * newly discovered parent table OID without risking deadlock. As
201 : : * above, we just error in this case.
202 : : */
203 [ + + - + ]: 4 : if (table_oid != relId && table_oid != *locked_oid)
204 [ # # ]: 0 : ereport(ERROR,
205 : : (errcode(ERRCODE_UNDEFINED_OBJECT),
206 : : errmsg("index \"%s\" was concurrently created",
207 : : relation->relname)));
208 : : }
209 : :
210 : 2553 : tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(table_oid));
211 [ - + ]: 2553 : if (!HeapTupleIsValid(tuple))
212 [ # # ]: 0 : elog(ERROR, "cache lookup failed for OID %u", table_oid);
213 : 2553 : form = (Form_pg_class) GETSTRUCT(tuple);
214 : :
215 : : /* the relkinds that can be used with ANALYZE */
216 [ + + ]: 2553 : switch (form->relkind)
217 : : {
218 : 2533 : case RELKIND_RELATION:
219 : : case RELKIND_MATVIEW:
220 : : case RELKIND_FOREIGN_TABLE:
221 : : case RELKIND_PARTITIONED_TABLE:
222 : 2533 : break;
223 : 20 : default:
224 [ + - ]: 20 : ereport(ERROR,
225 : : (errcode(ERRCODE_WRONG_OBJECT_TYPE),
226 : : errmsg("cannot modify statistics for relation \"%s\"",
227 : : NameStr(form->relname)),
228 : : errdetail_relkind_not_supported(form->relkind)));
229 : : }
230 : :
231 [ - + ]: 2533 : if (form->relisshared)
232 [ # # ]: 0 : ereport(ERROR,
233 : : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
234 : : errmsg("cannot modify statistics for shared relation")));
235 : :
236 : : /* Check permissions */
237 [ + + ]: 2533 : if (!object_ownercheck(DatabaseRelationId, MyDatabaseId, GetUserId()))
238 : : {
239 : 16 : AclResult aclresult = pg_class_aclcheck(table_oid,
240 : : GetUserId(),
241 : : ACL_MAINTAIN);
242 : :
243 [ + + ]: 16 : if (aclresult != ACLCHECK_OK)
244 : 8 : aclcheck_error(aclresult,
245 : 8 : get_relkind_objtype(form->relkind),
246 : 8 : NameStr(form->relname));
247 : : }
248 : :
249 : 2525 : ReleaseSysCache(tuple);
250 : :
251 : : /* Lock heap before index to avoid deadlock. */
252 [ + + + + ]: 2525 : if (relId != oldRelId && table_oid != relId)
253 : : {
254 : 322 : LockRelationOid(table_oid, ShareUpdateExclusiveLock);
255 : 322 : *locked_oid = table_oid;
256 : : }
257 : : }
258 : :
259 : :
260 : : /*
261 : : * Find the argument number for the given argument name, returning -1 if not
262 : : * found.
263 : : */
264 : : static int
265 : 17815 : get_arg_by_name(const char *argname, struct StatsArgInfo *arginfo)
266 : : {
267 : : int argnum;
268 : :
269 [ + + ]: 86996 : for (argnum = 0; arginfo[argnum].argname != NULL; argnum++)
270 [ + + ]: 86988 : if (pg_strcasecmp(argname, arginfo[argnum].argname) == 0)
271 : 17807 : return argnum;
272 : :
273 [ + - ]: 8 : ereport(WARNING,
274 : : (errmsg("unrecognized argument name: \"%s\"", argname)));
275 : :
276 : 8 : return -1;
277 : : }
278 : :
279 : : /*
280 : : * Ensure that a given argument matched the expected type.
281 : : */
282 : : static bool
283 : 17807 : stats_check_arg_type(const char *argname, Oid argtype, Oid expectedtype)
284 : : {
285 [ + + ]: 17807 : if (argtype != expectedtype)
286 : : {
287 [ + - ]: 16 : ereport(WARNING,
288 : : (errmsg("argument \"%s\" has type %s, expected type %s",
289 : : argname, format_type_be(argtype),
290 : : format_type_be(expectedtype))));
291 : 16 : return false;
292 : : }
293 : :
294 : 17791 : return true;
295 : : }
296 : :
297 : : /*
298 : : * Check if attribute of an index is an expression, then retrieve the
299 : : * expression if is it the case.
300 : : *
301 : : * If the attnum specified is known to be an expression, then we must
302 : : * walk the list attributes up to the specified attnum to get the right
303 : : * expression.
304 : : */
305 : : static Node *
306 : 946 : statatt_get_index_expr(Relation rel, int attnum)
307 : : {
308 : : List *index_exprs;
309 : : ListCell *indexpr_item;
310 : :
311 : : /* relation is not an index */
312 [ + + ]: 946 : if (rel->rd_rel->relkind != RELKIND_INDEX &&
313 [ + - ]: 936 : rel->rd_rel->relkind != RELKIND_PARTITIONED_INDEX)
314 : 936 : return NULL;
315 : :
316 : 10 : index_exprs = RelationGetIndexExpressions(rel);
317 : :
318 : : /* index has no expressions to give */
319 [ - + ]: 10 : if (index_exprs == NIL)
320 : 0 : return NULL;
321 : :
322 : : /*
323 : : * The index's attnum points directly to a relation attnum, hence it is
324 : : * not an expression attribute.
325 : : */
326 [ - + ]: 10 : if (rel->rd_index->indkey.values[attnum - 1] != 0)
327 : 0 : return NULL;
328 : :
329 : 10 : indexpr_item = list_head(rel->rd_indexprs);
330 : :
331 [ - + ]: 10 : for (int i = 0; i < attnum - 1; i++)
332 [ # # ]: 0 : if (rel->rd_index->indkey.values[i] == 0)
333 : 0 : indexpr_item = lnext(rel->rd_indexprs, indexpr_item);
334 : :
335 [ - + ]: 10 : if (indexpr_item == NULL) /* shouldn't happen */
336 [ # # ]: 0 : elog(ERROR, "too few entries in indexprs list");
337 : :
338 : 10 : return (Node *) lfirst(indexpr_item);
339 : : }
340 : :
341 : : /*
342 : : * Translate variadic argument pairs from 'pairs_fcinfo' into a
343 : : * 'positional_fcinfo' appropriate for calling relation_statistics_update() or
344 : : * attribute_statistics_update() with positional arguments.
345 : : *
346 : : * Caller should have already initialized positional_fcinfo with a size
347 : : * appropriate for calling the intended positional function, and arginfo
348 : : * should also match the intended positional function.
349 : : */
350 : : bool
351 : 2553 : stats_fill_fcinfo_from_arg_pairs(FunctionCallInfo pairs_fcinfo,
352 : : FunctionCallInfo positional_fcinfo,
353 : : struct StatsArgInfo *arginfo)
354 : : {
355 : : Datum *args;
356 : : bool *argnulls;
357 : : Oid *types;
358 : : int nargs;
359 : 2553 : bool result = true;
360 : :
361 : : /* clear positional args */
362 [ + + ]: 31435 : for (int i = 0; arginfo[i].argname != NULL; i++)
363 : : {
364 : 28882 : positional_fcinfo->args[i].value = (Datum) 0;
365 : 28882 : positional_fcinfo->args[i].isnull = true;
366 : : }
367 : :
368 : 2553 : nargs = extract_variadic_args(pairs_fcinfo, 0, true,
369 : : &args, &types, &argnulls);
370 : :
371 [ + + ]: 2553 : if (nargs % 2 != 0)
372 [ + - ]: 4 : ereport(ERROR,
373 : : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
374 : : errmsg("variadic arguments must be name/value pairs"),
375 : : errhint("Provide an even number of variadic arguments that can be divided into pairs.")));
376 : :
377 : : /*
378 : : * For each argument name/value pair, find corresponding positional
379 : : * argument for the argument name, and assign the argument value to
380 : : * positional_fcinfo.
381 : : */
382 [ + + ]: 22513 : for (int i = 0; i < nargs; i += 2)
383 : : {
384 : : int argnum;
385 : : char *argname;
386 : :
387 [ + + ]: 19968 : if (argnulls[i])
388 [ + - ]: 4 : ereport(ERROR,
389 : : (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
390 : : errmsg("name at variadic position %d is null", i + 1)));
391 : :
392 [ - + ]: 19964 : if (types[i] != TEXTOID)
393 [ # # ]: 0 : ereport(ERROR,
394 : : (errcode(ERRCODE_DATATYPE_MISMATCH),
395 : : errmsg("name at variadic position %d has type %s, expected type %s",
396 : : i + 1, format_type_be(types[i]),
397 : : format_type_be(TEXTOID))));
398 : :
399 [ + + ]: 19964 : if (argnulls[i + 1])
400 : 296 : continue;
401 : :
402 : 19668 : argname = TextDatumGetCString(args[i]);
403 : :
404 : : /*
405 : : * The 'version' argument is a special case, not handled by arginfo
406 : : * because it's not a valid positional argument.
407 : : *
408 : : * For now, 'version' is accepted but ignored. In the future it can be
409 : : * used to interpret older statistics properly.
410 : : */
411 [ + + ]: 19668 : if (pg_strcasecmp(argname, "version") == 0)
412 : 1853 : continue;
413 : :
414 : 17815 : argnum = get_arg_by_name(argname, arginfo);
415 : :
416 [ + + + + ]: 35622 : if (argnum < 0 || !stats_check_arg_type(argname, types[i + 1],
417 : 17807 : arginfo[argnum].argtype))
418 : : {
419 : 24 : result = false;
420 : 24 : continue;
421 : : }
422 : :
423 : 17791 : positional_fcinfo->args[argnum].value = args[i + 1];
424 : 17791 : positional_fcinfo->args[argnum].isnull = false;
425 : : }
426 : :
427 : 2545 : return result;
428 : : }
429 : :
430 : : /*
431 : : * Derive type information from a relation attribute.
432 : : *
433 : : * This is needed for setting most slot statistics for all data types.
434 : : *
435 : : * This duplicates the logic in examine_attribute() but it will not skip the
436 : : * attribute if the attstattarget is 0.
437 : : *
438 : : * *atttypid and *atttypmod describe the type as declared. *basetypcache is
439 : : * the cache entry of the base type behind any domain.
440 : : *
441 : : * This information, retrieved from pg_attribute and pg_type with some
442 : : * specific handling for index expressions, is a prerequisite to calling
443 : : * any of the other statatt_*() functions.
444 : : */
445 : : void
446 : 946 : statatt_get_type(Oid reloid, AttrNumber attnum,
447 : : Oid *atttypid, int32 *atttypmod,
448 : : TypeCacheEntry **basetypcache, Oid *atttypcoll,
449 : : Oid *eq_opr, Oid *lt_opr)
450 : : {
451 : 946 : Relation rel = relation_open(reloid, AccessShareLock);
452 : : Form_pg_attribute attr;
453 : : HeapTuple atup;
454 : : Node *expr;
455 : :
456 : 946 : atup = SearchSysCache2(ATTNUM, ObjectIdGetDatum(reloid),
457 : : Int16GetDatum(attnum));
458 : :
459 : : /* Attribute not found */
460 [ - + ]: 946 : if (!HeapTupleIsValid(atup))
461 [ # # ]: 0 : ereport(ERROR,
462 : : (errcode(ERRCODE_UNDEFINED_COLUMN),
463 : : errmsg("column %d of relation \"%s\" does not exist",
464 : : attnum, RelationGetRelationName(rel))));
465 : :
466 : 946 : attr = (Form_pg_attribute) GETSTRUCT(atup);
467 : :
468 [ - + ]: 946 : if (attr->attisdropped)
469 [ # # ]: 0 : ereport(ERROR,
470 : : (errcode(ERRCODE_UNDEFINED_COLUMN),
471 : : errmsg("column %d of relation \"%s\" does not exist",
472 : : attnum, RelationGetRelationName(rel))));
473 : :
474 : 946 : expr = statatt_get_index_expr(rel, attr->attnum);
475 : :
476 : : /*
477 : : * When analyzing an expression index, believe the expression tree's type
478 : : * not the column datatype --- the latter might be the opckeytype storage
479 : : * type of the opclass, which is not interesting for our purposes. This
480 : : * mimics the behavior of examine_attribute().
481 : : */
482 [ + + ]: 946 : if (expr == NULL)
483 : : {
484 : 936 : *atttypid = attr->atttypid;
485 : 936 : *atttypmod = attr->atttypmod;
486 : 936 : *atttypcoll = attr->attcollation;
487 : : }
488 : : else
489 : : {
490 : 10 : *atttypid = exprType(expr);
491 : 10 : *atttypmod = exprTypmod(expr);
492 : :
493 [ - + ]: 10 : if (OidIsValid(attr->attcollation))
494 : 0 : *atttypcoll = attr->attcollation;
495 : : else
496 : 10 : *atttypcoll = exprCollation(expr);
497 : : }
498 : 946 : ReleaseSysCache(atup);
499 : :
500 : : /* finds the right operators even if atttypid is a domain */
501 : 946 : *basetypcache = lookup_type_cache(*atttypid, TYPECACHE_LT_OPR |
502 : : TYPECACHE_EQ_OPR |
503 : : TYPECACHE_DOMAIN_BASE_INFO);
504 [ + + ]: 946 : if (OidIsValid((*basetypcache)->domainBaseType))
505 : 44 : *basetypcache = lookup_type_cache((*basetypcache)->domainBaseType,
506 : : TYPECACHE_LT_OPR |
507 : : TYPECACHE_EQ_OPR);
508 : :
509 : 946 : *eq_opr = (*basetypcache)->eq_opr;
510 : 946 : *lt_opr = (*basetypcache)->lt_opr;
511 : :
512 : : /*
513 : : * Special case: collation for tsvector is DEFAULT_COLLATION_OID. See
514 : : * compute_tsvector_stats().
515 : : */
516 [ + + ]: 946 : if ((*basetypcache)->type_id == TSVECTOROID)
517 : 9 : *atttypcoll = DEFAULT_COLLATION_OID;
518 : :
519 : 946 : relation_close(rel, NoLock);
520 : 946 : }
521 : :
522 : : /*
523 : : * Derive element type information from the base type of an attribute. This
524 : : * information is needed when the given type is one that contains elements of
525 : : * other types.
526 : : *
527 : : * The type cache entry should be derived from a previous call to
528 : : * statatt_get_type().
529 : : */
530 : : bool
531 : 88 : statatt_get_elem_type(TypeCacheEntry *basetypcache,
532 : : Oid *elemtypid, Oid *elem_eq_opr)
533 : : {
534 : : TypeCacheEntry *elemtypcache;
535 : :
536 [ + + ]: 88 : if (basetypcache->type_id == TSVECTOROID)
537 : : {
538 : : /*
539 : : * Special case: element type for tsvector is text. See
540 : : * compute_tsvector_stats().
541 : : */
542 : 17 : *elemtypid = TEXTOID;
543 : : }
544 : : else
545 : : {
546 : : /* find the underlying element type */
547 : 71 : *elemtypid = get_element_type(basetypcache->type_id);
548 : : }
549 : :
550 [ + + ]: 88 : if (!OidIsValid(*elemtypid))
551 : 20 : return false;
552 : :
553 : : /* finds the right operator even if elemtypid is a domain */
554 : 68 : elemtypcache = lookup_type_cache(*elemtypid, TYPECACHE_EQ_OPR);
555 [ - + ]: 68 : if (!OidIsValid(elemtypcache->eq_opr))
556 : 0 : return false;
557 : :
558 : 68 : *elem_eq_opr = elemtypcache->eq_opr;
559 : :
560 : 68 : return true;
561 : : }
562 : :
563 : : /*
564 : : * Derive the range type to use from the attribute type, returning false if
565 : : * the attribute cannot have range statistics at all.
566 : : *
567 : : * For a multirange type, we step down to its range type, because
568 : : * compute_range_stats() stores range bounds even when analyzing a multirange
569 : : * column (see also range_typanalyze() and multirange_typanalyze()).
570 : : *
571 : : * The type cache entry should be derived from a previous call to
572 : : * statatt_get_type(), so that any domain has already been looked through.
573 : : */
574 : : bool
575 : 116 : statatt_get_range_type(TypeCacheEntry *basetypcache, Oid *rangetypid)
576 : : {
577 [ + + ]: 116 : if (basetypcache->typtype == TYPTYPE_MULTIRANGE)
578 : 57 : *rangetypid = get_multirange_range(basetypcache->type_id);
579 [ + + ]: 59 : else if (basetypcache->typtype == TYPTYPE_RANGE)
580 : 43 : *rangetypid = basetypcache->type_id;
581 : : else
582 : : {
583 : 16 : *rangetypid = InvalidOid;
584 : 16 : return false;
585 : : }
586 : :
587 : 100 : return true;
588 : : }
589 : :
590 : : /*
591 : : * Build an array with element type typid from a text datum, used as
592 : : * value of an attribute in a tuple to-be-inserted into pg_statistic.
593 : : *
594 : : * The typid and typmod should be derived from a previous call to
595 : : * statatt_get_type().
596 : : *
597 : : * If an error is encountered, capture it and throw a WARNING, with "ok" set
598 : : * to false. If the resulting array contains NULLs, raise a WARNING and
599 : : * set "ok" to false. When the operation succeeds, set "ok" to true.
600 : : *
601 : : * The array must be one-dimensional. If "allow_empty" is true, an empty
602 : : * array is also accepted.
603 : : */
604 : : Datum
605 : 963 : statatt_build_stavalues(const char *staname, FmgrInfo *array_in, Datum d, Oid typid,
606 : : int32 typmod, bool allow_empty, bool *ok)
607 : : {
608 : : int ndim;
609 : :
610 : : char *s;
611 : : Datum result;
612 : 963 : ErrorSaveContext escontext = {T_ErrorSaveContext};
613 : :
614 : 963 : escontext.details_wanted = true;
615 : :
616 : 963 : s = TextDatumGetCString(d);
617 : :
618 [ + + ]: 963 : if (!InputFunctionCallSafe(array_in, s, typid, typmod,
619 : : (Node *) &escontext, &result))
620 : : {
621 : 12 : pfree(s);
622 : 12 : escontext.error_data->elevel = WARNING;
623 : 12 : ThrowErrorData(escontext.error_data);
624 : 12 : *ok = false;
625 : 12 : return (Datum) 0;
626 : : }
627 : :
628 : 947 : pfree(s);
629 : :
630 : 947 : ndim = ARR_NDIM(DatumGetArrayTypeP(result));
631 [ + + + + : 947 : if (ndim != 1 && !(allow_empty && ndim == 0))
+ + ]
632 : : {
633 [ + + ]: 12 : if (allow_empty)
634 [ + - ]: 4 : ereport(WARNING,
635 : : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
636 : : errmsg("\"%s\" must be an empty or one-dimensional array",
637 : : staname)));
638 : : else
639 [ + - ]: 8 : ereport(WARNING,
640 : : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
641 : : errmsg("\"%s\" must be a one-dimensional array", staname)));
642 : 12 : *ok = false;
643 : 12 : return (Datum) 0;
644 : : }
645 : :
646 [ + + ]: 935 : if (array_contains_nulls(DatumGetArrayTypeP(result)))
647 : : {
648 [ + - ]: 4 : ereport(WARNING,
649 : : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
650 : : errmsg("\"%s\" array must not contain null values", staname)));
651 : 4 : *ok = false;
652 : 4 : return (Datum) 0;
653 : : }
654 : :
655 : 931 : *ok = true;
656 : :
657 : 931 : return result;
658 : : }
659 : :
660 : : /*
661 : : * Find and update the slot of a stakind, or use the first empty slot.
662 : : *
663 : : * Core statistics types expect the stakind value to be one of the
664 : : * STATISTIC_KIND_* constants defined in pg_statistic.h, but types defined
665 : : * by extensions are not restricted to those values.
666 : : *
667 : : * In the case of core statistics, the required staop is determined by the
668 : : * stakind given and will either be a hardcoded oid, or the eq/lt operator
669 : : * derived from statatt_get_type(). Likewise, types defined by extensions
670 : : * have no such restriction.
671 : : *
672 : : * The stacoll value should be either the atttypcoll derived from
673 : : * statatt_get_type(), or a hardcoded value required by that particular
674 : : * stakind.
675 : : *
676 : : * The value/null pairs for stanumbers and stavalues should be calculated
677 : : * based on the stakind, using statatt_build_stavalues() or constructed arrays.
678 : : */
679 : : void
680 : 1836 : statatt_set_slot(Datum *values, bool *nulls, bool *replaces,
681 : : int16 stakind, Oid staop, Oid stacoll,
682 : : Datum stanumbers, bool stanumbers_isnull,
683 : : Datum stavalues, bool stavalues_isnull)
684 : : {
685 : : int slotidx;
686 : 1836 : int first_empty = -1;
687 : : AttrNumber stakind_attnum;
688 : : AttrNumber staop_attnum;
689 : : AttrNumber stacoll_attnum;
690 : :
691 : : /* find existing slot with given stakind */
692 [ + + ]: 10972 : for (slotidx = 0; slotidx < STATISTIC_NUM_SLOTS; slotidx++)
693 : : {
694 : 9148 : stakind_attnum = Anum_pg_statistic_stakind1 - 1 + slotidx;
695 : :
696 [ + + + + ]: 12108 : if (first_empty < 0 &&
697 : 2960 : DatumGetInt16(values[stakind_attnum]) == 0)
698 : 1824 : first_empty = slotidx;
699 [ + + ]: 9148 : if (DatumGetInt16(values[stakind_attnum]) == stakind)
700 : 12 : break;
701 : : }
702 : :
703 [ + + + - ]: 1836 : if (slotidx >= STATISTIC_NUM_SLOTS && first_empty >= 0)
704 : 1824 : slotidx = first_empty;
705 : :
706 [ - + ]: 1836 : if (slotidx >= STATISTIC_NUM_SLOTS)
707 [ # # ]: 0 : ereport(ERROR,
708 : : (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
709 : : errmsg("maximum number of statistics slots exceeded: %d",
710 : : slotidx + 1)));
711 : :
712 : 1836 : stakind_attnum = Anum_pg_statistic_stakind1 - 1 + slotidx;
713 : 1836 : staop_attnum = Anum_pg_statistic_staop1 - 1 + slotidx;
714 : 1836 : stacoll_attnum = Anum_pg_statistic_stacoll1 - 1 + slotidx;
715 : :
716 [ + + ]: 1836 : if (DatumGetInt16(values[stakind_attnum]) != stakind)
717 : : {
718 : 1824 : values[stakind_attnum] = Int16GetDatum(stakind);
719 : 1824 : replaces[stakind_attnum] = true;
720 : : }
721 [ + + ]: 1836 : if (DatumGetObjectId(values[staop_attnum]) != staop)
722 : : {
723 : 1768 : values[staop_attnum] = ObjectIdGetDatum(staop);
724 : 1768 : replaces[staop_attnum] = true;
725 : : }
726 [ + + ]: 1836 : if (DatumGetObjectId(values[stacoll_attnum]) != stacoll)
727 : : {
728 : 401 : values[stacoll_attnum] = ObjectIdGetDatum(stacoll);
729 : 401 : replaces[stacoll_attnum] = true;
730 : : }
731 [ + + ]: 1836 : if (!stanumbers_isnull)
732 : : {
733 : 1365 : values[Anum_pg_statistic_stanumbers1 - 1 + slotidx] = stanumbers;
734 : 1365 : nulls[Anum_pg_statistic_stanumbers1 - 1 + slotidx] = false;
735 : 1365 : replaces[Anum_pg_statistic_stanumbers1 - 1 + slotidx] = true;
736 : : }
737 [ + + ]: 1836 : if (!stavalues_isnull)
738 : : {
739 : 1066 : values[Anum_pg_statistic_stavalues1 - 1 + slotidx] = stavalues;
740 : 1066 : nulls[Anum_pg_statistic_stavalues1 - 1 + slotidx] = false;
741 : 1066 : replaces[Anum_pg_statistic_stavalues1 - 1 + slotidx] = true;
742 : : }
743 : 1836 : }
744 : :
745 : : /*
746 : : * Initialize values and nulls for a new pg_statistic tuple.
747 : : *
748 : : * The caller is responsible for allocating the arrays where the results are
749 : : * stored, which should be of size Natts_pg_statistic.
750 : : *
751 : : * When using this routine for a tuple inserted into pg_statistic, reloid,
752 : : * attnum and inherited flags should all be set.
753 : : *
754 : : * When using this routine for a tuple that is an element of a stxdexpr
755 : : * array inserted into pg_statistic_ext_data, reloid, attnum and inherited
756 : : * should be respectively set to InvalidOid, InvalidAttrNumber and false.
757 : : */
758 : : void
759 : 1045 : statatt_init_empty_tuple(Oid reloid, int16 attnum, bool inherited,
760 : : Datum *values, bool *nulls, bool *replaces)
761 : : {
762 : 1045 : memset(nulls, true, sizeof(bool) * Natts_pg_statistic);
763 : 1045 : memset(replaces, true, sizeof(bool) * Natts_pg_statistic);
764 : :
765 : : /* This must initialize non-NULL attributes */
766 : 1045 : values[Anum_pg_statistic_starelid - 1] = ObjectIdGetDatum(reloid);
767 : 1045 : nulls[Anum_pg_statistic_starelid - 1] = false;
768 : 1045 : values[Anum_pg_statistic_staattnum - 1] = Int16GetDatum(attnum);
769 : 1045 : nulls[Anum_pg_statistic_staattnum - 1] = false;
770 : 1045 : values[Anum_pg_statistic_stainherit - 1] = BoolGetDatum(inherited);
771 : 1045 : nulls[Anum_pg_statistic_stainherit - 1] = false;
772 : :
773 : 1045 : values[Anum_pg_statistic_stanullfrac - 1] = DEFAULT_STATATT_NULL_FRAC;
774 : 1045 : nulls[Anum_pg_statistic_stanullfrac - 1] = false;
775 : 1045 : values[Anum_pg_statistic_stawidth - 1] = DEFAULT_STATATT_AVG_WIDTH;
776 : 1045 : nulls[Anum_pg_statistic_stawidth - 1] = false;
777 : 1045 : values[Anum_pg_statistic_stadistinct - 1] = DEFAULT_STATATT_N_DISTINCT;
778 : 1045 : nulls[Anum_pg_statistic_stadistinct - 1] = false;
779 : :
780 : : /* initialize stakind, staop, and stacoll slots */
781 [ + + ]: 6270 : for (int slotnum = 0; slotnum < STATISTIC_NUM_SLOTS; slotnum++)
782 : : {
783 : 5225 : values[Anum_pg_statistic_stakind1 + slotnum - 1] = (Datum) 0;
784 : 5225 : nulls[Anum_pg_statistic_stakind1 + slotnum - 1] = false;
785 : 5225 : values[Anum_pg_statistic_staop1 + slotnum - 1] = ObjectIdGetDatum(InvalidOid);
786 : 5225 : nulls[Anum_pg_statistic_staop1 + slotnum - 1] = false;
787 : 5225 : values[Anum_pg_statistic_stacoll1 + slotnum - 1] = ObjectIdGetDatum(InvalidOid);
788 : 5225 : nulls[Anum_pg_statistic_stacoll1 + slotnum - 1] = false;
789 : : }
790 : 1045 : }
791 : :
792 : : /*
793 : : * Check that an imported bounds histogram (STATISTIC_KIND_BOUNDS_HISTOGRAM)
794 : : * is shaped the same way ANALYZE builds it in compute_range_stats().
795 : : *
796 : : * For both range-typed and multirange-typed columns the histogram is an array
797 : : * of ranges, so we take the range type from the array's element type.
798 : : */
799 : : bool
800 : 72 : statatt_check_bounds_histogram(Datum arrayval)
801 : : {
802 : 72 : ArrayType *arr = DatumGetArrayTypeP(arrayval);
803 : 72 : Oid rngtypid = ARR_ELEMTYPE(arr);
804 : : TypeCacheEntry *typcache;
805 : : int16 elmlen;
806 : : bool elmbyval;
807 : : char elmalign;
808 : : Datum *elems;
809 : : bool *nulls;
810 : : int nelems;
811 : 72 : RangeBound prev_lower = {0};
812 : 72 : RangeBound prev_upper = {0};
813 : :
814 : 72 : typcache = lookup_type_cache(rngtypid, TYPECACHE_RANGE_INFO);
815 : :
816 : : /*
817 : : * The element type should always be a range type here. This is
818 : : * defensive. If it isn't, the bounds histogram is never consulted by the
819 : : * range estimator, and there is nothing to verify.
820 : : */
821 [ - + ]: 72 : if (typcache->rngelemtype == NULL)
822 : 0 : return true;
823 : :
824 : 72 : get_typlenbyvalalign(rngtypid, &elmlen, &elmbyval, &elmalign);
825 : 72 : deconstruct_array(arr, rngtypid, elmlen, elmbyval, elmalign,
826 : : &elems, &nulls, &nelems);
827 : :
828 [ + + ]: 454 : for (int i = 0; i < nelems; i++)
829 : : {
830 : : RangeBound lower,
831 : : upper;
832 : : bool empty;
833 : :
834 : : /*
835 : : * NULL elements are already rejected by statatt_build_stavalues() and
836 : : * array_in_safe().
837 : : */
838 : 398 : range_deserialize(typcache, DatumGetRangeTypeP(elems[i]),
839 : : &lower, &upper, &empty);
840 : :
841 [ + + ]: 398 : if (empty)
842 : : {
843 [ + - ]: 8 : ereport(WARNING,
844 : : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
845 : : errmsg("\"%s\" must not contain empty ranges",
846 : : "range_bounds_histogram")));
847 : 16 : return false;
848 : : }
849 : :
850 [ + + + + ]: 716 : if (i > 0 &&
851 [ - + ]: 644 : (range_cmp_bounds(typcache, &lower, &prev_lower) < 0 ||
852 : 318 : range_cmp_bounds(typcache, &upper, &prev_upper) < 0))
853 : : {
854 [ + - ]: 8 : ereport(WARNING,
855 : : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
856 : : errmsg("\"%s\" must have its lower and upper bounds sorted in ascending order",
857 : : "range_bounds_histogram")));
858 : 8 : return false;
859 : : }
860 : :
861 : 382 : prev_lower = lower;
862 : 382 : prev_upper = upper;
863 : : }
864 : :
865 : 56 : return true;
866 : : }
|
