/src/postgres/src/include/utils/rel.h

Source
/*-------------------------------------------------------------------------
 *
 * rel.h
 *    POSTGRES relation descriptor (a/k/a relcache entry) definitions.
 *
 *
 * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 * src/include/utils/rel.h
 *
 *-------------------------------------------------------------------------
 */
#ifndef REL_H
#define REL_H

#include "access/tupdesc.h"
#include "access/xlog.h"
#include "catalog/catalog.h"
#include "catalog/pg_class.h"
#include "catalog/pg_index.h"
#include "catalog/pg_publication.h"
#include "nodes/bitmapset.h"
#include "partitioning/partdefs.h"
#include "rewrite/prs2lock.h"
#include "storage/block.h"
#include "storage/relfilelocator.h"
#include "storage/smgr.h"
#include "utils/relcache.h"
#include "utils/reltrigger.h"


/*
 * LockRelId and LockInfo really belong to lmgr.h, but it's more convenient
 * to declare them here so we can have a LockInfoData field in a Relation.
 */

typedef struct LockRelId
{
  Oid     relId;      /* a relation identifier */
  Oid     dbId;     /* a database identifier */
} LockRelId;

typedef struct LockInfoData
{
  LockRelId lockRelId;
} LockInfoData;

typedef LockInfoData *LockInfo;

/*
 * Here are the contents of a relation cache entry.
 */

