fcu->fs = pending;
/* save stats for this function, later used to compensate for recursion */
- fcu->save_f_total_time = pending->f_total_time;
+ fcu->save_f_total_time = pending->total_time;
/* save current backend-wide total time */
fcu->save_total = total_func_time;
/* get clock time as of function start */
- INSTR_TIME_SET_CURRENT(fcu->f_start);
+ INSTR_TIME_SET_CURRENT(fcu->start);
}
/*
pgstat_end_function_usage(PgStat_FunctionCallUsage *fcu, bool finalize)
{
PgStat_FunctionCounts *fs = fcu->fs;
- instr_time f_total;
- instr_time f_others;
- instr_time f_self;
+ instr_time total;
+ instr_time others;
+ instr_time self;
/* stats not wanted? */
if (fs == NULL)
return;
/* total elapsed time in this function call */
- INSTR_TIME_SET_CURRENT(f_total);
- INSTR_TIME_SUBTRACT(f_total, fcu->f_start);
+ INSTR_TIME_SET_CURRENT(total);
+ INSTR_TIME_SUBTRACT(total, fcu->start);
/* self usage: elapsed minus anything already charged to other calls */
- f_others = total_func_time;
- INSTR_TIME_SUBTRACT(f_others, fcu->save_total);
- f_self = f_total;
- INSTR_TIME_SUBTRACT(f_self, f_others);
+ others = total_func_time;
+ INSTR_TIME_SUBTRACT(others, fcu->save_total);
+ self = total;
+ INSTR_TIME_SUBTRACT(self, others);
/* update backend-wide total time */
- INSTR_TIME_ADD(total_func_time, f_self);
+ INSTR_TIME_ADD(total_func_time, self);
/*
- * Compute the new f_total_time as the total elapsed time added to the
- * pre-call value of f_total_time. This is necessary to avoid
+ * Compute the new total_time as the total elapsed time added to the
+ * pre-call value of total_time. This is necessary to avoid
* double-counting any time taken by recursive calls of myself. (We do
* not need any similar kluge for self time, since that already excludes
* any recursive calls.)
*/
- INSTR_TIME_ADD(f_total, fcu->save_f_total_time);
+ INSTR_TIME_ADD(total, fcu->save_f_total_time);
/* update counters in function stats table */
if (finalize)
- fs->f_numcalls++;
- fs->f_total_time = f_total;
- INSTR_TIME_ADD(fs->f_self_time, f_self);
+ fs->numcalls++;
+ fs->total_time = total;
+ INSTR_TIME_ADD(fs->self_time, self);
}
/*
if (!pgstat_lock_entry(entry_ref, nowait))
return false;
- shfuncent->stats.f_numcalls += localent->f_numcalls;
- shfuncent->stats.f_total_time +=
- INSTR_TIME_GET_MICROSEC(localent->f_total_time);
- shfuncent->stats.f_self_time +=
- INSTR_TIME_GET_MICROSEC(localent->f_self_time);
+ shfuncent->stats.numcalls += localent->numcalls;
+ shfuncent->stats.total_time +=
+ INSTR_TIME_GET_MICROSEC(localent->total_time);
+ shfuncent->stats.self_time +=
+ INSTR_TIME_GET_MICROSEC(localent->self_time);
pgstat_unlock_entry(entry_ref);
PgStat_Counter inserted_pre_truncdrop;
PgStat_Counter updated_pre_truncdrop;
PgStat_Counter deleted_pre_truncdrop;
- Oid t_id; /* table's OID */
- bool t_shared; /* is it a shared catalog? */
- bool t_truncdropped; /* was the relation truncated/dropped? */
+ Oid id; /* table's OID */
+ bool shared; /* is it a shared catalog? */
+ bool truncdropped; /* was the relation truncated/dropped? */
} TwoPhasePgStatRecord;
deadtuples -= trans->tuples_updated + trans->tuples_deleted;
}
/* count stuff inserted by already-aborted subxacts, too */
- deadtuples -= rel->pgstat_info->t_counts.t_delta_dead_tuples;
+ deadtuples -= rel->pgstat_info->counts.delta_dead_tuples;
/* Since ANALYZE's counts are estimates, we could have underflowed */
livetuples = Max(livetuples, 0);
deadtuples = Max(deadtuples, 0);
pgstat_info->trans->tuples_updated++;
/*
- * t_tuples_hot_updated and t_tuples_newpage_updated counters are
+ * tuples_hot_updated and tuples_newpage_updated counters are
* nontransactional, so just advance them
*/
if (hot)
- pgstat_info->t_counts.t_tuples_hot_updated++;
+ pgstat_info->counts.tuples_hot_updated++;
else if (newpage)
- pgstat_info->t_counts.t_tuples_newpage_updated++;
+ pgstat_info->counts.tuples_newpage_updated++;
}
}
* update dead-tuples count
*
* The semantics of this are that we are reporting the nontransactional
- * recovery of "delta" dead tuples; so t_delta_dead_tuples decreases
+ * recovery of "delta" dead tuples; so delta_dead_tuples decreases
* rather than increasing, and the change goes straight into the per-table
* counter, not into transactional state.
*/
{
PgStat_TableStatus *pgstat_info = rel->pgstat_info;
- pgstat_info->t_counts.t_delta_dead_tuples -= delta;
+ pgstat_info->counts.delta_dead_tuples -= delta;
}
}
if (!isCommit)
restore_truncdrop_counters(trans);
/* count attempted actions regardless of commit/abort */
- tabstat->t_counts.t_tuples_inserted += trans->tuples_inserted;
- tabstat->t_counts.t_tuples_updated += trans->tuples_updated;
- tabstat->t_counts.t_tuples_deleted += trans->tuples_deleted;
+ tabstat->counts.tuples_inserted += trans->tuples_inserted;
+ tabstat->counts.tuples_updated += trans->tuples_updated;
+ tabstat->counts.tuples_deleted += trans->tuples_deleted;
if (isCommit)
{
- tabstat->t_counts.t_truncdropped = trans->truncdropped;
+ tabstat->counts.truncdropped = trans->truncdropped;
if (trans->truncdropped)
{
/* forget live/dead stats seen by backend thus far */
- tabstat->t_counts.t_delta_live_tuples = 0;
- tabstat->t_counts.t_delta_dead_tuples = 0;
+ tabstat->counts.delta_live_tuples = 0;
+ tabstat->counts.delta_dead_tuples = 0;
}
/* insert adds a live tuple, delete removes one */
- tabstat->t_counts.t_delta_live_tuples +=
+ tabstat->counts.delta_live_tuples +=
trans->tuples_inserted - trans->tuples_deleted;
/* update and delete each create a dead tuple */
- tabstat->t_counts.t_delta_dead_tuples +=
+ tabstat->counts.delta_dead_tuples +=
trans->tuples_updated + trans->tuples_deleted;
/* insert, update, delete each count as one change event */
- tabstat->t_counts.t_changed_tuples +=
+ tabstat->counts.changed_tuples +=
trans->tuples_inserted + trans->tuples_updated +
trans->tuples_deleted;
}
else
{
/* inserted tuples are dead, deleted tuples are unaffected */
- tabstat->t_counts.t_delta_dead_tuples +=
+ tabstat->counts.delta_dead_tuples +=
trans->tuples_inserted + trans->tuples_updated;
/* an aborted xact generates no changed_tuple events */
}
/* first restore values obliterated by truncate/drop */
restore_truncdrop_counters(trans);
/* count attempted actions regardless of commit/abort */
- tabstat->t_counts.t_tuples_inserted += trans->tuples_inserted;
- tabstat->t_counts.t_tuples_updated += trans->tuples_updated;
- tabstat->t_counts.t_tuples_deleted += trans->tuples_deleted;
+ tabstat->counts.tuples_inserted += trans->tuples_inserted;
+ tabstat->counts.tuples_updated += trans->tuples_updated;
+ tabstat->counts.tuples_deleted += trans->tuples_deleted;
/* inserted tuples are dead, deleted tuples are unaffected */
- tabstat->t_counts.t_delta_dead_tuples +=
+ tabstat->counts.delta_dead_tuples +=
trans->tuples_inserted + trans->tuples_updated;
tabstat->trans = trans->upper;
pfree(trans);
record.inserted_pre_truncdrop = trans->inserted_pre_truncdrop;
record.updated_pre_truncdrop = trans->updated_pre_truncdrop;
record.deleted_pre_truncdrop = trans->deleted_pre_truncdrop;
- record.t_id = tabstat->t_id;
- record.t_shared = tabstat->t_shared;
- record.t_truncdropped = trans->truncdropped;
+ record.id = tabstat->id;
+ record.shared = tabstat->shared;
+ record.truncdropped = trans->truncdropped;
RegisterTwoPhaseRecord(TWOPHASE_RM_PGSTAT_ID, 0,
&record, sizeof(TwoPhasePgStatRecord));
PgStat_TableStatus *pgstat_info;
/* Find or create a tabstat entry for the rel */
- pgstat_info = pgstat_prep_relation_pending(rec->t_id, rec->t_shared);
+ pgstat_info = pgstat_prep_relation_pending(rec->id, rec->shared);
/* Same math as in AtEOXact_PgStat, commit case */
- pgstat_info->t_counts.t_tuples_inserted += rec->tuples_inserted;
- pgstat_info->t_counts.t_tuples_updated += rec->tuples_updated;
- pgstat_info->t_counts.t_tuples_deleted += rec->tuples_deleted;
- pgstat_info->t_counts.t_truncdropped = rec->t_truncdropped;
- if (rec->t_truncdropped)
+ pgstat_info->counts.tuples_inserted += rec->tuples_inserted;
+ pgstat_info->counts.tuples_updated += rec->tuples_updated;
+ pgstat_info->counts.tuples_deleted += rec->tuples_deleted;
+ pgstat_info->counts.truncdropped = rec->truncdropped;
+ if (rec->truncdropped)
{
/* forget live/dead stats seen by backend thus far */
- pgstat_info->t_counts.t_delta_live_tuples = 0;
- pgstat_info->t_counts.t_delta_dead_tuples = 0;
+ pgstat_info->counts.delta_live_tuples = 0;
+ pgstat_info->counts.delta_dead_tuples = 0;
}
- pgstat_info->t_counts.t_delta_live_tuples +=
+ pgstat_info->counts.delta_live_tuples +=
rec->tuples_inserted - rec->tuples_deleted;
- pgstat_info->t_counts.t_delta_dead_tuples +=
+ pgstat_info->counts.delta_dead_tuples +=
rec->tuples_updated + rec->tuples_deleted;
- pgstat_info->t_counts.t_changed_tuples +=
+ pgstat_info->counts.changed_tuples +=
rec->tuples_inserted + rec->tuples_updated +
rec->tuples_deleted;
}
PgStat_TableStatus *pgstat_info;
/* Find or create a tabstat entry for the rel */
- pgstat_info = pgstat_prep_relation_pending(rec->t_id, rec->t_shared);
+ pgstat_info = pgstat_prep_relation_pending(rec->id, rec->shared);
/* Same math as in AtEOXact_PgStat, abort case */
- if (rec->t_truncdropped)
+ if (rec->truncdropped)
{
rec->tuples_inserted = rec->inserted_pre_truncdrop;
rec->tuples_updated = rec->updated_pre_truncdrop;
rec->tuples_deleted = rec->deleted_pre_truncdrop;
}
- pgstat_info->t_counts.t_tuples_inserted += rec->tuples_inserted;
- pgstat_info->t_counts.t_tuples_updated += rec->tuples_updated;
- pgstat_info->t_counts.t_tuples_deleted += rec->tuples_deleted;
- pgstat_info->t_counts.t_delta_dead_tuples +=
+ pgstat_info->counts.tuples_inserted += rec->tuples_inserted;
+ pgstat_info->counts.tuples_updated += rec->tuples_updated;
+ pgstat_info->counts.tuples_deleted += rec->tuples_deleted;
+ pgstat_info->counts.delta_dead_tuples +=
rec->tuples_inserted + rec->tuples_updated;
}
* Ignore entries that didn't accumulate any actual counts, such as
* indexes that were opened by the planner but not used.
*/
- if (memcmp(&lstats->t_counts, &all_zeroes,
+ if (memcmp(&lstats->counts, &all_zeroes,
sizeof(PgStat_TableCounts)) == 0)
{
return true;
/* add the values to the shared entry. */
tabentry = &shtabstats->stats;
- tabentry->numscans += lstats->t_counts.t_numscans;
- if (lstats->t_counts.t_numscans)
+ tabentry->numscans += lstats->counts.numscans;
+ if (lstats->counts.numscans)
{
TimestampTz t = GetCurrentTransactionStopTimestamp();
if (t > tabentry->lastscan)
tabentry->lastscan = t;
}
- tabentry->tuples_returned += lstats->t_counts.t_tuples_returned;
- tabentry->tuples_fetched += lstats->t_counts.t_tuples_fetched;
- tabentry->tuples_inserted += lstats->t_counts.t_tuples_inserted;
- tabentry->tuples_updated += lstats->t_counts.t_tuples_updated;
- tabentry->tuples_deleted += lstats->t_counts.t_tuples_deleted;
- tabentry->tuples_hot_updated += lstats->t_counts.t_tuples_hot_updated;
- tabentry->tuples_newpage_updated += lstats->t_counts.t_tuples_newpage_updated;
+ tabentry->tuples_returned += lstats->counts.tuples_returned;
+ tabentry->tuples_fetched += lstats->counts.tuples_fetched;
+ tabentry->tuples_inserted += lstats->counts.tuples_inserted;
+ tabentry->tuples_updated += lstats->counts.tuples_updated;
+ tabentry->tuples_deleted += lstats->counts.tuples_deleted;
+ tabentry->tuples_hot_updated += lstats->counts.tuples_hot_updated;
+ tabentry->tuples_newpage_updated += lstats->counts.tuples_newpage_updated;
/*
* If table was truncated/dropped, first reset the live/dead counters.
*/
- if (lstats->t_counts.t_truncdropped)
+ if (lstats->counts.truncdropped)
{
tabentry->live_tuples = 0;
tabentry->dead_tuples = 0;
tabentry->ins_since_vacuum = 0;
}
- tabentry->live_tuples += lstats->t_counts.t_delta_live_tuples;
- tabentry->dead_tuples += lstats->t_counts.t_delta_dead_tuples;
- tabentry->mod_since_analyze += lstats->t_counts.t_changed_tuples;
- tabentry->ins_since_vacuum += lstats->t_counts.t_tuples_inserted;
- tabentry->blocks_fetched += lstats->t_counts.t_blocks_fetched;
- tabentry->blocks_hit += lstats->t_counts.t_blocks_hit;
+ tabentry->live_tuples += lstats->counts.delta_live_tuples;
+ tabentry->dead_tuples += lstats->counts.delta_dead_tuples;
+ tabentry->mod_since_analyze += lstats->counts.changed_tuples;
+ tabentry->ins_since_vacuum += lstats->counts.tuples_inserted;
+ tabentry->blocks_fetched += lstats->counts.blocks_fetched;
+ tabentry->blocks_hit += lstats->counts.blocks_hit;
/* Clamp live_tuples in case of negative delta_live_tuples */
tabentry->live_tuples = Max(tabentry->live_tuples, 0);
/* The entry was successfully flushed, add the same to database stats */
dbentry = pgstat_prep_database_pending(dboid);
- dbentry->tuples_returned += lstats->t_counts.t_tuples_returned;
- dbentry->tuples_fetched += lstats->t_counts.t_tuples_fetched;
- dbentry->tuples_inserted += lstats->t_counts.t_tuples_inserted;
- dbentry->tuples_updated += lstats->t_counts.t_tuples_updated;
- dbentry->tuples_deleted += lstats->t_counts.t_tuples_deleted;
- dbentry->blocks_fetched += lstats->t_counts.t_blocks_fetched;
- dbentry->blocks_hit += lstats->t_counts.t_blocks_hit;
+ dbentry->tuples_returned += lstats->counts.tuples_returned;
+ dbentry->tuples_fetched += lstats->counts.tuples_fetched;
+ dbentry->tuples_inserted += lstats->counts.tuples_inserted;
+ dbentry->tuples_updated += lstats->counts.tuples_updated;
+ dbentry->tuples_deleted += lstats->counts.tuples_deleted;
+ dbentry->blocks_fetched += lstats->counts.blocks_fetched;
+ dbentry->blocks_hit += lstats->counts.blocks_hit;
return true;
}
isshared ? InvalidOid : MyDatabaseId,
rel_id, NULL);
pending = entry_ref->pending;
- pending->t_id = rel_id;
- pending->t_shared = isshared;
+ pending->id = rel_id;
+ pending->shared = isshared;
return pending;
}
if ((funcentry = pgstat_fetch_stat_funcentry(funcid)) == NULL)
PG_RETURN_NULL();
- PG_RETURN_INT64(funcentry->f_numcalls);
+ PG_RETURN_INT64(funcentry->numcalls);
}
Datum
if ((funcentry = pgstat_fetch_stat_funcentry(funcid)) == NULL)
PG_RETURN_NULL();
/* convert counter from microsec to millisec for display */
- PG_RETURN_FLOAT8(((double) funcentry->f_total_time) / 1000.0);
+ PG_RETURN_FLOAT8(((double) funcentry->total_time) / 1000.0);
}
Datum
if ((funcentry = pgstat_fetch_stat_funcentry(funcid)) == NULL)
PG_RETURN_NULL();
/* convert counter from microsec to millisec for display */
- PG_RETURN_FLOAT8(((double) funcentry->f_self_time) / 1000.0);
+ PG_RETURN_FLOAT8(((double) funcentry->self_time) / 1000.0);
}
Datum
if ((tabentry = find_tabstat_entry(relid)) == NULL)
result = 0;
else
- result = (int64) (tabentry->t_counts.t_numscans);
+ result = (int64) (tabentry->counts.numscans);
PG_RETURN_INT64(result);
}
if ((tabentry = find_tabstat_entry(relid)) == NULL)
result = 0;
else
- result = (int64) (tabentry->t_counts.t_tuples_returned);
+ result = (int64) (tabentry->counts.tuples_returned);
PG_RETURN_INT64(result);
}
if ((tabentry = find_tabstat_entry(relid)) == NULL)
result = 0;
else
- result = (int64) (tabentry->t_counts.t_tuples_fetched);
+ result = (int64) (tabentry->counts.tuples_fetched);
PG_RETURN_INT64(result);
}
result = 0;
else
{
- result = tabentry->t_counts.t_tuples_inserted;
- /* live subtransactions' counts aren't in t_tuples_inserted yet */
+ result = tabentry->counts.tuples_inserted;
+ /* live subtransactions' counts aren't in tuples_inserted yet */
for (trans = tabentry->trans; trans != NULL; trans = trans->upper)
result += trans->tuples_inserted;
}
result = 0;
else
{
- result = tabentry->t_counts.t_tuples_updated;
- /* live subtransactions' counts aren't in t_tuples_updated yet */
+ result = tabentry->counts.tuples_updated;
+ /* live subtransactions' counts aren't in tuples_updated yet */
for (trans = tabentry->trans; trans != NULL; trans = trans->upper)
result += trans->tuples_updated;
}
result = 0;
else
{
- result = tabentry->t_counts.t_tuples_deleted;
- /* live subtransactions' counts aren't in t_tuples_deleted yet */
+ result = tabentry->counts.tuples_deleted;
+ /* live subtransactions' counts aren't in tuples_deleted yet */
for (trans = tabentry->trans; trans != NULL; trans = trans->upper)
result += trans->tuples_deleted;
}
if ((tabentry = find_tabstat_entry(relid)) == NULL)
result = 0;
else
- result = (int64) (tabentry->t_counts.t_tuples_hot_updated);
+ result = (int64) (tabentry->counts.tuples_hot_updated);
PG_RETURN_INT64(result);
}
if ((tabentry = find_tabstat_entry(relid)) == NULL)
result = 0;
else
- result = (int64) (tabentry->t_counts.t_tuples_newpage_updated);
+ result = (int64) (tabentry->counts.tuples_newpage_updated);
PG_RETURN_INT64(result);
}
if ((tabentry = find_tabstat_entry(relid)) == NULL)
result = 0;
else
- result = (int64) (tabentry->t_counts.t_blocks_fetched);
+ result = (int64) (tabentry->counts.blocks_fetched);
PG_RETURN_INT64(result);
}
if ((tabentry = find_tabstat_entry(relid)) == NULL)
result = 0;
else
- result = (int64) (tabentry->t_counts.t_blocks_hit);
+ result = (int64) (tabentry->counts.blocks_hit);
PG_RETURN_INT64(result);
}
if ((funcentry = find_funcstat_entry(funcid)) == NULL)
PG_RETURN_NULL();
- PG_RETURN_INT64(funcentry->f_numcalls);
+ PG_RETURN_INT64(funcentry->numcalls);
}
Datum
if ((funcentry = find_funcstat_entry(funcid)) == NULL)
PG_RETURN_NULL();
- PG_RETURN_FLOAT8(INSTR_TIME_GET_MILLISEC(funcentry->f_total_time));
+ PG_RETURN_FLOAT8(INSTR_TIME_GET_MILLISEC(funcentry->total_time));
}
Datum
if ((funcentry = find_funcstat_entry(funcid)) == NULL)
PG_RETURN_NULL();
- PG_RETURN_FLOAT8(INSTR_TIME_GET_MILLISEC(funcentry->f_self_time));
+ PG_RETURN_FLOAT8(INSTR_TIME_GET_MILLISEC(funcentry->self_time));
}
*/
typedef struct PgStat_FunctionCounts
{
- PgStat_Counter f_numcalls;
- instr_time f_total_time;
- instr_time f_self_time;
+ PgStat_Counter numcalls;
+ instr_time total_time;
+ instr_time self_time;
} PgStat_FunctionCounts;
/*
/* Backend-wide total time as of function start */
instr_time save_total;
/* system clock as of function start */
- instr_time f_start;
+ instr_time start;
} PgStat_FunctionCallUsage;
/* ----------
*/
typedef struct PgStat_TableCounts
{
- PgStat_Counter t_numscans;
+ PgStat_Counter numscans;
- PgStat_Counter t_tuples_returned;
- PgStat_Counter t_tuples_fetched;
+ PgStat_Counter tuples_returned;
+ PgStat_Counter tuples_fetched;
- PgStat_Counter t_tuples_inserted;
- PgStat_Counter t_tuples_updated;
- PgStat_Counter t_tuples_deleted;
- PgStat_Counter t_tuples_hot_updated;
- PgStat_Counter t_tuples_newpage_updated;
- bool t_truncdropped;
+ PgStat_Counter tuples_inserted;
+ PgStat_Counter tuples_updated;
+ PgStat_Counter tuples_deleted;
+ PgStat_Counter tuples_hot_updated;
+ PgStat_Counter tuples_newpage_updated;
+ bool truncdropped;
- PgStat_Counter t_delta_live_tuples;
- PgStat_Counter t_delta_dead_tuples;
- PgStat_Counter t_changed_tuples;
+ PgStat_Counter delta_live_tuples;
+ PgStat_Counter delta_dead_tuples;
+ PgStat_Counter changed_tuples;
- PgStat_Counter t_blocks_fetched;
- PgStat_Counter t_blocks_hit;
+ PgStat_Counter blocks_fetched;
+ PgStat_Counter blocks_hit;
} PgStat_TableCounts;
/* ----------
*/
typedef struct PgStat_TableStatus
{
- Oid t_id; /* table's OID */
- bool t_shared; /* is it a shared catalog? */
+ Oid id; /* table's OID */
+ bool shared; /* is it a shared catalog? */
struct PgStat_TableXactStatus *trans; /* lowest subxact's counts */
- PgStat_TableCounts t_counts; /* event counts to be sent */
+ PgStat_TableCounts counts; /* event counts to be sent */
Relation relation; /* rel that is using this entry */
} PgStat_TableStatus;
typedef struct PgStat_StatFuncEntry
{
- PgStat_Counter f_numcalls;
+ PgStat_Counter numcalls;
- PgStat_Counter f_total_time; /* times in microseconds */
- PgStat_Counter f_self_time;
+ PgStat_Counter total_time; /* times in microseconds */
+ PgStat_Counter self_time;
} PgStat_StatFuncEntry;
typedef struct PgStat_StatReplSlotEntry
#define pgstat_count_heap_scan(rel) \
do { \
if (pgstat_should_count_relation(rel)) \
- (rel)->pgstat_info->t_counts.t_numscans++; \
+ (rel)->pgstat_info->counts.numscans++; \
} while (0)
#define pgstat_count_heap_getnext(rel) \
do { \
if (pgstat_should_count_relation(rel)) \
- (rel)->pgstat_info->t_counts.t_tuples_returned++; \
+ (rel)->pgstat_info->counts.tuples_returned++; \
} while (0)
#define pgstat_count_heap_fetch(rel) \
do { \
if (pgstat_should_count_relation(rel)) \
- (rel)->pgstat_info->t_counts.t_tuples_fetched++; \
+ (rel)->pgstat_info->counts.tuples_fetched++; \
} while (0)
#define pgstat_count_index_scan(rel) \
do { \
if (pgstat_should_count_relation(rel)) \
- (rel)->pgstat_info->t_counts.t_numscans++; \
+ (rel)->pgstat_info->counts.numscans++; \
} while (0)
#define pgstat_count_index_tuples(rel, n) \
do { \
if (pgstat_should_count_relation(rel)) \
- (rel)->pgstat_info->t_counts.t_tuples_returned += (n); \
+ (rel)->pgstat_info->counts.tuples_returned += (n); \
} while (0)
#define pgstat_count_buffer_read(rel) \
do { \
if (pgstat_should_count_relation(rel)) \
- (rel)->pgstat_info->t_counts.t_blocks_fetched++; \
+ (rel)->pgstat_info->counts.blocks_fetched++; \
} while (0)
#define pgstat_count_buffer_hit(rel) \
do { \
if (pgstat_should_count_relation(rel)) \
- (rel)->pgstat_info->t_counts.t_blocks_hit++; \
+ (rel)->pgstat_info->counts.blocks_hit++; \
} while (0)
extern void pgstat_count_heap_insert(Relation rel, PgStat_Counter n);
projects / postgresql.git / commitdiff