v3-0001-remove_nonmeaningful_prefixes.patch

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