typedef struct RelationData
{
  RelFileLocator rd_locator;  /* relation physical identifier */
  SMgrRelation rd_smgr;   /* cached file handle, or NULL */
  int     rd_refcnt;    /* reference count */
  ProcNumber  rd_backend;   /* owning backend's proc number, if temp rel */
  bool    rd_islocaltemp; /* rel is a temp rel of this session */
  bool    rd_isnailed;  /* rel is nailed in cache */
  bool    rd_isvalid;   /* relcache entry is valid */
  bool    rd_indexvalid;  /* is rd_indexlist valid? (also rd_pkindex and
                 * rd_replidindex) */
  bool    rd_statvalid; /* is rd_statlist valid? */

  /*----------
   * rd_createSubid is the ID of the highest subtransaction the rel has
   * survived into or zero if the rel or its storage was created before the
   * current top transaction.  (IndexStmt.oldNumber leads to the case of a new
   * rel with an old rd_locator.)  rd_firstRelfilelocatorSubid is the ID of the
   * highest subtransaction an rd_locator change has survived into or zero if
   * rd_locator matches the value it had at the start of the current top
   * transaction.  (Rolling back the subtransaction that
   * rd_firstRelfilelocatorSubid denotes would restore rd_locator to the value it
   * had at the start of the current top transaction.  Rolling back any
   * lower subtransaction would not.)  Their accuracy is critical to
   * RelationNeedsWAL().
   *
   * rd_newRelfilelocatorSubid is the ID of the highest subtransaction the
   * most-recent relfilenumber change has survived into or zero if not changed
   * in the current transaction (or we have forgotten changing it).  This
   * field is accurate when non-zero, but it can be zero when a relation has
   * multiple new relfilenumbers within a single transaction, with one of them
   * occurring in a subsequently aborted subtransaction, e.g.
   *    BEGIN;
   *    TRUNCATE t;
   *    SAVEPOINT save;
   *    TRUNCATE t;
   *    ROLLBACK TO save;
   *    -- rd_newRelfilelocatorSubid is now forgotten
   *
   * If every rd_*Subid field is zero, they are read-only outside
   * relcache.c.  Files that trigger rd_locator changes by updating
   * pg_class.reltablespace and/or pg_class.relfilenode call
   * RelationAssumeNewRelfilelocator() to update rd_*Subid.
   *
   * rd_droppedSubid is the ID of the highest subtransaction that a drop of
   * the rel has survived into.  In entries visible outside relcache.c, this
   * is always zero.
   */
  SubTransactionId rd_createSubid;  /* rel was created in current xact */
  SubTransactionId rd_newRelfilelocatorSubid; /* highest subxact changing
                         * rd_locator to current value */
  SubTransactionId rd_firstRelfilelocatorSubid; /* highest subxact
                           * changing rd_locator to
                           * any value */
  SubTransactionId rd_droppedSubid; /* dropped with another Subid set */

  Form_pg_class rd_rel;   /* RELATION tuple */
  TupleDesc rd_att;     /* tuple descriptor */
  Oid     rd_id;      /* relation's object id */
  LockInfoData rd_lockInfo; /* lock mgr's info for locking relation */
  RuleLock   *rd_rules;   /* rewrite rules */
  MemoryContext rd_rulescxt;  /* private memory cxt for rd_rules, if any */
  TriggerDesc *trigdesc;    /* Trigger info, or NULL if rel has none */
  /* use "struct" here to avoid needing to include rowsecurity.h: */
  struct RowSecurityDesc *rd_rsdesc;  /* row security policies, or NULL */

  /* data managed by RelationGetFKeyList: */
  List     *rd_fkeylist;  /* list of ForeignKeyCacheInfo (see below) */
  bool    rd_fkeyvalid; /* true if list has been computed */

  /* data managed by RelationGetPartitionKey: */
  PartitionKey rd_partkey;  /* partition key, or NULL */
  MemoryContext rd_partkeycxt;  /* private context for rd_partkey, if any */

  /* data managed by RelationGetPartitionDesc: */
  PartitionDesc rd_partdesc;  /* partition descriptor, or NULL */
  MemoryContext rd_pdcxt;   /* private context for rd_partdesc, if any */

  /* Same as above, for partdescs that omit detached partitions */
  PartitionDesc rd_partdesc_nodetached; /* partdesc w/o detached parts */
  MemoryContext rd_pddcxt;  /* for rd_partdesc_nodetached, if any */

  /*
   * pg_inherits.xmin of the partition that was excluded in
   * rd_partdesc_nodetached.  This informs a future user of that partdesc:
   * if this value is not in progress for the active snapshot, then the
   * partdesc can be used, otherwise they have to build a new one.  (This
   * matches what find_inheritance_children_extended would do).
   */
  TransactionId rd_partdesc_nodetached_xmin;

  /* data managed by RelationGetPartitionQual: */
  List     *rd_partcheck; /* partition CHECK quals */
  bool    rd_partcheckvalid;  /* true if list has been computed */
  MemoryContext rd_partcheckcxt;  /* private cxt for rd_partcheck, if any */

  /* data managed by RelationGetIndexList: */
  List     *rd_indexlist; /* list of OIDs of indexes on relation */
  Oid     rd_pkindex;   /* OID of (deferrable?) primary key, if any */
  bool    rd_ispkdeferrable;  /* is rd_pkindex a deferrable PK? */
  Oid     rd_replidindex; /* OID of replica identity index, if any */

  /* data managed by RelationGetStatExtList: */
  List     *rd_statlist;  /* list of OIDs of extended stats */

  /* data managed by RelationGetIndexAttrBitmap: */
  bool    rd_attrsvalid;  /* are bitmaps of attrs valid? */
  Bitmapset  *rd_keyattr;   /* cols that can be ref'd by foreign keys */
  Bitmapset  *rd_pkattr;    /* cols included in primary key */
  Bitmapset  *rd_idattr;    /* included in replica identity index */
  Bitmapset  *rd_hotblockingattr; /* cols blocking HOT update */
  Bitmapset  *rd_summarizedattr;  /* cols indexed by summarizing indexes */

  PublicationDesc *rd_pubdesc;  /* publication descriptor, or NULL */

  /*
   * rd_options is set whenever rd_rel is loaded into the relcache entry.
   * Note that you can NOT look into rd_rel for this data.  NULL means "use
   * defaults".
   */
  bytea    *rd_options;   /* parsed pg_class.reloptions */

  /*
   * Oid of the handler for this relation. For an index this is a function
   * returning IndexAmRoutine, for table like relations a function returning
   * TableAmRoutine.  This is stored separately from rd_indam, rd_tableam as
   * its lookup requires syscache access, but during relcache bootstrap we
   * need to be able to initialize rd_tableam without syscache lookups.
   */
  Oid     rd_amhandler; /* OID of index AM's handler function */

  /*
   * Table access method.
   */
  const struct TableAmRoutine *rd_tableam;

  /* These are non-NULL only for an index relation: */
  Form_pg_index rd_index;   /* pg_index tuple describing this index */
  /* use "struct" here to avoid needing to include htup.h: */
  struct HeapTupleData *rd_indextuple;  /* all of pg_index tuple */

  /*
   * index access support info (used only for an index relation)
   *
   * Note: only default support procs for each opclass are cached, namely
   * those with lefttype and righttype equal to the opclass's opcintype. The
   * arrays are indexed by support function number, which is a sufficient
   * identifier given that restriction.
   */
  MemoryContext rd_indexcxt;  /* private memory cxt for this stuff */
  /* use "struct" here to avoid needing to include amapi.h: */
  const struct IndexAmRoutine *rd_indam;  /* index AM's API struct */
  Oid      *rd_opfamily;  /* OIDs of op families for each index col */
  Oid      *rd_opcintype; /* OIDs of opclass declared input data types */
  RegProcedure *rd_support; /* OIDs of support procedures */
  struct FmgrInfo *rd_supportinfo;  /* lookup info for support procedures */
  int16    *rd_indoption; /* per-column AM-specific flags */
  List     *rd_indexprs;  /* index expression trees, if any */
  List     *rd_indpred;   /* index predicate tree, if any */
  Oid      *rd_exclops;   /* OIDs of exclusion operators, if any */
  Oid      *rd_exclprocs; /* OIDs of exclusion ops' procs, if any */
  uint16     *rd_exclstrats;  /* exclusion ops' strategy numbers, if any */
  Oid      *rd_indcollation;  /* OIDs of index collations */
  bytea   **rd_opcoptions;  /* parsed opclass-specific options */

  /*
   * rd_amcache is available for index and table AMs to cache private data
   * about the relation.  This must be just a cache since it may get reset
   * at any time (in particular, it will get reset by a relcache inval
   * message for the relation).  If used, it must point to a single memory
   * chunk palloc'd in CacheMemoryContext, or in rd_indexcxt for an index
   * relation.  A relcache reset will include freeing that chunk and setting
   * rd_amcache = NULL.
   */
  void     *rd_amcache;   /* available for use by index/table AM */

  /*
   * foreign-table support
   *
   * rd_fdwroutine must point to a single memory chunk palloc'd in
   * CacheMemoryContext.  It will be freed and reset to NULL on a relcache
   * reset.
   */

  /* use "struct" here to avoid needing to include fdwapi.h: */
  struct FdwRoutine *rd_fdwroutine; /* cached function pointers, or NULL */

  /*
   * Hack for CLUSTER, rewriting ALTER TABLE, etc: when writing a new
   * version of a table, we need to make any toast pointers inserted into it
   * have the existing toast table's OID, not the OID of the transient toast
   * table.  If rd_toastoid isn't InvalidOid, it is the OID to place in
   * toast pointers inserted into this rel.  (Note it's set on the new
   * version of the main heap, not the toast table itself.)  This also
   * causes toast_save_datum() to try to preserve toast value OIDs.
   */
  Oid     rd_toastoid;  /* Real TOAST table's OID, or InvalidOid */

  /*
   * Type OID of the "chunk_id" column of this relation's TOAST table, i.e.
   * OIDOID or OID8OID.
   *
   * This data is filled on demand by RelationGetToastChunkIdType(), not at
   * relcache build time, so as to save on syscache lookups.
   */
  Oid     rd_toastchunkidtype;

  bool    pgstat_enabled; /* should relation stats be counted */
  /* use "struct" here to avoid needing to include pgstat.h: */
  struct PgStat_RelationStatus *pgstat_info;  /* statistics collection area */
} RelationData;


