diff --git a/src/backend/utils/activity/pgstat_function.c b/src/backend/utils/activity/pgstat_function.c index 6139a27fee..77af8541e0 100644 --- a/src/backend/utils/activity/pgstat_function.c +++ b/src/backend/utils/activity/pgstat_function.c @@ -124,7 +124,7 @@ pgstat_init_function_usage(FunctionCallInfo fcinfo, fcu->fs = &pending->f_counts; /* save stats for this function, later used to compensate for recursion */ - fcu->save_f_total_time = pending->f_counts.f_total_time; + fcu->save_total_time = pending->f_counts.total_time; /* save current backend-wide total time */ fcu->save_total = total_func_time; @@ -168,19 +168,19 @@ pgstat_end_function_usage(PgStat_FunctionCallUsage *fcu, bool finalize) INSTR_TIME_ADD(total_func_time, f_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(f_total, fcu->save_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->total_time = f_total; + INSTR_TIME_ADD(fs->self_time, f_self); } /* @@ -204,10 +204,10 @@ pgstat_function_flush_cb(PgStat_EntryRef *entry_ref, bool nowait) return false; shfuncent->stats.f_numcalls += localent->f_counts.f_numcalls; - shfuncent->stats.f_total_time += - INSTR_TIME_GET_MICROSEC(localent->f_counts.f_total_time); - shfuncent->stats.f_self_time += - INSTR_TIME_GET_MICROSEC(localent->f_counts.f_self_time); + shfuncent->stats.total_time += + INSTR_TIME_GET_MICROSEC(localent->f_counts.total_time); + shfuncent->stats.self_time += + INSTR_TIME_GET_MICROSEC(localent->f_counts.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 1730425de1..625cd2a96f 100644 --- a/src/backend/utils/activity/pgstat_relation.c +++ b/src/backend/utils/activity/pgstat_relation.c @@ -371,9 +371,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->t_counts.tuples_hot_updated++; } } @@ -501,9 +501,9 @@ 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->t_counts.tuples_inserted += trans->tuples_inserted; + tabstat->t_counts.tuples_updated += trans->tuples_updated; + tabstat->t_counts.tuples_deleted += trans->tuples_deleted; if (isCommit) { tabstat->t_counts.t_truncdropped = trans->truncdropped; @@ -607,9 +607,9 @@ 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->t_counts.tuples_inserted += trans->tuples_inserted; + tabstat->t_counts.tuples_updated += trans->tuples_updated; + tabstat->t_counts.tuples_deleted += trans->tuples_deleted; /* inserted tuples are dead, deleted tuples are unaffected */ tabstat->t_counts.t_delta_dead_tuples += trans->tuples_inserted + trans->tuples_updated; @@ -691,9 +691,9 @@ pgstat_twophase_postcommit(TransactionId xid, uint16 info, pgstat_info = pgstat_prep_relation_pending(rec->t_id, rec->t_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.tuples_inserted += rec->tuples_inserted; + pgstat_info->t_counts.tuples_updated += rec->tuples_updated; + pgstat_info->t_counts.tuples_deleted += rec->tuples_deleted; pgstat_info->t_counts.t_truncdropped = rec->t_truncdropped; if (rec->t_truncdropped) { @@ -733,9 +733,9 @@ pgstat_twophase_postabort(TransactionId xid, uint16 info, 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.tuples_inserted += rec->tuples_inserted; + pgstat_info->t_counts.tuples_updated += rec->tuples_updated; + pgstat_info->t_counts.tuples_deleted += rec->tuples_deleted; pgstat_info->t_counts.t_delta_dead_tuples += rec->tuples_inserted + rec->tuples_updated; } @@ -779,19 +779,19 @@ 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->t_counts.numscans; + if (lstats->t_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->t_counts.tuples_returned; + tabentry->tuples_fetched += lstats->t_counts.tuples_fetched; + tabentry->tuples_inserted += lstats->t_counts.tuples_inserted; + tabentry->tuples_updated += lstats->t_counts.tuples_updated; + tabentry->tuples_deleted += lstats->t_counts.tuples_deleted; + tabentry->tuples_hot_updated += lstats->t_counts.tuples_hot_updated; /* * If table was truncated/dropped, first reset the live/dead counters. @@ -806,9 +806,9 @@ pgstat_relation_flush_cb(PgStat_EntryRef *entry_ref, bool nowait) 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->ins_since_vacuum += lstats->t_counts.tuples_inserted; + tabentry->blocks_fetched += lstats->t_counts.blocks_fetched; + tabentry->blocks_hit += lstats->t_counts.blocks_hit; /* Clamp live_tuples in case of negative delta_live_tuples */ tabentry->live_tuples = Max(tabentry->live_tuples, 0); @@ -819,13 +819,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->t_counts.tuples_returned; + dbentry->tuples_fetched += lstats->t_counts.tuples_fetched; + dbentry->tuples_inserted += lstats->t_counts.tuples_inserted; + dbentry->tuples_updated += lstats->t_counts.tuples_updated; + dbentry->tuples_deleted += lstats->t_counts.tuples_deleted; + dbentry->blocks_fetched += lstats->t_counts.blocks_fetched; + dbentry->blocks_hit += lstats->t_counts.blocks_hit; return true; } diff --git a/src/backend/utils/adt/pgstatfuncs.c b/src/backend/utils/adt/pgstatfuncs.c index 6cddd74aa7..27bb928db4 100644 --- a/src/backend/utils/adt/pgstatfuncs.c +++ b/src/backend/utils/adt/pgstatfuncs.c @@ -148,29 +148,24 @@ pg_stat_get_function_calls(PG_FUNCTION_ARGS) PG_RETURN_INT64(funcentry->f_numcalls); } -Datum -pg_stat_get_function_total_time(PG_FUNCTION_ARGS) -{ - Oid funcid = PG_GETARG_OID(0); - PgStat_StatFuncEntry *funcentry; - - 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); +#define PG_STAT_GET_FUNCENTRY_FLOAT8(stat) \ +Datum \ +CppConcat(pg_stat_get_function_,stat)(PG_FUNCTION_ARGS) \ +{ \ + Oid funcid = PG_GETARG_OID(0); \ + PgStat_StatFuncEntry *funcentry; \ + \ + if ((funcentry = pgstat_fetch_stat_funcentry(funcid)) == NULL) \ + PG_RETURN_NULL(); \ + /* convert counter from microsec to millisec for display */ \ + PG_RETURN_FLOAT8(((double) funcentry->stat) / 1000.0); \ } -Datum -pg_stat_get_function_self_time(PG_FUNCTION_ARGS) -{ - Oid funcid = PG_GETARG_OID(0); - PgStat_StatFuncEntry *funcentry; +/* pg_stat_get_function_total_time */ +PG_STAT_GET_FUNCENTRY_FLOAT8(total_time) - 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_stat_get_function_self_time */ +PG_STAT_GET_FUNCENTRY_FLOAT8(self_time) Datum pg_stat_get_backend_idset(PG_FUNCTION_ARGS) @@ -1345,158 +1340,70 @@ pg_stat_get_slru(PG_FUNCTION_ARGS) return (Datum) 0; } -Datum -pg_stat_get_xact_numscans(PG_FUNCTION_ARGS) -{ - Oid relid = PG_GETARG_OID(0); - int64 result; - PgStat_TableStatus *tabentry; - - if ((tabentry = find_tabstat_entry(relid)) == NULL) - result = 0; - else - result = (int64) (tabentry->t_counts.t_numscans); - - PG_RETURN_INT64(result); -} - -Datum -pg_stat_get_xact_tuples_returned(PG_FUNCTION_ARGS) -{ - Oid relid = PG_GETARG_OID(0); - int64 result; - PgStat_TableStatus *tabentry; - - if ((tabentry = find_tabstat_entry(relid)) == NULL) - result = 0; - else - result = (int64) (tabentry->t_counts.t_tuples_returned); - - PG_RETURN_INT64(result); -} - -Datum -pg_stat_get_xact_tuples_fetched(PG_FUNCTION_ARGS) -{ - Oid relid = PG_GETARG_OID(0); - int64 result; - PgStat_TableStatus *tabentry; - - if ((tabentry = find_tabstat_entry(relid)) == NULL) - result = 0; - else - result = (int64) (tabentry->t_counts.t_tuples_fetched); - - PG_RETURN_INT64(result); -} - -Datum -pg_stat_get_xact_tuples_inserted(PG_FUNCTION_ARGS) -{ - Oid relid = PG_GETARG_OID(0); - int64 result; - PgStat_TableStatus *tabentry; - PgStat_TableXactStatus *trans; - - if ((tabentry = find_tabstat_entry(relid)) == NULL) - result = 0; - else - { - result = tabentry->t_counts.t_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; - } - - PG_RETURN_INT64(result); -} - -Datum -pg_stat_get_xact_tuples_updated(PG_FUNCTION_ARGS) -{ - Oid relid = PG_GETARG_OID(0); - int64 result; - PgStat_TableStatus *tabentry; - PgStat_TableXactStatus *trans; - - if ((tabentry = find_tabstat_entry(relid)) == NULL) - result = 0; - else - { - result = tabentry->t_counts.t_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; - } - - PG_RETURN_INT64(result); -} - -Datum -pg_stat_get_xact_tuples_deleted(PG_FUNCTION_ARGS) -{ - Oid relid = PG_GETARG_OID(0); - int64 result; - PgStat_TableStatus *tabentry; - PgStat_TableXactStatus *trans; - - if ((tabentry = find_tabstat_entry(relid)) == NULL) - result = 0; - else - { - result = tabentry->t_counts.t_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; - } - - PG_RETURN_INT64(result); -} - -Datum -pg_stat_get_xact_tuples_hot_updated(PG_FUNCTION_ARGS) -{ - Oid relid = PG_GETARG_OID(0); - int64 result; - PgStat_TableStatus *tabentry; - - if ((tabentry = find_tabstat_entry(relid)) == NULL) - result = 0; - else - result = (int64) (tabentry->t_counts.t_tuples_hot_updated); - - PG_RETURN_INT64(result); -} - -Datum -pg_stat_get_xact_blocks_fetched(PG_FUNCTION_ARGS) -{ - Oid relid = PG_GETARG_OID(0); - int64 result; - PgStat_TableStatus *tabentry; - - if ((tabentry = find_tabstat_entry(relid)) == NULL) - result = 0; - else - result = (int64) (tabentry->t_counts.t_blocks_fetched); - - PG_RETURN_INT64(result); -} - -Datum -pg_stat_get_xact_blocks_hit(PG_FUNCTION_ARGS) -{ - Oid relid = PG_GETARG_OID(0); - int64 result; - PgStat_TableStatus *tabentry; - - if ((tabentry = find_tabstat_entry(relid)) == NULL) - result = 0; - else - result = (int64) (tabentry->t_counts.t_blocks_hit); - - PG_RETURN_INT64(result); -} +#define PG_STAT_GET_XACT_RELENTRY_INT64(stat) \ +Datum \ +CppConcat(pg_stat_get_xact_,stat)(PG_FUNCTION_ARGS) \ +{ \ + Oid relid = PG_GETARG_OID(0); \ + int64 result; \ + PgStat_TableStatus *tabentry; \ + \ + if ((tabentry = find_tabstat_entry(relid)) == NULL) \ + result = 0; \ + else \ + result = (int64) (tabentry->t_counts.stat); \ + \ + PG_RETURN_INT64(result); \ +} + +/* pg_stat_get_xact_numscans */ +PG_STAT_GET_XACT_RELENTRY_INT64(numscans) + +/* pg_stat_get_xact_tuples_returned */ +PG_STAT_GET_XACT_RELENTRY_INT64(tuples_returned) + +/* pg_stat_get_xact_tuples_fetched */ +PG_STAT_GET_XACT_RELENTRY_INT64(tuples_fetched) + +/* pg_stat_get_xact_tuples_hot_updated */ +PG_STAT_GET_XACT_RELENTRY_INT64(tuples_hot_updated) + +/* pg_stat_get_xact_blocks_fetched */ +PG_STAT_GET_XACT_RELENTRY_INT64(blocks_fetched) + +/* pg_stat_get_xact_blocks_hit */ +PG_STAT_GET_XACT_RELENTRY_INT64(blocks_hit) + +#define PG_STAT_GET_XACT_WITH_SUBTRANS_RELENTRY_INT64(stat) \ +Datum \ +CppConcat(pg_stat_get_xact_,stat)(PG_FUNCTION_ARGS) \ +{ \ + Oid relid = PG_GETARG_OID(0); \ + int64 result; \ + PgStat_TableStatus *tabentry; \ + PgStat_TableXactStatus *trans; \ + \ + if ((tabentry = find_tabstat_entry(relid)) == NULL) \ + result = 0; \ + else \ + { \ + result = tabentry->t_counts.stat; \ + /* live subtransactions' counts aren't in the stat yet */ \ + for (trans = tabentry->trans; trans != NULL; trans = trans->upper) \ + result += trans->stat; \ + } \ + \ + PG_RETURN_INT64(result); \ +} + +/* pg_stat_get_xact_tuples_inserted */ +PG_STAT_GET_XACT_WITH_SUBTRANS_RELENTRY_INT64(tuples_inserted) + +/* pg_stat_get_xact_tuples_updated */ +PG_STAT_GET_XACT_WITH_SUBTRANS_RELENTRY_INT64(tuples_updated) + +/* pg_stat_get_xact_tuples_deleted */ +PG_STAT_GET_XACT_WITH_SUBTRANS_RELENTRY_INT64(tuples_deleted) Datum pg_stat_get_xact_function_calls(PG_FUNCTION_ARGS) @@ -1509,28 +1416,23 @@ pg_stat_get_xact_function_calls(PG_FUNCTION_ARGS) PG_RETURN_INT64(funcentry->f_counts.f_numcalls); } -Datum -pg_stat_get_xact_function_total_time(PG_FUNCTION_ARGS) -{ - Oid funcid = PG_GETARG_OID(0); - PgStat_BackendFunctionEntry *funcentry; - - if ((funcentry = find_funcstat_entry(funcid)) == NULL) - PG_RETURN_NULL(); - PG_RETURN_FLOAT8(INSTR_TIME_GET_MILLISEC(funcentry->f_counts.f_total_time)); +#define PG_STAT_GET_XACT_FUNCENTRY_FLOAT8(stat) \ +Datum \ +CppConcat(pg_stat_get_xact_function_,stat)(PG_FUNCTION_ARGS) \ +{ \ + Oid funcid = PG_GETARG_OID(0); \ + PgStat_BackendFunctionEntry *funcentry; \ + \ + if ((funcentry = find_funcstat_entry(funcid)) == NULL) \ + PG_RETURN_NULL(); \ + PG_RETURN_FLOAT8(INSTR_TIME_GET_MILLISEC(funcentry->f_counts.stat)); \ } -Datum -pg_stat_get_xact_function_self_time(PG_FUNCTION_ARGS) -{ - Oid funcid = PG_GETARG_OID(0); - PgStat_BackendFunctionEntry *funcentry; - - if ((funcentry = find_funcstat_entry(funcid)) == NULL) - PG_RETURN_NULL(); - PG_RETURN_FLOAT8(INSTR_TIME_GET_MILLISEC(funcentry->f_counts.f_self_time)); -} +/* pg_stat_get_xact_function_total_time */ +PG_STAT_GET_XACT_FUNCENTRY_FLOAT8(total_time) +/* pg_stat_get_xact_function_self_time */ +PG_STAT_GET_XACT_FUNCENTRY_FLOAT8(self_time) /* Get the timestamp of the current statistics snapshot */ Datum diff --git a/src/include/pgstat.h b/src/include/pgstat.h index d3e965d744..d26d0d8324 100644 --- a/src/include/pgstat.h +++ b/src/include/pgstat.h @@ -106,8 +106,8 @@ typedef int64 PgStat_Counter; typedef struct PgStat_FunctionCounts { PgStat_Counter f_numcalls; - instr_time f_total_time; - instr_time f_self_time; + instr_time total_time; + instr_time self_time; } PgStat_FunctionCounts; /* ---------- @@ -128,7 +128,7 @@ typedef struct PgStat_FunctionCallUsage /* NULL means we are not tracking the current function call */ PgStat_FunctionCounts *fs; /* Total time previously charged to function, as of function start */ - instr_time save_f_total_time; + instr_time save_total_time; /* Backend-wide total time as of function start */ instr_time save_total; /* system clock as of function start */ @@ -167,23 +167,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; + PgStat_Counter tuples_inserted; + PgStat_Counter tuples_updated; + PgStat_Counter tuples_deleted; + PgStat_Counter tuples_hot_updated; bool t_truncdropped; PgStat_Counter t_delta_live_tuples; PgStat_Counter t_delta_dead_tuples; PgStat_Counter t_changed_tuples; - PgStat_Counter t_blocks_fetched; - PgStat_Counter t_blocks_hit; + PgStat_Counter blocks_fetched; + PgStat_Counter blocks_hit; } PgStat_TableCounts; /* ---------- @@ -315,8 +315,8 @@ typedef struct PgStat_StatFuncEntry { PgStat_Counter f_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 @@ -525,37 +525,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->t_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->t_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->t_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->t_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->t_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->t_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->t_counts.blocks_hit++; \ } while (0) extern void pgstat_count_heap_insert(Relation rel, PgStat_Counter n);