Debian Codegraph @

src/backend/statistics/extended_stats.c

raw
1 /*-------------------------------------------------------------------------
2 *
3 * extended_stats.c
4 * POSTGRES extended statistics
5 *
6 * Generic code supporting statistics objects created via CREATE STATISTICS.
7 *
8 *
9 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
10 * Portions Copyright (c) 1994, Regents of the University of California
11 *
12 * IDENTIFICATION
13 * src/backend/statistics/extended_stats.c
14 *
15 *-------------------------------------------------------------------------
16 */
17 #include "postgres.h"
18
19 #include "access/detoast.h"
20 #include "access/genam.h"
21 #include "access/htup_details.h"
22 #include "access/table.h"
23 #include "catalog/indexing.h"
24 #include "catalog/pg_statistic_ext.h"
25 #include "catalog/pg_statistic_ext_data.h"
26 #include "commands/defrem.h"
27 #include "commands/progress.h"
28 #include "executor/executor.h"
29 #include "miscadmin.h"
30 #include "nodes/nodeFuncs.h"
31 #include "optimizer/optimizer.h"
32 #include "parser/parsetree.h"
33 #include "pgstat.h"
34 #include "postmaster/autovacuum.h"
35 #include "statistics/extended_stats_internal.h"
36 #include "statistics/statistics.h"
37 #include "utils/acl.h"
38 #include "utils/array.h"
39 #include "utils/attoptcache.h"
40 #include "utils/builtins.h"
41 #include "utils/datum.h"
42 #include "utils/fmgroids.h"
43 #include "utils/lsyscache.h"
44 #include "utils/memutils.h"
45 #include "utils/rel.h"
46 #include "utils/selfuncs.h"
47 #include "utils/syscache.h"
48
49 /*
50 * To avoid consuming too much memory during analysis and/or too much space
51 * in the resulting pg_statistic rows, we ignore varlena datums that are wider
52 * than WIDTH_THRESHOLD (after detoasting!). This is legitimate for MCV
53 * and distinct-value calculations since a wide value is unlikely to be
54 * duplicated at all, much less be a most-common value. For the same reason,
55 * ignoring wide values will not affect our estimates of histogram bin
56 * boundaries very much.
57 */
58 #define WIDTH_THRESHOLD 1024
59
60 /*
61 * Used internally to refer to an individual statistics object, i.e.,
62 * a pg_statistic_ext entry.
63 */
64 typedef struct StatExtEntry
65 {
66 Oid statOid; /* OID of pg_statistic_ext entry */
67 char *schema; /* statistics object's schema */
68 char *name; /* statistics object's name */
69 Bitmapset *columns; /* attribute numbers covered by the object */
70 List *types; /* 'char' list of enabled statistics kinds */
71 int stattarget; /* statistics target (-1 for default) */
72 List *exprs; /* expressions */
73 } StatExtEntry;
74
75
76 static List *fetch_statentries_for_relation(Relation pg_statext, Oid relid);
77 static VacAttrStats **lookup_var_attr_stats(Bitmapset *attrs, List *exprs,
78 int nvacatts, VacAttrStats **vacatts);
79 static void statext_store(Oid statOid, bool inh,
80 MVNDistinct *ndistinct, MVDependencies *dependencies,
81 MCVList *mcv, Datum exprs, VacAttrStats **stats);
82 static int statext_compute_stattarget(int stattarget,
83 int nattrs, VacAttrStats **stats);
84
85 /* Information needed to analyze a single simple expression. */
86 typedef struct AnlExprData
87 {
88 Node *expr; /* expression to analyze */
89 VacAttrStats *vacattrstat; /* statistics attrs to analyze */
90 } AnlExprData;
91
92 static void compute_expr_stats(Relation onerel, AnlExprData *exprdata,
93 int nexprs, HeapTuple *rows, int numrows);
94 static Datum serialize_expr_stats(AnlExprData *exprdata, int nexprs);
95 static Datum expr_fetch_func(VacAttrStatsP stats, int rownum, bool *isNull);
96 static AnlExprData *build_expr_data(List *exprs, int stattarget);
97
98 static StatsBuildData *make_build_data(Relation rel, StatExtEntry *stat,
99 int numrows, HeapTuple *rows,
100 VacAttrStats **stats, int stattarget);
101
102
103 /*
104 * Compute requested extended stats, using the rows sampled for the plain
105 * (single-column) stats.
106 *
107 * This fetches a list of stats types from pg_statistic_ext, computes the
108 * requested stats, and serializes them back into the catalog.
109 */
110 void
111 BuildRelationExtStatistics(Relation onerel, bool inh, double totalrows,
112 int numrows, HeapTuple *rows,
113 int natts, VacAttrStats **vacattrstats)
114 {
115 Relation pg_stext;
116 ListCell *lc;
117 List *statslist;
118 MemoryContext cxt;
119 MemoryContext oldcxt;
120 int64 ext_cnt;
121
122 /* Do nothing if there are no columns to analyze. */
123 if (!natts)
124 return;
125
126 /* the list of stats has to be allocated outside the memory context */
127 pg_stext = table_open(StatisticExtRelationId, RowExclusiveLock);
128 statslist = fetch_statentries_for_relation(pg_stext, RelationGetRelid(onerel));
129
130 /* memory context for building each statistics object */
131 cxt = AllocSetContextCreate(CurrentMemoryContext,
132 "BuildRelationExtStatistics",
133 ALLOCSET_DEFAULT_SIZES);
134 oldcxt = MemoryContextSwitchTo(cxt);
135
136 /* report this phase */
137 if (statslist != NIL)
138 {
139 const int index[] = {
140 PROGRESS_ANALYZE_PHASE,
141 PROGRESS_ANALYZE_EXT_STATS_TOTAL
142 };
143 const int64 val[] = {
144 PROGRESS_ANALYZE_PHASE_COMPUTE_EXT_STATS,
145 list_length(statslist)
146 };
147
148 pgstat_progress_update_multi_param(2, index, val);
149 }
150
151 ext_cnt = 0;
152 foreach(lc, statslist)
153 {
154 StatExtEntry *stat = (StatExtEntry *) lfirst(lc);
155 MVNDistinct *ndistinct = NULL;
156 MVDependencies *dependencies = NULL;
157 MCVList *mcv = NULL;
158 Datum exprstats = (Datum) 0;
159 VacAttrStats **stats;
160 ListCell *lc2;
161 int stattarget;
162 StatsBuildData *data;
163
164 /*
165 * Check if we can build these stats based on the column analyzed. If
166 * not, report this fact (except in autovacuum) and move on.
167 */
168 stats = lookup_var_attr_stats(stat->columns, stat->exprs,
169 natts, vacattrstats);
170 if (!stats)
171 {
172 if (!AmAutoVacuumWorkerProcess())
173 ereport(WARNING,
174 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
175 errmsg("statistics object \"%s.%s\" could not be computed for relation \"%s.%s\"",
176 stat->schema, stat->name,
177 get_namespace_name(onerel->rd_rel->relnamespace),
178 RelationGetRelationName(onerel)),
179 errtable(onerel)));
180 continue;
181 }
182
183 /* compute statistics target for this statistics object */
184 stattarget = statext_compute_stattarget(stat->stattarget,
185 bms_num_members(stat->columns),
186 stats);
187
188 /*
189 * Don't rebuild statistics objects with statistics target set to 0
190 * (we just leave the existing values around, just like we do for
191 * regular per-column statistics).
192 */
193 if (stattarget == 0)
194 continue;
195
196 /* evaluate expressions (if the statistics object has any) */
197 data = make_build_data(onerel, stat, numrows, rows, stats, stattarget);
198
199 /* compute statistic of each requested type */
200 foreach(lc2, stat->types)
201 {
202 char t = (char) lfirst_int(lc2);
203
204 if (t == STATS_EXT_NDISTINCT)
205 ndistinct = statext_ndistinct_build(totalrows, data);
206 else if (t == STATS_EXT_DEPENDENCIES)
207 dependencies = statext_dependencies_build(data);
208 else if (t == STATS_EXT_MCV)
209 mcv = statext_mcv_build(data, totalrows, stattarget);
210 else if (t == STATS_EXT_EXPRESSIONS)
211 {
212 AnlExprData *exprdata;
213 int nexprs;
214
215 /* should not happen, thanks to checks when defining stats */
216 if (!stat->exprs)
217 elog(ERROR, "requested expression stats, but there are no expressions");
218
219 exprdata = build_expr_data(stat->exprs, stattarget);
220 nexprs = list_length(stat->exprs);
221
222 compute_expr_stats(onerel, exprdata, nexprs, rows, numrows);
223
224 exprstats = serialize_expr_stats(exprdata, nexprs);
225 }
226 }
227
228 /* store the statistics in the catalog */
229 statext_store(stat->statOid, inh,
230 ndistinct, dependencies, mcv, exprstats, stats);
231
232 /* for reporting progress */
233 pgstat_progress_update_param(PROGRESS_ANALYZE_EXT_STATS_COMPUTED,
234 ++ext_cnt);
235
236 /* free the data used for building this statistics object */
237 MemoryContextReset(cxt);
238 }
239
240 MemoryContextSwitchTo(oldcxt);
241 MemoryContextDelete(cxt);
242
243 list_free(statslist);
244
245 table_close(pg_stext, RowExclusiveLock);
246 }
247
248 /*
249 * ComputeExtStatisticsRows
250 * Compute number of rows required by extended statistics on a table.
251 *
252 * Computes number of rows we need to sample to build extended statistics on a
253 * table. This only looks at statistics we can actually build - for example
254 * when analyzing only some of the columns, this will skip statistics objects
255 * that would require additional columns.
256 *
257 * See statext_compute_stattarget for details about how we compute the
258 * statistics target for a statistics object (from the object target,
259 * attribute targets and default statistics target).
260 */
261 int
262 ComputeExtStatisticsRows(Relation onerel,
263 int natts, VacAttrStats **vacattrstats)
264 {
265 Relation pg_stext;
266 ListCell *lc;
267 List *lstats;
268 MemoryContext cxt;
269 MemoryContext oldcxt;
270 int result = 0;
271
272 /* If there are no columns to analyze, just return 0. */
273 if (!natts)
274 return 0;
275
276 cxt = AllocSetContextCreate(CurrentMemoryContext,
277 "ComputeExtStatisticsRows",
278 ALLOCSET_DEFAULT_SIZES);
279 oldcxt = MemoryContextSwitchTo(cxt);
280
281 pg_stext = table_open(StatisticExtRelationId, RowExclusiveLock);
282 lstats = fetch_statentries_for_relation(pg_stext, RelationGetRelid(onerel));
283
284 foreach(lc, lstats)
285 {
286 StatExtEntry *stat = (StatExtEntry *) lfirst(lc);
287 int stattarget;
288 VacAttrStats **stats;
289 int nattrs = bms_num_members(stat->columns);
290
291 /*
292 * Check if we can build this statistics object based on the columns
293 * analyzed. If not, ignore it (don't report anything, we'll do that
294 * during the actual build BuildRelationExtStatistics).
295 */
296 stats = lookup_var_attr_stats(stat->columns, stat->exprs,
297 natts, vacattrstats);
298
299 if (!stats)
300 continue;
301
302 /*
303 * Compute statistics target, based on what's set for the statistic
304 * object itself, and for its attributes.
305 */
306 stattarget = statext_compute_stattarget(stat->stattarget,
307 nattrs, stats);
308
309 /* Use the largest value for all statistics objects. */
310 if (stattarget > result)
311 result = stattarget;
312 }
313
314 table_close(pg_stext, RowExclusiveLock);
315
316 MemoryContextSwitchTo(oldcxt);
317 MemoryContextDelete(cxt);
318
319 /* compute sample size based on the statistics target */
320 return (300 * result);
321 }
322
323 /*
324 * statext_compute_stattarget
325 * compute statistics target for an extended statistic
326 *
327 * When computing target for extended statistics objects, we consider three
328 * places where the target may be set - the statistics object itself,
329 * attributes the statistics object is defined on, and then the default
330 * statistics target.
331 *
332 * First we look at what's set for the statistics object itself, using the
333 * ALTER STATISTICS ... SET STATISTICS command. If we find a valid value
334 * there (i.e. not -1) we're done. Otherwise we look at targets set for any
335 * of the attributes the statistic is defined on, and if there are columns
336 * with defined target, we use the maximum value. We do this mostly for
337 * backwards compatibility, because this is what we did before having
338 * statistics target for extended statistics.
339 *
340 * And finally, if we still don't have a statistics target, we use the value
341 * set in default_statistics_target.
342 */
343 static int
344 statext_compute_stattarget(int stattarget, int nattrs, VacAttrStats **stats)
345 {
346 int i;
347
348 /*
349 * If there's statistics target set for the statistics object, use it. It
350 * may be set to 0 which disables building of that statistic.
351 */
352 if (stattarget >= 0)
353 return stattarget;
354
355 /*
356 * The target for the statistics object is set to -1, in which case we
357 * look at the maximum target set for any of the attributes the object is
358 * defined on.
359 */
360 for (i = 0; i < nattrs; i++)
361 {
362 /* keep the maximum statistics target */
363 if (stats[i]->attstattarget > stattarget)
364 stattarget = stats[i]->attstattarget;
365 }
366
367 /*
368 * If the value is still negative (so neither the statistics object nor
369 * any of the columns have custom statistics target set), use the global
370 * default target.
371 */
372 if (stattarget < 0)
373 stattarget = default_statistics_target;
374
375 /* As this point we should have a valid statistics target. */
376 Assert((stattarget >= 0) && (stattarget <= MAX_STATISTICS_TARGET));
377
378 return stattarget;
379 }
380
381 /*
382 * statext_is_kind_built
383 * Is this stat kind built in the given pg_statistic_ext_data tuple?
384 */
385 bool
386 statext_is_kind_built(HeapTuple htup, char type)
387 {
388 AttrNumber attnum;
389
390 switch (type)
391 {
392 case STATS_EXT_NDISTINCT:
393 attnum = Anum_pg_statistic_ext_data_stxdndistinct;
394 break;
395
396 case STATS_EXT_DEPENDENCIES:
397 attnum = Anum_pg_statistic_ext_data_stxddependencies;
398 break;
399
400 case STATS_EXT_MCV:
401 attnum = Anum_pg_statistic_ext_data_stxdmcv;
402 break;
403
404 case STATS_EXT_EXPRESSIONS:
405 attnum = Anum_pg_statistic_ext_data_stxdexpr;
406 break;
407
408 default:
409 elog(ERROR, "unexpected statistics type requested: %d", type);
410 }
411
412 return !heap_attisnull(htup, attnum, NULL);
413 }
414
415 /*
416 * Return a list (of StatExtEntry) of statistics objects for the given relation.
417 */
418 static List *
419 fetch_statentries_for_relation(Relation pg_statext, Oid relid)
420 {
421 SysScanDesc scan;
422 ScanKeyData skey;
423 HeapTuple htup;
424 List *result = NIL;
425
426 /*
427 * Prepare to scan pg_statistic_ext for entries having stxrelid = this
428 * rel.
429 */
430 ScanKeyInit(&skey,
431 Anum_pg_statistic_ext_stxrelid,
432 BTEqualStrategyNumber, F_OIDEQ,
433 ObjectIdGetDatum(relid));
434
435 scan = systable_beginscan(pg_statext, StatisticExtRelidIndexId, true,
436 NULL, 1, &skey);
437
438 while (HeapTupleIsValid(htup = systable_getnext(scan)))
439 {
440 StatExtEntry *entry;
441 Datum datum;
442 bool isnull;
443 int i;
444 ArrayType *arr;
445 char *enabled;
446 Form_pg_statistic_ext staForm;
447 List *exprs = NIL;
448
449 entry = palloc0(sizeof(StatExtEntry));
450 staForm = (Form_pg_statistic_ext) GETSTRUCT(htup);
451 entry->statOid = staForm->oid;
452 entry->schema = get_namespace_name(staForm->stxnamespace);
453 entry->name = pstrdup(NameStr(staForm->stxname));
454 for (i = 0; i < staForm->stxkeys.dim1; i++)
455 {
456 entry->columns = bms_add_member(entry->columns,
457 staForm->stxkeys.values[i]);
458 }
459
460 datum = SysCacheGetAttr(STATEXTOID, htup, Anum_pg_statistic_ext_stxstattarget, &isnull);
461 entry->stattarget = isnull ? -1 : DatumGetInt16(datum);
462
463 /* decode the stxkind char array into a list of chars */
464 datum = SysCacheGetAttrNotNull(STATEXTOID, htup,
465 Anum_pg_statistic_ext_stxkind);
466 arr = DatumGetArrayTypeP(datum);
467 if (ARR_NDIM(arr) != 1 ||
468 ARR_HASNULL(arr) ||
469 ARR_ELEMTYPE(arr) != CHAROID)
470 elog(ERROR, "stxkind is not a 1-D char array");
471 enabled = (char *) ARR_DATA_PTR(arr);
472 for (i = 0; i < ARR_DIMS(arr)[0]; i++)
473 {
474 Assert((enabled[i] == STATS_EXT_NDISTINCT) ||
475 (enabled[i] == STATS_EXT_DEPENDENCIES) ||
476 (enabled[i] == STATS_EXT_MCV) ||
477 (enabled[i] == STATS_EXT_EXPRESSIONS));
478 entry->types = lappend_int(entry->types, (int) enabled[i]);
479 }
480
481 /* decode expression (if any) */
482 datum = SysCacheGetAttr(STATEXTOID, htup,
483 Anum_pg_statistic_ext_stxexprs, &isnull);
484
485 if (!isnull)
486 {
487 char *exprsString;
488
489 exprsString = TextDatumGetCString(datum);
490 exprs = (List *) stringToNode(exprsString);
491
492 pfree(exprsString);
493
494 /*
495 * Run the expressions through eval_const_expressions. This is not
496 * just an optimization, but is necessary, because the planner
497 * will be comparing them to similarly-processed qual clauses, and
498 * may fail to detect valid matches without this. We must not use
499 * canonicalize_qual, however, since these aren't qual
500 * expressions.
501 */
502 exprs = (List *) eval_const_expressions(NULL, (Node *) exprs);
503
504 /* May as well fix opfuncids too */
505 fix_opfuncids((Node *) exprs);
506 }
507
508 entry->exprs = exprs;
509
510 result = lappend(result, entry);
511 }
512
513 systable_endscan(scan);
514
515 return result;
516 }
517
518 /*
519 * examine_attribute -- pre-analysis of a single column
520 *
521 * Determine whether the column is analyzable; if so, create and initialize
522 * a VacAttrStats struct for it. If not, return NULL.
523 */
524 static VacAttrStats *
525 examine_attribute(Node *expr)
526 {
527 HeapTuple typtuple;
528 VacAttrStats *stats;
529 int i;
530 bool ok;
531
532 /*
533 * Create the VacAttrStats struct.
534 */
535 stats = (VacAttrStats *) palloc0(sizeof(VacAttrStats));
536 stats->attstattarget = -1;
537
538 /*
539 * When analyzing an expression, believe the expression tree's type not
540 * the column datatype --- the latter might be the opckeytype storage type
541 * of the opclass, which is not interesting for our purposes. (Note: if
542 * we did anything with non-expression statistics columns, we'd need to
543 * figure out where to get the correct type info from, but for now that's
544 * not a problem.) It's not clear whether anyone will care about the
545 * typmod, but we store that too just in case.
546 */
547 stats->attrtypid = exprType(expr);
548 stats->attrtypmod = exprTypmod(expr);
549 stats->attrcollid = exprCollation(expr);
550
551 typtuple = SearchSysCacheCopy1(TYPEOID,
552 ObjectIdGetDatum(stats->attrtypid));
553 if (!HeapTupleIsValid(typtuple))
554 elog(ERROR, "cache lookup failed for type %u", stats->attrtypid);
555 stats->attrtype = (Form_pg_type) GETSTRUCT(typtuple);
556
557 /*
558 * We don't actually analyze individual attributes, so no need to set the
559 * memory context.
560 */
561 stats->anl_context = NULL;
562 stats->tupattnum = InvalidAttrNumber;
563
564 /*
565 * The fields describing the stats->stavalues[n] element types default to
566 * the type of the data being analyzed, but the type-specific typanalyze
567 * function can change them if it wants to store something else.
568 */
569 for (i = 0; i < STATISTIC_NUM_SLOTS; i++)
570 {
571 stats->statypid[i] = stats->attrtypid;
572 stats->statyplen[i] = stats->attrtype->typlen;
573 stats->statypbyval[i] = stats->attrtype->typbyval;
574 stats->statypalign[i] = stats->attrtype->typalign;
575 }
576
577 /*
578 * Call the type-specific typanalyze function. If none is specified, use
579 * std_typanalyze().
580 */
581 if (OidIsValid(stats->attrtype->typanalyze))
582 ok = DatumGetBool(OidFunctionCall1(stats->attrtype->typanalyze,
583 PointerGetDatum(stats)));
584 else
585 ok = std_typanalyze(stats);
586
587 if (!ok || stats->compute_stats == NULL || stats->minrows <= 0)
588 {
589 heap_freetuple(typtuple);
590 pfree(stats);
591 return NULL;
592 }
593
594 return stats;
595 }
596
597 /*
598 * examine_expression -- pre-analysis of a single expression
599 *
600 * Determine whether the expression is analyzable; if so, create and initialize
601 * a VacAttrStats struct for it. If not, return NULL.
602 */
603 static VacAttrStats *
604 examine_expression(Node *expr, int stattarget)
605 {
606 HeapTuple typtuple;
607 VacAttrStats *stats;
608 int i;
609 bool ok;
610
611 Assert(expr != NULL);
612
613 /*
614 * Create the VacAttrStats struct.
615 */
616 stats = (VacAttrStats *) palloc0(sizeof(VacAttrStats));
617
618 /*
619 * We can't have statistics target specified for the expression, so we
620 * could use either the default_statistics_target, or the target computed
621 * for the extended statistics. The second option seems more reasonable.
622 */
623 stats->attstattarget = stattarget;
624
625 /*
626 * When analyzing an expression, believe the expression tree's type.
627 */
628 stats->attrtypid = exprType(expr);
629 stats->attrtypmod = exprTypmod(expr);
630
631 /*
632 * We don't allow collation to be specified in CREATE STATISTICS, so we
633 * have to use the collation specified for the expression. It's possible
634 * to specify the collation in the expression "(col COLLATE "en_US")" in
635 * which case exprCollation() does the right thing.
636 */
637 stats->attrcollid = exprCollation(expr);
638
639 typtuple = SearchSysCacheCopy1(TYPEOID,
640 ObjectIdGetDatum(stats->attrtypid));
641 if (!HeapTupleIsValid(typtuple))
642 elog(ERROR, "cache lookup failed for type %u", stats->attrtypid);
643
644 stats->attrtype = (Form_pg_type) GETSTRUCT(typtuple);
645 stats->anl_context = CurrentMemoryContext; /* XXX should be using
646 * something else? */
647 stats->tupattnum = InvalidAttrNumber;
648
649 /*
650 * The fields describing the stats->stavalues[n] element types default to
651 * the type of the data being analyzed, but the type-specific typanalyze
652 * function can change them if it wants to store something else.
653 */
654 for (i = 0; i < STATISTIC_NUM_SLOTS; i++)
655 {
656 stats->statypid[i] = stats->attrtypid;
657 stats->statyplen[i] = stats->attrtype->typlen;
658 stats->statypbyval[i] = stats->attrtype->typbyval;
659 stats->statypalign[i] = stats->attrtype->typalign;
660 }
661
662 /*
663 * Call the type-specific typanalyze function. If none is specified, use
664 * std_typanalyze().
665 */
666 if (OidIsValid(stats->attrtype->typanalyze))
667 ok = DatumGetBool(OidFunctionCall1(stats->attrtype->typanalyze,
668 PointerGetDatum(stats)));
669 else
670 ok = std_typanalyze(stats);
671
672 if (!ok || stats->compute_stats == NULL || stats->minrows <= 0)
673 {
674 heap_freetuple(typtuple);
675 pfree(stats);
676 return NULL;
677 }
678
679 return stats;
680 }
681
682 /*
683 * Using 'vacatts' of size 'nvacatts' as input data, return a newly-built
684 * VacAttrStats array which includes only the items corresponding to
685 * attributes indicated by 'attrs'. If we don't have all of the per-column
686 * stats available to compute the extended stats, then we return NULL to
687 * indicate to the caller that the stats should not be built.
688 */
689 static VacAttrStats **
690 lookup_var_attr_stats(Bitmapset *attrs, List *exprs,
691 int nvacatts, VacAttrStats **vacatts)
692 {
693 int i = 0;
694 int x = -1;
695 int natts;
696 VacAttrStats **stats;
697 ListCell *lc;
698
699 natts = bms_num_members(attrs) + list_length(exprs);
700
701 stats = (VacAttrStats **) palloc(natts * sizeof(VacAttrStats *));
702
703 /* lookup VacAttrStats info for the requested columns (same attnum) */
704 while ((x = bms_next_member(attrs, x)) >= 0)
705 {
706 int j;
707
708 stats[i] = NULL;
709 for (j = 0; j < nvacatts; j++)
710 {
711 if (x == vacatts[j]->tupattnum)
712 {
713 stats[i] = vacatts[j];
714 break;
715 }
716 }
717
718 if (!stats[i])
719 {
720 /*
721 * Looks like stats were not gathered for one of the columns
722 * required. We'll be unable to build the extended stats without
723 * this column.
724 */
725 pfree(stats);
726 return NULL;
727 }
728
729 i++;
730 }
731
732 /* also add info for expressions */
733 foreach(lc, exprs)
734 {
735 Node *expr = (Node *) lfirst(lc);
736
737 stats[i] = examine_attribute(expr);
738
739 /*
740 * If the expression has been found as non-analyzable, give up. We
741 * will not be able to build extended stats with it.
742 */
743 if (stats[i] == NULL)
744 {
745 pfree(stats);
746 return NULL;
747 }
748
749 /*
750 * XXX We need tuple descriptor later, and we just grab it from
751 * stats[0]->tupDesc (see e.g. statext_mcv_build). But as coded
752 * examine_attribute does not set that, so just grab it from the first
753 * vacatts element.
754 */
755 stats[i]->tupDesc = vacatts[0]->tupDesc;
756
757 i++;
758 }
759
760 return stats;
761 }
762
763 /*
764 * statext_store
765 * Serializes the statistics and stores them into the pg_statistic_ext_data
766 * tuple.
767 */
768 static void
769 statext_store(Oid statOid, bool inh,
770 MVNDistinct *ndistinct, MVDependencies *dependencies,
771 MCVList *mcv, Datum exprs, VacAttrStats **stats)
772 {
773 Relation pg_stextdata;
774 HeapTuple stup;
775 Datum values[Natts_pg_statistic_ext_data];
776 bool nulls[Natts_pg_statistic_ext_data];
777
778 pg_stextdata = table_open(StatisticExtDataRelationId, RowExclusiveLock);
779
780 memset(nulls, true, sizeof(nulls));
781 memset(values, 0, sizeof(values));
782
783 /* basic info */
784 values[Anum_pg_statistic_ext_data_stxoid - 1] = ObjectIdGetDatum(statOid);
785 nulls[Anum_pg_statistic_ext_data_stxoid - 1] = false;
786
787 values[Anum_pg_statistic_ext_data_stxdinherit - 1] = BoolGetDatum(inh);
788 nulls[Anum_pg_statistic_ext_data_stxdinherit - 1] = false;
789
790 /*
791 * Construct a new pg_statistic_ext_data tuple, replacing the calculated
792 * stats.
793 */
794 if (ndistinct != NULL)
795 {
796 bytea *data = statext_ndistinct_serialize(ndistinct);
797
798 nulls[Anum_pg_statistic_ext_data_stxdndistinct - 1] = (data == NULL);
799 values[Anum_pg_statistic_ext_data_stxdndistinct - 1] = PointerGetDatum(data);
800 }
801
802 if (dependencies != NULL)
803 {
804 bytea *data = statext_dependencies_serialize(dependencies);
805
806 nulls[Anum_pg_statistic_ext_data_stxddependencies - 1] = (data == NULL);
807 values[Anum_pg_statistic_ext_data_stxddependencies - 1] = PointerGetDatum(data);
808 }
809 if (mcv != NULL)
810 {
811 bytea *data = statext_mcv_serialize(mcv, stats);
812
813 nulls[Anum_pg_statistic_ext_data_stxdmcv - 1] = (data == NULL);
814 values[Anum_pg_statistic_ext_data_stxdmcv - 1] = PointerGetDatum(data);
815 }
816 if (exprs != (Datum) 0)
817 {
818 nulls[Anum_pg_statistic_ext_data_stxdexpr - 1] = false;
819 values[Anum_pg_statistic_ext_data_stxdexpr - 1] = exprs;
820 }
821
822 /*
823 * Delete the old tuple if it exists, and insert a new one. It's easier
824 * than trying to update or insert, based on various conditions.
825 */
826 RemoveStatisticsDataById(statOid, inh);
827
828 /* form and insert a new tuple */
829 stup = heap_form_tuple(RelationGetDescr(pg_stextdata), values, nulls);
830 CatalogTupleInsert(pg_stextdata, stup);
831
832 heap_freetuple(stup);
833
834 table_close(pg_stextdata, RowExclusiveLock);
835 }
836
837 /* initialize multi-dimensional sort */
838 MultiSortSupport
839 multi_sort_init(int ndims)
840 {
841 MultiSortSupport mss;
842
843 Assert(ndims >= 2);
844
845 mss = (MultiSortSupport) palloc0(offsetof(MultiSortSupportData, ssup)
846 + sizeof(SortSupportData) * ndims);
847
848 mss->ndims = ndims;
849
850 return mss;
851 }
852
853 /*
854 * Prepare sort support info using the given sort operator and collation
855 * at the position 'sortdim'
856 */
857 void
858 multi_sort_add_dimension(MultiSortSupport mss, int sortdim,
859 Oid oper, Oid collation)
860 {
861 SortSupport ssup = &mss->ssup[sortdim];
862
863 ssup->ssup_cxt = CurrentMemoryContext;
864 ssup->ssup_collation = collation;
865 ssup->ssup_nulls_first = false;
866
867 PrepareSortSupportFromOrderingOp(oper, ssup);
868 }
869
870 /* compare all the dimensions in the selected order */
871 int
872 multi_sort_compare(const void *a, const void *b, void *arg)
873 {
874 MultiSortSupport mss = (MultiSortSupport) arg;
875 SortItem *ia = (SortItem *) a;
876 SortItem *ib = (SortItem *) b;
877 int i;
878
879 for (i = 0; i < mss->ndims; i++)
880 {
881 int compare;
882
883 compare = ApplySortComparator(ia->values[i], ia->isnull[i],
884 ib->values[i], ib->isnull[i],
885 &mss->ssup[i]);
886
887 if (compare != 0)
888 return compare;
889 }
890
891 /* equal by default */
892 return 0;
893 }
894
895 /* compare selected dimension */
896 int
897 multi_sort_compare_dim(int dim, const SortItem *a, const SortItem *b,
898 MultiSortSupport mss)
899 {
900 return ApplySortComparator(a->values[dim], a->isnull[dim],
901 b->values[dim], b->isnull[dim],
902 &mss->ssup[dim]);
903 }
904
905 int
906 multi_sort_compare_dims(int start, int end,
907 const SortItem *a, const SortItem *b,
908 MultiSortSupport mss)
909 {
910 int dim;
911
912 for (dim = start; dim <= end; dim++)
913 {
914 int r = ApplySortComparator(a->values[dim], a->isnull[dim],
915 b->values[dim], b->isnull[dim],
916 &mss->ssup[dim]);
917
918 if (r != 0)
919 return r;
920 }
921
922 return 0;
923 }
924
925 int
926 compare_scalars_simple(const void *a, const void *b, void *arg)
927 {
928 return compare_datums_simple(*(Datum *) a,
929 *(Datum *) b,
930 (SortSupport) arg);
931 }
932
933 int
934 compare_datums_simple(Datum a, Datum b, SortSupport ssup)
935 {
936 return ApplySortComparator(a, false, b, false, ssup);
937 }
938
939 /*
940 * build_attnums_array
941 * Transforms a bitmap into an array of AttrNumber values.
942 *
943 * This is used for extended statistics only, so all the attributes must be
944 * user-defined. That means offsetting by FirstLowInvalidHeapAttributeNumber
945 * is not necessary here (and when querying the bitmap).
946 */
947 AttrNumber *
948 build_attnums_array(Bitmapset *attrs, int nexprs, int *numattrs)
949 {
950 int i,
951 j;
952 AttrNumber *attnums;
953 int num = bms_num_members(attrs);
954
955 if (numattrs)
956 *numattrs = num;
957
958 /* build attnums from the bitmapset */
959 attnums = (AttrNumber *) palloc(sizeof(AttrNumber) * num);
960 i = 0;
961 j = -1;
962 while ((j = bms_next_member(attrs, j)) >= 0)
963 {
964 int attnum = (j - nexprs);
965
966 /*
967 * Make sure the bitmap contains only user-defined attributes. As
968 * bitmaps can't contain negative values, this can be violated in two
969 * ways. Firstly, the bitmap might contain 0 as a member, and secondly
970 * the integer value might be larger than MaxAttrNumber.
971 */
972 Assert(AttributeNumberIsValid(attnum));
973 Assert(attnum <= MaxAttrNumber);
974 Assert(attnum >= (-nexprs));
975
976 attnums[i++] = (AttrNumber) attnum;
977
978 /* protect against overflows */
979 Assert(i <= num);
980 }
981
982 return attnums;
983 }
984
985 /*
986 * build_sorted_items
987 * build a sorted array of SortItem with values from rows
988 *
989 * Note: All the memory is allocated in a single chunk, so that the caller
990 * can simply pfree the return value to release all of it.
991 */
992 SortItem *
993 build_sorted_items(StatsBuildData *data, int *nitems,
994 MultiSortSupport mss,
995 int numattrs, AttrNumber *attnums)
996 {
997 int i,
998 j,
999 len,
1000 nrows;
1001 int nvalues = data->numrows * numattrs;
1002
1003 SortItem *items;
1004 Datum *values;
1005 bool *isnull;
1006 char *ptr;
1007 int *typlen;
1008
1009 /* Compute the total amount of memory we need (both items and values). */
1010 len = data->numrows * sizeof(SortItem) + nvalues * (sizeof(Datum) + sizeof(bool));
1011
1012 /* Allocate the memory and split it into the pieces. */
1013 ptr = palloc0(len);
1014
1015 /* items to sort */
1016 items = (SortItem *) ptr;
1017 ptr += data->numrows * sizeof(SortItem);
1018
1019 /* values and null flags */
1020 values = (Datum *) ptr;
1021 ptr += nvalues * sizeof(Datum);
1022
1023 isnull = (bool *) ptr;
1024 ptr += nvalues * sizeof(bool);
1025
1026 /* make sure we consumed the whole buffer exactly */
1027 Assert((ptr - (char *) items) == len);
1028
1029 /* fix the pointers to Datum and bool arrays */
1030 nrows = 0;
1031 for (i = 0; i < data->numrows; i++)
1032 {
1033 items[nrows].values = &values[nrows * numattrs];
1034 items[nrows].isnull = &isnull[nrows * numattrs];
1035
1036 nrows++;
1037 }
1038
1039 /* build a local cache of typlen for all attributes */
1040 typlen = (int *) palloc(sizeof(int) * data->nattnums);
1041 for (i = 0; i < data->nattnums; i++)
1042 typlen[i] = get_typlen(data->stats[i]->attrtypid);
1043
1044 nrows = 0;
1045 for (i = 0; i < data->numrows; i++)
1046 {
1047 bool toowide = false;
1048
1049 /* load the values/null flags from sample rows */
1050 for (j = 0; j < numattrs; j++)
1051 {
1052 Datum value;
1053 bool isnull;
1054 int attlen;
1055 AttrNumber attnum = attnums[j];
1056
1057 int idx;
1058
1059 /* match attnum to the pre-calculated data */
1060 for (idx = 0; idx < data->nattnums; idx++)
1061 {
1062 if (attnum == data->attnums[idx])
1063 break;
1064 }
1065
1066 Assert(idx < data->nattnums);
1067
1068 value = data->values[idx][i];
1069 isnull = data->nulls[idx][i];
1070 attlen = typlen[idx];
1071
1072 /*
1073 * If this is a varlena value, check if it's too wide and if yes
1074 * then skip the whole item. Otherwise detoast the value.
1075 *
1076 * XXX It may happen that we've already detoasted some preceding
1077 * values for the current item. We don't bother to cleanup those
1078 * on the assumption that those are small (below WIDTH_THRESHOLD)
1079 * and will be discarded at the end of analyze.
1080 */
1081 if ((!isnull) && (attlen == -1))
1082 {
1083 if (toast_raw_datum_size(value) > WIDTH_THRESHOLD)
1084 {
1085 toowide = true;
1086 break;
1087 }
1088
1089 value = PointerGetDatum(PG_DETOAST_DATUM(value));
1090 }
1091
1092 items[nrows].values[j] = value;
1093 items[nrows].isnull[j] = isnull;
1094 }
1095
1096 if (toowide)
1097 continue;
1098
1099 nrows++;
1100 }
1101
1102 /* store the actual number of items (ignoring the too-wide ones) */
1103 *nitems = nrows;
1104
1105 /* all items were too wide */
1106 if (nrows == 0)
1107 {
1108 /* everything is allocated as a single chunk */
1109 pfree(items);
1110 return NULL;
1111 }
1112
1113 /* do the sort, using the multi-sort */
1114 qsort_interruptible(items, nrows, sizeof(SortItem),
1115 multi_sort_compare, mss);
1116
1117 return items;
1118 }
1119
1120 /*
1121 * has_stats_of_kind
1122 * Check whether the list contains statistic of a given kind
1123 */
1124 bool
1125 has_stats_of_kind(List *stats, char requiredkind)
1126 {
1127 ListCell *l;
1128
1129 foreach(l, stats)
1130 {
1131 StatisticExtInfo *stat = (StatisticExtInfo *) lfirst(l);
1132
1133 if (stat->kind == requiredkind)
1134 return true;
1135 }
1136
1137 return false;
1138 }
1139
1140 /*
1141 * stat_find_expression
1142 * Search for an expression in statistics object's list of expressions.
1143 *
1144 * Returns the index of the expression in the statistics object's list of
1145 * expressions, or -1 if not found.
1146 */
1147 static int
1148 stat_find_expression(StatisticExtInfo *stat, Node *expr)
1149 {
1150 ListCell *lc;
1151 int idx;
1152
1153 idx = 0;
1154 foreach(lc, stat->exprs)
1155 {
1156 Node *stat_expr = (Node *) lfirst(lc);
1157
1158 if (equal(stat_expr, expr))
1159 return idx;
1160 idx++;
1161 }
1162
1163 /* Expression not found */
1164 return -1;
1165 }
1166
1167 /*
1168 * stat_covers_expressions
1169 * Test whether a statistics object covers all expressions in a list.
1170 *
1171 * Returns true if all expressions are covered. If expr_idxs is non-NULL, it
1172 * is populated with the indexes of the expressions found.
1173 */
1174 static bool
1175 stat_covers_expressions(StatisticExtInfo *stat, List *exprs,
1176 Bitmapset **expr_idxs)
1177 {
1178 ListCell *lc;
1179
1180 foreach(lc, exprs)
1181 {
1182 Node *expr = (Node *) lfirst(lc);
1183 int expr_idx;
1184
1185 expr_idx = stat_find_expression(stat, expr);
1186 if (expr_idx == -1)
1187 return false;
1188
1189 if (expr_idxs != NULL)
1190 *expr_idxs = bms_add_member(*expr_idxs, expr_idx);
1191 }
1192
1193 /* If we reach here, all expressions are covered */
1194 return true;
1195 }
1196
1197 /*
1198 * choose_best_statistics
1199 * Look for and return statistics with the specified 'requiredkind' which
1200 * have keys that match at least two of the given attnums. Return NULL if
1201 * there's no match.
1202 *
1203 * The current selection criteria is very simple - we choose the statistics
1204 * object referencing the most attributes in covered (and still unestimated
1205 * clauses), breaking ties in favor of objects with fewer keys overall.
1206 *
1207 * The clause_attnums is an array of bitmaps, storing attnums for individual
1208 * clauses. A NULL element means the clause is either incompatible or already
1209 * estimated.
1210 *
1211 * XXX If multiple statistics objects tie on both criteria, then which object
1212 * is chosen depends on the order that they appear in the stats list. Perhaps
1213 * further tiebreakers are needed.
1214 */
1215 StatisticExtInfo *
1216 choose_best_statistics(List *stats, char requiredkind, bool inh,
1217 Bitmapset **clause_attnums, List **clause_exprs,
1218 int nclauses)
1219 {
1220 ListCell *lc;
1221 StatisticExtInfo *best_match = NULL;
1222 int best_num_matched = 2; /* goal #1: maximize */
1223 int best_match_keys = (STATS_MAX_DIMENSIONS + 1); /* goal #2: minimize */
1224
1225 foreach(lc, stats)
1226 {
1227 int i;
1228 StatisticExtInfo *info = (StatisticExtInfo *) lfirst(lc);
1229 Bitmapset *matched_attnums = NULL;
1230 Bitmapset *matched_exprs = NULL;
1231 int num_matched;
1232 int numkeys;
1233
1234 /* skip statistics that are not of the correct type */
1235 if (info->kind != requiredkind)
1236 continue;
1237
1238 /* skip statistics with mismatching inheritance flag */
1239 if (info->inherit != inh)
1240 continue;
1241
1242 /*
1243 * Collect attributes and expressions in remaining (unestimated)
1244 * clauses fully covered by this statistic object.
1245 *
1246 * We know already estimated clauses have both clause_attnums and
1247 * clause_exprs set to NULL. We leave the pointers NULL if already
1248 * estimated, or we reset them to NULL after estimating the clause.
1249 */
1250 for (i = 0; i < nclauses; i++)
1251 {
1252 Bitmapset *expr_idxs = NULL;
1253
1254 /* ignore incompatible/estimated clauses */
1255 if (!clause_attnums[i] && !clause_exprs[i])
1256 continue;
1257
1258 /* ignore clauses that are not covered by this object */
1259 if (!bms_is_subset(clause_attnums[i], info->keys) ||
1260 !stat_covers_expressions(info, clause_exprs[i], &expr_idxs))
1261 continue;
1262
1263 /* record attnums and indexes of expressions covered */
1264 matched_attnums = bms_add_members(matched_attnums, clause_attnums[i]);
1265 matched_exprs = bms_add_members(matched_exprs, expr_idxs);
1266 }
1267
1268 num_matched = bms_num_members(matched_attnums) + bms_num_members(matched_exprs);
1269
1270 bms_free(matched_attnums);
1271 bms_free(matched_exprs);
1272
1273 /*
1274 * save the actual number of keys in the stats so that we can choose
1275 * the narrowest stats with the most matching keys.
1276 */
1277 numkeys = bms_num_members(info->keys) + list_length(info->exprs);
1278
1279 /*
1280 * Use this object when it increases the number of matched attributes
1281 * and expressions or when it matches the same number of attributes
1282 * and expressions but these stats have fewer keys than any previous
1283 * match.
1284 */
1285 if (num_matched > best_num_matched ||
1286 (num_matched == best_num_matched && numkeys < best_match_keys))
1287 {
1288 best_match = info;
1289 best_num_matched = num_matched;
1290 best_match_keys = numkeys;
1291 }
1292 }
1293
1294 return best_match;
1295 }
1296
1297 /*
1298 * statext_is_compatible_clause_internal
1299 * Determines if the clause is compatible with MCV lists.
1300 *
1301 * To be compatible, the given clause must be a combination of supported
1302 * clauses built from Vars or sub-expressions (where a sub-expression is
1303 * something that exactly matches an expression found in statistics objects).
1304 * This function recursively examines the clause and extracts any
1305 * sub-expressions that will need to be matched against statistics.
1306 *
1307 * Currently, we only support the following types of clauses:
1308 *
1309 * (a) OpExprs of the form (Var/Expr op Const), or (Const op Var/Expr), where
1310 * the op is one of ("=", "<", ">", ">=", "<=")
1311 *
1312 * (b) (Var/Expr IS [NOT] NULL)
1313 *
1314 * (c) combinations using AND/OR/NOT
1315 *
1316 * (d) ScalarArrayOpExprs of the form (Var/Expr op ANY (Const)) or
1317 * (Var/Expr op ALL (Const))
1318 *
1319 * In the future, the range of supported clauses may be expanded to more
1320 * complex cases, for example (Var op Var).
1321 *
1322 * Arguments:
1323 * clause: (sub)clause to be inspected (bare clause, not a RestrictInfo)
1324 * relid: rel that all Vars in clause must belong to
1325 * *attnums: input/output parameter collecting attribute numbers of all
1326 * mentioned Vars. Note that we do not offset the attribute numbers,
1327 * so we can't cope with system columns.
1328 * *exprs: input/output parameter collecting primitive subclauses within
1329 * the clause tree
1330 * *leakproof: input/output parameter recording the leakproofness of the
1331 * clause tree. This should be true initially, and will be set to false
1332 * if any operator function used in an OpExpr is not leakproof.
1333 *
1334 * Returns false if there is something we definitively can't handle.
1335 * On true return, we can proceed to match the *exprs against statistics.
1336 */
1337 static bool
1338 statext_is_compatible_clause_internal(PlannerInfo *root, Node *clause,
1339 Index relid, Bitmapset **attnums,
1340 List **exprs, bool *leakproof)
1341 {
1342 /* Look inside any binary-compatible relabeling (as in examine_variable) */
1343 if (IsA(clause, RelabelType))
1344 clause = (Node *) ((RelabelType *) clause)->arg;
1345
1346 /* plain Var references (boolean Vars or recursive checks) */
1347 if (IsA(clause, Var))
1348 {
1349 Var *var = (Var *) clause;
1350
1351 /* Ensure var is from the correct relation */
1352 if (var->varno != relid)
1353 return false;
1354
1355 /* we also better ensure the Var is from the current level */
1356 if (var->varlevelsup > 0)
1357 return false;
1358
1359 /*
1360 * Also reject system attributes and whole-row Vars (we don't allow
1361 * stats on those).
1362 */
1363 if (!AttrNumberIsForUserDefinedAttr(var->varattno))
1364 return false;
1365
1366 /* OK, record the attnum for later permissions checks. */
1367 *attnums = bms_add_member(*attnums, var->varattno);
1368
1369 return true;
1370 }
1371
1372 /* (Var/Expr op Const) or (Const op Var/Expr) */
1373 if (is_opclause(clause))
1374 {
1375 OpExpr *expr = (OpExpr *) clause;
1376 Node *clause_expr;
1377
1378 /* Only expressions with two arguments are considered compatible. */
1379 if (list_length(expr->args) != 2)
1380 return false;
1381
1382 /* Check if the expression has the right shape */
1383 if (!examine_opclause_args(expr->args, &clause_expr, NULL, NULL))
1384 return false;
1385
1386 /*
1387 * If it's not one of the supported operators ("=", "<", ">", etc.),
1388 * just ignore the clause, as it's not compatible with MCV lists.
1389 *
1390 * This uses the function for estimating selectivity, not the operator
1391 * directly (a bit awkward, but well ...).
1392 */
1393 switch (get_oprrest(expr->opno))
1394 {
1395 case F_EQSEL:
1396 case F_NEQSEL:
1397 case F_SCALARLTSEL:
1398 case F_SCALARLESEL:
1399 case F_SCALARGTSEL:
1400 case F_SCALARGESEL:
1401 /* supported, will continue with inspection of the Var/Expr */
1402 break;
1403
1404 default:
1405 /* other estimators are considered unknown/unsupported */
1406 return false;
1407 }
1408
1409 /* Check if the operator is leakproof */
1410 if (*leakproof)
1411 *leakproof = get_func_leakproof(get_opcode(expr->opno));
1412
1413 /* Check (Var op Const) or (Const op Var) clauses by recursing. */
1414 if (IsA(clause_expr, Var))
1415 return statext_is_compatible_clause_internal(root, clause_expr,
1416 relid, attnums,
1417 exprs, leakproof);
1418
1419 /* Otherwise we have (Expr op Const) or (Const op Expr). */
1420 *exprs = lappend(*exprs, clause_expr);
1421 return true;
1422 }
1423
1424 /* Var/Expr IN Array */
1425 if (IsA(clause, ScalarArrayOpExpr))
1426 {
1427 ScalarArrayOpExpr *expr = (ScalarArrayOpExpr *) clause;
1428 Node *clause_expr;
1429 bool expronleft;
1430
1431 /* Only expressions with two arguments are considered compatible. */
1432 if (list_length(expr->args) != 2)
1433 return false;
1434
1435 /* Check if the expression has the right shape (one Var, one Const) */
1436 if (!examine_opclause_args(expr->args, &clause_expr, NULL, &expronleft))
1437 return false;
1438
1439 /* We only support Var on left, Const on right */
1440 if (!expronleft)
1441 return false;
1442
1443 /*
1444 * If it's not one of the supported operators ("=", "<", ">", etc.),
1445 * just ignore the clause, as it's not compatible with MCV lists.
1446 *
1447 * This uses the function for estimating selectivity, not the operator
1448 * directly (a bit awkward, but well ...).
1449 */
1450 switch (get_oprrest(expr->opno))
1451 {
1452 case F_EQSEL:
1453 case F_NEQSEL:
1454 case F_SCALARLTSEL:
1455 case F_SCALARLESEL:
1456 case F_SCALARGTSEL:
1457 case F_SCALARGESEL:
1458 /* supported, will continue with inspection of the Var/Expr */
1459 break;
1460
1461 default:
1462 /* other estimators are considered unknown/unsupported */
1463 return false;
1464 }
1465
1466 /* Check if the operator is leakproof */
1467 if (*leakproof)
1468 *leakproof = get_func_leakproof(get_opcode(expr->opno));
1469
1470 /* Check Var IN Array clauses by recursing. */
1471 if (IsA(clause_expr, Var))
1472 return statext_is_compatible_clause_internal(root, clause_expr,
1473 relid, attnums,
1474 exprs, leakproof);
1475
1476 /* Otherwise we have Expr IN Array. */
1477 *exprs = lappend(*exprs, clause_expr);
1478 return true;
1479 }
1480
1481 /* AND/OR/NOT clause */
1482 if (is_andclause(clause) ||
1483 is_orclause(clause) ||
1484 is_notclause(clause))
1485 {
1486 /*
1487 * AND/OR/NOT-clauses are supported if all sub-clauses are supported
1488 *
1489 * Perhaps we could improve this by handling mixed cases, when some of
1490 * the clauses are supported and some are not. Selectivity for the
1491 * supported subclauses would be computed using extended statistics,
1492 * and the remaining clauses would be estimated using the traditional
1493 * algorithm (product of selectivities).
1494 *
1495 * It however seems overly complex, and in a way we already do that
1496 * because if we reject the whole clause as unsupported here, it will
1497 * be eventually passed to clauselist_selectivity() which does exactly
1498 * this (split into supported/unsupported clauses etc).
1499 */
1500 BoolExpr *expr = (BoolExpr *) clause;
1501 ListCell *lc;
1502
1503 foreach(lc, expr->args)
1504 {
1505 /*
1506 * If we find an incompatible clause in the arguments, treat the
1507 * whole clause as incompatible.
1508 */
1509 if (!statext_is_compatible_clause_internal(root,
1510 (Node *) lfirst(lc),
1511 relid, attnums, exprs,
1512 leakproof))
1513 return false;
1514 }
1515
1516 return true;
1517 }
1518
1519 /* Var/Expr IS NULL */
1520 if (IsA(clause, NullTest))
1521 {
1522 NullTest *nt = (NullTest *) clause;
1523
1524 /* Check Var IS NULL clauses by recursing. */
1525 if (IsA(nt->arg, Var))
1526 return statext_is_compatible_clause_internal(root,
1527 (Node *) (nt->arg),
1528 relid, attnums,
1529 exprs, leakproof);
1530
1531 /* Otherwise we have Expr IS NULL. */
1532 *exprs = lappend(*exprs, nt->arg);
1533 return true;
1534 }
1535
1536 /*
1537 * Treat any other expressions as bare expressions to be matched against
1538 * expressions in statistics objects.
1539 */
1540 *exprs = lappend(*exprs, clause);
1541 return true;
1542 }
1543
1544 /*
1545 * statext_is_compatible_clause
1546 * Determines if the clause is compatible with MCV lists.
1547 *
1548 * See statext_is_compatible_clause_internal, above, for the basic rules.
1549 * This layer deals with RestrictInfo superstructure and applies permissions
1550 * checks to verify that it's okay to examine all mentioned Vars.
1551 *
1552 * Arguments:
1553 * clause: clause to be inspected (in RestrictInfo form)
1554 * relid: rel that all Vars in clause must belong to
1555 * *attnums: input/output parameter collecting attribute numbers of all
1556 * mentioned Vars. Note that we do not offset the attribute numbers,
1557 * so we can't cope with system columns.
1558 * *exprs: input/output parameter collecting primitive subclauses within
1559 * the clause tree
1560 *
1561 * Returns false if there is something we definitively can't handle.
1562 * On true return, we can proceed to match the *exprs against statistics.
1563 */
1564 static bool
1565 statext_is_compatible_clause(PlannerInfo *root, Node *clause, Index relid,
1566 Bitmapset **attnums, List **exprs)
1567 {
1568 RestrictInfo *rinfo;
1569 int clause_relid;
1570 bool leakproof;
1571
1572 /*
1573 * Special-case handling for bare BoolExpr AND clauses, because the
1574 * restrictinfo machinery doesn't build RestrictInfos on top of AND
1575 * clauses.
1576 */
1577 if (is_andclause(clause))
1578 {
1579 BoolExpr *expr = (BoolExpr *) clause;
1580 ListCell *lc;
1581
1582 /*
1583 * Check that each sub-clause is compatible. We expect these to be
1584 * RestrictInfos.
1585 */
1586 foreach(lc, expr->args)
1587 {
1588 if (!statext_is_compatible_clause(root, (Node *) lfirst(lc),
1589 relid, attnums, exprs))
1590 return false;
1591 }
1592
1593 return true;
1594 }
1595
1596 /* Otherwise it must be a RestrictInfo. */
1597 if (!IsA(clause, RestrictInfo))
1598 return false;
1599 rinfo = (RestrictInfo *) clause;
1600
1601 /* Pseudoconstants are not really interesting here. */
1602 if (rinfo->pseudoconstant)
1603 return false;
1604
1605 /* Clauses referencing other varnos are incompatible. */
1606 if (!bms_get_singleton_member(rinfo->clause_relids, &clause_relid) ||
1607 clause_relid != relid)
1608 return false;
1609
1610 /*
1611 * Check the clause, determine what attributes it references, and whether
1612 * it includes any non-leakproof operators.
1613 */
1614 leakproof = true;
1615 if (!statext_is_compatible_clause_internal(root, (Node *) rinfo->clause,
1616 relid, attnums, exprs,
1617 &leakproof))
1618 return false;
1619
1620 /*
1621 * If the clause includes any non-leakproof operators, check that the user
1622 * has permission to read all required attributes, otherwise the operators
1623 * might reveal values from the MCV list that the user doesn't have
1624 * permission to see. We require all rows to be selectable --- there must
1625 * be no securityQuals from security barrier views or RLS policies. See
1626 * similar code in examine_variable(), examine_simple_variable(), and
1627 * statistic_proc_security_check().
1628 *
1629 * Note that for an inheritance child, the permission checks are performed
1630 * on the inheritance root parent, and whole-table select privilege on the
1631 * parent doesn't guarantee that the user could read all columns of the
1632 * child. Therefore we must check all referenced columns.
1633 */
1634 if (!leakproof)
1635 {
1636 Bitmapset *clause_attnums = NULL;
1637 int attnum = -1;
1638
1639 /*
1640 * We have to check per-column privileges. *attnums has the attnums
1641 * for individual Vars we saw, but there may also be Vars within
1642 * subexpressions in *exprs. We can use pull_varattnos() to extract
1643 * those, but there's an impedance mismatch: attnums returned by
1644 * pull_varattnos() are offset by FirstLowInvalidHeapAttributeNumber,
1645 * while attnums within *attnums aren't. Convert *attnums to the
1646 * offset style so we can combine the results.
1647 */
1648 while ((attnum = bms_next_member(*attnums, attnum)) >= 0)
1649 {
1650 clause_attnums =
1651 bms_add_member(clause_attnums,
1652 attnum - FirstLowInvalidHeapAttributeNumber);
1653 }
1654
1655 /* Now merge attnums from *exprs into clause_attnums */
1656 if (*exprs != NIL)
1657 pull_varattnos((Node *) *exprs, relid, &clause_attnums);
1658
1659 /* Must have permission to read all rows from these columns */
1660 if (!all_rows_selectable(root, relid, clause_attnums))
1661 return false;
1662 }
1663
1664 /* If we reach here, the clause is OK */
1665 return true;
1666 }
1667
1668 /*
1669 * statext_mcv_clauselist_selectivity
1670 * Estimate clauses using the best multi-column statistics.
1671 *
1672 * Applies available extended (multi-column) statistics on a table. There may
1673 * be multiple applicable statistics (with respect to the clauses), in which
1674 * case we use greedy approach. In each round we select the best statistic on
1675 * a table (measured by the number of attributes extracted from the clauses
1676 * and covered by it), and compute the selectivity for the supplied clauses.
1677 * We repeat this process with the remaining clauses (if any), until none of
1678 * the available statistics can be used.
1679 *
1680 * One of the main challenges with using MCV lists is how to extrapolate the
1681 * estimate to the data not covered by the MCV list. To do that, we compute
1682 * not only the "MCV selectivity" (selectivities for MCV items matching the
1683 * supplied clauses), but also the following related selectivities:
1684 *
1685 * - simple selectivity: Computed without extended statistics, i.e. as if the
1686 * columns/clauses were independent.
1687 *
1688 * - base selectivity: Similar to simple selectivity, but is computed using
1689 * the extended statistic by adding up the base frequencies (that we compute
1690 * and store for each MCV item) of matching MCV items.
1691 *
1692 * - total selectivity: Selectivity covered by the whole MCV list.
1693 *
1694 * These are passed to mcv_combine_selectivities() which combines them to
1695 * produce a selectivity estimate that makes use of both per-column statistics
1696 * and the multi-column MCV statistics.
1697 *
1698 * 'estimatedclauses' is an input/output parameter. We set bits for the
1699 * 0-based 'clauses' indexes we estimate for and also skip clause items that
1700 * already have a bit set.
1701 */
1702 static Selectivity
1703 statext_mcv_clauselist_selectivity(PlannerInfo *root, List *clauses, int varRelid,
1704 JoinType jointype, SpecialJoinInfo *sjinfo,
1705 RelOptInfo *rel, Bitmapset **estimatedclauses,
1706 bool is_or)
1707 {
1708 ListCell *l;
1709 Bitmapset **list_attnums; /* attnums extracted from the clause */
1710 List **list_exprs; /* expressions matched to any statistic */
1711 int listidx;
1712 Selectivity sel = (is_or) ? 0.0 : 1.0;
1713 RangeTblEntry *rte = planner_rt_fetch(rel->relid, root);
1714
1715 /* check if there's any stats that might be useful for us. */
1716 if (!has_stats_of_kind(rel->statlist, STATS_EXT_MCV))
1717 return sel;
1718
1719 list_attnums = (Bitmapset **) palloc(sizeof(Bitmapset *) *
1720 list_length(clauses));
1721
1722 /* expressions extracted from complex expressions */
1723 list_exprs = (List **) palloc(sizeof(Node *) * list_length(clauses));
1724
1725 /*
1726 * Pre-process the clauses list to extract the attnums and expressions
1727 * seen in each item. We need to determine if there are any clauses which
1728 * will be useful for selectivity estimations with extended stats. Along
1729 * the way we'll record all of the attnums and expressions for each clause
1730 * in lists which we'll reference later so we don't need to repeat the
1731 * same work again.
1732 *
1733 * We also skip clauses that we already estimated using different types of
1734 * statistics (we treat them as incompatible).
1735 */
1736 listidx = 0;
1737 foreach(l, clauses)
1738 {
1739 Node *clause = (Node *) lfirst(l);
1740 Bitmapset *attnums = NULL;
1741 List *exprs = NIL;
1742
1743 if (!bms_is_member(listidx, *estimatedclauses) &&
1744 statext_is_compatible_clause(root, clause, rel->relid, &attnums, &exprs))
1745 {
1746 list_attnums[listidx] = attnums;
1747 list_exprs[listidx] = exprs;
1748 }
1749 else
1750 {
1751 list_attnums[listidx] = NULL;
1752 list_exprs[listidx] = NIL;
1753 }
1754
1755 listidx++;
1756 }
1757
1758 /* apply as many extended statistics as possible */
1759 while (true)
1760 {
1761 StatisticExtInfo *stat;
1762 List *stat_clauses;
1763 Bitmapset *simple_clauses;
1764
1765 /* find the best suited statistics object for these attnums */
1766 stat = choose_best_statistics(rel->statlist, STATS_EXT_MCV, rte->inh,
1767 list_attnums, list_exprs,
1768 list_length(clauses));
1769
1770 /*
1771 * if no (additional) matching stats could be found then we've nothing
1772 * to do
1773 */
1774 if (!stat)
1775 break;
1776
1777 /* Ensure choose_best_statistics produced an expected stats type. */
1778 Assert(stat->kind == STATS_EXT_MCV);
1779
1780 /* now filter the clauses to be estimated using the selected MCV */
1781 stat_clauses = NIL;
1782
1783 /* record which clauses are simple (single column or expression) */
1784 simple_clauses = NULL;
1785
1786 listidx = -1;
1787 foreach(l, clauses)
1788 {
1789 /* Increment the index before we decide if to skip the clause. */
1790 listidx++;
1791
1792 /*
1793 * Ignore clauses from which we did not extract any attnums or
1794 * expressions (this needs to be consistent with what we do in
1795 * choose_best_statistics).
1796 *
1797 * This also eliminates already estimated clauses - both those
1798 * estimated before and during applying extended statistics.
1799 *
1800 * XXX This check is needed because both bms_is_subset and
1801 * stat_covers_expressions return true for empty attnums and
1802 * expressions.
1803 */
1804 if (!list_attnums[listidx] && !list_exprs[listidx])
1805 continue;
1806
1807 /*
1808 * The clause was not estimated yet, and we've extracted either
1809 * attnums or expressions from it. Ignore it if it's not fully
1810 * covered by the chosen statistics object.
1811 *
1812 * We need to check both attributes and expressions, and reject if
1813 * either is not covered.
1814 */
1815 if (!bms_is_subset(list_attnums[listidx], stat->keys) ||
1816 !stat_covers_expressions(stat, list_exprs[listidx], NULL))
1817 continue;
1818
1819 /*
1820 * Now we know the clause is compatible (we have either attnums or
1821 * expressions extracted from it), and was not estimated yet.
1822 */
1823
1824 /* record simple clauses (single column or expression) */
1825 if ((list_attnums[listidx] == NULL &&
1826 list_length(list_exprs[listidx]) == 1) ||
1827 (list_exprs[listidx] == NIL &&
1828 bms_membership(list_attnums[listidx]) == BMS_SINGLETON))
1829 simple_clauses = bms_add_member(simple_clauses,
1830 list_length(stat_clauses));
1831
1832 /* add clause to list and mark it as estimated */
1833 stat_clauses = lappend(stat_clauses, (Node *) lfirst(l));
1834 *estimatedclauses = bms_add_member(*estimatedclauses, listidx);
1835
1836 /*
1837 * Reset the pointers, so that choose_best_statistics knows this
1838 * clause was estimated and does not consider it again.
1839 */
1840 bms_free(list_attnums[listidx]);
1841 list_attnums[listidx] = NULL;
1842
1843 list_free(list_exprs[listidx]);
1844 list_exprs[listidx] = NULL;
1845 }
1846
1847 if (is_or)
1848 {
1849 bool *or_matches = NULL;
1850 Selectivity simple_or_sel = 0.0,
1851 stat_sel = 0.0;
1852 MCVList *mcv_list;
1853
1854 /* Load the MCV list stored in the statistics object */
1855 mcv_list = statext_mcv_load(stat->statOid, rte->inh);
1856
1857 /*
1858 * Compute the selectivity of the ORed list of clauses covered by
1859 * this statistics object by estimating each in turn and combining
1860 * them using the formula P(A OR B) = P(A) + P(B) - P(A AND B).
1861 * This allows us to use the multivariate MCV stats to better
1862 * estimate the individual terms and their overlap.
1863 *
1864 * Each time we iterate this formula, the clause "A" above is
1865 * equal to all the clauses processed so far, combined with "OR".
1866 */
1867 listidx = 0;
1868 foreach(l, stat_clauses)
1869 {
1870 Node *clause = (Node *) lfirst(l);
1871 Selectivity simple_sel,
1872 overlap_simple_sel,
1873 mcv_sel,
1874 mcv_basesel,
1875 overlap_mcvsel,
1876 overlap_basesel,
1877 mcv_totalsel,
1878 clause_sel,
1879 overlap_sel;
1880
1881 /*
1882 * "Simple" selectivity of the next clause and its overlap
1883 * with any of the previous clauses. These are our initial
1884 * estimates of P(B) and P(A AND B), assuming independence of
1885 * columns/clauses.
1886 */
1887 simple_sel = clause_selectivity_ext(root, clause, varRelid,
1888 jointype, sjinfo, false);
1889
1890 overlap_simple_sel = simple_or_sel * simple_sel;
1891
1892 /*
1893 * New "simple" selectivity of all clauses seen so far,
1894 * assuming independence.
1895 */
1896 simple_or_sel += simple_sel - overlap_simple_sel;
1897 CLAMP_PROBABILITY(simple_or_sel);
1898
1899 /*
1900 * Multi-column estimate of this clause using MCV statistics,
1901 * along with base and total selectivities, and corresponding
1902 * selectivities for the overlap term P(A AND B).
1903 */
1904 mcv_sel = mcv_clause_selectivity_or(root, stat, mcv_list,
1905 clause, &or_matches,
1906 &mcv_basesel,
1907 &overlap_mcvsel,
1908 &overlap_basesel,
1909 &mcv_totalsel);
1910
1911 /*
1912 * Combine the simple and multi-column estimates.
1913 *
1914 * If this clause is a simple single-column clause, then we
1915 * just use the simple selectivity estimate for it, since the
1916 * multi-column statistics are unlikely to improve on that
1917 * (and in fact could make it worse). For the overlap, we
1918 * always make use of the multi-column statistics.
1919 */
1920 if (bms_is_member(listidx, simple_clauses))
1921 clause_sel = simple_sel;
1922 else
1923 clause_sel = mcv_combine_selectivities(simple_sel,
1924 mcv_sel,
1925 mcv_basesel,
1926 mcv_totalsel);
1927
1928 overlap_sel = mcv_combine_selectivities(overlap_simple_sel,
1929 overlap_mcvsel,
1930 overlap_basesel,
1931 mcv_totalsel);
1932
1933 /* Factor these into the result for this statistics object */
1934 stat_sel += clause_sel - overlap_sel;
1935 CLAMP_PROBABILITY(stat_sel);
1936
1937 listidx++;
1938 }
1939
1940 /*
1941 * Factor the result for this statistics object into the overall
1942 * result. We treat the results from each separate statistics
1943 * object as independent of one another.
1944 */
1945 sel = sel + stat_sel - sel * stat_sel;
1946 }
1947 else /* Implicitly-ANDed list of clauses */
1948 {
1949 Selectivity simple_sel,
1950 mcv_sel,
1951 mcv_basesel,
1952 mcv_totalsel,
1953 stat_sel;
1954
1955 /*
1956 * "Simple" selectivity, i.e. without any extended statistics,
1957 * essentially assuming independence of the columns/clauses.
1958 */
1959 simple_sel = clauselist_selectivity_ext(root, stat_clauses,
1960 varRelid, jointype,
1961 sjinfo, false);
1962
1963 /*
1964 * Multi-column estimate using MCV statistics, along with base and
1965 * total selectivities.
1966 */
1967 mcv_sel = mcv_clauselist_selectivity(root, stat, stat_clauses,
1968 varRelid, jointype, sjinfo,
1969 rel, &mcv_basesel,
1970 &mcv_totalsel);
1971
1972 /* Combine the simple and multi-column estimates. */
1973 stat_sel = mcv_combine_selectivities(simple_sel,
1974 mcv_sel,
1975 mcv_basesel,
1976 mcv_totalsel);
1977
1978 /* Factor this into the overall result */
1979 sel *= stat_sel;
1980 }
1981 }
1982
1983 return sel;
1984 }
1985
1986 /*
1987 * statext_clauselist_selectivity
1988 * Estimate clauses using the best multi-column statistics.
1989 */
1990 Selectivity
1991 statext_clauselist_selectivity(PlannerInfo *root, List *clauses, int varRelid,
1992 JoinType jointype, SpecialJoinInfo *sjinfo,
1993 RelOptInfo *rel, Bitmapset **estimatedclauses,
1994 bool is_or)
1995 {
1996 Selectivity sel;
1997
1998 /* First, try estimating clauses using a multivariate MCV list. */
1999 sel = statext_mcv_clauselist_selectivity(root, clauses, varRelid, jointype,
2000 sjinfo, rel, estimatedclauses, is_or);
2001
2002 /*
2003 * Functional dependencies only work for clauses connected by AND, so for
2004 * OR clauses we're done.
2005 */
2006 if (is_or)
2007 return sel;
2008
2009 /*
2010 * Then, apply functional dependencies on the remaining clauses by calling
2011 * dependencies_clauselist_selectivity. Pass 'estimatedclauses' so the
2012 * function can properly skip clauses already estimated above.
2013 *
2014 * The reasoning for applying dependencies last is that the more complex
2015 * stats can track more complex correlations between the attributes, and
2016 * so may be considered more reliable.
2017 *
2018 * For example, MCV list can give us an exact selectivity for values in
2019 * two columns, while functional dependencies can only provide information
2020 * about the overall strength of the dependency.
2021 */
2022 sel *= dependencies_clauselist_selectivity(root, clauses, varRelid,
2023 jointype, sjinfo, rel,
2024 estimatedclauses);
2025
2026 return sel;
2027 }
2028
2029 /*
2030 * examine_opclause_args
2031 * Split an operator expression's arguments into Expr and Const parts.
2032 *
2033 * Attempts to match the arguments to either (Expr op Const) or (Const op
2034 * Expr), possibly with a RelabelType on top. When the expression matches this
2035 * form, returns true, otherwise returns false.
2036 *
2037 * Optionally returns pointers to the extracted Expr/Const nodes, when passed
2038 * non-null pointers (exprp, cstp and expronleftp). The expronleftp flag
2039 * specifies on which side of the operator we found the expression node.
2040 */
2041 bool
2042 examine_opclause_args(List *args, Node **exprp, Const **cstp,
2043 bool *expronleftp)
2044 {
2045 Node *expr;
2046 Const *cst;
2047 bool expronleft;
2048 Node *leftop,
2049 *rightop;
2050
2051 /* enforced by statext_is_compatible_clause_internal */
2052 Assert(list_length(args) == 2);
2053
2054 leftop = linitial(args);
2055 rightop = lsecond(args);
2056
2057 /* strip RelabelType from either side of the expression */
2058 if (IsA(leftop, RelabelType))
2059 leftop = (Node *) ((RelabelType *) leftop)->arg;
2060
2061 if (IsA(rightop, RelabelType))
2062 rightop = (Node *) ((RelabelType *) rightop)->arg;
2063
2064 if (IsA(rightop, Const))
2065 {
2066 expr = (Node *) leftop;
2067 cst = (Const *) rightop;
2068 expronleft = true;
2069 }
2070 else if (IsA(leftop, Const))
2071 {
2072 expr = (Node *) rightop;
2073 cst = (Const *) leftop;
2074 expronleft = false;
2075 }
2076 else
2077 return false;
2078
2079 /* return pointers to the extracted parts if requested */
2080 if (exprp)
2081 *exprp = expr;
2082
2083 if (cstp)
2084 *cstp = cst;
2085
2086 if (expronleftp)
2087 *expronleftp = expronleft;
2088
2089 return true;
2090 }
2091
2092
2093 /*
2094 * Compute statistics about expressions of a relation.
2095 */
2096 static void
2097 compute_expr_stats(Relation onerel, AnlExprData *exprdata, int nexprs,
2098 HeapTuple *rows, int numrows)
2099 {
2100 MemoryContext expr_context,
2101 old_context;
2102 int ind,
2103 i;
2104
2105 expr_context = AllocSetContextCreate(CurrentMemoryContext,
2106 "Analyze Expression",
2107 ALLOCSET_DEFAULT_SIZES);
2108 old_context = MemoryContextSwitchTo(expr_context);
2109
2110 for (ind = 0; ind < nexprs; ind++)
2111 {
2112 AnlExprData *thisdata = &exprdata[ind];
2113 VacAttrStats *stats = thisdata->vacattrstat;
2114 Node *expr = thisdata->expr;
2115 TupleTableSlot *slot;
2116 EState *estate;
2117 ExprContext *econtext;
2118 Datum *exprvals;
2119 bool *exprnulls;
2120 ExprState *exprstate;
2121 int tcnt;
2122
2123 /* Are we still in the main context? */
2124 Assert(CurrentMemoryContext == expr_context);
2125
2126 /*
2127 * Need an EState for evaluation of expressions. Create it in the
2128 * per-expression context to be sure it gets cleaned up at the bottom
2129 * of the loop.
2130 */
2131 estate = CreateExecutorState();
2132 econtext = GetPerTupleExprContext(estate);
2133
2134 /* Set up expression evaluation state */
2135 exprstate = ExecPrepareExpr((Expr *) expr, estate);
2136
2137 /* Need a slot to hold the current heap tuple, too */
2138 slot = MakeSingleTupleTableSlot(RelationGetDescr(onerel),
2139 &TTSOpsHeapTuple);
2140
2141 /* Arrange for econtext's scan tuple to be the tuple under test */
2142 econtext->ecxt_scantuple = slot;
2143
2144 /* Compute and save expression values */
2145 exprvals = (Datum *) palloc(numrows * sizeof(Datum));
2146 exprnulls = (bool *) palloc(numrows * sizeof(bool));
2147
2148 tcnt = 0;
2149 for (i = 0; i < numrows; i++)
2150 {
2151 Datum datum;
2152 bool isnull;
2153
2154 /*
2155 * Reset the per-tuple context each time, to reclaim any cruft
2156 * left behind by evaluating the statistics expressions.
2157 */
2158 ResetExprContext(econtext);
2159
2160 /* Set up for expression evaluation */
2161 ExecStoreHeapTuple(rows[i], slot, false);
2162
2163 /*
2164 * Evaluate the expression. We do this in the per-tuple context so
2165 * as not to leak memory, and then copy the result into the
2166 * context created at the beginning of this function.
2167 */
2168 datum = ExecEvalExprSwitchContext(exprstate,
2169 GetPerTupleExprContext(estate),
2170 &isnull);
2171 if (isnull)
2172 {
2173 exprvals[tcnt] = (Datum) 0;
2174 exprnulls[tcnt] = true;
2175 }
2176 else
2177 {
2178 /* Make sure we copy the data into the context. */
2179 Assert(CurrentMemoryContext == expr_context);
2180
2181 exprvals[tcnt] = datumCopy(datum,
2182 stats->attrtype->typbyval,
2183 stats->attrtype->typlen);
2184 exprnulls[tcnt] = false;
2185 }
2186
2187 tcnt++;
2188 }
2189
2190 /*
2191 * Now we can compute the statistics for the expression columns.
2192 *
2193 * XXX Unlike compute_index_stats we don't need to switch and reset
2194 * memory contexts here, because we're only computing stats for a
2195 * single expression (and not iterating over many indexes), so we just
2196 * do it in expr_context. Note that compute_stats copies the result
2197 * into stats->anl_context, so it does not disappear.
2198 */
2199 if (tcnt > 0)
2200 {
2201 AttributeOpts *aopt =
2202 get_attribute_options(onerel->rd_id, stats->tupattnum);
2203
2204 stats->exprvals = exprvals;
2205 stats->exprnulls = exprnulls;
2206 stats->rowstride = 1;
2207 stats->compute_stats(stats,
2208 expr_fetch_func,
2209 tcnt,
2210 tcnt);
2211
2212 /*
2213 * If the n_distinct option is specified, it overrides the above
2214 * computation.
2215 */
2216 if (aopt != NULL && aopt->n_distinct != 0.0)
2217 stats->stadistinct = aopt->n_distinct;
2218 }
2219
2220 /* And clean up */
2221 MemoryContextSwitchTo(expr_context);
2222
2223 ExecDropSingleTupleTableSlot(slot);
2224 FreeExecutorState(estate);
2225 MemoryContextReset(expr_context);
2226 }
2227
2228 MemoryContextSwitchTo(old_context);
2229 MemoryContextDelete(expr_context);
2230 }
2231
2232
2233 /*
2234 * Fetch function for analyzing statistics object expressions.
2235 *
2236 * We have not bothered to construct tuples from the data, instead the data
2237 * is just in Datum arrays.
2238 */
2239 static Datum
2240 expr_fetch_func(VacAttrStatsP stats, int rownum, bool *isNull)
2241 {
2242 int i;
2243
2244 /* exprvals and exprnulls are already offset for proper column */
2245 i = rownum * stats->rowstride;
2246 *isNull = stats->exprnulls[i];
2247 return stats->exprvals[i];
2248 }
2249
2250 /*
2251 * Build analyze data for a list of expressions. As this is not tied
2252 * directly to a relation (table or index), we have to fake some of
2253 * the fields in examine_expression().
2254 */
2255 static AnlExprData *
2256 build_expr_data(List *exprs, int stattarget)
2257 {
2258 int idx;
2259 int nexprs = list_length(exprs);
2260 AnlExprData *exprdata;
2261 ListCell *lc;
2262
2263 exprdata = (AnlExprData *) palloc0(nexprs * sizeof(AnlExprData));
2264
2265 idx = 0;
2266 foreach(lc, exprs)
2267 {
2268 Node *expr = (Node *) lfirst(lc);
2269 AnlExprData *thisdata = &exprdata[idx];
2270
2271 thisdata->expr = expr;
2272 thisdata->vacattrstat = examine_expression(expr, stattarget);
2273 idx++;
2274 }
2275
2276 return exprdata;
2277 }
2278
2279 /* form an array of pg_statistic rows (per update_attstats) */
2280 static Datum
2281 serialize_expr_stats(AnlExprData *exprdata, int nexprs)
2282 {
2283 int exprno;
2284 Oid typOid;
2285 Relation sd;
2286
2287 ArrayBuildState *astate = NULL;
2288
2289 sd = table_open(StatisticRelationId, RowExclusiveLock);
2290
2291 /* lookup OID of composite type for pg_statistic */
2292 typOid = get_rel_type_id(StatisticRelationId);
2293 if (!OidIsValid(typOid))
2294 ereport(ERROR,
2295 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
2296 errmsg("relation \"%s\" does not have a composite type",
2297 "pg_statistic")));
2298
2299 for (exprno = 0; exprno < nexprs; exprno++)
2300 {
2301 int i,
2302 k;
2303 VacAttrStats *stats = exprdata[exprno].vacattrstat;
2304
2305 Datum values[Natts_pg_statistic];
2306 bool nulls[Natts_pg_statistic];
2307 HeapTuple stup;
2308
2309 if (!stats->stats_valid)
2310 {
2311 astate = accumArrayResult(astate,
2312 (Datum) 0,
2313 true,
2314 typOid,
2315 CurrentMemoryContext);
2316 continue;
2317 }
2318
2319 /*
2320 * Construct a new pg_statistic tuple
2321 */
2322 for (i = 0; i < Natts_pg_statistic; ++i)
2323 {
2324 nulls[i] = false;
2325 }
2326
2327 values[Anum_pg_statistic_starelid - 1] = ObjectIdGetDatum(InvalidOid);
2328 values[Anum_pg_statistic_staattnum - 1] = Int16GetDatum(InvalidAttrNumber);
2329 values[Anum_pg_statistic_stainherit - 1] = BoolGetDatum(false);
2330 values[Anum_pg_statistic_stanullfrac - 1] = Float4GetDatum(stats->stanullfrac);
2331 values[Anum_pg_statistic_stawidth - 1] = Int32GetDatum(stats->stawidth);
2332 values[Anum_pg_statistic_stadistinct - 1] = Float4GetDatum(stats->stadistinct);
2333 i = Anum_pg_statistic_stakind1 - 1;
2334 for (k = 0; k < STATISTIC_NUM_SLOTS; k++)
2335 {
2336 values[i++] = Int16GetDatum(stats->stakind[k]); /* stakindN */
2337 }
2338 i = Anum_pg_statistic_staop1 - 1;
2339 for (k = 0; k < STATISTIC_NUM_SLOTS; k++)
2340 {
2341 values[i++] = ObjectIdGetDatum(stats->staop[k]); /* staopN */
2342 }
2343 i = Anum_pg_statistic_stacoll1 - 1;
2344 for (k = 0; k < STATISTIC_NUM_SLOTS; k++)
2345 {
2346 values[i++] = ObjectIdGetDatum(stats->stacoll[k]); /* stacollN */
2347 }
2348 i = Anum_pg_statistic_stanumbers1 - 1;
2349 for (k = 0; k < STATISTIC_NUM_SLOTS; k++)
2350 {
2351 int nnum = stats->numnumbers[k];
2352
2353 if (nnum > 0)
2354 {
2355 int n;
2356 Datum *numdatums = (Datum *) palloc(nnum * sizeof(Datum));
2357 ArrayType *arry;
2358
2359 for (n = 0; n < nnum; n++)
2360 numdatums[n] = Float4GetDatum(stats->stanumbers[k][n]);
2361 arry = construct_array_builtin(numdatums, nnum, FLOAT4OID);
2362 values[i++] = PointerGetDatum(arry); /* stanumbersN */
2363 }
2364 else
2365 {
2366 nulls[i] = true;
2367 values[i++] = (Datum) 0;
2368 }
2369 }
2370 i = Anum_pg_statistic_stavalues1 - 1;
2371 for (k = 0; k < STATISTIC_NUM_SLOTS; k++)
2372 {
2373 if (stats->numvalues[k] > 0)
2374 {
2375 ArrayType *arry;
2376
2377 arry = construct_array(stats->stavalues[k],
2378 stats->numvalues[k],
2379 stats->statypid[k],
2380 stats->statyplen[k],
2381 stats->statypbyval[k],
2382 stats->statypalign[k]);
2383 values[i++] = PointerGetDatum(arry); /* stavaluesN */
2384 }
2385 else
2386 {
2387 nulls[i] = true;
2388 values[i++] = (Datum) 0;
2389 }
2390 }
2391
2392 stup = heap_form_tuple(RelationGetDescr(sd), values, nulls);
2393
2394 astate = accumArrayResult(astate,
2395 heap_copy_tuple_as_datum(stup, RelationGetDescr(sd)),
2396 false,
2397 typOid,
2398 CurrentMemoryContext);
2399 }
2400
2401 table_close(sd, RowExclusiveLock);
2402
2403 return makeArrayResult(astate, CurrentMemoryContext);
2404 }
2405
2406 /*
2407 * Loads pg_statistic record from expression statistics for expression
2408 * identified by the supplied index.
2409 *
2410 * Returns the pg_statistic record found, or NULL if there is no statistics
2411 * data to use.
2412 */
2413 HeapTuple
2414 statext_expressions_load(Oid stxoid, bool inh, int idx)
2415 {
2416 bool isnull;
2417 Datum value;
2418 HeapTuple htup;
2419 ExpandedArrayHeader *eah;
2420 HeapTupleHeader td;
2421 HeapTupleData tmptup;
2422 HeapTuple tup;
2423
2424 htup = SearchSysCache2(STATEXTDATASTXOID,
2425 ObjectIdGetDatum(stxoid), BoolGetDatum(inh));
2426 if (!HeapTupleIsValid(htup))
2427 elog(ERROR, "cache lookup failed for statistics object %u", stxoid);
2428
2429 value = SysCacheGetAttr(STATEXTDATASTXOID, htup,
2430 Anum_pg_statistic_ext_data_stxdexpr, &isnull);
2431 if (isnull)
2432 elog(ERROR,
2433 "requested statistics kind \"%c\" is not yet built for statistics object %u",
2434 STATS_EXT_EXPRESSIONS, stxoid);
2435
2436 eah = DatumGetExpandedArray(value);
2437
2438 deconstruct_expanded_array(eah);
2439
2440 if (eah->dnulls && eah->dnulls[idx])
2441 {
2442 /* No data found for this expression, give up. */
2443 ReleaseSysCache(htup);
2444 return NULL;
2445 }
2446
2447 td = DatumGetHeapTupleHeader(eah->dvalues[idx]);
2448
2449 /* Build a temporary HeapTuple control structure */
2450 tmptup.t_len = HeapTupleHeaderGetDatumLength(td);
2451 ItemPointerSetInvalid(&(tmptup.t_self));
2452 tmptup.t_tableOid = InvalidOid;
2453 tmptup.t_data = td;
2454
2455 tup = heap_copytuple(&tmptup);
2456
2457 ReleaseSysCache(htup);
2458
2459 return tup;
2460 }
2461
2462 /*
2463 * Evaluate the expressions, so that we can use the results to build
2464 * all the requested statistics types. This matters especially for
2465 * expensive expressions, of course.
2466 */
2467 static StatsBuildData *
2468 make_build_data(Relation rel, StatExtEntry *stat, int numrows, HeapTuple *rows,
2469 VacAttrStats **stats, int stattarget)
2470 {
2471 /* evaluated expressions */
2472 StatsBuildData *result;
2473 char *ptr;
2474 Size len;
2475
2476 int i;
2477 int k;
2478 int idx;
2479 TupleTableSlot *slot;
2480 EState *estate;
2481 ExprContext *econtext;
2482 List *exprstates = NIL;
2483 int nkeys = bms_num_members(stat->columns) + list_length(stat->exprs);
2484 ListCell *lc;
2485
2486 /* allocate everything as a single chunk, so we can free it easily */
2487 len = MAXALIGN(sizeof(StatsBuildData));
2488 len += MAXALIGN(sizeof(AttrNumber) * nkeys); /* attnums */
2489 len += MAXALIGN(sizeof(VacAttrStats *) * nkeys); /* stats */
2490
2491 /* values */
2492 len += MAXALIGN(sizeof(Datum *) * nkeys);
2493 len += nkeys * MAXALIGN(sizeof(Datum) * numrows);
2494
2495 /* nulls */
2496 len += MAXALIGN(sizeof(bool *) * nkeys);
2497 len += nkeys * MAXALIGN(sizeof(bool) * numrows);
2498
2499 ptr = palloc(len);
2500
2501 /* set the pointers */
2502 result = (StatsBuildData *) ptr;
2503 ptr += MAXALIGN(sizeof(StatsBuildData));
2504
2505 /* attnums */
2506 result->attnums = (AttrNumber *) ptr;
2507 ptr += MAXALIGN(sizeof(AttrNumber) * nkeys);
2508
2509 /* stats */
2510 result->stats = (VacAttrStats **) ptr;
2511 ptr += MAXALIGN(sizeof(VacAttrStats *) * nkeys);
2512
2513 /* values */
2514 result->values = (Datum **) ptr;
2515 ptr += MAXALIGN(sizeof(Datum *) * nkeys);
2516
2517 /* nulls */
2518 result->nulls = (bool **) ptr;
2519 ptr += MAXALIGN(sizeof(bool *) * nkeys);
2520
2521 for (i = 0; i < nkeys; i++)
2522 {
2523 result->values[i] = (Datum *) ptr;
2524 ptr += MAXALIGN(sizeof(Datum) * numrows);
2525
2526 result->nulls[i] = (bool *) ptr;
2527 ptr += MAXALIGN(sizeof(bool) * numrows);
2528 }
2529
2530 Assert((ptr - (char *) result) == len);
2531
2532 /* we have it allocated, so let's fill the values */
2533 result->nattnums = nkeys;
2534 result->numrows = numrows;
2535
2536 /* fill the attribute info - first attributes, then expressions */
2537 idx = 0;
2538 k = -1;
2539 while ((k = bms_next_member(stat->columns, k)) >= 0)
2540 {
2541 result->attnums[idx] = k;
2542 result->stats[idx] = stats[idx];
2543
2544 idx++;
2545 }
2546
2547 k = -1;
2548 foreach(lc, stat->exprs)
2549 {
2550 Node *expr = (Node *) lfirst(lc);
2551
2552 result->attnums[idx] = k;
2553 result->stats[idx] = examine_expression(expr, stattarget);
2554
2555 idx++;
2556 k--;
2557 }
2558
2559 /* first extract values for all the regular attributes */
2560 for (i = 0; i < numrows; i++)
2561 {
2562 idx = 0;
2563 k = -1;
2564 while ((k = bms_next_member(stat->columns, k)) >= 0)
2565 {
2566 result->values[idx][i] = heap_getattr(rows[i], k,
2567 result->stats[idx]->tupDesc,
2568 &result->nulls[idx][i]);
2569
2570 idx++;
2571 }
2572 }
2573
2574 /* Need an EState for evaluation expressions. */
2575 estate = CreateExecutorState();
2576 econtext = GetPerTupleExprContext(estate);
2577
2578 /* Need a slot to hold the current heap tuple, too */
2579 slot = MakeSingleTupleTableSlot(RelationGetDescr(rel),
2580 &TTSOpsHeapTuple);
2581
2582 /* Arrange for econtext's scan tuple to be the tuple under test */
2583 econtext->ecxt_scantuple = slot;
2584
2585 /* Set up expression evaluation state */
2586 exprstates = ExecPrepareExprList(stat->exprs, estate);
2587
2588 for (i = 0; i < numrows; i++)
2589 {
2590 /*
2591 * Reset the per-tuple context each time, to reclaim any cruft left
2592 * behind by evaluating the statistics object expressions.
2593 */
2594 ResetExprContext(econtext);
2595
2596 /* Set up for expression evaluation */
2597 ExecStoreHeapTuple(rows[i], slot, false);
2598
2599 idx = bms_num_members(stat->columns);
2600 foreach(lc, exprstates)
2601 {
2602 Datum datum;
2603 bool isnull;
2604 ExprState *exprstate = (ExprState *) lfirst(lc);
2605
2606 /*
2607 * XXX This probably leaks memory. Maybe we should use
2608 * ExecEvalExprSwitchContext but then we need to copy the result
2609 * somewhere else.
2610 */
2611 datum = ExecEvalExpr(exprstate,
2612 GetPerTupleExprContext(estate),
2613 &isnull);
2614 if (isnull)
2615 {
2616 result->values[idx][i] = (Datum) 0;
2617 result->nulls[idx][i] = true;
2618 }
2619 else
2620 {
2621 result->values[idx][i] = (Datum) datum;
2622 result->nulls[idx][i] = false;
2623 }
2624
2625 idx++;
2626 }
2627 }
2628
2629 ExecDropSingleTupleTableSlot(slot);
2630 FreeExecutorState(estate);
2631
2632 return result;
2633 }