src/backend/utils/activity/pgstat_xact.c - cloudberry - Git at Google

 /* -------------------------------------------------------------------------
  *
  * 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);
 }
	/* -------------------------------------------------------------------------
	*
	* 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);
	}