PostgreSQL Source Code  git master
array_typanalyze.c File Reference
#include "postgres.h"
#include "access/detoast.h"
#include "commands/vacuum.h"
#include "utils/array.h"
#include "utils/builtins.h"
#include "utils/datum.h"
#include "utils/lsyscache.h"
#include "utils/typcache.h"
Include dependency graph for array_typanalyze.c:

Go to the source code of this file.

Data Structures

struct  ArrayAnalyzeExtraData
 
struct  TrackItem
 
struct  DECountItem
 

Macros

#define ARRAY_WIDTH_THRESHOLD   0x10000
 

Functions

static void compute_array_stats (VacAttrStats *stats, AnalyzeAttrFetchFunc fetchfunc, int samplerows, double totalrows)
 
static void prune_element_hashtable (HTAB *elements_tab, int b_current)
 
static uint32 element_hash (const void *key, Size keysize)
 
static int element_match (const void *key1, const void *key2, Size keysize)
 
static int element_compare (const void *key1, const void *key2)
 
static int trackitem_compare_frequencies_desc (const void *e1, const void *e2)
 
static int trackitem_compare_element (const void *e1, const void *e2)
 
static int countitem_compare_count (const void *e1, const void *e2)
 
Datum array_typanalyze (PG_FUNCTION_ARGS)
 

Variables

static ArrayAnalyzeExtraDataarray_extra_data
 

Macro Definition Documentation

◆ ARRAY_WIDTH_THRESHOLD

#define ARRAY_WIDTH_THRESHOLD   0x10000

Definition at line 33 of file array_typanalyze.c.

Referenced by compute_array_stats().

Function Documentation

◆ array_typanalyze()

Datum array_typanalyze ( PG_FUNCTION_ARGS  )

Definition at line 98 of file array_typanalyze.c.

References VacAttrStats::attrcollid, VacAttrStats::attrtypid, ArrayAnalyzeExtraData::cmp, TypeCacheEntry::cmp_proc_finfo, ArrayAnalyzeExtraData::coll_id, compute_array_stats(), VacAttrStats::compute_stats, elog, ArrayAnalyzeExtraData::eq_opr, TypeCacheEntry::eq_opr, ERROR, VacAttrStats::extra_data, FmgrInfo::fn_oid, get_base_element_type(), ArrayAnalyzeExtraData::hash, TypeCacheEntry::hash_proc_finfo, lookup_type_cache(), OidIsValid, palloc(), PG_GETARG_POINTER, PG_RETURN_BOOL, ArrayAnalyzeExtraData::std_compute_stats, ArrayAnalyzeExtraData::std_extra_data, std_typanalyze(), TypeCacheEntry::typalign, ArrayAnalyzeExtraData::typalign, TypeCacheEntry::typbyval, ArrayAnalyzeExtraData::typbyval, TypeCacheEntry::type_id, ArrayAnalyzeExtraData::type_id, TYPECACHE_CMP_PROC_FINFO, TYPECACHE_EQ_OPR, TYPECACHE_HASH_PROC_FINFO, TypeCacheEntry::typlen, and ArrayAnalyzeExtraData::typlen.