/*
 * ForeignKeyCacheInfo
 *    Information the relcache can cache about foreign key constraints
 *
 * This is basically just an image of relevant columns from pg_constraint.
 * We make it a subclass of Node so that copyObject() can be used on a list
 * of these, but we also ensure it is a "flat" object without substructure,
 * so that list_free_deep() is sufficient to free such a list.
 * The per-FK-column arrays can be fixed-size because we allow at most
 * INDEX_MAX_KEYS columns in a foreign key constraint.
 *
 * Currently, we mostly cache fields of interest to the planner, but the set
 * of fields has already grown the constraint OID for other uses.
 */
typedef struct ForeignKeyCacheInfo
{
  pg_node_attr(no_equal, no_read, no_query_jumble)

  NodeTag   type;
  /* oid of the constraint itself */
  Oid     conoid;
  /* relation constrained by the foreign key */
  Oid     conrelid;
  /* relation referenced by the foreign key */
  Oid     confrelid;
  /* number of columns in the foreign key */
  int     nkeys;

  /* Is enforced ? */
  bool    conenforced;

  /*
   * these arrays each have nkeys valid entries:
   */
  /* cols in referencing table */
  AttrNumber  conkey[INDEX_MAX_KEYS] pg_node_attr(array_size(nkeys));
  /* cols in referenced table */
  AttrNumber  confkey[INDEX_MAX_KEYS] pg_node_attr(array_size(nkeys));
  /* PK = FK operator OIDs */
  Oid     conpfeqop[INDEX_MAX_KEYS] pg_node_attr(array_size(nkeys));
} ForeignKeyCacheInfo;


