Hi,
On 3/23/23 1:09 AM, Michael Paquier wrote:
On Wed, Mar 22, 2023 at 02:52:23PM -0400, Melanie Plageman wrote:
This comment still has the t_ prefix as does the one for tuples_updated
and deleted.
otherwise, LGTM.
Good catch. pgstat_count_heap_update() has a t_tuples_hot_updated,
and pgstat_update_heap_dead_tuples() a t_delta_dead_tuples on top of
the three you have just reported.
I have grepped for all the fields renamed, and nothing else stands
out. However, my eyes don't have a 100% accuracy, either.
Thank you both for your keen eye! I just did another check too and did not
find more than the ones you've just reported.
Please find attached V3 getting rid of them.
Regards,
--
Bertrand Drouvot
PostgreSQL Contributors Team
RDS Open Source Databases
Amazon Web Services: https://aws.amazon.com
diff --git a/src/backend/utils/activity/pgstat_function.c
b/src/backend/utils/activity/pgstat_function.c
index 0fdcefb783..79e781167b 100644
--- a/src/backend/utils/activity/pgstat_function.c
+++ b/src/backend/utils/activity/pgstat_function.c
@@ -124,13 +124,13 @@ pgstat_init_function_usage(FunctionCallInfo fcinfo,
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);
}
/*
@@ -146,41 +146,41 @@ void
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);
}
/*
@@ -203,11 +203,11 @@ pgstat_function_flush_cb(PgStat_EntryRef *entry_ref, bool
nowait)
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);
diff --git a/src/backend/utils/activity/pgstat_relation.c
b/src/backend/utils/activity/pgstat_relation.c
index f793ac1516..8b230778d3 100644
--- a/src/backend/utils/activity/pgstat_relation.c
+++ b/src/backend/utils/activity/pgstat_relation.c
@@ -38,9 +38,9 @@ typedef struct TwoPhasePgStatRecord
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;
@@ -310,7 +310,7 @@ pgstat_report_analyze(Relation rel,
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);
@@ -382,9 +382,9 @@ pgstat_count_heap_update(Relation rel, bool hot)
ensure_tabstat_xact_level(pgstat_info);
pgstat_info->trans->tuples_updated++;
- /* t_tuples_hot_updated is nontransactional, so just advance it
*/
+ /* tuples_hot_updated is nontransactional, so just advance it */
if (hot)
- pgstat_info->t_counts.t_tuples_hot_updated++;
+ pgstat_info->counts.tuples_hot_updated++;
}
}
@@ -425,7 +425,7 @@ pgstat_count_truncate(Relation rel)
* 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.
*/
@@ -436,7 +436,7 @@ pgstat_update_heap_dead_tuples(Relation rel, int delta)
{
PgStat_TableStatus *pgstat_info = rel->pgstat_info;
- pgstat_info->t_counts.t_delta_dead_tuples -= delta;
+ pgstat_info->counts.delta_dead_tuples -= delta;
}
}
@@ -512,33 +512,33 @@ AtEOXact_PgStat_Relations(PgStat_SubXactStatus
*xact_state, bool isCommit)
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 */
}
@@ -618,11 +618,11 @@ AtEOSubXact_PgStat_Relations(PgStat_SubXactStatus
*xact_state, bool isCommit, in
/* 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);
@@ -655,9 +655,9 @@ AtPrepare_PgStat_Relations(PgStat_SubXactStatus *xact_state)
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));
@@ -699,24 +699,24 @@ pgstat_twophase_postcommit(TransactionId xid, uint16 info,
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;
}
@@ -735,19 +735,19 @@ pgstat_twophase_postabort(TransactionId xid, uint16 info,
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;
}
@@ -778,7 +778,7 @@ pgstat_relation_flush_cb(PgStat_EntryRef *entry_ref, bool
nowait)
* 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;
@@ -790,37 +790,37 @@ pgstat_relation_flush_cb(PgStat_EntryRef *entry_ref, bool
nowait)
/* 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_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;
/*
* 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);
@@ -831,13 +831,13 @@ pgstat_relation_flush_cb(PgStat_EntryRef *entry_ref, bool
nowait)
/* 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;
}
@@ -865,8 +865,8 @@ pgstat_prep_relation_pending(Oid rel_id, bool isshared)
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;
}
diff --git a/src/backend/utils/adt/pgstatfuncs.c
b/src/backend/utils/adt/pgstatfuncs.c
index 35c6d46555..96e7b6fa7a 100644
--- a/src/backend/utils/adt/pgstatfuncs.c
+++ b/src/backend/utils/adt/pgstatfuncs.c
@@ -146,7 +146,7 @@ pg_stat_get_function_calls(PG_FUNCTION_ARGS)
if ((funcentry = pgstat_fetch_stat_funcentry(funcid)) == NULL)
PG_RETURN_NULL();
- PG_RETURN_INT64(funcentry->f_numcalls);
+ PG_RETURN_INT64(funcentry->numcalls);
}
Datum
@@ -158,7 +158,7 @@ pg_stat_get_function_total_time(PG_FUNCTION_ARGS)
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
@@ -170,7 +170,7 @@ pg_stat_get_function_self_time(PG_FUNCTION_ARGS)
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
@@ -1505,7 +1505,7 @@ pg_stat_get_xact_numscans(PG_FUNCTION_ARGS)
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);
}
@@ -1520,7 +1520,7 @@ pg_stat_get_xact_tuples_returned(PG_FUNCTION_ARGS)
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);
}
@@ -1535,7 +1535,7 @@ pg_stat_get_xact_tuples_fetched(PG_FUNCTION_ARGS)
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);
}
@@ -1552,8 +1552,8 @@ pg_stat_get_xact_tuples_inserted(PG_FUNCTION_ARGS)
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;
}
@@ -1573,8 +1573,8 @@ pg_stat_get_xact_tuples_updated(PG_FUNCTION_ARGS)
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;
}
@@ -1594,8 +1594,8 @@ pg_stat_get_xact_tuples_deleted(PG_FUNCTION_ARGS)
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;
}
@@ -1613,7 +1613,7 @@ pg_stat_get_xact_tuples_hot_updated(PG_FUNCTION_ARGS)
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);
}
@@ -1628,7 +1628,7 @@ pg_stat_get_xact_blocks_fetched(PG_FUNCTION_ARGS)
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);
}
@@ -1643,7 +1643,7 @@ pg_stat_get_xact_blocks_hit(PG_FUNCTION_ARGS)
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);
}
@@ -1656,7 +1656,7 @@ pg_stat_get_xact_function_calls(PG_FUNCTION_ARGS)
if ((funcentry = find_funcstat_entry(funcid)) == NULL)
PG_RETURN_NULL();
- PG_RETURN_INT64(funcentry->f_numcalls);
+ PG_RETURN_INT64(funcentry->numcalls);
}
Datum
@@ -1667,7 +1667,7 @@ pg_stat_get_xact_function_total_time(PG_FUNCTION_ARGS)
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
@@ -1678,7 +1678,7 @@ pg_stat_get_xact_function_self_time(PG_FUNCTION_ARGS)
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));
}
diff --git a/src/include/pgstat.h b/src/include/pgstat.h
index 1e418b682b..9077469657 100644
--- a/src/include/pgstat.h
+++ b/src/include/pgstat.h
@@ -106,9 +106,9 @@ typedef int64 PgStat_Counter;
*/
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;
/*
@@ -124,7 +124,7 @@ typedef struct PgStat_FunctionCallUsage
/* 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;
/* ----------
@@ -159,23 +159,23 @@ typedef struct PgStat_BackendSubEntry
*/
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;
- bool t_truncdropped;
+ PgStat_Counter tuples_inserted;
+ PgStat_Counter tuples_updated;
+ PgStat_Counter tuples_deleted;
+ PgStat_Counter tuples_hot_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;
/* ----------
@@ -195,10 +195,10 @@ typedef struct 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;
@@ -351,10 +351,10 @@ typedef struct PgStat_StatDBEntry
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
@@ -582,37 +582,37 @@ extern void pgstat_report_analyze(Relation rel,
#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);
