384 lines
9.7 KiB
C
384 lines
9.7 KiB
C
/* -------------------------------------------------------------------------
|
|
*
|
|
* pgstat_xact.c
|
|
* Transactional integration for the cumulative statistics system.
|
|
*
|
|
* Copyright (c) 2001-2023, PostgreSQL Global Development Group
|
|
*
|
|
* IDENTIFICATION
|
|
* src/backend/utils/activity/pgstat_xact.c
|
|
* -------------------------------------------------------------------------
|
|
*/
|
|
|
|
#include "postgres.h"
|
|
|
|
#include "access/transam.h"
|
|
#include "access/xact.h"
|
|
#include "pgstat.h"
|
|
#include "utils/memutils.h"
|
|
#include "utils/pgstat_internal.h"
|
|
|
|
|
|
typedef struct PgStat_PendingDroppedStatsItem
|
|
{
|
|
xl_xact_stats_item item;
|
|
bool is_create;
|
|
dlist_node node;
|
|
} PgStat_PendingDroppedStatsItem;
|
|
|
|
|
|
static void AtEOXact_PgStat_DroppedStats(PgStat_SubXactStatus *xact_state, bool isCommit);
|
|
static void AtEOSubXact_PgStat_DroppedStats(PgStat_SubXactStatus *xact_state,
|
|
bool isCommit, int nestDepth);
|
|
|
|
static PgStat_SubXactStatus *pgStatXactStack = NULL;
|
|
|
|
|
|
/*
|
|
* Called from access/transam/xact.c at top-level transaction commit/abort.
|
|
*/
|
|
void
|
|
AtEOXact_PgStat(bool isCommit, bool parallel)
|
|
{
|
|
PgStat_SubXactStatus *xact_state;
|
|
|
|
AtEOXact_PgStat_Database(isCommit, parallel);
|
|
|
|
/* handle transactional stats information */
|
|
xact_state = pgStatXactStack;
|
|
if (xact_state != NULL)
|
|
{
|
|
Assert(xact_state->nest_level == 1);
|
|
Assert(xact_state->prev == NULL);
|
|
|
|
AtEOXact_PgStat_Relations(xact_state, isCommit);
|
|
AtEOXact_PgStat_DroppedStats(xact_state, isCommit);
|
|
}
|
|
pgStatXactStack = NULL;
|
|
|
|
/* Make sure any stats snapshot is thrown away */
|
|
pgstat_clear_snapshot();
|
|
}
|
|
|
|
/*
|
|
* When committing, drop stats for objects dropped in the transaction. When
|
|
* aborting, drop stats for objects created in the transaction.
|
|
*/
|
|
static void
|
|
AtEOXact_PgStat_DroppedStats(PgStat_SubXactStatus *xact_state, bool isCommit)
|
|
{
|
|
dlist_mutable_iter iter;
|
|
int not_freed_count = 0;
|
|
|
|
if (dclist_count(&xact_state->pending_drops) == 0)
|
|
return;
|
|
|
|
dclist_foreach_modify(iter, &xact_state->pending_drops)
|
|
{
|
|
PgStat_PendingDroppedStatsItem *pending =
|
|
dclist_container(PgStat_PendingDroppedStatsItem, node, iter.cur);
|
|
xl_xact_stats_item *it = &pending->item;
|
|
|
|
if (isCommit && !pending->is_create)
|
|
{
|
|
/*
|
|
* Transaction that dropped an object committed. Drop the stats
|
|
* too.
|
|
*/
|
|
if (!pgstat_drop_entry(it->kind, it->dboid, it->objoid))
|
|
not_freed_count++;
|
|
}
|
|
else if (!isCommit && pending->is_create)
|
|
{
|
|
/*
|
|
* Transaction that created an object aborted. Drop the stats
|
|
* associated with the object.
|
|
*/
|
|
if (!pgstat_drop_entry(it->kind, it->dboid, it->objoid))
|
|
not_freed_count++;
|
|
}
|
|
|
|
dclist_delete_from(&xact_state->pending_drops, &pending->node);
|
|
pfree(pending);
|
|
}
|
|
|
|
if (not_freed_count > 0)
|
|
pgstat_request_entry_refs_gc();
|
|
}
|
|
|
|
/*
|
|
* Called from access/transam/xact.c at subtransaction commit/abort.
|
|
*/
|
|
void
|
|
AtEOSubXact_PgStat(bool isCommit, int nestDepth)
|
|
{
|
|
PgStat_SubXactStatus *xact_state;
|
|
|
|
/* merge the sub-transaction's transactional stats into the parent */
|
|
xact_state = pgStatXactStack;
|
|
if (xact_state != NULL &&
|
|
xact_state->nest_level >= nestDepth)
|
|
{
|
|
/* delink xact_state from stack immediately to simplify reuse case */
|
|
pgStatXactStack = xact_state->prev;
|
|
|
|
AtEOSubXact_PgStat_Relations(xact_state, isCommit, nestDepth);
|
|
AtEOSubXact_PgStat_DroppedStats(xact_state, isCommit, nestDepth);
|
|
|
|
pfree(xact_state);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Like AtEOXact_PgStat_DroppedStats(), but for subtransactions.
|
|
*/
|
|
static void
|
|
AtEOSubXact_PgStat_DroppedStats(PgStat_SubXactStatus *xact_state,
|
|
bool isCommit, int nestDepth)
|
|
{
|
|
PgStat_SubXactStatus *parent_xact_state;
|
|
dlist_mutable_iter iter;
|
|
int not_freed_count = 0;
|
|
|
|
if (dclist_count(&xact_state->pending_drops) == 0)
|
|
return;
|
|
|
|
parent_xact_state = pgstat_get_xact_stack_level(nestDepth - 1);
|
|
|
|
dclist_foreach_modify(iter, &xact_state->pending_drops)
|
|
{
|
|
PgStat_PendingDroppedStatsItem *pending =
|
|
dclist_container(PgStat_PendingDroppedStatsItem, node, iter.cur);
|
|
xl_xact_stats_item *it = &pending->item;
|
|
|
|
dclist_delete_from(&xact_state->pending_drops, &pending->node);
|
|
|
|
if (!isCommit && pending->is_create)
|
|
{
|
|
/*
|
|
* Subtransaction creating a new stats object aborted. Drop the
|
|
* stats object.
|
|
*/
|
|
if (!pgstat_drop_entry(it->kind, it->dboid, it->objoid))
|
|
not_freed_count++;
|
|
pfree(pending);
|
|
}
|
|
else if (isCommit)
|
|
{
|
|
/*
|
|
* Subtransaction dropping a stats object committed. Can't yet
|
|
* remove the stats object, the surrounding transaction might
|
|
* still abort. Pass it on to the parent.
|
|
*/
|
|
dclist_push_tail(&parent_xact_state->pending_drops, &pending->node);
|
|
}
|
|
else
|
|
{
|
|
pfree(pending);
|
|
}
|
|
}
|
|
|
|
Assert(dclist_count(&xact_state->pending_drops) == 0);
|
|
if (not_freed_count > 0)
|
|
pgstat_request_entry_refs_gc();
|
|
}
|
|
|
|
/*
|
|
* Save the transactional stats state at 2PC transaction prepare.
|
|
*/
|
|
void
|
|
AtPrepare_PgStat(void)
|
|
{
|
|
PgStat_SubXactStatus *xact_state;
|
|
|
|
xact_state = pgStatXactStack;
|
|
if (xact_state != NULL)
|
|
{
|
|
Assert(xact_state->nest_level == 1);
|
|
Assert(xact_state->prev == NULL);
|
|
|
|
AtPrepare_PgStat_Relations(xact_state);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Clean up after successful PREPARE.
|
|
*
|
|
* Note: AtEOXact_PgStat is not called during PREPARE.
|
|
*/
|
|
void
|
|
PostPrepare_PgStat(void)
|
|
{
|
|
PgStat_SubXactStatus *xact_state;
|
|
|
|
/*
|
|
* We don't bother to free any of the transactional state, since it's all
|
|
* in TopTransactionContext and will go away anyway.
|
|
*/
|
|
xact_state = pgStatXactStack;
|
|
if (xact_state != NULL)
|
|
{
|
|
Assert(xact_state->nest_level == 1);
|
|
Assert(xact_state->prev == NULL);
|
|
|
|
PostPrepare_PgStat_Relations(xact_state);
|
|
}
|
|
pgStatXactStack = NULL;
|
|
|
|
/* Make sure any stats snapshot is thrown away */
|
|
pgstat_clear_snapshot();
|
|
}
|
|
|
|
/*
|
|
* Ensure (sub)transaction stack entry for the given nest_level exists, adding
|
|
* it if needed.
|
|
*/
|
|
PgStat_SubXactStatus *
|
|
pgstat_get_xact_stack_level(int nest_level)
|
|
{
|
|
PgStat_SubXactStatus *xact_state;
|
|
|
|
xact_state = pgStatXactStack;
|
|
if (xact_state == NULL || xact_state->nest_level != nest_level)
|
|
{
|
|
xact_state = (PgStat_SubXactStatus *)
|
|
MemoryContextAlloc(TopTransactionContext,
|
|
sizeof(PgStat_SubXactStatus));
|
|
dclist_init(&xact_state->pending_drops);
|
|
xact_state->nest_level = nest_level;
|
|
xact_state->prev = pgStatXactStack;
|
|
xact_state->first = NULL;
|
|
pgStatXactStack = xact_state;
|
|
}
|
|
return xact_state;
|
|
}
|
|
|
|
/*
|
|
* Get stat items that need to be dropped at commit / abort.
|
|
*
|
|
* When committing, stats for objects that have been dropped in the
|
|
* transaction are returned. When aborting, stats for newly created objects are
|
|
* returned.
|
|
*
|
|
* Used by COMMIT / ABORT and 2PC PREPARE processing when building their
|
|
* respective WAL records, to ensure stats are dropped in case of a crash / on
|
|
* standbys.
|
|
*
|
|
* The list of items is allocated in CurrentMemoryContext and must be freed by
|
|
* the caller (directly or via memory context reset).
|
|
*/
|
|
int
|
|
pgstat_get_transactional_drops(bool isCommit, xl_xact_stats_item **items)
|
|
{
|
|
PgStat_SubXactStatus *xact_state = pgStatXactStack;
|
|
int nitems = 0;
|
|
dlist_iter iter;
|
|
|
|
if (xact_state == NULL)
|
|
return 0;
|
|
|
|
/*
|
|
* We expect to be called for subtransaction abort (which logs a WAL
|
|
* record), but not for subtransaction commit (which doesn't).
|
|
*/
|
|
Assert(!isCommit || xact_state->nest_level == 1);
|
|
Assert(!isCommit || xact_state->prev == NULL);
|
|
|
|
*items = palloc(dclist_count(&xact_state->pending_drops)
|
|
* sizeof(xl_xact_stats_item));
|
|
|
|
dclist_foreach(iter, &xact_state->pending_drops)
|
|
{
|
|
PgStat_PendingDroppedStatsItem *pending =
|
|
dclist_container(PgStat_PendingDroppedStatsItem, node, iter.cur);
|
|
|
|
if (isCommit && pending->is_create)
|
|
continue;
|
|
if (!isCommit && !pending->is_create)
|
|
continue;
|
|
|
|
Assert(nitems < dclist_count(&xact_state->pending_drops));
|
|
(*items)[nitems++] = pending->item;
|
|
}
|
|
|
|
return nitems;
|
|
}
|
|
|
|
/*
|
|
* Execute scheduled drops post-commit. Called from xact_redo_commit() /
|
|
* xact_redo_abort() during recovery, and from FinishPreparedTransaction()
|
|
* during normal 2PC COMMIT/ABORT PREPARED processing.
|
|
*/
|
|
void
|
|
pgstat_execute_transactional_drops(int ndrops, struct xl_xact_stats_item *items, bool is_redo)
|
|
{
|
|
int not_freed_count = 0;
|
|
|
|
if (ndrops == 0)
|
|
return;
|
|
|
|
for (int i = 0; i < ndrops; i++)
|
|
{
|
|
xl_xact_stats_item *it = &items[i];
|
|
|
|
if (!pgstat_drop_entry(it->kind, it->dboid, it->objoid))
|
|
not_freed_count++;
|
|
}
|
|
|
|
if (not_freed_count > 0)
|
|
pgstat_request_entry_refs_gc();
|
|
}
|
|
|
|
static void
|
|
create_drop_transactional_internal(PgStat_Kind kind, Oid dboid, Oid objoid, bool is_create)
|
|
{
|
|
int nest_level = GetCurrentTransactionNestLevel();
|
|
PgStat_SubXactStatus *xact_state;
|
|
PgStat_PendingDroppedStatsItem *drop = (PgStat_PendingDroppedStatsItem *)
|
|
MemoryContextAlloc(TopTransactionContext, sizeof(PgStat_PendingDroppedStatsItem));
|
|
|
|
xact_state = pgstat_get_xact_stack_level(nest_level);
|
|
|
|
drop->is_create = is_create;
|
|
drop->item.kind = kind;
|
|
drop->item.dboid = dboid;
|
|
drop->item.objoid = objoid;
|
|
|
|
dclist_push_tail(&xact_state->pending_drops, &drop->node);
|
|
}
|
|
|
|
/*
|
|
* Create a stats entry for a newly created database object in a transactional
|
|
* manner.
|
|
*
|
|
* I.e. if the current (sub-)transaction aborts, the stats entry will also be
|
|
* dropped.
|
|
*/
|
|
void
|
|
pgstat_create_transactional(PgStat_Kind kind, Oid dboid, Oid objoid)
|
|
{
|
|
if (pgstat_get_entry_ref(kind, dboid, objoid, false, NULL))
|
|
{
|
|
ereport(WARNING,
|
|
errmsg("resetting existing statistics for kind %s, db=%u, oid=%u",
|
|
(pgstat_get_kind_info(kind))->name, dboid, objoid));
|
|
|
|
pgstat_reset(kind, dboid, objoid);
|
|
}
|
|
|
|
create_drop_transactional_internal(kind, dboid, objoid, /* create */ true);
|
|
}
|
|
|
|
/*
|
|
* Drop a stats entry for a just dropped database object in a transactional
|
|
* manner.
|
|
*
|
|
* I.e. if the current (sub-)transaction aborts, the stats entry will stay
|
|
* alive.
|
|
*/
|
|
void
|
|
pgstat_drop_transactional(PgStat_Kind kind, Oid dboid, Oid objoid)
|
|
{
|
|
create_drop_transactional_internal(kind, dboid, objoid, /* create */ false);
|
|
}
|