/*
 * StdRdOptions
 *    Standard contents of rd_options for heaps.
 *
 * RelationGetFillFactor() and RelationGetTargetPageFreeSpace() can only
 * be applied to relations that use this format or a superset for
 * private options data.
 */
 /* autovacuum-related reloptions. */
typedef struct AutoVacOpts
{
  pg_ternary  enabled;

  int     autovacuum_parallel_workers;
  int     vacuum_threshold;
  int     vacuum_max_threshold;
  int     vacuum_ins_threshold;
  int     analyze_threshold;
  int     vacuum_cost_limit;
  int     freeze_min_age;
  int     freeze_max_age;
  int     freeze_table_age;
  int     multixact_freeze_min_age;
  int     multixact_freeze_max_age;
  int     multixact_freeze_table_age;
  int     log_vacuum_min_duration;
  int     log_analyze_min_duration;
  float8    vacuum_cost_delay;
  float8    vacuum_scale_factor;
  float8    vacuum_ins_scale_factor;
  float8    analyze_scale_factor;
} AutoVacOpts;

/* StdRdOptions->vacuum_index_cleanup values */
typedef enum StdRdOptIndexCleanup
{
  STDRD_OPTION_VACUUM_INDEX_CLEANUP_AUTO = 0,
  STDRD_OPTION_VACUUM_INDEX_CLEANUP_OFF,
  STDRD_OPTION_VACUUM_INDEX_CLEANUP_ON,
  STDRD_OPTION_VACUUM_INDEX_CLEANUP_NOT_SET,
} StdRdOptIndexCleanup;

/* StdRdOptions->toast_value_type values */
typedef enum StdRdOptToastValueType
{
  STDRD_OPTION_TOAST_VALUE_TYPE_INVALID = 0,
  STDRD_OPTION_TOAST_VALUE_TYPE_OID,
  STDRD_OPTION_TOAST_VALUE_TYPE_OID8,
} StdRdOptToastValueType;

