80 bool inh,
bool in_outer_xact,
int elevel);
89 double *totalrows,
double *totaldeadrows);
93 double *totalrows,
double *totaldeadrows);
187 if (onerel->
rd_rel->relkind == RELKIND_RELATION ||
188 onerel->
rd_rel->relkind == RELKIND_MATVIEW)
195 else if (onerel->
rd_rel->relkind == RELKIND_FOREIGN_TABLE)
214 (
errmsg(
"skipping \"%s\" --- cannot analyze this foreign table",
220 else if (onerel->
rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
231 (
errmsg(
"skipping \"%s\" --- cannot analyze non-tables or special system tables",
247 if (onerel->
rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
249 relpages,
false, in_outer_xact, elevel);
254 if (onerel->
rd_rel->relhassubclass)
256 true, in_outer_xact, elevel);
279 BlockNumber relpages,
bool inh,
bool in_outer_xact,
303 int save_sec_context;
316 (
errmsg(
"analyzing \"%s.%s\" inheritance tree",
321 (
errmsg(
"analyzing \"%s.%s\"",
386 (
errcode(ERRCODE_UNDEFINED_COLUMN),
387 errmsg(
"column \"%s\" of relation \"%s\" does not exist",
391 (
errcode(ERRCODE_DUPLICATE_COLUMN),
392 errmsg(
"column \"%s\" of relation \"%s\" appears more than once",
397 if (vacattrstats[tcnt] != NULL)
408 for (
i = 1;
i <= attr_cnt;
i++)
411 if (vacattrstats[tcnt] != NULL)
426 if (onerel->
rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
432 hasindex = idxs !=
NIL;
438 hasindex = nindexes > 0;
473 if (indexpr_item == NULL)
474 elog(
ERROR,
"too few entries in indexprs list");
496 for (
i = 0;
i < attr_cnt;
i++)
498 if (targrows < vacattrstats[
i]->minrows)
499 targrows = vacattrstats[
i]->
minrows;
507 if (targrows < thisdata->vacattrstats[
i]->minrows)
519 if (targrows < minrows)
532 &totalrows, &totaldeadrows);
534 numrows = (*acquirefunc) (onerel, elevel,
536 &totalrows, &totaldeadrows);
557 for (
i = 0;
i < attr_cnt;
i++)
579 if (n_distinct != 0.0)
601 attr_cnt, vacattrstats);
613 attr_cnt, vacattrstats);
635 if (RELKIND_HAS_STORAGE(onerel->
rd_rel->relkind))
658 double totalindexrows;
660 totalindexrows = ceil(thisdata->
tupleFract * totalrows);
672 else if (onerel->
rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
697 (va_cols ==
NIL), starttime);
698 else if (onerel->
rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
744 double read_rate = 0;
745 double write_rate = 0;
748 int64 total_blks_hit;
749 int64 total_blks_read;
750 int64 total_blks_dirtied;
754 memset(&walusage, 0,
sizeof(
WalUsage));
788 read_rate = (double) BLCKSZ * total_blks_read /
789 (1024 * 1024) / (delay_in_ms / 1000.0);
790 write_rate = (double) BLCKSZ * total_blks_dirtied /
791 (1024 * 1024) / (delay_in_ms / 1000.0);
802 msgfmt =
_(
"automatic analyze of table \"%s.%s.%s\"\n");
804 msgfmt =
_(
"finished analyzing table \"%s.%s.%s\"\n");
828 read_rate, write_rate);
829 appendStringInfo(&
buf,
_(
"buffer usage: %" PRId64
" hits, %" PRId64
" reads, %" PRId64
" dirtied\n"),
834 _(
"WAL usage: %" PRId64
" records, %" PRId64
" full page images, %" PRIu64
" bytes, %" PRId64
" buffers full\n"),
895 double totalindexrows;
920 exprnulls = (
bool *)
palloc(numrows * attr_cnt *
sizeof(
bool));
923 for (rowno = 0; rowno < numrows; rowno++)
939 if (predicate != NULL)
962 for (
i = 0;
i < attr_cnt;
i++)
969 exprvals[tcnt] = (
Datum) 0;
970 exprnulls[tcnt] =
true;
977 exprnulls[tcnt] =
false;
988 thisdata->
tupleFract = (double) numindexrows / (
double) numrows;
989 totalindexrows = ceil(thisdata->
tupleFract * totalrows);
994 if (numindexrows > 0)
997 for (
i = 0;
i < attr_cnt;
i++)
1048 if (attr->attisdropped)
1052 if (attr->attgenerated == ATTRIBUTE_GENERATED_VIRTUAL)
1062 elog(
ERROR,
"cache lookup failed for attribute %d of relation %u",
1064 dat =
SysCacheGetAttr(ATTNUM, atttuple, Anum_pg_attribute_attstattarget, &isnull);
1069 if (attstattarget == 0)
1156 void *callback_private_data,
1157 void *per_buffer_data)
1200 double *totalrows,
double *totaldeadrows)
1203 double samplerows = 0;
1204 double liverows = 0;
1205 double deadrows = 0;
1206 double rowstoskip = -1;
1271 if (numrows < targrows)
1283 if (rowstoskip <= 0)
1291 Assert(k >= 0 && k < targrows);
1319 if (numrows == targrows)
1332 *totalrows = floor((liverows / bs.
m) * totalblocks + 0.5);
1333 *totaldeadrows = floor((deadrows / bs.
m) * totalblocks + 0.5);
1338 *totaldeadrows = 0.0;
1345 (
errmsg(
"\"%s\": scanned %d of %u pages, "
1346 "containing %.0f live rows and %.0f dead rows; "
1347 "%d rows in sample, %.0f estimated total rows",
1351 numrows, *totalrows)));
1392 double *totalrows,
double *totaldeadrows)
1429 (
errmsg(
"skipping analyze of \"%s.%s\" inheritance tree --- this inheritance tree contains no child tables",
1446 foreach(lc, tableOIDs)
1460 Assert(childrel != onerel);
1466 if (childrel->
rd_rel->relkind == RELKIND_RELATION ||
1467 childrel->
rd_rel->relkind == RELKIND_MATVIEW)
1473 else if (childrel->
rd_rel->relkind == RELKIND_FOREIGN_TABLE)
1492 Assert(childrel != onerel);
1503 Assert(childrel->
rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
1504 if (childrel != onerel)
1513 rels[nrels] = childrel;
1514 acquirefuncs[nrels] = acquirefunc;
1515 relblocks[nrels] = (double) relpages;
1516 totalblocks += (double) relpages;
1527 (
errmsg(
"skipping analyze of \"%s.%s\" inheritance tree --- this inheritance tree contains no analyzable child tables",
1542 for (
i = 0;
i < nrels;
i++)
1546 double childblocks = relblocks[
i];
1554 const int progress_index[] = {
1559 const int64 progress_vals[] = {
1568 if (childblocks > 0)
1572 childtargrows = (int) rint(targrows * childblocks / totalblocks);
1574 childtargrows =
Min(childtargrows, targrows - numrows);
1575 if (childtargrows > 0)
1582 childrows = (*acquirefunc) (childrel, elevel,
1583 rows + numrows, childtargrows,
1587 if (childrows > 0 &&
1599 for (
j = 0;
j < childrows;
j++)
1605 rows[numrows +
j] = newtup;
1612 numrows += childrows;
1613 *totalrows += trows;
1614 *totaldeadrows += tdrows;
1665 for (attno = 0; attno < natts; attno++)
1674 bool nulls[Natts_pg_statistic];
1675 bool replaces[Natts_pg_statistic];
1684 for (
i = 0;
i < Natts_pg_statistic; ++
i)
1696 i = Anum_pg_statistic_stakind1 - 1;
1701 i = Anum_pg_statistic_staop1 - 1;
1706 i = Anum_pg_statistic_stacoll1 - 1;
1711 i = Anum_pg_statistic_stanumbers1 - 1;
1720 for (n = 0; n < nnum; n++)
1731 i = Anum_pg_statistic_stavalues1 - 1;
1760 if (indstate == NULL)
1784 if (indstate != NULL)
1842#define WIDTH_THRESHOLD 1024
1844#define swapInt(a,b) do {int _tmp; _tmp=a; a=b; b=_tmp;} while(0)
1845#define swapDatum(a,b) do {Datum _tmp; _tmp=a; a=b; b=_tmp;} while(0)
1901 false,
false,
false,
1902 <opr, &eqopr, NULL,
1907 mystats->
eqopr = eqopr;
1909 mystats->
ltopr = ltopr;
1974 int nonnull_cnt = 0;
1975 double total_width = 0;
1976 bool is_varlena = (!stats->
attrtype->typbyval &&
1978 bool is_varwidth = (!stats->
attrtype->typbyval &&
1981 for (
i = 0;
i < samplerows;
i++)
1988 value = fetchfunc(stats,
i, &isnull);
2008 else if (is_varwidth)
2016 if (nonnull_cnt > 0)
2020 stats->
stanullfrac = (double) null_cnt / (
double) samplerows;
2022 stats->
stawidth = total_width / (double) nonnull_cnt;
2027 else if (null_cnt > 0)
2064 int nonnull_cnt = 0;
2065 int toowide_cnt = 0;
2066 double total_width = 0;
2067 bool is_varlena = (!stats->
attrtype->typbyval &&
2069 bool is_varwidth = (!stats->
attrtype->typbyval &&
2086 track_max = 2 * num_mcv;
2094 for (
i = 0;
i < samplerows;
i++)
2104 value = fetchfunc(stats,
i, &isnull);
2138 else if (is_varwidth)
2148 firstcount1 = track_cnt;
2149 for (
j = 0;
j < track_cnt;
j++)
2158 if (
j < firstcount1 && track[
j].count == 1)
2167 while (
j > 0 && track[
j].count > track[
j - 1].count)
2170 swapInt(track[
j].count, track[
j - 1].count);
2177 if (track_cnt < track_max)
2179 for (
j = track_cnt - 1;
j > firstcount1;
j--)
2181 track[
j].value = track[
j - 1].value;
2182 track[
j].count = track[
j - 1].count;
2184 if (firstcount1 < track_cnt)
2186 track[firstcount1].value =
value;
2187 track[firstcount1].count = 1;
2193 if (nonnull_cnt > 0)
2200 stats->
stanullfrac = (double) null_cnt / (
double) samplerows;
2202 stats->
stawidth = total_width / (double) nonnull_cnt;
2208 for (nmultiple = 0; nmultiple < track_cnt; nmultiple++)
2210 if (track[nmultiple].count == 1)
2212 summultiple += track[nmultiple].count;
2223 else if (track_cnt < track_max && toowide_cnt == 0 &&
2224 nmultiple == track_cnt)
2263 int f1 = nonnull_cnt - summultiple;
2264 int d =
f1 + nmultiple;
2265 double n = samplerows - null_cnt;
2266 double N = totalrows * (1.0 - stats->
stanullfrac);
2271 stadistinct = (n * d) / ((n -
f1) +
f1 * n / N);
2276 if (stadistinct < d)
2278 if (stadistinct > N)
2309 if (track_cnt < track_max && toowide_cnt == 0 &&
2311 track_cnt <= num_mcv)
2314 num_mcv = track_cnt;
2321 if (num_mcv > track_cnt)
2322 num_mcv = track_cnt;
2326 mcv_counts = (
int *)
palloc(num_mcv *
sizeof(
int));
2327 for (
i = 0;
i < num_mcv;
i++)
2328 mcv_counts[
i] = track[
i].count;
2333 samplerows, totalrows);
2348 for (
i = 0;
i < num_mcv;
i++)
2353 mcv_freqs[
i] = (double) track[
i].count / (
double) samplerows;
2357 stats->
stakind[0] = STATISTIC_KIND_MCV;
2371 else if (null_cnt > 0)
2407 int nonnull_cnt = 0;
2408 int toowide_cnt = 0;
2409 double total_width = 0;
2410 bool is_varlena = (!stats->
attrtype->typbyval &&
2412 bool is_varwidth = (!stats->
attrtype->typbyval &&
2426 tupnoLink = (
int *)
palloc(samplerows *
sizeof(
int));
2429 memset(&ssup, 0,
sizeof(ssup));
2444 for (
i = 0;
i < samplerows;
i++)
2451 value = fetchfunc(stats,
i, &isnull);
2485 else if (is_varwidth)
2493 values[values_cnt].tupno = values_cnt;
2494 tupnoLink[values_cnt] = values_cnt;
2537 for (
i = 0;
i < values_cnt;
i++)
2541 corr_xysum += ((double)
i) * ((double) tupno);
2543 if (tupnoLink[tupno] == tupno)
2550 if (track_cnt < num_mcv ||
2551 dups_cnt > track[track_cnt - 1].count)
2561 if (track_cnt < num_mcv)
2563 for (
j = track_cnt - 1;
j > 0;
j--)
2565 if (dups_cnt <= track[
j - 1].count)
2570 track[
j].
count = dups_cnt;
2571 track[
j].
first =
i + 1 - dups_cnt;
2580 stats->
stanullfrac = (double) null_cnt / (
double) samplerows;
2582 stats->
stawidth = total_width / (double) nonnull_cnt;
2594 else if (toowide_cnt == 0 && nmultiple == ndistinct)
2628 int f1 = ndistinct - nmultiple + toowide_cnt;
2629 int d =
f1 + nmultiple;
2630 double n = samplerows - null_cnt;
2631 double N = totalrows * (1.0 - stats->
stanullfrac);
2636 stadistinct = (n * d) / ((n -
f1) +
f1 * n / N);
2641 if (stadistinct < d)
2643 if (stadistinct > N)
2674 if (track_cnt == ndistinct && toowide_cnt == 0 &&
2676 track_cnt <= num_mcv)
2679 num_mcv = track_cnt;
2686 if (num_mcv > track_cnt)
2687 num_mcv = track_cnt;
2691 mcv_counts = (
int *)
palloc(num_mcv *
sizeof(
int));
2692 for (
i = 0;
i < num_mcv;
i++)
2693 mcv_counts[
i] = track[
i].count;
2698 samplerows, totalrows);
2713 for (
i = 0;
i < num_mcv;
i++)
2718 mcv_freqs[
i] = (double) track[
i].count / (
double) samplerows;
2722 stats->
stakind[slot_idx] = STATISTIC_KIND_MCV;
2727 stats->
stavalues[slot_idx] = mcv_values;
2742 num_hist = ndistinct - num_mcv;
2743 if (num_hist > num_bins)
2744 num_hist = num_bins + 1;
2774 while (src < values_cnt)
2780 int first = track[
j].
first;
2785 src = first + track[
j].
count;
2789 ncopy = first - src;
2792 ncopy = values_cnt - src;
2802 Assert(nvals >= num_hist);
2817 delta = (nvals - 1) / (num_hist - 1);
2818 deltafrac = (nvals - 1) % (num_hist - 1);
2821 for (
i = 0;
i < num_hist;
i++)
2827 posfrac += deltafrac;
2828 if (posfrac >= (num_hist - 1))
2832 posfrac -= (num_hist - 1);
2838 stats->
stakind[slot_idx] = STATISTIC_KIND_HISTOGRAM;
2841 stats->
stavalues[slot_idx] = hist_values;
2873 corr_xsum = ((double) (values_cnt - 1)) *
2874 ((
double) values_cnt) / 2.0;
2875 corr_x2sum = ((double) (values_cnt - 1)) *
2876 ((
double) values_cnt) * (
double) (2 * values_cnt - 1) / 6.0;
2879 corrs[0] = (values_cnt * corr_xysum - corr_xsum * corr_xsum) /
2880 (values_cnt * corr_x2sum - corr_xsum * corr_xsum);
2882 stats->
stakind[slot_idx] = STATISTIC_KIND_CORRELATION;
2890 else if (nonnull_cnt > 0)
2893 Assert(nonnull_cnt == toowide_cnt);
2896 stats->
stanullfrac = (double) null_cnt / (
double) samplerows;
2898 stats->
stawidth = total_width / (double) nonnull_cnt;
2904 else if (null_cnt > 0)
2985 double ndistinct_table;
2993 if (samplerows == totalrows || totalrows <= 1.0)
2997 ndistinct_table = stadistinct;
2998 if (ndistinct_table < 0)
2999 ndistinct_table = -ndistinct_table * totalrows;
3021 for (
i = 0;
i < num_mcv - 1;
i++)
3022 sumcount += mcv_counts[
i];
3038 selec = 1.0 - sumcount / samplerows - stanullfrac;
3043 otherdistinct = ndistinct_table - (num_mcv - 1);
3044 if (otherdistinct > 1)
3045 selec /= otherdistinct;
3065 K = N * mcv_counts[num_mcv - 1] / n;
3066 variance = n *
K * (N -
K) * (N - n) / (N * N * (N - 1));
3067 stddev = sqrt(variance);
3069 if (mcv_counts[num_mcv - 1] > selec * samplerows + 2 * stddev + 0.5)
3084 sumcount -= mcv_counts[num_mcv - 1];
ArrayType * construct_array(Datum *elems, int nelems, Oid elmtype, int elmlen, bool elmbyval, char elmalign)
ArrayType * construct_array_builtin(Datum *elems, int nelems, Oid elmtype)
#define InvalidAttrNumber
AttributeOpts * get_attribute_options(Oid attrelid, int attnum)
long TimestampDifferenceMilliseconds(TimestampTz start_time, TimestampTz stop_time)
bool TimestampDifferenceExceeds(TimestampTz start_time, TimestampTz stop_time, int msec)
TimestampTz GetCurrentTimestamp(void)
void pgstat_progress_start_command(ProgressCommandType cmdtype, Oid relid)
void pgstat_progress_update_param(int index, int64 val)
void pgstat_progress_update_multi_param(int nparam, const int *index, const int64 *val)
void pgstat_progress_end_command(void)
@ PROGRESS_COMMAND_ANALYZE
PgBackendStatus * MyBEEntry
bool bms_is_member(int x, const Bitmapset *a)
Bitmapset * bms_add_member(Bitmapset *a, int x)
#define InvalidBlockNumber
static Datum values[MAXATTR]
#define RelationGetNumberOfBlocks(reln)
#define OidIsValid(objectId)
static Datum std_fetch_func(VacAttrStatsP stats, int rownum, bool *isNull)
static void compute_scalar_stats(VacAttrStatsP stats, AnalyzeAttrFetchFunc fetchfunc, int samplerows, double totalrows)
static void update_attstats(Oid relid, bool inh, int natts, VacAttrStats **vacattrstats)
int default_statistics_target
static void do_analyze_rel(Relation onerel, const VacuumParams params, List *va_cols, AcquireSampleRowsFunc acquirefunc, BlockNumber relpages, bool inh, bool in_outer_xact, int elevel)
static void compute_distinct_stats(VacAttrStatsP stats, AnalyzeAttrFetchFunc fetchfunc, int samplerows, double totalrows)
static MemoryContext anl_context
bool std_typanalyze(VacAttrStats *stats)
static int analyze_mcv_list(int *mcv_counts, int num_mcv, double stadistinct, double stanullfrac, int samplerows, double totalrows)
static int acquire_inherited_sample_rows(Relation onerel, int elevel, HeapTuple *rows, int targrows, double *totalrows, double *totaldeadrows)
static BufferAccessStrategy vac_strategy
static BlockNumber block_sampling_read_stream_next(ReadStream *stream, void *callback_private_data, void *per_buffer_data)
static int compare_mcvs(const void *a, const void *b, void *arg)
void analyze_rel(Oid relid, RangeVar *relation, const VacuumParams params, List *va_cols, bool in_outer_xact, BufferAccessStrategy bstrategy)
struct AnlIndexData AnlIndexData
static int acquire_sample_rows(Relation onerel, int elevel, HeapTuple *rows, int targrows, double *totalrows, double *totaldeadrows)
static void compute_trivial_stats(VacAttrStatsP stats, AnalyzeAttrFetchFunc fetchfunc, int samplerows, double totalrows)
static int compare_scalars(const void *a, const void *b, void *arg)
static Datum ind_fetch_func(VacAttrStatsP stats, int rownum, bool *isNull)
static VacAttrStats * examine_attribute(Relation onerel, int attnum, Node *index_expr)
static int compare_rows(const void *a, const void *b, void *arg)
static void compute_index_stats(Relation onerel, double totalrows, AnlIndexData *indexdata, int nindexes, HeapTuple *rows, int numrows, MemoryContext col_context)
Datum datumCopy(Datum value, bool typByVal, int typLen)
Size toast_raw_datum_size(Datum value)
int errmsg_internal(const char *fmt,...)
int errcode(int sqlerrcode)
int errmsg(const char *fmt,...)
#define ereport(elevel,...)
ExprState * ExecPrepareQual(List *qual, EState *estate)
TupleTableSlot * MakeSingleTupleTableSlot(TupleDesc tupdesc, const TupleTableSlotOps *tts_ops)
void ExecDropSingleTupleTableSlot(TupleTableSlot *slot)
const TupleTableSlotOps TTSOpsHeapTuple
TupleTableSlot * ExecStoreHeapTuple(HeapTuple tuple, TupleTableSlot *slot, bool shouldFree)
void FreeExecutorState(EState *estate)
EState * CreateExecutorState(void)
#define GetPerTupleExprContext(estate)
#define ResetExprContext(econtext)
static bool ExecQual(ExprState *state, ExprContext *econtext)
int ComputeExtStatisticsRows(Relation onerel, int natts, VacAttrStats **vacattrstats)
void BuildRelationExtStatistics(Relation onerel, bool inh, double totalrows, int numrows, HeapTuple *rows, int natts, VacAttrStats **vacattrstats)
int(* AcquireSampleRowsFunc)(Relation relation, int elevel, HeapTuple *rows, int targrows, double *totalrows, double *totaldeadrows)
Datum FunctionCall2Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2)
void fmgr_info(Oid functionId, FmgrInfo *finfo)
#define OidFunctionCall1(functionId, arg1)
#define PG_DETOAST_DATUM(datum)
FdwRoutine * GetFdwRoutineForRelation(Relation relation, bool makecopy)
static int compare(const void *arg1, const void *arg2)
int NewGUCNestLevel(void)
void RestrictSearchPath(void)
void AtEOXact_GUC(bool isCommit, int nestLevel)
Assert(PointerIsAligned(start, uint64))
HeapTuple heap_modify_tuple(HeapTuple tuple, TupleDesc tupleDesc, const Datum *replValues, const bool *replIsnull, const bool *doReplace)
HeapTuple heap_form_tuple(TupleDesc tupleDescriptor, const Datum *values, const bool *isnull)
void heap_freetuple(HeapTuple htup)
#define HeapTupleIsValid(tuple)
static Datum heap_getattr(HeapTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)
static void * GETSTRUCT(const HeapTupleData *tuple)
IndexInfo * BuildIndexInfo(Relation index)
void FormIndexDatum(IndexInfo *indexInfo, TupleTableSlot *slot, EState *estate, Datum *values, bool *isnull)
IndexBulkDeleteResult * index_vacuum_cleanup(IndexVacuumInfo *info, IndexBulkDeleteResult *istat)
void CatalogTupleInsertWithInfo(Relation heapRel, HeapTuple tup, CatalogIndexState indstate)
void CatalogCloseIndexes(CatalogIndexState indstate)
CatalogIndexState CatalogOpenIndexes(Relation heapRel)
void CatalogTupleUpdateWithInfo(Relation heapRel, ItemPointer otid, HeapTuple tup, CatalogIndexState indstate)
void WalUsageAccumDiff(WalUsage *dst, const WalUsage *add, const WalUsage *sub)
BufferUsage pgBufferUsage
void BufferUsageAccumDiff(BufferUsage *dst, const BufferUsage *add, const BufferUsage *sub)
if(TABLE==NULL||TABLE_index==NULL)
static OffsetNumber ItemPointerGetOffsetNumber(const ItemPointerData *pointer)
static BlockNumber ItemPointerGetBlockNumber(const ItemPointerData *pointer)
void list_free(List *list)
#define ShareUpdateExclusiveLock
char * get_database_name(Oid dbid)
RegProcedure get_opcode(Oid opno)
char * get_namespace_name(Oid nspid)
void MemoryContextReset(MemoryContext context)
void pfree(void *pointer)
void * palloc0(Size size)
MemoryContext CurrentMemoryContext
void MemoryContextDelete(MemoryContext context)
#define AllocSetContextCreate
#define ALLOCSET_DEFAULT_SIZES
#define AmAutoVacuumWorkerProcess()
#define SECURITY_RESTRICTED_OPERATION
#define CHECK_FOR_INTERRUPTS()
void GetUserIdAndSecContext(Oid *userid, int *sec_context)
void SetUserIdAndSecContext(Oid userid, int sec_context)
#define InvalidMultiXactId
Oid exprType(const Node *expr)
int32 exprTypmod(const Node *expr)
Oid exprCollation(const Node *expr)
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
void get_sort_group_operators(Oid argtype, bool needLT, bool needEQ, bool needGT, Oid *ltOpr, Oid *eqOpr, Oid *gtOpr, bool *isHashable)
int attnameAttNum(Relation rd, const char *attname, bool sysColOK)
FormData_pg_attribute * Form_pg_attribute
List * find_all_inheritors(Oid parentrelId, LOCKMODE lockmode, List **numparents)
static int list_length(const List *l)
static ListCell * list_head(const List *l)
static ListCell * lnext(const List *l, const ListCell *c)
uint32 pg_prng_uint32(pg_prng_state *state)
pg_prng_state pg_global_prng_state
const char * pg_rusage_show(const PGRUsage *ru0)
void pg_rusage_init(PGRUsage *ru0)
#define STATISTIC_NUM_SLOTS
FormData_pg_type * Form_pg_type
PgStat_Counter pgStatBlockReadTime
PgStat_Counter pgStatBlockWriteTime
void pgstat_report_analyze(Relation rel, PgStat_Counter livetuples, PgStat_Counter deadtuples, bool resetcounter, TimestampTz starttime)
void qsort_interruptible(void *base, size_t nel, size_t elsize, qsort_arg_comparator cmp, void *arg)
static bool DatumGetBool(Datum X)
static Datum PointerGetDatum(const void *X)
static Datum Float4GetDatum(float4 X)
static Datum Int16GetDatum(int16 X)
static Datum BoolGetDatum(bool X)
static Datum ObjectIdGetDatum(Oid X)
static char * DatumGetCString(Datum X)
static Pointer DatumGetPointer(Datum X)
static Datum Int32GetDatum(int32 X)
static int16 DatumGetInt16(Datum X)
TransactionId GetOldestNonRemovableTransactionId(Relation rel)
#define PROGRESS_ANALYZE_PHASE_FINALIZE_ANALYZE
#define PROGRESS_ANALYZE_PHASE_ACQUIRE_SAMPLE_ROWS_INH
#define PROGRESS_ANALYZE_BLOCKS_DONE
#define PROGRESS_ANALYZE_PHASE
#define PROGRESS_ANALYZE_CHILD_TABLES_TOTAL
#define PROGRESS_ANALYZE_BLOCKS_TOTAL
#define PROGRESS_ANALYZE_PHASE_COMPUTE_STATS
#define PROGRESS_ANALYZE_DELAY_TIME
#define PROGRESS_ANALYZE_PHASE_ACQUIRE_SAMPLE_ROWS
#define PROGRESS_ANALYZE_CHILD_TABLES_DONE
#define PROGRESS_ANALYZE_CURRENT_CHILD_TABLE_RELID
ReadStream * read_stream_begin_relation(int flags, BufferAccessStrategy strategy, Relation rel, ForkNumber forknum, ReadStreamBlockNumberCB callback, void *callback_private_data, size_t per_buffer_data_size)
void read_stream_end(ReadStream *stream)
#define READ_STREAM_MAINTENANCE
#define READ_STREAM_USE_BATCHING
#define RelationGetRelid(relation)
#define RelationGetDescr(relation)
#define RelationGetRelationName(relation)
#define RELATION_IS_OTHER_TEMP(relation)
#define RelationGetNamespace(relation)
List * RelationGetIndexList(Relation relation)
struct RelationData * Relation
BlockNumber BlockSampler_Init(BlockSampler bs, BlockNumber nblocks, int samplesize, uint32 randseed)
void reservoir_init_selection_state(ReservoirState rs, int n)
double sampler_random_fract(pg_prng_state *randstate)
bool BlockSampler_HasMore(BlockSampler bs)
BlockNumber BlockSampler_Next(BlockSampler bs)
double reservoir_get_next_S(ReservoirState rs, double t, int n)
void PrepareSortSupportFromOrderingOp(Oid orderingOp, SortSupport ssup)
static int ApplySortComparator(Datum datum1, bool isNull1, Datum datum2, bool isNull2, SortSupport ssup)
void relation_close(Relation relation, LOCKMODE lockmode)
void appendStringInfo(StringInfo str, const char *fmt,...)
void initStringInfo(StringInfo str)
VacAttrStats ** vacattrstats
float8 n_distinct_inherited
int64 shared_blks_dirtied
TupleTableSlot * ecxt_scantuple
AnalyzeForeignTable_function AnalyzeForeignTable
AttrNumber ii_IndexAttrNumbers[INDEX_MAX_KEYS]
BufferAccessStrategy strategy
int64 st_progress_param[PGSTAT_NUM_PROGRESS_PARAM]
int16 stakind[STATISTIC_NUM_SLOTS]
MemoryContext anl_context
Oid statypid[STATISTIC_NUM_SLOTS]
Oid staop[STATISTIC_NUM_SLOTS]
Oid stacoll[STATISTIC_NUM_SLOTS]
char statypalign[STATISTIC_NUM_SLOTS]
float4 * stanumbers[STATISTIC_NUM_SLOTS]
bool statypbyval[STATISTIC_NUM_SLOTS]
int16 statyplen[STATISTIC_NUM_SLOTS]
int numvalues[STATISTIC_NUM_SLOTS]
Datum * stavalues[STATISTIC_NUM_SLOTS]
int numnumbers[STATISTIC_NUM_SLOTS]
AnalyzeAttrComputeStatsFunc compute_stats
void ReleaseSysCache(HeapTuple tuple)
HeapTuple SearchSysCache3(int cacheId, Datum key1, Datum key2, Datum key3)
Datum SysCacheGetAttr(int cacheId, HeapTuple tup, AttrNumber attributeNumber, bool *isNull)
HeapTuple SearchSysCache2(int cacheId, Datum key1, Datum key2)
#define SearchSysCacheCopy1(cacheId, key1)
void table_close(Relation relation, LOCKMODE lockmode)
Relation table_open(Oid relationId, LOCKMODE lockmode)
TupleTableSlot * table_slot_create(Relation relation, List **reglist)
static void table_endscan(TableScanDesc scan)
static bool table_scan_analyze_next_tuple(TableScanDesc scan, TransactionId OldestXmin, double *liverows, double *deadrows, TupleTableSlot *slot)
static bool table_scan_analyze_next_block(TableScanDesc scan, ReadStream *stream)
static TableScanDesc table_beginscan_analyze(Relation rel)
void SetRelationHasSubclass(Oid relationId, bool relhassubclass)
#define InvalidTransactionId
TupleConversionMap * convert_tuples_by_name(TupleDesc indesc, TupleDesc outdesc)
void free_conversion_map(TupleConversionMap *map)
HeapTuple execute_attr_map_tuple(HeapTuple tuple, TupleConversionMap *map)
bool equalRowTypes(TupleDesc tupdesc1, TupleDesc tupdesc2)
static FormData_pg_attribute * TupleDescAttr(TupleDesc tupdesc, int i)
static HeapTuple ExecCopySlotHeapTuple(TupleTableSlot *slot)
bool track_cost_delay_timing
void vac_open_indexes(Relation relation, LOCKMODE lockmode, int *nindexes, Relation **Irel)
Relation vacuum_open_relation(Oid relid, RangeVar *relation, bits32 options, bool verbose, LOCKMODE lmode)
void vac_close_indexes(int nindexes, Relation *Irel, LOCKMODE lockmode)
void vacuum_delay_point(bool is_analyze)
bool vacuum_is_permitted_for_relation(Oid relid, Form_pg_class reltuple, bits32 options)
void vac_update_relstats(Relation relation, BlockNumber num_pages, double num_tuples, BlockNumber num_all_visible_pages, BlockNumber num_all_frozen_pages, bool hasindex, TransactionId frozenxid, MultiXactId minmulti, bool *frozenxid_updated, bool *minmulti_updated, bool in_outer_xact)
Datum(* AnalyzeAttrFetchFunc)(VacAttrStatsP stats, int rownum, bool *isNull)
static Size VARSIZE_ANY(const void *PTR)
void visibilitymap_count(Relation rel, BlockNumber *all_visible, BlockNumber *all_frozen)
void CommandCounterIncrement(void)