open-dsi
/
postgres
mirror of https://github.com/postgres/postgres
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Rename fields in pgstat structures for functions and relations

Browse Source 
This commit renames the members of a few pgstat structures related to
functions and relations, by respectively removing their prefix "f_" and
"t_".  The statistics for functions and relations and handled in their
own file, and pgstatfuncs.c associates each field in a structure
variable named based on the object type handled, so no information is
lost with this rename.

This will help with some of the refactoring aimed for pgstatfuncs.c, as
this makes more consistent the field names with the SQL functions
retrieving them.

Author: Bertrand Drouvot
Reviewed-by: Michael Paquier, Melanie Plageman
Discussion: https://postgr.es/m/9142f62a-a422-145c-bde0-b5bc498a4ada@gmail.com
pull/137/head
Michael Paquier 3 years ago
parent 11a0a8b529
commit 8089517ab8
4 changed files with 142 additions and 142 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 46
      src/backend/utils/activity/pgstat_function.c
  2. 138
      src/backend/utils/activity/pgstat_relation.c
  3. 38
      src/backend/utils/adt/pgstatfuncs.c
  4. 62
      src/include/pgstat.h

46
src/backend/utils/activity/pgstat_function.c
Unescape View File

@ -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);

138
src/backend/utils/activity/pgstat_relation.c
Unescape View File

@ -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);
@ -385,13 +385,13 @@ pgstat_count_heap_update(Relation rel, bool hot, bool newpage)
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++;
}
}
@ -432,7 +432,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.
*/
@ -443,7 +443,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;
}
}
@ -519,33 +519,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 */
}
@ -625,11 +625,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);
@ -662,9 +662,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));
@ -706,24 +706,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;
}
@ -742,19 +742,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;
}
@ -785,7 +785,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;
@ -797,38 +797,38 @@ 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_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);
@ -839,13 +839,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;
}
@ -873,8 +873,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;
}

38
src/backend/utils/adt/pgstatfuncs.c
Unescape View File

@ -149,7 +149,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
@ -161,7 +161,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
@ -173,7 +173,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
@ -1508,7 +1508,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);
}
@ -1523,7 +1523,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);
}
@ -1538,7 +1538,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);
}
@ -1555,8 +1555,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;
}
@ -1576,8 +1576,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;
}
@ -1597,8 +1597,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;
}
@ -1616,7 +1616,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);
}
@ -1631,7 +1631,7 @@ pg_stat_get_xact_tuples_newpage_updated(PG_FUNCTION_ARGS)
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);
}
@ -1646,7 +1646,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);
}
@ -1661,7 +1661,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);
}
@ -1674,7 +1674,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
@ -1685,7 +1685,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
@ -1696,7 +1696,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));
}

62
src/include/pgstat.h
Unescape View File

@ -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,24 +159,24 @@ 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;
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;
/* ----------
@ -196,10 +196,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;
@ -352,10 +352,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
@ -584,37 +584,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);

Write Preview
Loading…
Cancel
Save