typedef struct StdRdOptions
{
  int32   vl_len_;    /* varlena header (do not touch directly!) */
  int     fillfactor;   /* page fill factor in percent (0..100) */
  int     toast_tuple_target; /* target for tuple toasting */
  StdRdOptToastValueType toast_value_type;  /* type assigned to chunk_id
                         * at toast table creation */
  AutoVacOpts autovacuum;   /* autovacuum-related options */
  bool    user_catalog_table; /* use as an additional catalog relation */
  int     parallel_workers; /* max number of parallel workers */
  StdRdOptIndexCleanup vacuum_index_cleanup;  /* controls index vacuuming */
  pg_ternary  vacuum_truncate;  /* enables vacuum to truncate a relation */

  /*
   * Fraction of pages in a relation that vacuum can eagerly scan and fail
   * to freeze. 0 if disabled, -1 if unspecified.
   */
  double    vacuum_max_eager_freeze_failure_rate;
} StdRdOptions;

#define HEAP_MIN_FILLFACTOR     10
#define HEAP_DEFAULT_FILLFACTOR   100

/*
 * RelationGetToastTupleTarget
 *    Returns the relation's toast_tuple_target.  Note multiple eval of argument!
 */
#define RelationGetToastTupleTarget(relation, defaulttarg) \
  ((relation)->rd_options ? \
   ((StdRdOptions *) (relation)->rd_options)->toast_tuple_target : (defaulttarg))

/*
 * RelationGetToastValueType
 *    Returns the relation's toast_value_type.  Note multiple eval of argument!
 */
#define RelationGetToastValueType(relation, defaulttarg) \
  ((relation)->rd_options ? \
   ((StdRdOptions *) (relation)->rd_options)->toast_value_type : (defaulttarg))

/*
 * RelationGetFillFactor
 *    Returns the relation's fillfactor.  Note multiple eval of argument!
 */
#define RelationGetFillFactor(relation, defaultff) \
  ((relation)->rd_options ? \
   ((StdRdOptions *) (relation)->rd_options)->fillfactor : (defaultff))

/*
 * RelationGetTargetPageUsage
 *    Returns the relation's desired space usage per page in bytes.
 */
#define RelationGetTargetPageUsage(relation, defaultff) \
  (BLCKSZ * RelationGetFillFactor(relation, defaultff) / 100)

/*
 * RelationGetTargetPageFreeSpace
 *    Returns the relation's desired freespace per page in bytes.
 */
#define RelationGetTargetPageFreeSpace(relation, defaultff) \
  (BLCKSZ * (100 - RelationGetFillFactor(relation, defaultff)) / 100)

/*
 * RelationIsUsedAsCatalogTable
 *    Returns whether the relation should be treated as a catalog table
 *    from the pov of logical decoding.  Note multiple eval of argument!
 */
#define RelationIsUsedAsCatalogTable(relation)  \
  ((relation)->rd_options && \
   ((relation)->rd_rel->relkind == RELKIND_RELATION || \
    (relation)->rd_rel->relkind == RELKIND_MATVIEW) ? \
   ((StdRdOptions *) (relation)->rd_options)->user_catalog_table : false)

/*
 * RelationGetParallelWorkers
 *    Returns the relation's parallel_workers reloption setting.
 *    Note multiple eval of argument!
 */
#define RelationGetParallelWorkers(relation, defaultpw) \
  ((relation)->rd_options ? \
   ((StdRdOptions *) (relation)->rd_options)->parallel_workers : (defaultpw))

/* ViewOptions->check_option values */
typedef enum ViewOptCheckOption
{
  VIEW_OPTION_CHECK_OPTION_NOT_SET,
  VIEW_OPTION_CHECK_OPTION_LOCAL,
  VIEW_OPTION_CHECK_OPTION_CASCADED,
} ViewOptCheckOption;

