LCOV - differential code coverage report
Current view: top level - src/include/utils - rel.h (source / functions) Coverage Total Hit GNC CBC DCB
Current: Differential Code Coverage 16@8cea358b128 vs 17@8cea358b128 Lines: 100.0 % 11 11 4 7 2
Current Date: 2024-04-14 14:21:10 Functions: 100.0 % 2 2 2
Baseline: 16@8cea358b128 Branches: 100.0 % 4 4 4
Baseline Date: 2024-04-14 14:21:09 Line coverage date bins:
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed (60,120] days: 100.0 % 4 4 4
(240..) days: 100.0 % 7 7 7
Function coverage date bins:
(240..) days: 100.0 % 2 2 2
Branch coverage date bins:
(240..) days: 100.0 % 4 4 4

 Age         Owner                    Branch data    TLA  Line data    Source code
                                  1                 :                : /*-------------------------------------------------------------------------
                                  2                 :                :  *
                                  3                 :                :  * rel.h
                                  4                 :                :  *    POSTGRES relation descriptor (a/k/a relcache entry) definitions.
                                  5                 :                :  *
                                  6                 :                :  *
                                  7                 :                :  * Portions Copyright (c) 1996-2024, 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                 :                : {
                                 40                 :                :     Oid         relId;          /* a relation identifier */
                                 41                 :                :     Oid         dbId;           /* a database identifier */
                                 42                 :                : } LockRelId;
                                 43                 :                : 
                                 44                 :                : typedef struct LockInfoData
                                 45                 :                : {
                                 46                 :                :     LockRelId   lockRelId;
                                 47                 :                : } LockInfoData;
                                 48                 :                : 
                                 49                 :                : typedef LockInfoData *LockInfo;
                                 50                 :                : 
                                 51                 :                : /*
                                 52                 :                :  * Here are the contents of a relation cache entry.
                                 53                 :                :  */
                                 54                 :                : 
                                 55                 :                : typedef struct RelationData
                                 56                 :                : {
                                 57                 :                :     RelFileLocator rd_locator;  /* relation physical identifier */
                                 58                 :                :     SMgrRelation rd_smgr;       /* cached file handle, or NULL */
                                 59                 :                :     int         rd_refcnt;      /* reference count */
                                 60                 :                :     ProcNumber  rd_backend;     /* owning backend's proc number, if temp rel */
                                 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 and
                                 65                 :                :                                  * rd_replidindex) */
                                 66                 :                :     bool        rd_statvalid;   /* is rd_statlist valid? */
                                 67                 :                : 
                                 68                 :                :     /*----------
                                 69                 :                :      * rd_createSubid is the ID of the highest subtransaction the rel has
                                 70                 :                :      * survived into or zero if the rel or its storage was created before the
                                 71                 :                :      * current top transaction.  (IndexStmt.oldNumber leads to the case of a new
                                 72                 :                :      * rel with an old rd_locator.)  rd_firstRelfilelocatorSubid is the ID of the
                                 73                 :                :      * highest subtransaction an rd_locator change has survived into or zero if
                                 74                 :                :      * rd_locator matches the value it had at the start of the current top
                                 75                 :                :      * transaction.  (Rolling back the subtransaction that
                                 76                 :                :      * rd_firstRelfilelocatorSubid denotes would restore rd_locator to the value it
                                 77                 :                :      * had at the start of the current top transaction.  Rolling back any
                                 78                 :                :      * lower subtransaction would not.)  Their accuracy is critical to
                                 79                 :                :      * RelationNeedsWAL().
                                 80                 :                :      *
                                 81                 :                :      * rd_newRelfilelocatorSubid is the ID of the highest subtransaction the
                                 82                 :                :      * most-recent relfilenumber change has survived into or zero if not changed
                                 83                 :                :      * in the current transaction (or we have forgotten changing it).  This
                                 84                 :                :      * field is accurate when non-zero, but it can be zero when a relation has
                                 85                 :                :      * multiple new relfilenumbers within a single transaction, with one of them
                                 86                 :                :      * 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 forgotten
                                 93                 :                :      *
                                 94                 :                :      * If every rd_*Subid field is zero, they are read-only outside
                                 95                 :                :      * relcache.c.  Files that trigger rd_locator changes by updating
                                 96                 :                :      * pg_class.reltablespace and/or pg_class.relfilenode call
                                 97                 :                :      * RelationAssumeNewRelfilelocator() to update rd_*Subid.
                                 98                 :                :      *
                                 99                 :                :      * rd_droppedSubid is the ID of the highest subtransaction that a drop of
                                100                 :                :      * the rel has survived into.  In entries visible outside relcache.c, this
                                101                 :                :      * is always zero.
                                102                 :                :      */
                                103                 :                :     SubTransactionId rd_createSubid;    /* rel was created in current xact */
                                104                 :                :     SubTransactionId rd_newRelfilelocatorSubid; /* highest subxact changing
                                105                 :                :                                                  * rd_locator to current value */
                                106                 :                :     SubTransactionId rd_firstRelfilelocatorSubid;   /* highest subxact
                                107                 :                :                                                      * changing rd_locator to
                                108                 :                :                                                      * 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 in
                                139                 :                :      * rd_partdesc_nodetached.  This informs a future user of that partdesc:
                                140                 :                :      * if this value is not in progress for the active snapshot, then the
                                141                 :                :      * partdesc can be used, otherwise they have to build a new one.  (This
                                142                 :                :      * 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 (deferrable?) primary key, if any */
                                154                 :                :     bool        rd_ispkdeferrable;  /* is rd_pkindex a deferrable PK? */
                                155                 :                :     Oid         rd_replidindex; /* OID of replica identity index, if any */
                                156                 :                : 
                                157                 :                :     /* data managed by RelationGetStatExtList: */
                                158                 :                :     List       *rd_statlist;    /* list of OIDs of extended stats */
                                159                 :                : 
                                160                 :                :     /* data managed by RelationGetIndexAttrBitmap: */
                                161                 :                :     bool        rd_attrsvalid;  /* are bitmaps of attrs valid? */
                                162                 :                :     Bitmapset  *rd_keyattr;     /* cols that can be ref'd by foreign keys */
                                163                 :                :     Bitmapset  *rd_pkattr;      /* cols included in primary key */
                                164                 :                :     Bitmapset  *rd_idattr;      /* included in replica identity index */
                                165                 :                :     Bitmapset  *rd_hotblockingattr; /* cols blocking HOT update */
                                166                 :                :     Bitmapset  *rd_summarizedattr;  /* cols indexed by summarizing indexes */
                                167                 :                : 
                                168                 :                :     PublicationDesc *rd_pubdesc;    /* publication descriptor, or NULL */
                                169                 :                : 
                                170                 :                :     /*
                                171                 :                :      * rd_options is set whenever rd_rel is loaded into the relcache entry.
                                172                 :                :      * Note that you can NOT look into rd_rel for this data.  NULL means "use
                                173                 :                :      * defaults".
                                174                 :                :      */
                                175                 :                :     bytea      *rd_options;     /* parsed pg_class.reloptions */
                                176                 :                : 
                                177                 :                :     /*
                                178                 :                :      * Oid of the handler for this relation. For an index this is a function
                                179                 :                :      * returning IndexAmRoutine, for table like relations a function returning
                                180                 :                :      * TableAmRoutine.  This is stored separately from rd_indam, rd_tableam as
                                181                 :                :      * its lookup requires syscache access, but during relcache bootstrap we
                                182                 :                :      * need to be able to initialize rd_tableam without syscache lookups.
                                183                 :                :      */
                                184                 :                :     Oid         rd_amhandler;   /* OID of index AM's handler function */
                                185                 :                : 
                                186                 :                :     /*
                                187                 :                :      * Table access method.
                                188                 :                :      */
                                189                 :                :     const struct TableAmRoutine *rd_tableam;
                                190                 :                : 
                                191                 :                :     /* These are non-NULL only for an index relation: */
                                192                 :                :     Form_pg_index rd_index;     /* pg_index tuple describing this index */
                                193                 :                :     /* use "struct" here to avoid needing to include htup.h: */
                                194                 :                :     struct HeapTupleData *rd_indextuple;    /* all of pg_index tuple */
                                195                 :                : 
                                196                 :                :     /*
                                197                 :                :      * index access support info (used only for an index relation)
                                198                 :                :      *
                                199                 :                :      * Note: only default support procs for each opclass are cached, namely
                                200                 :                :      * those with lefttype and righttype equal to the opclass's opcintype. The
                                201                 :                :      * arrays are indexed by support function number, which is a sufficient
                                202                 :                :      * identifier given that restriction.
                                203                 :                :      */
                                204                 :                :     MemoryContext rd_indexcxt;  /* private memory cxt for this stuff */
                                205                 :                :     /* use "struct" here to avoid needing to include amapi.h: */
                                206                 :                :     struct IndexAmRoutine *rd_indam;    /* index AM's API struct */
                                207                 :                :     Oid        *rd_opfamily;    /* OIDs of op families for each index col */
                                208                 :                :     Oid        *rd_opcintype;   /* OIDs of opclass declared input data types */
                                209                 :                :     RegProcedure *rd_support;   /* OIDs of support procedures */
                                210                 :                :     struct FmgrInfo *rd_supportinfo;    /* lookup info for support procedures */
                                211                 :                :     int16      *rd_indoption;   /* per-column AM-specific flags */
                                212                 :                :     List       *rd_indexprs;    /* index expression trees, if any */
                                213                 :                :     List       *rd_indpred;     /* index predicate tree, if any */
                                214                 :                :     Oid        *rd_exclops;     /* OIDs of exclusion operators, if any */
                                215                 :                :     Oid        *rd_exclprocs;   /* OIDs of exclusion ops' procs, if any */
                                216                 :                :     uint16     *rd_exclstrats;  /* exclusion ops' strategy numbers, if any */
                                217                 :                :     Oid        *rd_indcollation;    /* OIDs of index collations */
                                218                 :                :     bytea     **rd_opcoptions;  /* parsed opclass-specific options */
                                219                 :                : 
                                220                 :                :     /*
                                221                 :                :      * rd_amcache is available for index and table AMs to cache private data
                                222                 :                :      * about the relation.  This must be just a cache since it may get reset
                                223                 :                :      * at any time (in particular, it will get reset by a relcache inval
                                224                 :                :      * message for the relation).  If used, it must point to a single memory
                                225                 :                :      * chunk palloc'd in CacheMemoryContext, or in rd_indexcxt for an index
                                226                 :                :      * relation.  A relcache reset will include freeing that chunk and setting
                                227                 :                :      * rd_amcache = NULL.
                                228                 :                :      */
                                229                 :                :     void       *rd_amcache;     /* available for use by index/table AM */
                                230                 :                : 
                                231                 :                :     /*
                                232                 :                :      * foreign-table support
                                233                 :                :      *
                                234                 :                :      * rd_fdwroutine must point to a single memory chunk palloc'd in
                                235                 :                :      * CacheMemoryContext.  It will be freed and reset to NULL on a relcache
                                236                 :                :      * reset.
                                237                 :                :      */
                                238                 :                : 
                                239                 :                :     /* use "struct" here to avoid needing to include fdwapi.h: */
                                240                 :                :     struct FdwRoutine *rd_fdwroutine;   /* cached function pointers, or NULL */
                                241                 :                : 
                                242                 :                :     /*
                                243                 :                :      * Hack for CLUSTER, rewriting ALTER TABLE, etc: when writing a new
                                244                 :                :      * version of a table, we need to make any toast pointers inserted into it
                                245                 :                :      * have the existing toast table's OID, not the OID of the transient toast
                                246                 :                :      * table.  If rd_toastoid isn't InvalidOid, it is the OID to place in
                                247                 :                :      * toast pointers inserted into this rel.  (Note it's set on the new
                                248                 :                :      * version of the main heap, not the toast table itself.)  This also
                                249                 :                :      * causes toast_save_datum() to try to preserve toast value OIDs.
                                250                 :                :      */
                                251                 :                :     Oid         rd_toastoid;    /* Real TOAST table's OID, or InvalidOid */
                                252                 :                : 
                                253                 :                :     bool        pgstat_enabled; /* should relation stats be counted */
                                254                 :                :     /* use "struct" here to avoid needing to include pgstat.h: */
                                255                 :                :     struct PgStat_TableStatus *pgstat_info; /* statistics collection area */
                                256                 :                : } RelationData;
                                257                 :                : 
                                258                 :                : 
                                259                 :                : /*
                                260                 :                :  * ForeignKeyCacheInfo
                                261                 :                :  *      Information the relcache can cache about foreign key constraints
                                262                 :                :  *
                                263                 :                :  * This is basically just an image of relevant columns from pg_constraint.
                                264                 :                :  * We make it a subclass of Node so that copyObject() can be used on a list
                                265                 :                :  * of these, but we also ensure it is a "flat" object without substructure,
                                266                 :                :  * so that list_free_deep() is sufficient to free such a list.
                                267                 :                :  * The per-FK-column arrays can be fixed-size because we allow at most
                                268                 :                :  * INDEX_MAX_KEYS columns in a foreign key constraint.
                                269                 :                :  *
                                270                 :                :  * Currently, we mostly cache fields of interest to the planner, but the set
                                271                 :                :  * of fields has already grown the constraint OID for other uses.
                                272                 :                :  */
                                273                 :                : typedef struct ForeignKeyCacheInfo
                                274                 :                : {
                                275                 :                :     pg_node_attr(no_equal, no_read, no_query_jumble)
                                276                 :                : 
                                277                 :                :     NodeTag     type;
                                278                 :                :     /* oid of the constraint itself */
                                279                 :                :     Oid         conoid;
                                280                 :                :     /* relation constrained by the foreign key */
                                281                 :                :     Oid         conrelid;
                                282                 :                :     /* relation referenced by the foreign key */
                                283                 :                :     Oid         confrelid;
                                284                 :                :     /* number of columns in the foreign key */
                                285                 :                :     int         nkeys;
                                286                 :                : 
                                287                 :                :     /*
                                288                 :                :      * these arrays each have nkeys valid entries:
                                289                 :                :      */
                                290                 :                :     /* cols in referencing table */
                                291                 :                :     AttrNumber  conkey[INDEX_MAX_KEYS] pg_node_attr(array_size(nkeys));
                                292                 :                :     /* cols in referenced table */
                                293                 :                :     AttrNumber  confkey[INDEX_MAX_KEYS] pg_node_attr(array_size(nkeys));
                                294                 :                :     /* PK = FK operator OIDs */
                                295                 :                :     Oid         conpfeqop[INDEX_MAX_KEYS] pg_node_attr(array_size(nkeys));
                                296                 :                : } ForeignKeyCacheInfo;
                                297                 :                : 
                                298                 :                : 
                                299                 :                : /*
                                300                 :                :  * StdRdOptions
                                301                 :                :  *      Standard contents of rd_options for heaps.
                                302                 :                :  *
                                303                 :                :  * RelationGetFillFactor() and RelationGetTargetPageFreeSpace() can only
                                304                 :                :  * be applied to relations that use this format or a superset for
                                305                 :                :  * private options data.
                                306                 :                :  */
                                307                 :                :  /* autovacuum-related reloptions. */
                                308                 :                : typedef struct AutoVacOpts
                                309                 :                : {
                                310                 :                :     bool        enabled;
                                311                 :                :     int         vacuum_threshold;
                                312                 :                :     int         vacuum_ins_threshold;
                                313                 :                :     int         analyze_threshold;
                                314                 :                :     int         vacuum_cost_limit;
                                315                 :                :     int         freeze_min_age;
                                316                 :                :     int         freeze_max_age;
                                317                 :                :     int         freeze_table_age;
                                318                 :                :     int         multixact_freeze_min_age;
                                319                 :                :     int         multixact_freeze_max_age;
                                320                 :                :     int         multixact_freeze_table_age;
                                321                 :                :     int         log_min_duration;
                                322                 :                :     float8      vacuum_cost_delay;
                                323                 :                :     float8      vacuum_scale_factor;
                                324                 :                :     float8      vacuum_ins_scale_factor;
                                325                 :                :     float8      analyze_scale_factor;
                                326                 :                : } AutoVacOpts;
                                327                 :                : 
                                328                 :                : /* StdRdOptions->vacuum_index_cleanup values */
                                329                 :                : typedef enum StdRdOptIndexCleanup
                                330                 :                : {
                                331                 :                :     STDRD_OPTION_VACUUM_INDEX_CLEANUP_AUTO = 0,
                                332                 :                :     STDRD_OPTION_VACUUM_INDEX_CLEANUP_OFF,
                                333                 :                :     STDRD_OPTION_VACUUM_INDEX_CLEANUP_ON,
                                334                 :                : } StdRdOptIndexCleanup;
                                335                 :                : 
                                336                 :                : typedef struct StdRdOptions
                                337                 :                : {
                                338                 :                :     int32       vl_len_;        /* varlena header (do not touch directly!) */
                                339                 :                :     int         fillfactor;     /* page fill factor in percent (0..100) */
                                340                 :                :     int         toast_tuple_target; /* target for tuple toasting */
                                341                 :                :     AutoVacOpts autovacuum;     /* autovacuum-related options */
                                342                 :                :     bool        user_catalog_table; /* use as an additional catalog relation */
                                343                 :                :     int         parallel_workers;   /* max number of parallel workers */
                                344                 :                :     StdRdOptIndexCleanup vacuum_index_cleanup;  /* controls index vacuuming */
                                345                 :                :     bool        vacuum_truncate;    /* enables vacuum to truncate a relation */
                                346                 :                : } StdRdOptions;
                                347                 :                : 
                                348                 :                : #define HEAP_MIN_FILLFACTOR         10
                                349                 :                : #define HEAP_DEFAULT_FILLFACTOR     100
                                350                 :                : 
                                351                 :                : /*
                                352                 :                :  * RelationGetToastTupleTarget
                                353                 :                :  *      Returns the relation's toast_tuple_target.  Note multiple eval of argument!
                                354                 :                :  */
                                355                 :                : #define RelationGetToastTupleTarget(relation, defaulttarg) \
                                356                 :                :     ((relation)->rd_options ? \
                                357                 :                :      ((StdRdOptions *) (relation)->rd_options)->toast_tuple_target : (defaulttarg))
                                358                 :                : 
                                359                 :                : /*
                                360                 :                :  * RelationGetFillFactor
                                361                 :                :  *      Returns the relation's fillfactor.  Note multiple eval of argument!
                                362                 :                :  */
                                363                 :                : #define RelationGetFillFactor(relation, defaultff) \
                                364                 :                :     ((relation)->rd_options ? \
                                365                 :                :      ((StdRdOptions *) (relation)->rd_options)->fillfactor : (defaultff))
                                366                 :                : 
                                367                 :                : /*
                                368                 :                :  * RelationGetTargetPageUsage
                                369                 :                :  *      Returns the relation's desired space usage per page in bytes.
                                370                 :                :  */
                                371                 :                : #define RelationGetTargetPageUsage(relation, defaultff) \
                                372                 :                :     (BLCKSZ * RelationGetFillFactor(relation, defaultff) / 100)
                                373                 :                : 
                                374                 :                : /*
                                375                 :                :  * RelationGetTargetPageFreeSpace
                                376                 :                :  *      Returns the relation's desired freespace per page in bytes.
                                377                 :                :  */
                                378                 :                : #define RelationGetTargetPageFreeSpace(relation, defaultff) \
                                379                 :                :     (BLCKSZ * (100 - RelationGetFillFactor(relation, defaultff)) / 100)
                                380                 :                : 
                                381                 :                : /*
                                382                 :                :  * RelationIsUsedAsCatalogTable
                                383                 :                :  *      Returns whether the relation should be treated as a catalog table
                                384                 :                :  *      from the pov of logical decoding.  Note multiple eval of argument!
                                385                 :                :  */
                                386                 :                : #define RelationIsUsedAsCatalogTable(relation)  \
                                387                 :                :     ((relation)->rd_options && \
                                388                 :                :      ((relation)->rd_rel->relkind == RELKIND_RELATION || \
                                389                 :                :       (relation)->rd_rel->relkind == RELKIND_MATVIEW) ? \
                                390                 :                :      ((StdRdOptions *) (relation)->rd_options)->user_catalog_table : false)
                                391                 :                : 
                                392                 :                : /*
                                393                 :                :  * RelationGetParallelWorkers
                                394                 :                :  *      Returns the relation's parallel_workers reloption setting.
                                395                 :                :  *      Note multiple eval of argument!
                                396                 :                :  */
                                397                 :                : #define RelationGetParallelWorkers(relation, defaultpw) \
                                398                 :                :     ((relation)->rd_options ? \
                                399                 :                :      ((StdRdOptions *) (relation)->rd_options)->parallel_workers : (defaultpw))
                                400                 :                : 
                                401                 :                : /* ViewOptions->check_option values */
                                402                 :                : typedef enum ViewOptCheckOption
                                403                 :                : {
                                404                 :                :     VIEW_OPTION_CHECK_OPTION_NOT_SET,
                                405                 :                :     VIEW_OPTION_CHECK_OPTION_LOCAL,
                                406                 :                :     VIEW_OPTION_CHECK_OPTION_CASCADED,
                                407                 :                : } ViewOptCheckOption;
                                408                 :                : 
                                409                 :                : /*
                                410                 :                :  * ViewOptions
                                411                 :                :  *      Contents of rd_options for views
                                412                 :                :  */
                                413                 :                : typedef struct ViewOptions
                                414                 :                : {
                                415                 :                :     int32       vl_len_;        /* varlena header (do not touch directly!) */
                                416                 :                :     bool        security_barrier;
                                417                 :                :     bool        security_invoker;
                                418                 :                :     ViewOptCheckOption check_option;
                                419                 :                : } ViewOptions;
                                420                 :                : 
                                421                 :                : /*
                                422                 :                :  * RelationIsSecurityView
                                423                 :                :  *      Returns whether the relation is security view, or not.  Note multiple
                                424                 :                :  *      eval of argument!
                                425                 :                :  */
                                426                 :                : #define RelationIsSecurityView(relation)                                    \
                                427                 :                :     (AssertMacro(relation->rd_rel->relkind == RELKIND_VIEW),              \
                                428                 :                :      (relation)->rd_options ?                                                \
                                429                 :                :       ((ViewOptions *) (relation)->rd_options)->security_barrier : false)
                                430                 :                : 
                                431                 :                : /*
                                432                 :                :  * RelationHasSecurityInvoker
                                433                 :                :  *      Returns true if the relation has the security_invoker property set.
                                434                 :                :  *      Note multiple eval of argument!
                                435                 :                :  */
                                436                 :                : #define RelationHasSecurityInvoker(relation)                                \
                                437                 :                :     (AssertMacro(relation->rd_rel->relkind == RELKIND_VIEW),              \
                                438                 :                :      (relation)->rd_options ?                                                \
                                439                 :                :       ((ViewOptions *) (relation)->rd_options)->security_invoker : false)
                                440                 :                : 
                                441                 :                : /*
                                442                 :                :  * RelationHasCheckOption
                                443                 :                :  *      Returns true if the relation is a view defined with either the local
                                444                 :                :  *      or the cascaded check option.  Note multiple eval of argument!
                                445                 :                :  */
                                446                 :                : #define RelationHasCheckOption(relation)                                    \
                                447                 :                :     (AssertMacro(relation->rd_rel->relkind == RELKIND_VIEW),              \
                                448                 :                :      (relation)->rd_options &&                                               \
                                449                 :                :      ((ViewOptions *) (relation)->rd_options)->check_option !=                \
                                450                 :                :      VIEW_OPTION_CHECK_OPTION_NOT_SET)
                                451                 :                : 
                                452                 :                : /*
                                453                 :                :  * RelationHasLocalCheckOption
                                454                 :                :  *      Returns true if the relation is a view defined with the local check
                                455                 :                :  *      option.  Note multiple eval of argument!
                                456                 :                :  */
                                457                 :                : #define RelationHasLocalCheckOption(relation)                               \
                                458                 :                :     (AssertMacro(relation->rd_rel->relkind == RELKIND_VIEW),              \
                                459                 :                :      (relation)->rd_options &&                                               \
                                460                 :                :      ((ViewOptions *) (relation)->rd_options)->check_option ==                \
                                461                 :                :      VIEW_OPTION_CHECK_OPTION_LOCAL)
                                462                 :                : 
                                463                 :                : /*
                                464                 :                :  * RelationHasCascadedCheckOption
                                465                 :                :  *      Returns true if the relation is a view defined with the cascaded check
                                466                 :                :  *      option.  Note multiple eval of argument!
                                467                 :                :  */
                                468                 :                : #define RelationHasCascadedCheckOption(relation)                            \
                                469                 :                :     (AssertMacro(relation->rd_rel->relkind == RELKIND_VIEW),              \
                                470                 :                :      (relation)->rd_options &&                                               \
                                471                 :                :      ((ViewOptions *) (relation)->rd_options)->check_option ==                \
                                472                 :                :       VIEW_OPTION_CHECK_OPTION_CASCADED)
                                473                 :                : 
                                474                 :                : /*
                                475                 :                :  * RelationIsValid
                                476                 :                :  *      True iff relation descriptor is valid.
                                477                 :                :  */
                                478                 :                : #define RelationIsValid(relation) PointerIsValid(relation)
                                479                 :                : 
                                480                 :                : #define InvalidRelation ((Relation) NULL)
                                481                 :                : 
                                482                 :                : /*
                                483                 :                :  * RelationHasReferenceCountZero
                                484                 :                :  *      True iff relation reference count is zero.
                                485                 :                :  *
                                486                 :                :  * Note:
                                487                 :                :  *      Assumes relation descriptor is valid.
                                488                 :                :  */
                                489                 :                : #define RelationHasReferenceCountZero(relation) \
                                490                 :                :         ((bool)((relation)->rd_refcnt == 0))
                                491                 :                : 
                                492                 :                : /*
                                493                 :                :  * RelationGetForm
                                494                 :                :  *      Returns pg_class tuple for a relation.
                                495                 :                :  *
                                496                 :                :  * Note:
                                497                 :                :  *      Assumes relation descriptor is valid.
                                498                 :                :  */
                                499                 :                : #define RelationGetForm(relation) ((relation)->rd_rel)
                                500                 :                : 
                                501                 :                : /*
                                502                 :                :  * RelationGetRelid
                                503                 :                :  *      Returns the OID of the relation
                                504                 :                :  */
                                505                 :                : #define RelationGetRelid(relation) ((relation)->rd_id)
                                506                 :                : 
                                507                 :                : /*
                                508                 :                :  * RelationGetNumberOfAttributes
                                509                 :                :  *      Returns the total number of attributes in a relation.
                                510                 :                :  */
                                511                 :                : #define RelationGetNumberOfAttributes(relation) ((relation)->rd_rel->relnatts)
                                512                 :                : 
                                513                 :                : /*
                                514                 :                :  * IndexRelationGetNumberOfAttributes
                                515                 :                :  *      Returns the number of attributes in an index.
                                516                 :                :  */
                                517                 :                : #define IndexRelationGetNumberOfAttributes(relation) \
                                518                 :                :         ((relation)->rd_index->indnatts)
                                519                 :                : 
                                520                 :                : /*
                                521                 :                :  * IndexRelationGetNumberOfKeyAttributes
                                522                 :                :  *      Returns the number of key attributes in an index.
                                523                 :                :  */
                                524                 :                : #define IndexRelationGetNumberOfKeyAttributes(relation) \
                                525                 :                :         ((relation)->rd_index->indnkeyatts)
                                526                 :                : 
                                527                 :                : /*
                                528                 :                :  * RelationGetDescr
                                529                 :                :  *      Returns tuple descriptor for a relation.
                                530                 :                :  */
                                531                 :                : #define RelationGetDescr(relation) ((relation)->rd_att)
                                532                 :                : 
                                533                 :                : /*
                                534                 :                :  * RelationGetRelationName
                                535                 :                :  *      Returns the rel's name.
                                536                 :                :  *
                                537                 :                :  * Note that the name is only unique within the containing namespace.
                                538                 :                :  */
                                539                 :                : #define RelationGetRelationName(relation) \
                                540                 :                :     (NameStr((relation)->rd_rel->relname))
                                541                 :                : 
                                542                 :                : /*
                                543                 :                :  * RelationGetNamespace
                                544                 :                :  *      Returns the rel's namespace OID.
                                545                 :                :  */
                                546                 :                : #define RelationGetNamespace(relation) \
                                547                 :                :     ((relation)->rd_rel->relnamespace)
                                548                 :                : 
                                549                 :                : /*
                                550                 :                :  * RelationIsMapped
                                551                 :                :  *      True if the relation uses the relfilenumber map.  Note multiple eval
                                552                 :                :  *      of argument!
                                553                 :                :  */
                                554                 :                : #define RelationIsMapped(relation) \
                                555                 :                :     (RELKIND_HAS_STORAGE((relation)->rd_rel->relkind) && \
                                556                 :                :      ((relation)->rd_rel->relfilenode == InvalidRelFileNumber))
                                557                 :                : 
                                558                 :                : #ifndef FRONTEND
                                559                 :                : /*
                                560                 :                :  * RelationGetSmgr
                                561                 :                :  *      Returns smgr file handle for a relation, opening it if needed.
                                562                 :                :  *
                                563                 :                :  * Very little code is authorized to touch rel->rd_smgr directly.  Instead
                                564                 :                :  * use this function to fetch its value.
                                565                 :                :  */
                                566                 :                : static inline SMgrRelation
 1007 tgl@sss.pgh.pa.us         567                 :CBC    58863201 : RelationGetSmgr(Relation rel)
                                568                 :                : {
                                569         [ +  + ]:       58863201 :     if (unlikely(rel->rd_smgr == NULL))
                                570                 :                :     {
   74 heikki.linnakangas@i      571                 :GNC      841270 :         rel->rd_smgr = smgropen(rel->rd_locator, rel->rd_backend);
                                572                 :         841270 :         smgrpin(rel->rd_smgr);
                                573                 :                :     }
 1007 tgl@sss.pgh.pa.us         574                 :CBC    58863201 :     return rel->rd_smgr;
                                575                 :                : }
                                576                 :                : 
                                577                 :                : /*
                                578                 :                :  * RelationCloseSmgr
                                579                 :                :  *      Close the relation at the smgr level, if not already done.
                                580                 :                :  */
                                581                 :                : static inline void
  555 peter@eisentraut.org      582                 :        1215176 : RelationCloseSmgr(Relation relation)
                                583                 :                : {
                                584         [ +  + ]:        1215176 :     if (relation->rd_smgr != NULL)
                                585                 :                :     {
   74 heikki.linnakangas@i      586                 :GNC      199709 :         smgrunpin(relation->rd_smgr);
  555 peter@eisentraut.org      587                 :CBC      199709 :         smgrclose(relation->rd_smgr);
   74 heikki.linnakangas@i      588                 :GNC      199709 :         relation->rd_smgr = NULL;
                                589                 :                :     }
  555 peter@eisentraut.org      590                 :CBC     1215176 : }
                                591                 :                : #endif                          /* !FRONTEND */
                                592                 :                : 
                                593                 :                : /*
                                594                 :                :  * RelationGetTargetBlock
                                595                 :                :  *      Fetch relation's current insertion target block.
                                596                 :                :  *
                                597                 :                :  * Returns InvalidBlockNumber if there is no current target block.  Note
                                598                 :                :  * that the target block status is discarded on any smgr-level invalidation,
                                599                 :                :  * so there's no need to re-open the smgr handle if it's not currently open.
                                600                 :                :  */
                                601                 :                : #define RelationGetTargetBlock(relation) \
                                602                 :                :     ( (relation)->rd_smgr != NULL ? (relation)->rd_smgr->smgr_targblock : InvalidBlockNumber )
                                603                 :                : 
                                604                 :                : /*
                                605                 :                :  * RelationSetTargetBlock
                                606                 :                :  *      Set relation's current insertion target block.
                                607                 :                :  */
                                608                 :                : #define RelationSetTargetBlock(relation, targblock) \
                                609                 :                :     do { \
                                610                 :                :         RelationGetSmgr(relation)->smgr_targblock = (targblock); \
                                611                 :                :     } while (0)
                                612                 :                : 
                                613                 :                : /*
                                614                 :                :  * RelationIsPermanent
                                615                 :                :  *      True if relation is permanent.
                                616                 :                :  */
                                617                 :                : #define RelationIsPermanent(relation) \
                                618                 :                :     ((relation)->rd_rel->relpersistence == RELPERSISTENCE_PERMANENT)
                                619                 :                : 
                                620                 :                : /*
                                621                 :                :  * RelationNeedsWAL
                                622                 :                :  *      True if relation needs WAL.
                                623                 :                :  *
                                624                 :                :  * Returns false if wal_level = minimal and this relation is created or
                                625                 :                :  * truncated in the current transaction.  See "Skipping WAL for New
                                626                 :                :  * RelFileLocator" in src/backend/access/transam/README.
                                627                 :                :  */
                                628                 :                : #define RelationNeedsWAL(relation)                                      \
                                629                 :                :     (RelationIsPermanent(relation) && (XLogIsNeeded() ||                \
                                630                 :                :       (relation->rd_createSubid == InvalidSubTransactionId &&            \
                                631                 :                :        relation->rd_firstRelfilelocatorSubid == InvalidSubTransactionId)))
                                632                 :                : 
                                633                 :                : /*
                                634                 :                :  * RelationUsesLocalBuffers
                                635                 :                :  *      True if relation's pages are stored in local buffers.
                                636                 :                :  */
                                637                 :                : #define RelationUsesLocalBuffers(relation) \
                                638                 :                :     ((relation)->rd_rel->relpersistence == RELPERSISTENCE_TEMP)
                                639                 :                : 
                                640                 :                : /*
                                641                 :                :  * RELATION_IS_LOCAL
                                642                 :                :  *      If a rel is either temp or newly created in the current transaction,
                                643                 :                :  *      it can be assumed to be accessible only to the current backend.
                                644                 :                :  *      This is typically used to decide that we can skip acquiring locks.
                                645                 :                :  *
                                646                 :                :  * Beware of multiple eval of argument
                                647                 :                :  */
                                648                 :                : #define RELATION_IS_LOCAL(relation) \
                                649                 :                :     ((relation)->rd_islocaltemp || \
                                650                 :                :      (relation)->rd_createSubid != InvalidSubTransactionId)
                                651                 :                : 
                                652                 :                : /*
                                653                 :                :  * RELATION_IS_OTHER_TEMP
                                654                 :                :  *      Test for a temporary relation that belongs to some other session.
                                655                 :                :  *
                                656                 :                :  * Beware of multiple eval of argument
                                657                 :                :  */
                                658                 :                : #define RELATION_IS_OTHER_TEMP(relation) \
                                659                 :                :     ((relation)->rd_rel->relpersistence == RELPERSISTENCE_TEMP && \
                                660                 :                :      !(relation)->rd_islocaltemp)
                                661                 :                : 
                                662                 :                : 
                                663                 :                : /*
                                664                 :                :  * RelationIsScannable
                                665                 :                :  *      Currently can only be false for a materialized view which has not been
                                666                 :                :  *      populated by its query.  This is likely to get more complicated later,
                                667                 :                :  *      so use a macro which looks like a function.
                                668                 :                :  */
                                669                 :                : #define RelationIsScannable(relation) ((relation)->rd_rel->relispopulated)
                                670                 :                : 
                                671                 :                : /*
                                672                 :                :  * RelationIsPopulated
                                673                 :                :  *      Currently, we don't physically distinguish the "populated" and
                                674                 :                :  *      "scannable" properties of matviews, but that may change later.
                                675                 :                :  *      Hence, use the appropriate one of these macros in code tests.
                                676                 :                :  */
                                677                 :                : #define RelationIsPopulated(relation) ((relation)->rd_rel->relispopulated)
                                678                 :                : 
                                679                 :                : /*
                                680                 :                :  * RelationIsAccessibleInLogicalDecoding
                                681                 :                :  *      True if we need to log enough information to have access via
                                682                 :                :  *      decoding snapshot.
                                683                 :                :  */
                                684                 :                : #define RelationIsAccessibleInLogicalDecoding(relation) \
                                685                 :                :     (XLogLogicalInfoActive() && \
                                686                 :                :      RelationNeedsWAL(relation) && \
                                687                 :                :      (IsCatalogRelation(relation) || RelationIsUsedAsCatalogTable(relation)))
                                688                 :                : 
                                689                 :                : /*
                                690                 :                :  * RelationIsLogicallyLogged
                                691                 :                :  *      True if we need to log enough information to extract the data from the
                                692                 :                :  *      WAL stream.
                                693                 :                :  *
                                694                 :                :  * We don't log information for unlogged tables (since they don't WAL log
                                695                 :                :  * anyway), for foreign tables (since they don't WAL log, either),
                                696                 :                :  * and for system tables (their content is hard to make sense of, and
                                697                 :                :  * it would complicate decoding slightly for little gain). Note that we *do*
                                698                 :                :  * log information for user defined catalog tables since they presumably are
                                699                 :                :  * interesting to the user...
                                700                 :                :  */
                                701                 :                : #define RelationIsLogicallyLogged(relation) \
                                702                 :                :     (XLogLogicalInfoActive() && \
                                703                 :                :      RelationNeedsWAL(relation) && \
                                704                 :                :      (relation)->rd_rel->relkind != RELKIND_FOREIGN_TABLE &&  \
                                705                 :                :      !IsCatalogRelation(relation))
                                706                 :                : 
                                707                 :                : /* routines in utils/cache/relcache.c */
                                708                 :                : extern void RelationIncrementReferenceCount(Relation rel);
                                709                 :                : extern void RelationDecrementReferenceCount(Relation rel);
                                710                 :                : 
                                711                 :                : #endif                          /* REL_H */
        

Generated by: LCOV version 2.1-beta2-3-g6141622