Hi,
On 3/20/23 8:32 AM, Michael Paquier wrote:
/* Total time previously charged to function, as of function start */
- instr_time save_f_total_time;
+ instr_time save_total_time;
I have something to say about this one, though.. I find this change a
bit confusing. It may be better kept as it is, or I think that we'd
better rename also "save_total" and "start" to reflect in a better way
what they do, because removing "f_" reduces the meaning of the field
with the two others in the same structure.
Thanks for looking at it!
Good point and keeping it as it is currently would not
affect the work that is/will be done in [1].
So, please find attached V2 attached taking this comment into account.
[1]:
https://www.postgresql.org/message-id/flat/89606d96-cd94-af74-18f3-c7ab2b684ba2%40gmail.com
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..85c24e6869 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);
@@ -384,7 +384,7 @@ pgstat_count_heap_update(Relation rel, bool hot)
/* t_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++;
}
}
@@ -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..4f21fb2dc2 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,7 +1552,7 @@ pg_stat_get_xact_tuples_inserted(PG_FUNCTION_ARGS)
result = 0;
else
{
- result = tabentry->t_counts.t_tuples_inserted;
+ result = tabentry->counts.tuples_inserted;
/* live subtransactions' counts aren't in t_tuples_inserted yet
*/
for (trans = tabentry->trans; trans != NULL; trans =
trans->upper)
result += trans->tuples_inserted;
@@ -1573,7 +1573,7 @@ pg_stat_get_xact_tuples_updated(PG_FUNCTION_ARGS)
result = 0;
else
{
- result = tabentry->t_counts.t_tuples_updated;
+ result = tabentry->counts.tuples_updated;
/* live subtransactions' counts aren't in t_tuples_updated yet
*/
for (trans = tabentry->trans; trans != NULL; trans =
trans->upper)
result += trans->tuples_updated;
@@ -1594,7 +1594,7 @@ pg_stat_get_xact_tuples_deleted(PG_FUNCTION_ARGS)
result = 0;
else
{
- result = tabentry->t_counts.t_tuples_deleted;
+ result = tabentry->counts.tuples_deleted;
/* live subtransactions' counts aren't in t_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);