/*
 * ViewOptions
 *    Contents of rd_options for views
 */
typedef struct ViewOptions
{
  int32   vl_len_;    /* varlena header (do not touch directly!) */
  bool    security_barrier;
  bool    security_invoker;
  ViewOptCheckOption check_option;
} ViewOptions;

/*
 * RelationIsSecurityView
 *    Returns whether the relation is security view, or not.  Note multiple
 *    eval of argument!
 */
#define RelationIsSecurityView(relation)                  \
  (AssertMacro(relation->rd_rel->relkind == RELKIND_VIEW),        \
   (relation)->rd_options ?                        \
    ((ViewOptions *) (relation)->rd_options)->security_barrier : false)

/*
 * RelationHasSecurityInvoker
 *    Returns true if the relation has the security_invoker property set.
 *    Note multiple eval of argument!
 */
#define RelationHasSecurityInvoker(relation)                \
  (AssertMacro(relation->rd_rel->relkind == RELKIND_VIEW),        \
   (relation)->rd_options ?                        \
    ((ViewOptions *) (relation)->rd_options)->security_invoker : false)

/*
 * RelationHasCheckOption
 *    Returns true if the relation is a view defined with either the local
 *    or the cascaded check option.  Note multiple eval of argument!
 */
#define RelationHasCheckOption(relation)                  \
  (AssertMacro(relation->rd_rel->relkind == RELKIND_VIEW),        \
   (relation)->rd_options &&                       \
   ((ViewOptions *) (relation)->rd_options)->check_option !=       \
   VIEW_OPTION_CHECK_OPTION_NOT_SET)

/*
 * RelationHasLocalCheckOption
 *    Returns true if the relation is a view defined with the local check
 *    option.  Note multiple eval of argument!
 */
#define RelationHasLocalCheckOption(relation)               \
  (AssertMacro(relation->rd_rel->relkind == RELKIND_VIEW),        \
   (relation)->rd_options &&                        \
   ((ViewOptions *) (relation)->rd_options)->check_option ==        \
   VIEW_OPTION_CHECK_OPTION_LOCAL)

/*
 * RelationHasCascadedCheckOption
 *    Returns true if the relation is a view defined with the cascaded check
 *    option.  Note multiple eval of argument!
 */
#define RelationHasCascadedCheckOption(relation)              \
  (AssertMacro(relation->rd_rel->relkind == RELKIND_VIEW),        \
   (relation)->rd_options &&                       \
   ((ViewOptions *) (relation)->rd_options)->check_option ==       \
    VIEW_OPTION_CHECK_OPTION_CASCADED)

/*
 * RelationIsValid
 *    True iff relation descriptor is valid.
 */
#define RelationIsValid(relation) ((relation) != NULL)

/*
 * RelationHasReferenceCountZero
 *    True iff relation reference count is zero.
 *
 * Note:
 *    Assumes relation descriptor is valid.
 */
#define RelationHasReferenceCountZero(relation) \
    ((bool)((relation)->rd_refcnt == 0))

/*
 * RelationGetForm
 *    Returns pg_class tuple for a relation.
 *
 * Note:
 *    Assumes relation descriptor is valid.
 */
#define RelationGetForm(relation) ((relation)->rd_rel)

/*
 * RelationGetRelid
 *    Returns the OID of the relation
 */
#define RelationGetRelid(relation) ((relation)->rd_id)

/*
 * RelationGetNumberOfAttributes
 *    Returns the total number of attributes in a relation.
 */
#define RelationGetNumberOfAttributes(relation) ((relation)->rd_rel->relnatts)

/*
 * IndexRelationGetNumberOfAttributes
 *    Returns the number of attributes in an index.
 */
#define IndexRelationGetNumberOfAttributes(relation) \
    ((relation)->rd_index->indnatts)

/*
 * IndexRelationGetNumberOfKeyAttributes
 *    Returns the number of key attributes in an index.
 */
