src/include/storage/relfilenode.h

   1 /*-------------------------------------------------------------------------
   2  *
   3  * relfilenode.h
   4  *        Physical access information for relations.
   5  *
   6  *
   7  * Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group
   8  * Portions Copyright (c) 1994, Regents of the University of California
   9  *
  10  * src/include/storage/relfilenode.h
  11  *
  12  *-------------------------------------------------------------------------
  13  */
  14 #ifndef RELFILENODE_H
  15 #define RELFILENODE_H
  16
  17 #include "common/relpath.h"
  18 #include "storage/backendid.h"
  19
  20 /*
  21  * RelFileNode must provide all that we need to know to physically access
  22  * a relation, with the exception of the backend ID, which can be provided
  23  * separately. Note, however, that a "physical" relation is comprised of
  24  * multiple files on the filesystem, as each fork is stored as a separate
  25  * file, and each fork can be divided into multiple segments. See md.c.
  26  *
  27  * spcNode identifies the tablespace of the relation.  It corresponds to
  28  * pg_tablespace.oid.
  29  *
  30  * dbNode identifies the database of the relation.  It is zero for
  31  * "shared" relations (those common to all databases of a cluster).
  32  * Nonzero dbNode values correspond to pg_database.oid.
  33  *
  34  * relNode identifies the specific relation.  relNode corresponds to
  35  * pg_class.relfilenode (NOT pg_class.oid, because we need to be able
  36  * to assign new physical files to relations in some situations).
  37  * Notice that relNode is only unique within a database in a particular
  38  * tablespace.
  39  *
  40  * Note: spcNode must be GLOBALTABLESPACE_OID if and only if dbNode is
  41  * zero.  We support shared relations only in the "global" tablespace.
  42  *
  43  * Note: in pg_class we allow reltablespace == 0 to denote that the
  44  * relation is stored in its database's "default" tablespace (as
  45  * identified by pg_database.dattablespace).  However this shorthand
  46  * is NOT allowed in RelFileNode structs --- the real tablespace ID
  47  * must be supplied when setting spcNode.
  48  *
  49  * Note: in pg_class, relfilenode can be zero to denote that the relation
  50  * is a "mapped" relation, whose current true filenode number is available
  51  * from relmapper.c.  Again, this case is NOT allowed in RelFileNodes.
  52  *
  53  * Note: various places use RelFileNode in hashtable keys.  Therefore,
  54  * there *must not* be any unused padding bytes in this struct.  That
  55  * should be safe as long as all the fields are of type Oid.
  56  */
  57 typedef struct RelFileNode
  58 {
  59         Oid                     spcNode;                /* tablespace */
  60         Oid                     dbNode;                 /* database */
  61         Oid                     relNode;                /* relation */
  62 } RelFileNode;
  63
  64 /*
  65  * Augmenting a relfilenode with the backend ID provides all the information
  66  * we need to locate the physical storage.  The backend ID is InvalidBackendId
  67  * for regular relations (those accessible to more than one backend), or the
  68  * owning backend's ID for backend-local relations.  Backend-local relations
  69  * are always transient and removed in case of a database crash; they are
  70  * never WAL-logged or fsync'd.
  71  */
  72 typedef struct RelFileNodeBackend
  73 {
  74         RelFileNode node;
  75         BackendId       backend;
  76 } RelFileNodeBackend;
  77
  78 #define RelFileNodeBackendIsTemp(rnode) \
  79         ((rnode).backend != InvalidBackendId)
  80
  81 /*
  82  * Note: RelFileNodeEquals and RelFileNodeBackendEquals compare relNode first
  83  * since that is most likely to be different in two unequal RelFileNodes.  It
  84  * is probably redundant to compare spcNode if the other fields are found equal,
  85  * but do it anyway to be sure.  Likewise for checking the backend ID in
  86  * RelFileNodeBackendEquals.
  87  */
  88 #define RelFileNodeEquals(node1, node2) \
  89         ((node1).relNode == (node2).relNode && \
  90          (node1).dbNode == (node2).dbNode && \
  91          (node1).spcNode == (node2).spcNode)
  92
  93 #define RelFileNodeBackendEquals(node1, node2) \
  94         ((node1).node.relNode == (node2).node.relNode && \
  95          (node1).node.dbNode == (node2).node.dbNode && \
  96          (node1).backend == (node2).backend && \
  97          (node1).node.spcNode == (node2).node.spcNode)
  98
  99 #endif                                                  /* RELFILENODE_H */