99 {
101  Oid element_typeid;
102  TypeCacheEntry *typentry;
103  ArrayAnalyzeExtraData *extra_data;
104 
105  /*
106  * Call the standard typanalyze function. It may fail to find needed
107  * operators, in which case we also can't do anything, so just fail.
108  */
109  if (!std_typanalyze(stats))
110  PG_RETURN_BOOL(false);
111 
112  /*
113  * Check attribute data type is a varlena array (or a domain over one).
114  */
115  element_typeid = get_base_element_type(stats->attrtypid);
116  if (!OidIsValid(element_typeid))
117  elog(ERROR, "array_typanalyze was invoked for non-array type %u",
118  stats->attrtypid);
119 
120  /*
121  * Gather information about the element type. If we fail to find
122  * something, return leaving the state from std_typanalyze() in place.
123  */
124  typentry = lookup_type_cache(element_typeid,
128 
129  if (!OidIsValid(typentry->eq_opr) ||
130  !OidIsValid(typentry->cmp_proc_finfo.fn_oid) ||
131  !OidIsValid(typentry->hash_proc_finfo.fn_oid))
132  PG_RETURN_BOOL(true);
133 
134  /* Store our findings for use by compute_array_stats() */
135  extra_data = (ArrayAnalyzeExtraData *) palloc(sizeof(ArrayAnalyzeExtraData));
136  extra_data->type_id = typentry->type_id;
137  extra_data->eq_opr = typentry->eq_opr;
138  extra_data->coll_id = stats->attrcollid; /* collation we should use */
139  extra_data->typbyval = typentry->typbyval;
140  extra_data->typlen = typentry->typlen;
141  extra_data->typalign = typentry->typalign;
142  extra_data->cmp = &typentry->cmp_proc_finfo;
143  extra_data->hash = &typentry->hash_proc_finfo;
144 
145  /* Save old compute_stats and extra_data for scalar statistics ... */
146  extra_data->std_compute_stats = stats->compute_stats;
147  extra_data->std_extra_data = stats->extra_data;
148 
149  /* ... and replace with our info */
151  stats->extra_data = extra_data;
152 
153  /*
154  * Note we leave stats->minrows set as std_typanalyze set it. Should it
155  * be increased for array analysis purposes?
156  */
157 
158  PG_RETURN_BOOL(true);
159 }
#define TYPECACHE_HASH_PROC_FINFO
Definition: typcache.h:143
static void compute_array_stats(VacAttrStats *stats, AnalyzeAttrFetchFunc fetchfunc, int samplerows, double totalrows)
#define TYPECACHE_EQ_OPR
Definition: typcache.h:136
#define PG_GETARG_POINTER(n)
Definition: fmgr.h:276
bool std_typanalyze(VacAttrStats *stats)
Definition: analyze.c:1872
unsigned int Oid
Definition: postgres_ext.h:31
int16 typlen
Definition: typcache.h:39
bool typbyval
Definition: typcache.h:40
#define OidIsValid(objectId)
Definition: c.h:710
FmgrInfo cmp_proc_finfo
Definition: typcache.h:76
Oid attrtypid
Definition: vacuum.h:124
#define ERROR
Definition: elog.h:46
AnalyzeAttrComputeStatsFunc std_compute_stats
FmgrInfo hash_proc_finfo
Definition: typcache.h:77
#define PG_RETURN_BOOL(x)
Definition: fmgr.h:359
TypeCacheEntry * lookup_type_cache(Oid type_id, int flags)
Definition: typcache.c:338
Oid fn_oid
Definition: fmgr.h:59
Oid attrcollid
Definition: vacuum.h:127
Oid get_base_element_type(Oid typid)
Definition: lsyscache.c:2779
char typalign
Definition: typcache.h:41
void * palloc(Size size)
Definition: mcxt.c:1062
#define elog(elevel,...)
Definition: elog.h:232
AnalyzeAttrComputeStatsFunc compute_stats
Definition: vacuum.h:134
#define TYPECACHE_CMP_PROC_FINFO
Definition: typcache.h:142
void * extra_data
Definition: vacuum.h:136

◆ compute_array_stats()

static void compute_array_stats ( VacAttrStats stats,
AnalyzeAttrFetchFunc  fetchfunc,
int  samplerows,
double  totalrows 
)
static

Definition at line 216 of file array_typanalyze.c.

References VacAttrStats::anl_context, ARR_ELEMTYPE, ARRAY_WIDTH_THRESHOLD, Assert, VacAttrStats::attr, ArrayAnalyzeExtraData::coll_id, DECountItem::count, countitem_compare_count(), CurrentMemoryContext, datumCopy(), DatumGetArrayTypeP, DEBUG3, deconstruct_array(), TrackItem::delta, element_hash(), element_match(), elog, HASHCTL::entrysize, ArrayAnalyzeExtraData::eq_opr, ERROR, VacAttrStats::extra_data, TrackItem::frequency, DECountItem::frequency, HASHCTL::hash, HASH_BLOBS, HASH_COMPARE, HASH_CONTEXT, hash_create(), HASH_ELEM, HASH_ENTER, HASH_FUNCTION, hash_get_num_entries(), hash_search(), hash_seq_init(), hash_seq_search(), HASHCTL::hcxt, i, INT64_FORMAT, TrackItem::key, HASHCTL::keysize, TrackItem::last_container, HASHCTL::match, Max, MemoryContextAlloc(), MemoryContextSwitchTo(), Min, VacAttrStats::numnumbers, VacAttrStats::numvalues, palloc(), pfree(), PointerGetDatum, prune_element_hashtable(), qsort, VacAttrStats::stacoll, VacAttrStats::stakind, VacAttrStats::stanumbers, VacAttrStats::staop, STATISTIC_NUM_SLOTS, VacAttrStats::statypalign, VacAttrStats::statypbyval, VacAttrStats::statypid, VacAttrStats::statyplen, VacAttrStats::stavalues, ArrayAnalyzeExtraData::std_compute_stats, ArrayAnalyzeExtraData::std_extra_data, toast_raw_datum_size(), trackitem_compare_element(), trackitem_compare_frequencies_desc(), ArrayAnalyzeExtraData::typalign, ArrayAnalyzeExtraData::typbyval, ArrayAnalyzeExtraData::type_id, ArrayAnalyzeExtraData::typlen, vacuum_delay_point(), and value.

Referenced by array_typanalyze().

218 {
219  ArrayAnalyzeExtraData *extra_data;
220  int num_mcelem;
221  int null_cnt = 0;
222  int null_elem_cnt = 0;
223  int analyzed_rows = 0;
224 
225  /* This is D from the LC algorithm. */
226  HTAB *elements_tab;
227  HASHCTL elem_hash_ctl;
228  HASH_SEQ_STATUS scan_status;
229 
230  /* This is the current bucket number from the LC algorithm */
231  int b_current;
232 
233  /* This is 'w' from the LC algorithm */
234  int bucket_width;
235  int array_no;
236  int64 element_no;
237  TrackItem *item;
238  int slot_idx;
239  HTAB *count_tab;
240  HASHCTL count_hash_ctl;
241  DECountItem *count_item;
242 
243  extra_data = (ArrayAnalyzeExtraData *) stats->extra_data;
244 
245  /*
246  * Invoke analyze.c's standard analysis function to create scalar-style
247  * stats for the column. It will expect its own extra_data pointer, so
248  * temporarily install that.
249  */
250  stats->extra_data = extra_data->std_extra_data;
251  extra_data->std_compute_stats(stats, fetchfunc, samplerows, totalrows);
252  stats->extra_data = extra_data;
253 
254  /*
255  * Set up static pointer for use by subroutines. We wait till here in
256  * case std_compute_stats somehow recursively invokes us (probably not
257  * possible, but ...)
258  */
259  array_extra_data = extra_data;
260 
261  /*
262  * We want statistics_target * 10 elements in the MCELEM array. This
263  * multiplier is pretty arbitrary, but is meant to reflect the fact that
264  * the number of individual elements tracked in pg_statistic ought to be
265  * more than the number of values for a simple scalar column.
266  */
267  num_mcelem = stats->attr->attstattarget * 10;
268 
269  /*
270  * We set bucket width equal to num_mcelem / 0.007 as per the comment
271  * above.
272  */
273  bucket_width = num_mcelem * 1000 / 7;
274 
275  /*
276  * Create the hashtable. It will be in local memory, so we don't need to
277  * worry about overflowing the initial size. Also we don't need to pay any
278  * attention to locking and memory management.
279  */
280  elem_hash_ctl.keysize = sizeof(Datum);
281  elem_hash_ctl.entrysize = sizeof(TrackItem);
282  elem_hash_ctl.hash = element_hash;
283  elem_hash_ctl.match = element_match;
284  elem_hash_ctl.hcxt = CurrentMemoryContext;
285  elements_tab = hash_create("Analyzed elements table",
286  num_mcelem,
287  &elem_hash_ctl,
289 
290  /* hashtable for array distinct elements counts */
291  count_hash_ctl.keysize = sizeof(int);
292  count_hash_ctl.entrysize = sizeof(DECountItem);
293  count_hash_ctl.hcxt = CurrentMemoryContext;
294  count_tab = hash_create("Array distinct element count table",
295  64,
296  &count_hash_ctl,
298 
299  /* Initialize counters. */
300  b_current = 1;
301  element_no = 0;
302 
303  /* Loop over the arrays. */
304  for (array_no = 0; array_no < samplerows; array_no++)
305  {
306  Datum value;
307  bool isnull;
308  ArrayType *array;
309  int num_elems;
310  Datum *elem_values;
311  bool *elem_nulls;
312  bool null_present;
313  int j;
314  int64 prev_element_no = element_no;
315  int distinct_count;
316  bool count_item_found;
317 
319 
320  value = fetchfunc(stats, array_no, &isnull);
321  if (isnull)
322  {
323  /* array is null, just count that */
324  null_cnt++;
325  continue;
326  }
327 
328  /* Skip too-large values. */
330  continue;
331  else
332  analyzed_rows++;
333 
334  /*
335  * Now detoast the array if needed, and deconstruct into datums.
336  */
337  array = DatumGetArrayTypeP(value);
338 
339  Assert(ARR_ELEMTYPE(array) == extra_data->type_id);
340  deconstruct_array(array,
341  extra_data->type_id,
342  extra_data->typlen,
343  extra_data->typbyval,
344  extra_data->typalign,
345  &elem_values, &elem_nulls, &num_elems);
346 
347  /*
348  * We loop through the elements in the array and add them to our
349  * tracking hashtable.
350  */
351  null_present = false;
352  for (j = 0; j < num_elems; j++)
353  {
354  Datum elem_value;
355  bool found;
356 
357  /* No null element processing other than flag setting here */
358  if (elem_nulls[j])
359  {
360  null_present = true;
361  continue;
362  }
363 
364  /* Lookup current element in hashtable, adding it if new */
365  elem_value = elem_values[j];
366  item = (TrackItem *) hash_search(elements_tab,
367  (const void *) &elem_value,
368  HASH_ENTER, &found);
369 
370  if (found)
371  {
372  /* The element value is already on the tracking list */
373 
374  /*
375  * The operators we assist ignore duplicate array elements, so
376  * count a given distinct element only once per array.
377  */
378  if (item->last_container == array_no)
379  continue;
380 
381  item->frequency++;
382  item->last_container = array_no;
383  }
384  else
385  {
386  /* Initialize new tracking list element */
387 
388  /*
389  * If element type is pass-by-reference, we must copy it into
390  * palloc'd space, so that we can release the array below. (We
391  * do this so that the space needed for element values is
392  * limited by the size of the hashtable; if we kept all the
393  * array values around, it could be much more.)
394  */
395  item->key = datumCopy(elem_value,
396  extra_data->typbyval,
397  extra_data->typlen);
398 
399  item->frequency = 1;
400  item->delta = b_current - 1;
401  item->last_container = array_no;
402  }
403 
404  /* element_no is the number of elements processed (ie N) */
405  element_no++;
406 
407  /* We prune the D structure after processing each bucket */
408  if (element_no % bucket_width == 0)
409  {
410  prune_element_hashtable(elements_tab, b_current);
411  b_current++;
412  }
413  }
414 
415  /* Count null element presence once per array. */
416  if (null_present)
417  null_elem_cnt++;
418 
419  /* Update frequency of the particular array distinct element count. */
420  distinct_count = (int) (element_no - prev_element_no);
421  count_item = (DECountItem *) hash_search(count_tab, &distinct_count,
422  HASH_ENTER,
423  &count_item_found);
424 
425  if (count_item_found)
426  count_item->frequency++;
427  else
428  count_item->frequency = 1;
429 
430  /* Free memory allocated while detoasting. */
431  if (PointerGetDatum(array) != value)
432  pfree(array);
433  pfree(elem_values);
434  pfree(elem_nulls);
435  }
436 
437  /* Skip pg_statistic slots occupied by standard statistics */
438  slot_idx = 0;
439  while (slot_idx < STATISTIC_NUM_SLOTS && stats->stakind[slot_idx] != 0)
440  slot_idx++;
441  if (slot_idx > STATISTIC_NUM_SLOTS - 2)
442  elog(ERROR, "insufficient pg_statistic slots for array stats");
443 
444  /* We can only compute real stats if we found some non-null values. */
445  if (analyzed_rows > 0)
446  {
447  int nonnull_cnt = analyzed_rows;
448  int count_items_count;
449  int i;
450  TrackItem **sort_table;
451  int track_len;
452  int64 cutoff_freq;
453  int64 minfreq,
454  maxfreq;
455 
456  /*
457  * We assume the standard stats code already took care of setting
458  * stats_valid, stanullfrac, stawidth, stadistinct. We'd have to
459  * re-compute those values if we wanted to not store the standard
460  * stats.
461  */
462 
463  /*
464  * Construct an array of the interesting hashtable items, that is,
465  * those meeting the cutoff frequency (s - epsilon)*N. Also identify
466  * the minimum and maximum frequencies among these items.
467  *
468  * Since epsilon = s/10 and bucket_width = 1/epsilon, the cutoff
469  * frequency is 9*N / bucket_width.
470  */
471  cutoff_freq = 9 * element_no / bucket_width;
472 
473  i = hash_get_num_entries(elements_tab); /* surely enough space */
474  sort_table = (TrackItem **) palloc(sizeof(TrackItem *) * i);
475 
476  hash_seq_init(&scan_status, elements_tab);
477  track_len = 0;
478  minfreq = element_no;
479  maxfreq = 0;
480  while ((item = (TrackItem *) hash_seq_search(&scan_status)) != NULL)
481  {
482  if (item->frequency > cutoff_freq)
483  {
484  sort_table[track_len++] = item;
485  minfreq = Min(minfreq, item->frequency);
486  maxfreq = Max(maxfreq, item->frequency);
487  }
488  }
489  Assert(track_len <= i);
490 
491  /* emit some statistics for debug purposes */
492  elog(DEBUG3, "compute_array_stats: target # mces = %d, "
493  "bucket width = %d, "
494  "# elements = " INT64_FORMAT ", hashtable size = %d, "
495  "usable entries = %d",
496  num_mcelem, bucket_width, element_no, i, track_len);
497 
498  /*
499  * If we obtained more elements than we really want, get rid of those
500  * with least frequencies. The easiest way is to qsort the array into
501  * descending frequency order and truncate the array.
502  */
503  if (num_mcelem < track_len)
504  {
505  qsort(sort_table, track_len, sizeof(TrackItem *),
507  /* reset minfreq to the smallest frequency we're keeping */
508  minfreq = sort_table[num_mcelem - 1]->frequency;
509  }
510  else
511  num_mcelem = track_len;
512 
513  /* Generate MCELEM slot entry */
514  if (num_mcelem > 0)
515  {
516  MemoryContext old_context;
517  Datum *mcelem_values;
518  float4 *mcelem_freqs;
519 
520  /*
521  * We want to store statistics sorted on the element value using
522  * the element type's default comparison function. This permits
523  * fast binary searches in selectivity estimation functions.
524  */
525  qsort(sort_table, num_mcelem, sizeof(TrackItem *),
527 
528  /* Must copy the target values into anl_context */
529  old_context = MemoryContextSwitchTo(stats->anl_context);
530 
531  /*
532  * We sorted statistics on the element value, but we want to be
533  * able to find the minimal and maximal frequencies without going
534  * through all the values. We also want the frequency of null
535  * elements. Store these three values at the end of mcelem_freqs.
536  */
537  mcelem_values = (Datum *) palloc(num_mcelem * sizeof(Datum));
538  mcelem_freqs = (float4 *) palloc((num_mcelem + 3) * sizeof(float4));
539 
540  /*
541  * See comments above about use of nonnull_cnt as the divisor for
542  * the final frequency estimates.
543  */
544  for (i = 0; i < num_mcelem; i++)
545  {
546  TrackItem *item = sort_table[i];
547 
548  mcelem_values[i] = datumCopy(item->key,
549  extra_data->typbyval,
550  extra_data->typlen);
551  mcelem_freqs[i] = (double) item->frequency /
552  (double) nonnull_cnt;
553  }
554  mcelem_freqs[i++] = (double) minfreq / (double) nonnull_cnt;
555  mcelem_freqs[i++] = (double) maxfreq / (double) nonnull_cnt;
556  mcelem_freqs[i++] = (double) null_elem_cnt / (double) nonnull_cnt;
557 
558  MemoryContextSwitchTo(old_context);
559 
560  stats->stakind[slot_idx] = STATISTIC_KIND_MCELEM;
561  stats->staop[slot_idx] = extra_data->eq_opr;
562  stats->stacoll[slot_idx] = extra_data->coll_id;
563  stats->stanumbers[slot_idx] = mcelem_freqs;
564  /* See above comment about extra stanumber entries */
565  stats->numnumbers[slot_idx] = num_mcelem + 3;
566  stats->stavalues[slot_idx] = mcelem_values;
567  stats->numvalues[slot_idx] = num_mcelem;
568  /* We are storing values of element type */
569  stats->statypid[slot_idx] = extra_data->type_id;
570  stats->statyplen[slot_idx] = extra_data->typlen;
571  stats->statypbyval[slot_idx] = extra_data->typbyval;
572  stats->statypalign[slot_idx] = extra_data->typalign;
573  slot_idx++;
574  }
575 
576  /* Generate DECHIST slot entry */
577  count_items_count = hash_get_num_entries(count_tab);
578  if (count_items_count > 0)
579  {
580  int num_hist = stats->attr->attstattarget;
581  DECountItem **sorted_count_items;
582  int j;
583  int delta;
584  int64 frac;
585  float4 *hist;
586 
587  /* num_hist must be at least 2 for the loop below to work */
588  num_hist = Max(num_hist, 2);
589 
590  /*
591  * Create an array of DECountItem pointers, and sort them into
592  * increasing count order.
593  */
594  sorted_count_items = (DECountItem **)
595  palloc(sizeof(DECountItem *) * count_items_count);
596  hash_seq_init(&scan_status, count_tab);
597  j = 0;
598  while ((count_item = (DECountItem *) hash_seq_search(&scan_status)) != NULL)
599  {
600  sorted_count_items[j++] = count_item;
601  }
602  qsort(sorted_count_items, count_items_count,
604 
605  /*
606  * Prepare to fill stanumbers with the histogram, followed by the
607  * average count. This array must be stored in anl_context.
608  */
609  hist = (float4 *)
611  sizeof(float4) * (num_hist + 1));
612  hist[num_hist] = (double) element_no / (double) nonnull_cnt;
613 
614  /*----------
615  * Construct the histogram of distinct-element counts (DECs).
616  *
617  * The object of this loop is to copy the min and max DECs to
618  * hist[0] and hist[num_hist - 1], along with evenly-spaced DECs
619  * in between (where "evenly-spaced" is with reference to the
620  * whole input population of arrays). If we had a complete sorted
621  * array of DECs, one per analyzed row, the i'th hist value would
622  * come from DECs[i * (analyzed_rows - 1) / (num_hist - 1)]
623  * (compare the histogram-making loop in compute_scalar_stats()).
624  * But instead of that we have the sorted_count_items[] array,
625  * which holds unique DEC values with their frequencies (that is,
626  * a run-length-compressed version of the full array). So we
627  * control advancing through sorted_count_items[] with the
628  * variable "frac", which is defined as (x - y) * (num_hist - 1),
629  * where x is the index in the notional DECs array corresponding
630  * to the start of the next sorted_count_items[] element's run,
631  * and y is the index in DECs from which we should take the next
632  * histogram value. We have to advance whenever x <= y, that is
633  * frac <= 0. The x component is the sum of the frequencies seen
634  * so far (up through the current sorted_count_items[] element),
635  * and of course y * (num_hist - 1) = i * (analyzed_rows - 1),
636  * per the subscript calculation above. (The subscript calculation
637  * implies dropping any fractional part of y; in this formulation
638  * that's handled by not advancing until frac reaches 1.)
639  *
640  * Even though frac has a bounded range, it could overflow int32
641  * when working with very large statistics targets, so we do that
642  * math in int64.
643  *----------
644  */
645  delta = analyzed_rows - 1;
646  j = 0; /* current index in sorted_count_items */
647  /* Initialize frac for sorted_count_items[0]; y is initially 0 */
648  frac = (int64) sorted_count_items[0]->frequency * (num_hist - 1);
649  for (i = 0; i < num_hist; i++)
650  {
651  while (frac <= 0)
652  {
653  /* Advance, and update x component of frac */
654  j++;
655  frac += (int64) sorted_count_items[j]->frequency * (num_hist - 1);
656  }
657  hist[i] = sorted_count_items[j]->count;
658  frac -= delta; /* update y for upcoming i increment */
659  }
660  Assert(j == count_items_count - 1);
661 
662  stats->stakind[slot_idx] = STATISTIC_KIND_DECHIST;
663  stats->staop[slot_idx] = extra_data->eq_opr;
664  stats->stacoll[slot_idx] = extra_data->coll_id;
665  stats->stanumbers[slot_idx] = hist;
666  stats->numnumbers[slot_idx] = num_hist + 1;
667  slot_idx++;
668  }
669  }
670 
671  /*
672  * We don't need to bother cleaning up any of our temporary palloc's. The
673  * hashtable should also go away, as it used a child memory context.
674  */
675 }
static void prune_element_hashtable(HTAB *elements_tab, int b_current)
#define HASH_CONTEXT
Definition: hsearch.h:102
#define HASH_ELEM
Definition: hsearch.h:95
static struct @142 value
MemoryContext hcxt
Definition: hsearch.h:86
#define DEBUG3
Definition: elog.h:23
#define PointerGetDatum(X)
Definition: postgres.h:600
#define Min(x, y)
Definition: c.h:986
Datum * stavalues[STATISTIC_NUM_SLOTS]
Definition: vacuum.h:152
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:109
Size entrysize
Definition: hsearch.h:76
long hash_get_num_entries(HTAB *hashp)
Definition: dynahash.c:1382
bool statypbyval[STATISTIC_NUM_SLOTS]
Definition: vacuum.h:162
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:954
static int countitem_compare_count(const void *e1, const void *e2)
char statypalign[STATISTIC_NUM_SLOTS]
Definition: vacuum.h:163
Form_pg_attribute attr
Definition: vacuum.h:123
static int element_match(const void *key1, const void *key2, Size keysize)
Definition: dynahash.c:219
void pfree(void *pointer)
Definition: mcxt.c:1169
#define ERROR
Definition: elog.h:46
Oid stacoll[STATISTIC_NUM_SLOTS]
Definition: vacuum.h:148
AnalyzeAttrComputeStatsFunc std_compute_stats
int numnumbers[STATISTIC_NUM_SLOTS]
Definition: vacuum.h:149
LexemeHashKey key
Definition: ts_typanalyze.c:34
HTAB * hash_create(const char *tabname, long nelem, const HASHCTL *info, int flags)
Definition: dynahash.c:349
static ArrayAnalyzeExtraData * array_extra_data
MemoryContext CurrentMemoryContext
Definition: mcxt.c:42
Size toast_raw_datum_size(Datum value)
Definition: detoast.c:545
Datum datumCopy(Datum value, bool typByVal, int typLen)
Definition: datum.c:131
static int trackitem_compare_element(const void *e1, const void *e2)
Oid staop[STATISTIC_NUM_SLOTS]
Definition: vacuum.h:147
float float4
Definition: c.h:564
#define HASH_BLOBS
Definition: hsearch.h:97
uintptr_t Datum
Definition: postgres.h:411
int16 stakind[STATISTIC_NUM_SLOTS]
Definition: vacuum.h:146
Size keysize
Definition: hsearch.h:75
HashCompareFunc match
Definition: hsearch.h:80
Oid statypid[STATISTIC_NUM_SLOTS]
Definition: vacuum.h:160
#define STATISTIC_NUM_SLOTS
Definition: pg_statistic.h:127
#define Max(x, y)
Definition: c.h:980
#define ARRAY_WIDTH_THRESHOLD
#define Assert(condition)
Definition: c.h:804
float4 * stanumbers[STATISTIC_NUM_SLOTS]
Definition: vacuum.h:150
#define HASH_COMPARE
Definition: hsearch.h:99
void * hash_seq_search(HASH_SEQ_STATUS *status)
Definition: dynahash.c:1436
void hash_seq_init(HASH_SEQ_STATUS *status, HTAB *hashp)
Definition: dynahash.c:1426
#define INT64_FORMAT
Definition: c.h:483
MemoryContext anl_context
Definition: vacuum.h:128
static uint32 element_hash(const void *key, Size keysize)
void deconstruct_array(ArrayType *array, Oid elmtype, int elmlen, bool elmbyval, char elmalign, Datum **elemsp, bool **nullsp, int *nelemsp)
Definition: arrayfuncs.c:3490
int numvalues[STATISTIC_NUM_SLOTS]
Definition: vacuum.h:151
void * palloc(Size size)
Definition: mcxt.c:1062
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition: mcxt.c:863
int16 statyplen[STATISTIC_NUM_SLOTS]
Definition: vacuum.h:161
#define elog(elevel,...)
Definition: elog.h:232
int i
void * extra_data
Definition: vacuum.h:136
#define qsort(a, b, c, d)
Definition: port.h:504
void vacuum_delay_point(void)
Definition: vacuum.c:2116
#define ARR_ELEMTYPE(a)
Definition: array.h:285
HashValueFunc hash
Definition: hsearch.h:78
#define HASH_FUNCTION
Definition: hsearch.h:98
#define DatumGetArrayTypeP(X)
Definition: array.h:254
static int trackitem_compare_frequencies_desc(const void *e1, const void *e2)

◆ countitem_compare_count()

static int countitem_compare_count ( const void *  e1,
const void *  e2 
)
static

Definition at line 781 of file array_typanalyze.c.

Referenced by compute_array_stats().

782 {
783  const DECountItem *const *t1 = (const DECountItem *const *) e1;
784  const DECountItem *const *t2 = (const DECountItem *const *) e2;
785 
786  if ((*t1)->count < (*t2)->count)
787  return -1;
788  else if ((*t1)->count == (*t2)->count)
789  return 0;
790  else
791  return 1;
792 }

◆ element_compare()

static int element_compare ( const void *  key1,
const void *  key2 
)
static

Definition at line 741 of file array_typanalyze.c.

References ArrayAnalyzeExtraData::cmp, ArrayAnalyzeExtraData::coll_id, DatumGetInt32, and FunctionCall2Coll().

Referenced by element_match(), and trackitem_compare_element().

742 {
743  Datum d1 = *((const Datum *) key1);
744  Datum d2 = *((const Datum *) key2);
745  Datum c;
746 
749  d1, d2);
750  return DatumGetInt32(c);
751 }
#define DatumGetInt32(X)
Definition: postgres.h:516
Datum FunctionCall2Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2)
Definition: fmgr.c:1148
char * c
static ArrayAnalyzeExtraData * array_extra_data
uintptr_t Datum
Definition: postgres.h:411

◆ element_hash()

static uint32 element_hash ( const void *  key,
Size  keysize 
)
static

Definition at line 711 of file array_typanalyze.c.

References ArrayAnalyzeExtraData::coll_id, DatumGetUInt32, FunctionCall1Coll(), and ArrayAnalyzeExtraData::hash.

Referenced by compute_array_stats(), hash_record(), and hash_record_extended().

712 {
713  Datum d = *((const Datum *) key);
714  Datum h;
715 
718  d);
719  return DatumGetUInt32(h);
720 }
#define DatumGetUInt32(X)
Definition: postgres.h:530
static ArrayAnalyzeExtraData * array_extra_data
uintptr_t Datum
Definition: postgres.h:411
Datum FunctionCall1Coll(FmgrInfo *flinfo, Oid collation, Datum arg1)
Definition: fmgr.c:1128

◆ element_match()

static int element_match ( const void *  key1,
const void *  key2,
Size  keysize 
)
static

Definition at line 726 of file array_typanalyze.c.

References element_compare().

Referenced by compute_array_stats().

727 {
728  /* The keysize parameter is superfluous here */
729  return element_compare(key1, key2);
730 }
static int element_compare(const void *key1, const void *key2)

◆ prune_element_hashtable()

static void prune_element_hashtable ( HTAB elements_tab,
int  b_current 
)
static

Definition at line 682 of file array_typanalyze.c.

References DatumGetPointer, TrackItem::delta, elog, ERROR, TrackItem::frequency, HASH_REMOVE, hash_search(), hash_seq_init(), hash_seq_search(), TrackItem::key, pfree(), ArrayAnalyzeExtraData::typbyval, and value.

Referenced by compute_array_stats().

683 {
684  HASH_SEQ_STATUS scan_status;
685  TrackItem *item;
686 
687  hash_seq_init(&scan_status, elements_tab);
688  while ((item = (TrackItem *) hash_seq_search(&scan_status)) != NULL)
689  {
690  if (item->frequency + item->delta <= b_current)
691  {
692  Datum value = item->key;
693 
694  if (hash_search(elements_tab, (const void *) &item->key,
695  HASH_REMOVE, NULL) == NULL)
696  elog(ERROR, "hash table corrupted");
697  /* We should free memory if element is not passed by value */
699  pfree(DatumGetPointer(value));
700  }
701  }
702 }
static struct @142 value
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:954
void pfree(void *pointer)
Definition: mcxt.c:1169
#define ERROR
Definition: elog.h:46
LexemeHashKey key
Definition: ts_typanalyze.c:34
static ArrayAnalyzeExtraData * array_extra_data
uintptr_t Datum
Definition: postgres.h:411
void * hash_seq_search(HASH_SEQ_STATUS *status)
Definition: dynahash.c:1436
void hash_seq_init(HASH_SEQ_STATUS *status, HTAB *hashp)
Definition: dynahash.c:1426
#define DatumGetPointer(X)
Definition: postgres.h:593
#define elog(elevel,...)
Definition: elog.h:232

◆ trackitem_compare_element()

static int trackitem_compare_element ( const void *  e1,
const void *  e2 
)
static

Definition at line 769 of file array_typanalyze.c.

References element_compare().

Referenced by compute_array_stats().

770 {
771  const TrackItem *const *t1 = (const TrackItem *const *) e1;
772  const TrackItem *const *t2 = (const TrackItem *const *) e2;
773 
774  return element_compare(&(*t1)->key, &(*t2)->key);
775 }
static int element_compare(const void *key1, const void *key2)

◆ trackitem_compare_frequencies_desc()

static int trackitem_compare_frequencies_desc ( const void *  e1,
const void *  e2 
)
static

Definition at line 757 of file array_typanalyze.c.

References TrackItem::frequency.

Referenced by compute_array_stats().

758 {
759  const TrackItem *const *t1 = (const TrackItem *const *) e1;
760  const TrackItem *const *t2 = (const TrackItem *const *) e2;
761 
762  return (*t2)->frequency - (*t1)->frequency;
763 }

Variable Documentation

◆ array_extra_data

ArrayAnalyzeExtraData* array_extra_data
static

Definition at line 65 of file array_typanalyze.c.