#define IndexRelationGetNumberOfKeyAttributes(relation) \
    ((relation)->rd_index->indnkeyatts)

/*
 * RelationGetDescr
 *    Returns tuple descriptor for a relation.
 */
#define RelationGetDescr(relation) ((relation)->rd_att)

/*
 * RelationGetRelationName
 *    Returns the rel's name.
 *
 * Note that the name is only unique within the containing namespace.
 */
#define RelationGetRelationName(relation) \
  (NameStr((relation)->rd_rel->relname))

/*
 * RelationGetNamespace
 *    Returns the rel's namespace OID.
 */
#define RelationGetNamespace(relation) \
  ((relation)->rd_rel->relnamespace)

/*
 * RelationIsMapped
 *    True if the relation uses the relfilenumber map.  Note multiple eval
 *    of argument!
 */
#define RelationIsMapped(relation) \
  (RELKIND_HAS_STORAGE((relation)->rd_rel->relkind) && \
   ((relation)->rd_rel->relfilenode == InvalidRelFileNumber))

#ifndef FRONTEND
/*
 * RelationGetSmgr
 *    Returns smgr file handle for a relation, opening it if needed.
 *
 * Very little code is authorized to touch rel->rd_smgr directly.  Instead
 * use this function to fetch its value.
 */
static inline SMgrRelation
RelationGetSmgr(Relation rel)
{
  if (unlikely(rel->rd_smgr == NULL))
  {
    rel->rd_smgr = smgropen(rel->rd_locator, rel->rd_backend);
    smgrpin(rel->rd_smgr);
  }
  return rel->rd_smgr;
}

/*
 * RelationCloseSmgr
 *    Close the relation at the smgr level, if not already done.
 */
static inline void
RelationCloseSmgr(Relation relation)
{
  if (relation->rd_smgr != NULL)
  {
    smgrunpin(relation->rd_smgr);
    smgrclose(relation->rd_smgr);
    relation->rd_smgr = NULL;
  }
}
#endif              /* !FRONTEND */

/*
 * RelationGetTargetBlock
 *    Fetch relation's current insertion target block.
 *
 * Returns InvalidBlockNumber if there is no current target block.  Note
 * that the target block status is discarded on any smgr-level invalidation,
 * so there's no need to re-open the smgr handle if it's not currently open.
 */
#define RelationGetTargetBlock(relation) \
  ( (relation)->rd_smgr != NULL ? (relation)->rd_smgr->smgr_targblock : InvalidBlockNumber )

/*
 * RelationSetTargetBlock
 *    Set relation's current insertion target block.
 */
#define RelationSetTargetBlock(relation, targblock) \
  do { \
    RelationGetSmgr(relation)->smgr_targblock = (targblock); \
  } while (0)

/*
 * RelationIsPermanent
 *    True if relation is permanent.
 */
#define RelationIsPermanent(relation) \
  ((relation)->rd_rel->relpersistence == RELPERSISTENCE_PERMANENT)

/*
 * RelationNeedsWAL
 *    True if relation needs WAL.
 *
 * Returns false if wal_level = minimal and this relation is created or
 * truncated in the current transaction.  See "Skipping WAL for New
 * RelFileLocator" in src/backend/access/transam/README.
 */
#define RelationNeedsWAL(relation)                    \
  (RelationIsPermanent(relation) && (XLogIsNeeded() ||       \
    (relation->rd_createSubid == InvalidSubTransactionId &&     \
     relation->rd_firstRelfilelocatorSubid == InvalidSubTransactionId)))

/*
 * RelationUsesLocalBuffers
 *    True if relation's pages are stored in local buffers.
 */
#define RelationUsesLocalBuffers(relation) \
  ((relation)->rd_rel->relpersistence == RELPERSISTENCE_TEMP)

