codekingpro/portable-devtools

1/*-------------------------------------------------------------------------2 *3 * rel.h4 *	  POSTGRES relation descriptor (a/k/a relcache entry) definitions.5 *6 *7 * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group8 * Portions Copyright (c) 1994, Regents of the University of California9 *10 * src/include/utils/rel.h11 *12 *-------------------------------------------------------------------------13 */14#ifndef REL_H15#define REL_H16 17#include "access/tupdesc.h"18#include "access/xlog.h"19#include "catalog/catalog.h"20#include "catalog/pg_class.h"21#include "catalog/pg_index.h"22#include "catalog/pg_publication.h"23#include "nodes/bitmapset.h"24#include "partitioning/partdefs.h"25#include "rewrite/prs2lock.h"26#include "storage/block.h"27#include "storage/relfilelocator.h"28#include "storage/smgr.h"29#include "utils/relcache.h"30#include "utils/reltrigger.h"31 32 33/*34 * LockRelId and LockInfo really belong to lmgr.h, but it's more convenient35 * to declare them here so we can have a LockInfoData field in a Relation.36 */37 38typedef struct LockRelId39{40	Oid			relId;			/* a relation identifier */41	Oid			dbId;			/* a database identifier */42} LockRelId;43 44typedef struct LockInfoData45{46	LockRelId	lockRelId;47} LockInfoData;48 49typedef LockInfoData *LockInfo;50 51/*52 * Here are the contents of a relation cache entry.53 */54 55typedef struct RelationData56{57	RelFileLocator rd_locator;	/* relation physical identifier */58	SMgrRelation rd_smgr;		/* cached file handle, or NULL */59	int			rd_refcnt;		/* reference count */60	BackendId	rd_backend;		/* owning backend id, if temporary relation */61	bool		rd_islocaltemp; /* rel is a temp rel of this session */62	bool		rd_isnailed;	/* rel is nailed in cache */63	bool		rd_isvalid;		/* relcache entry is valid */64	bool		rd_indexvalid;	/* is rd_indexlist valid? (also rd_pkindex and65								 * rd_replidindex) */66	bool		rd_statvalid;	/* is rd_statlist valid? */67 68	/*----------69	 * rd_createSubid is the ID of the highest subtransaction the rel has70	 * survived into or zero if the rel or its storage was created before the71	 * current top transaction.  (IndexStmt.oldNumber leads to the case of a new72	 * rel with an old rd_locator.)  rd_firstRelfilelocatorSubid is the ID of the73	 * highest subtransaction an rd_locator change has survived into or zero if74	 * rd_locator matches the value it had at the start of the current top75	 * transaction.  (Rolling back the subtransaction that76	 * rd_firstRelfilelocatorSubid denotes would restore rd_locator to the value it77	 * had at the start of the current top transaction.  Rolling back any78	 * lower subtransaction would not.)  Their accuracy is critical to79	 * RelationNeedsWAL().80	 *81	 * rd_newRelfilelocatorSubid is the ID of the highest subtransaction the82	 * most-recent relfilenumber change has survived into or zero if not changed83	 * in the current transaction (or we have forgotten changing it).  This84	 * field is accurate when non-zero, but it can be zero when a relation has85	 * multiple new relfilenumbers within a single transaction, with one of them86	 * occurring in a subsequently aborted subtransaction, e.g.87	 *		BEGIN;88	 *		TRUNCATE t;89	 *		SAVEPOINT save;90	 *		TRUNCATE t;91	 *		ROLLBACK TO save;92	 *		-- rd_newRelfilelocatorSubid is now forgotten93	 *94	 * If every rd_*Subid field is zero, they are read-only outside95	 * relcache.c.  Files that trigger rd_locator changes by updating96	 * pg_class.reltablespace and/or pg_class.relfilenode call97	 * RelationAssumeNewRelfilelocator() to update rd_*Subid.98	 *99	 * rd_droppedSubid is the ID of the highest subtransaction that a drop of100	 * the rel has survived into.  In entries visible outside relcache.c, this101	 * is always zero.102	 */103	SubTransactionId rd_createSubid;	/* rel was created in current xact */104	SubTransactionId rd_newRelfilelocatorSubid; /* highest subxact changing105												 * rd_locator to current value */106	SubTransactionId rd_firstRelfilelocatorSubid;	/* highest subxact107													 * changing rd_locator to108													 * any value */109	SubTransactionId rd_droppedSubid;	/* dropped with another Subid set */110 111	Form_pg_class rd_rel;		/* RELATION tuple */112	TupleDesc	rd_att;			/* tuple descriptor */113	Oid			rd_id;			/* relation's object id */114	LockInfoData rd_lockInfo;	/* lock mgr's info for locking relation */115	RuleLock   *rd_rules;		/* rewrite rules */116	MemoryContext rd_rulescxt;	/* private memory cxt for rd_rules, if any */117	TriggerDesc *trigdesc;		/* Trigger info, or NULL if rel has none */118	/* use "struct" here to avoid needing to include rowsecurity.h: */119	struct RowSecurityDesc *rd_rsdesc;	/* row security policies, or NULL */120 121	/* data managed by RelationGetFKeyList: */122	List	   *rd_fkeylist;	/* list of ForeignKeyCacheInfo (see below) */123	bool		rd_fkeyvalid;	/* true if list has been computed */124 125	/* data managed by RelationGetPartitionKey: */126	PartitionKey rd_partkey;	/* partition key, or NULL */127	MemoryContext rd_partkeycxt;	/* private context for rd_partkey, if any */128 129	/* data managed by RelationGetPartitionDesc: */130	PartitionDesc rd_partdesc;	/* partition descriptor, or NULL */131	MemoryContext rd_pdcxt;		/* private context for rd_partdesc, if any */132 133	/* Same as above, for partdescs that omit detached partitions */134	PartitionDesc rd_partdesc_nodetached;	/* partdesc w/o detached parts */135	MemoryContext rd_pddcxt;	/* for rd_partdesc_nodetached, if any */136 137	/*138	 * pg_inherits.xmin of the partition that was excluded in139	 * rd_partdesc_nodetached.  This informs a future user of that partdesc:140	 * if this value is not in progress for the active snapshot, then the141	 * partdesc can be used, otherwise they have to build a new one.  (This142	 * matches what find_inheritance_children_extended would do).143	 */144	TransactionId rd_partdesc_nodetached_xmin;145 146	/* data managed by RelationGetPartitionQual: */147	List	   *rd_partcheck;	/* partition CHECK quals */148	bool		rd_partcheckvalid;	/* true if list has been computed */149	MemoryContext rd_partcheckcxt;	/* private cxt for rd_partcheck, if any */150 151	/* data managed by RelationGetIndexList: */152	List	   *rd_indexlist;	/* list of OIDs of indexes on relation */153	Oid			rd_pkindex;		/* OID of primary key, if any */154	Oid			rd_replidindex; /* OID of replica identity index, if any */155 156	/* data managed by RelationGetStatExtList: */157	List	   *rd_statlist;	/* list of OIDs of extended stats */158 159	/* data managed by RelationGetIndexAttrBitmap: */160	bool		rd_attrsvalid;	/* are bitmaps of attrs valid? */161	Bitmapset  *rd_keyattr;		/* cols that can be ref'd by foreign keys */162	Bitmapset  *rd_pkattr;		/* cols included in primary key */163	Bitmapset  *rd_idattr;		/* included in replica identity index */164	Bitmapset  *rd_hotblockingattr; /* cols blocking HOT update */165	Bitmapset  *rd_summarizedattr;	/* cols indexed by summarizing indexes */166 167	PublicationDesc *rd_pubdesc;	/* publication descriptor, or NULL */168 169	/*170	 * rd_options is set whenever rd_rel is loaded into the relcache entry.171	 * Note that you can NOT look into rd_rel for this data.  NULL means "use172	 * defaults".173	 */174	bytea	   *rd_options;		/* parsed pg_class.reloptions */175 176	/*177	 * Oid of the handler for this relation. For an index this is a function178	 * returning IndexAmRoutine, for table like relations a function returning179	 * TableAmRoutine.  This is stored separately from rd_indam, rd_tableam as180	 * its lookup requires syscache access, but during relcache bootstrap we181	 * need to be able to initialize rd_tableam without syscache lookups.182	 */183	Oid			rd_amhandler;	/* OID of index AM's handler function */184 185	/*186	 * Table access method.187	 */188	const struct TableAmRoutine *rd_tableam;189 190	/* These are non-NULL only for an index relation: */191	Form_pg_index rd_index;		/* pg_index tuple describing this index */192	/* use "struct" here to avoid needing to include htup.h: */193	struct HeapTupleData *rd_indextuple;	/* all of pg_index tuple */194 195	/*196	 * index access support info (used only for an index relation)197	 *198	 * Note: only default support procs for each opclass are cached, namely199	 * those with lefttype and righttype equal to the opclass's opcintype. The200	 * arrays are indexed by support function number, which is a sufficient201	 * identifier given that restriction.202	 */203	MemoryContext rd_indexcxt;	/* private memory cxt for this stuff */204	/* use "struct" here to avoid needing to include amapi.h: */205	struct IndexAmRoutine *rd_indam;	/* index AM's API struct */206	Oid		   *rd_opfamily;	/* OIDs of op families for each index col */207	Oid		   *rd_opcintype;	/* OIDs of opclass declared input data types */208	RegProcedure *rd_support;	/* OIDs of support procedures */209	struct FmgrInfo *rd_supportinfo;	/* lookup info for support procedures */210	int16	   *rd_indoption;	/* per-column AM-specific flags */211	List	   *rd_indexprs;	/* index expression trees, if any */212	List	   *rd_indpred;		/* index predicate tree, if any */213	Oid		   *rd_exclops;		/* OIDs of exclusion operators, if any */214	Oid		   *rd_exclprocs;	/* OIDs of exclusion ops' procs, if any */215	uint16	   *rd_exclstrats;	/* exclusion ops' strategy numbers, if any */216	Oid		   *rd_indcollation;	/* OIDs of index collations */217	bytea	  **rd_opcoptions;	/* parsed opclass-specific options */218 219	/*220	 * rd_amcache is available for index and table AMs to cache private data221	 * about the relation.  This must be just a cache since it may get reset222	 * at any time (in particular, it will get reset by a relcache inval223	 * message for the relation).  If used, it must point to a single memory224	 * chunk palloc'd in CacheMemoryContext, or in rd_indexcxt for an index225	 * relation.  A relcache reset will include freeing that chunk and setting226	 * rd_amcache = NULL.227	 */228	void	   *rd_amcache;		/* available for use by index/table AM */229 230	/*231	 * foreign-table support232	 *233	 * rd_fdwroutine must point to a single memory chunk palloc'd in234	 * CacheMemoryContext.  It will be freed and reset to NULL on a relcache235	 * reset.236	 */237 238	/* use "struct" here to avoid needing to include fdwapi.h: */239	struct FdwRoutine *rd_fdwroutine;	/* cached function pointers, or NULL */240 241	/*242	 * Hack for CLUSTER, rewriting ALTER TABLE, etc: when writing a new243	 * version of a table, we need to make any toast pointers inserted into it244	 * have the existing toast table's OID, not the OID of the transient toast245	 * table.  If rd_toastoid isn't InvalidOid, it is the OID to place in246	 * toast pointers inserted into this rel.  (Note it's set on the new247	 * version of the main heap, not the toast table itself.)  This also248	 * causes toast_save_datum() to try to preserve toast value OIDs.249	 */250	Oid			rd_toastoid;	/* Real TOAST table's OID, or InvalidOid */251 252	bool		pgstat_enabled; /* should relation stats be counted */253	/* use "struct" here to avoid needing to include pgstat.h: */254	struct PgStat_TableStatus *pgstat_info; /* statistics collection area */255} RelationData;256 257 258/*259 * ForeignKeyCacheInfo260 *		Information the relcache can cache about foreign key constraints261 *262 * This is basically just an image of relevant columns from pg_constraint.263 * We make it a subclass of Node so that copyObject() can be used on a list264 * of these, but we also ensure it is a "flat" object without substructure,265 * so that list_free_deep() is sufficient to free such a list.266 * The per-FK-column arrays can be fixed-size because we allow at most267 * INDEX_MAX_KEYS columns in a foreign key constraint.268 *269 * Currently, we mostly cache fields of interest to the planner, but the set270 * of fields has already grown the constraint OID for other uses.271 */272typedef struct ForeignKeyCacheInfo273{274	pg_node_attr(no_equal, no_read, no_query_jumble)275 276	NodeTag		type;277	/* oid of the constraint itself */278	Oid			conoid;279	/* relation constrained by the foreign key */280	Oid			conrelid;281	/* relation referenced by the foreign key */282	Oid			confrelid;283	/* number of columns in the foreign key */284	int			nkeys;285 286	/*287	 * these arrays each have nkeys valid entries:288	 */289	/* cols in referencing table */290	AttrNumber	conkey[INDEX_MAX_KEYS] pg_node_attr(array_size(nkeys));291	/* cols in referenced table */292	AttrNumber	confkey[INDEX_MAX_KEYS] pg_node_attr(array_size(nkeys));293	/* PK = FK operator OIDs */294	Oid			conpfeqop[INDEX_MAX_KEYS] pg_node_attr(array_size(nkeys));295} ForeignKeyCacheInfo;296 297 298/*299 * StdRdOptions300 *		Standard contents of rd_options for heaps.301 *302 * RelationGetFillFactor() and RelationGetTargetPageFreeSpace() can only303 * be applied to relations that use this format or a superset for304 * private options data.305 */306 /* autovacuum-related reloptions. */307typedef struct AutoVacOpts308{309	bool		enabled;310	int			vacuum_threshold;311	int			vacuum_ins_threshold;312	int			analyze_threshold;313	int			vacuum_cost_limit;314	int			freeze_min_age;315	int			freeze_max_age;316	int			freeze_table_age;317	int			multixact_freeze_min_age;318	int			multixact_freeze_max_age;319	int			multixact_freeze_table_age;320	int			log_min_duration;321	float8		vacuum_cost_delay;322	float8		vacuum_scale_factor;323	float8		vacuum_ins_scale_factor;324	float8		analyze_scale_factor;325} AutoVacOpts;326 327/* StdRdOptions->vacuum_index_cleanup values */328typedef enum StdRdOptIndexCleanup329{330	STDRD_OPTION_VACUUM_INDEX_CLEANUP_AUTO = 0,331	STDRD_OPTION_VACUUM_INDEX_CLEANUP_OFF,332	STDRD_OPTION_VACUUM_INDEX_CLEANUP_ON333} StdRdOptIndexCleanup;334 335typedef struct StdRdOptions336{337	int32		vl_len_;		/* varlena header (do not touch directly!) */338	int			fillfactor;		/* page fill factor in percent (0..100) */339	int			toast_tuple_target; /* target for tuple toasting */340	AutoVacOpts autovacuum;		/* autovacuum-related options */341	bool		user_catalog_table; /* use as an additional catalog relation */342	int			parallel_workers;	/* max number of parallel workers */343	StdRdOptIndexCleanup vacuum_index_cleanup;	/* controls index vacuuming */344	bool		vacuum_truncate;	/* enables vacuum to truncate a relation */345} StdRdOptions;346 347#define HEAP_MIN_FILLFACTOR			10348#define HEAP_DEFAULT_FILLFACTOR		100349 350/*351 * RelationGetToastTupleTarget352 *		Returns the relation's toast_tuple_target.  Note multiple eval of argument!353 */354#define RelationGetToastTupleTarget(relation, defaulttarg) \355	((relation)->rd_options ? \356	 ((StdRdOptions *) (relation)->rd_options)->toast_tuple_target : (defaulttarg))357 358/*359 * RelationGetFillFactor360 *		Returns the relation's fillfactor.  Note multiple eval of argument!361 */362#define RelationGetFillFactor(relation, defaultff) \363	((relation)->rd_options ? \364	 ((StdRdOptions *) (relation)->rd_options)->fillfactor : (defaultff))365 366/*367 * RelationGetTargetPageUsage368 *		Returns the relation's desired space usage per page in bytes.369 */370#define RelationGetTargetPageUsage(relation, defaultff) \371	(BLCKSZ * RelationGetFillFactor(relation, defaultff) / 100)372 373/*374 * RelationGetTargetPageFreeSpace375 *		Returns the relation's desired freespace per page in bytes.376 */377#define RelationGetTargetPageFreeSpace(relation, defaultff) \378	(BLCKSZ * (100 - RelationGetFillFactor(relation, defaultff)) / 100)379 380/*381 * RelationIsUsedAsCatalogTable382 *		Returns whether the relation should be treated as a catalog table383 *		from the pov of logical decoding.  Note multiple eval of argument!384 */385#define RelationIsUsedAsCatalogTable(relation)	\386	((relation)->rd_options && \387	 ((relation)->rd_rel->relkind == RELKIND_RELATION || \388	  (relation)->rd_rel->relkind == RELKIND_MATVIEW) ? \389	 ((StdRdOptions *) (relation)->rd_options)->user_catalog_table : false)390 391/*392 * RelationGetParallelWorkers393 *		Returns the relation's parallel_workers reloption setting.394 *		Note multiple eval of argument!395 */396#define RelationGetParallelWorkers(relation, defaultpw) \397	((relation)->rd_options ? \398	 ((StdRdOptions *) (relation)->rd_options)->parallel_workers : (defaultpw))399 400/* ViewOptions->check_option values */401typedef enum ViewOptCheckOption402{403	VIEW_OPTION_CHECK_OPTION_NOT_SET,404	VIEW_OPTION_CHECK_OPTION_LOCAL,405	VIEW_OPTION_CHECK_OPTION_CASCADED406} ViewOptCheckOption;407 408/*409 * ViewOptions410 *		Contents of rd_options for views411 */412typedef struct ViewOptions413{414	int32		vl_len_;		/* varlena header (do not touch directly!) */415	bool		security_barrier;416	bool		security_invoker;417	ViewOptCheckOption check_option;418} ViewOptions;419 420/*421 * RelationIsSecurityView422 *		Returns whether the relation is security view, or not.  Note multiple423 *		eval of argument!424 */425#define RelationIsSecurityView(relation)									\426	(AssertMacro(relation->rd_rel->relkind == RELKIND_VIEW),				\427	 (relation)->rd_options ?												\428	  ((ViewOptions *) (relation)->rd_options)->security_barrier : false)429 430/*431 * RelationHasSecurityInvoker432 *		Returns true if the relation has the security_invoker property set.433 *		Note multiple eval of argument!434 */435#define RelationHasSecurityInvoker(relation)								\436	(AssertMacro(relation->rd_rel->relkind == RELKIND_VIEW),				\437	 (relation)->rd_options ?												\438	  ((ViewOptions *) (relation)->rd_options)->security_invoker : false)439 440/*441 * RelationHasCheckOption442 *		Returns true if the relation is a view defined with either the local443 *		or the cascaded check option.  Note multiple eval of argument!444 */445#define RelationHasCheckOption(relation)									\446	(AssertMacro(relation->rd_rel->relkind == RELKIND_VIEW),				\447	 (relation)->rd_options &&												\448	 ((ViewOptions *) (relation)->rd_options)->check_option !=				\449	 VIEW_OPTION_CHECK_OPTION_NOT_SET)450 451/*452 * RelationHasLocalCheckOption453 *		Returns true if the relation is a view defined with the local check454 *		option.  Note multiple eval of argument!455 */456#define RelationHasLocalCheckOption(relation)								\457	(AssertMacro(relation->rd_rel->relkind == RELKIND_VIEW),				\458	 (relation)->rd_options &&												\459	 ((ViewOptions *) (relation)->rd_options)->check_option ==				\460	 VIEW_OPTION_CHECK_OPTION_LOCAL)461 462/*463 * RelationHasCascadedCheckOption464 *		Returns true if the relation is a view defined with the cascaded check465 *		option.  Note multiple eval of argument!466 */467#define RelationHasCascadedCheckOption(relation)							\468	(AssertMacro(relation->rd_rel->relkind == RELKIND_VIEW),				\469	 (relation)->rd_options &&												\470	 ((ViewOptions *) (relation)->rd_options)->check_option ==				\471	  VIEW_OPTION_CHECK_OPTION_CASCADED)472 473/*474 * RelationIsValid475 *		True iff relation descriptor is valid.476 */477#define RelationIsValid(relation) PointerIsValid(relation)478 479#define InvalidRelation ((Relation) NULL)480 481/*482 * RelationHasReferenceCountZero483 *		True iff relation reference count is zero.484 *485 * Note:486 *		Assumes relation descriptor is valid.487 */488#define RelationHasReferenceCountZero(relation) \489		((bool)((relation)->rd_refcnt == 0))490 491/*492 * RelationGetForm493 *		Returns pg_class tuple for a relation.494 *495 * Note:496 *		Assumes relation descriptor is valid.497 */498#define RelationGetForm(relation) ((relation)->rd_rel)499 500/*501 * RelationGetRelid502 *		Returns the OID of the relation503 */504#define RelationGetRelid(relation) ((relation)->rd_id)505 506/*507 * RelationGetNumberOfAttributes508 *		Returns the total number of attributes in a relation.509 */510#define RelationGetNumberOfAttributes(relation) ((relation)->rd_rel->relnatts)511 512/*513 * IndexRelationGetNumberOfAttributes514 *		Returns the number of attributes in an index.515 */516#define IndexRelationGetNumberOfAttributes(relation) \517		((relation)->rd_index->indnatts)518 519/*520 * IndexRelationGetNumberOfKeyAttributes521 *		Returns the number of key attributes in an index.522 */523#define IndexRelationGetNumberOfKeyAttributes(relation) \524		((relation)->rd_index->indnkeyatts)525 526/*527 * RelationGetDescr528 *		Returns tuple descriptor for a relation.529 */530#define RelationGetDescr(relation) ((relation)->rd_att)531 532/*533 * RelationGetRelationName534 *		Returns the rel's name.535 *536 * Note that the name is only unique within the containing namespace.537 */538#define RelationGetRelationName(relation) \539	(NameStr((relation)->rd_rel->relname))540 541/*542 * RelationGetNamespace543 *		Returns the rel's namespace OID.544 */545#define RelationGetNamespace(relation) \546	((relation)->rd_rel->relnamespace)547 548/*549 * RelationIsMapped550 *		True if the relation uses the relfilenumber map.  Note multiple eval551 *		of argument!552 */553#define RelationIsMapped(relation) \554	(RELKIND_HAS_STORAGE((relation)->rd_rel->relkind) && \555	 ((relation)->rd_rel->relfilenode == InvalidRelFileNumber))556 557#ifndef FRONTEND558/*559 * RelationGetSmgr560 *		Returns smgr file handle for a relation, opening it if needed.561 *562 * Very little code is authorized to touch rel->rd_smgr directly.  Instead563 * use this function to fetch its value.564 *565 * Note: since a relcache flush can cause the file handle to be closed again,566 * it's unwise to hold onto the pointer returned by this function for any567 * long period.  Recommended practice is to just re-execute RelationGetSmgr568 * each time you need to access the SMgrRelation.  It's quite cheap in569 * comparison to whatever an smgr function is going to do.570 */571static inline SMgrRelation572RelationGetSmgr(Relation rel)573{574	if (unlikely(rel->rd_smgr == NULL))575		smgrsetowner(&(rel->rd_smgr), smgropen(rel->rd_locator, rel->rd_backend));576	return rel->rd_smgr;577}578 579/*580 * RelationCloseSmgr581 *		Close the relation at the smgr level, if not already done.582 */583static inline void584RelationCloseSmgr(Relation relation)585{586	if (relation->rd_smgr != NULL)587		smgrclose(relation->rd_smgr);588 589	/* smgrclose should unhook from owner pointer */590	Assert(relation->rd_smgr == NULL);591}592#endif							/* !FRONTEND */593 594/*595 * RelationGetTargetBlock596 *		Fetch relation's current insertion target block.597 *598 * Returns InvalidBlockNumber if there is no current target block.  Note599 * that the target block status is discarded on any smgr-level invalidation,600 * so there's no need to re-open the smgr handle if it's not currently open.601 */602#define RelationGetTargetBlock(relation) \603	( (relation)->rd_smgr != NULL ? (relation)->rd_smgr->smgr_targblock : InvalidBlockNumber )604 605/*606 * RelationSetTargetBlock607 *		Set relation's current insertion target block.608 */609#define RelationSetTargetBlock(relation, targblock) \610	do { \611		RelationGetSmgr(relation)->smgr_targblock = (targblock); \612	} while (0)613 614/*615 * RelationIsPermanent616 *		True if relation is permanent.617 */618#define RelationIsPermanent(relation) \619	((relation)->rd_rel->relpersistence == RELPERSISTENCE_PERMANENT)620 621/*622 * RelationNeedsWAL623 *		True if relation needs WAL.624 *625 * Returns false if wal_level = minimal and this relation is created or626 * truncated in the current transaction.  See "Skipping WAL for New627 * RelFileLocator" in src/backend/access/transam/README.628 */629#define RelationNeedsWAL(relation)										\630	(RelationIsPermanent(relation) && (XLogIsNeeded() ||				\631	  (relation->rd_createSubid == InvalidSubTransactionId &&			\632	   relation->rd_firstRelfilelocatorSubid == InvalidSubTransactionId)))633 634/*635 * RelationUsesLocalBuffers636 *		True if relation's pages are stored in local buffers.637 */638#define RelationUsesLocalBuffers(relation) \639	((relation)->rd_rel->relpersistence == RELPERSISTENCE_TEMP)640 641/*642 * RELATION_IS_LOCAL643 *		If a rel is either temp or newly created in the current transaction,644 *		it can be assumed to be accessible only to the current backend.645 *		This is typically used to decide that we can skip acquiring locks.646 *647 * Beware of multiple eval of argument648 */649#define RELATION_IS_LOCAL(relation) \650	((relation)->rd_islocaltemp || \651	 (relation)->rd_createSubid != InvalidSubTransactionId)652 653/*654 * RELATION_IS_OTHER_TEMP655 *		Test for a temporary relation that belongs to some other session.656 *657 * Beware of multiple eval of argument658 */659#define RELATION_IS_OTHER_TEMP(relation) \660	((relation)->rd_rel->relpersistence == RELPERSISTENCE_TEMP && \661	 !(relation)->rd_islocaltemp)662 663 664/*665 * RelationIsScannable666 *		Currently can only be false for a materialized view which has not been667 *		populated by its query.  This is likely to get more complicated later,668 *		so use a macro which looks like a function.669 */670#define RelationIsScannable(relation) ((relation)->rd_rel->relispopulated)671 672/*673 * RelationIsPopulated674 *		Currently, we don't physically distinguish the "populated" and675 *		"scannable" properties of matviews, but that may change later.676 *		Hence, use the appropriate one of these macros in code tests.677 */678#define RelationIsPopulated(relation) ((relation)->rd_rel->relispopulated)679 680/*681 * RelationIsAccessibleInLogicalDecoding682 *		True if we need to log enough information to have access via683 *		decoding snapshot.684 */685#define RelationIsAccessibleInLogicalDecoding(relation) \686	(XLogLogicalInfoActive() && \687	 RelationNeedsWAL(relation) && \688	 (IsCatalogRelation(relation) || RelationIsUsedAsCatalogTable(relation)))689 690/*691 * RelationIsLogicallyLogged692 *		True if we need to log enough information to extract the data from the693 *		WAL stream.694 *695 * We don't log information for unlogged tables (since they don't WAL log696 * anyway), for foreign tables (since they don't WAL log, either),697 * and for system tables (their content is hard to make sense of, and698 * it would complicate decoding slightly for little gain). Note that we *do*699 * log information for user defined catalog tables since they presumably are700 * interesting to the user...701 */702#define RelationIsLogicallyLogged(relation) \703	(XLogLogicalInfoActive() && \704	 RelationNeedsWAL(relation) && \705	 (relation)->rd_rel->relkind != RELKIND_FOREIGN_TABLE &&	\706	 !IsCatalogRelation(relation))707 708/* routines in utils/cache/relcache.c */709extern void RelationIncrementReferenceCount(Relation rel);710extern void RelationDecrementReferenceCount(Relation rel);711 712#endif							/* REL_H */713