/*
 * RELATION_IS_LOCAL
 *    If a rel is either temp or newly created in the current transaction,
 *    it can be assumed to be accessible only to the current backend.
 *    This is typically used to decide that we can skip acquiring locks.
 *
 * Beware of multiple eval of argument
 */
#define RELATION_IS_LOCAL(relation) \
  ((relation)->rd_islocaltemp || \
   (relation)->rd_createSubid != InvalidSubTransactionId)

/*
 * RELATION_IS_OTHER_TEMP
 *    Test for a temporary relation that belongs to some other session.
 *
 * Reading another session's temp-table data through never works right:
 * the owning session keeps the data in its private local buffer pool,
 * which we cannot access.  Existing buffer-manager entry points
 * (ReadBuffer_common(), StartReadBuffersImpl(), read_stream_begin_impl(),
 * PrefetchBuffer() and ExtendBufferedRelCommon()) already enforce this; any
 * new buffer-access entry points must do the same.  Command-level code
 * (TRUNCATE, ALTER TABLE, VACUUM, CLUSTER, REINDEX, ...) additionally uses
 * this macro for command-specific error messages.
 *
 * Beware of multiple eval of argument
 */
#define RELATION_IS_OTHER_TEMP(relation) \
  ((relation)->rd_rel->relpersistence == RELPERSISTENCE_TEMP && \
   !(relation)->rd_islocaltemp)


/*
 * RelationIsScannable
 *    Currently can only be false for a materialized view which has not been
 *    populated by its query.  This is likely to get more complicated later,
 *    so use a macro which looks like a function.
 */
#define RelationIsScannable(relation) ((relation)->rd_rel->relispopulated)

/*
 * RelationIsPopulated
 *    Currently, we don't physically distinguish the "populated" and
 *    "scannable" properties of matviews, but that may change later.
 *    Hence, use the appropriate one of these macros in code tests.
 */
#define RelationIsPopulated(relation) ((relation)->rd_rel->relispopulated)

/*
 * RelationIsAccessibleInLogicalDecoding
 *    True if we need to log enough information to have access via
 *    decoding snapshot.
 */
#define RelationIsAccessibleInLogicalDecoding(relation) \
  (XLogLogicalInfoActive() && \
   RelationNeedsWAL(relation) && \
   (IsCatalogRelation(relation) || RelationIsUsedAsCatalogTable(relation)))

/*
 * RelationIsLogicallyLogged
 *    True if we need to log enough information to extract the data from the
 *    WAL stream.
 *
 * We don't log information for unlogged tables (since they don't WAL log
 * anyway), for foreign tables (since they don't WAL log, either),
 * and for system tables (their content is hard to make sense of, and
 * it would complicate decoding slightly for little gain). Note that we *do*
 * log information for user defined catalog tables since they presumably are
 * interesting to the user...
 */
#define RelationIsLogicallyLogged(relation) \
  (XLogLogicalInfoActive() && \
   RelationNeedsWAL(relation) && \
   (relation)->rd_rel->relkind != RELKIND_FOREIGN_TABLE && \
   !IsCatalogRelation(relation))

/* routines in utils/cache/relcache.c */
extern void RelationIncrementReferenceCount(Relation rel);
extern void RelationDecrementReferenceCount(Relation rel);

#endif              /* REL_H */

Coverage Report

Created: 2026-09-28 06:55

Line	Count	Source
1		/*-------------------------------------------------------------------------
2		*
3		* rel.h
4		* POSTGRES relation descriptor (a/k/a relcache entry) definitions.
5		*
6		*
7		* Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
8		* Portions Copyright (c) 1994, Regents of the University of California
9		*
10		* src/include/utils/rel.h
11		*
12		*-------------------------------------------------------------------------
13		*/
14		#ifndef REL_H
15		#define REL_H
16
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 convenient
35		* to declare them here so we can have a LockInfoData field in a Relation.
36		*/
37
38		typedef struct LockRelId
39		{