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-2025, 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_max_threshold;
313 : int vacuum_ins_threshold;
314 : int analyze_threshold;
315 : int vacuum_cost_limit;
316 : int freeze_min_age;
317 : int freeze_max_age;
318 : int freeze_table_age;
319 : int multixact_freeze_min_age;
320 : int multixact_freeze_max_age;
321 : int multixact_freeze_table_age;
322 : int log_min_duration;
323 : float8 vacuum_cost_delay;
324 : float8 vacuum_scale_factor;
325 : float8 vacuum_ins_scale_factor;
326 : float8 analyze_scale_factor;
327 : } AutoVacOpts;
328 :
329 : /* StdRdOptions->vacuum_index_cleanup values */
330 : typedef enum StdRdOptIndexCleanup
331 : {
332 : STDRD_OPTION_VACUUM_INDEX_CLEANUP_AUTO = 0,
333 : STDRD_OPTION_VACUUM_INDEX_CLEANUP_OFF,
334 : STDRD_OPTION_VACUUM_INDEX_CLEANUP_ON,
335 : } StdRdOptIndexCleanup;
336 :
337 : typedef struct StdRdOptions
338 : {
339 : int32 vl_len_; /* varlena header (do not touch directly!) */
340 : int fillfactor; /* page fill factor in percent (0..100) */
341 : int toast_tuple_target; /* target for tuple toasting */
342 : AutoVacOpts autovacuum; /* autovacuum-related options */
343 : bool user_catalog_table; /* use as an additional catalog relation */
344 : int parallel_workers; /* max number of parallel workers */
345 : StdRdOptIndexCleanup vacuum_index_cleanup; /* controls index vacuuming */
346 : bool vacuum_truncate; /* enables vacuum to truncate a relation */
347 : bool vacuum_truncate_set; /* whether vacuum_truncate is set */
348 :
349 : /*
350 : * Fraction of pages in a relation that vacuum can eagerly scan and fail
351 : * to freeze. 0 if disabled, -1 if unspecified.
352 : */
353 : double vacuum_max_eager_freeze_failure_rate;
354 : } StdRdOptions;
355 :
356 : #define HEAP_MIN_FILLFACTOR 10
357 : #define HEAP_DEFAULT_FILLFACTOR 100
358 :
359 : /*
360 : * RelationGetToastTupleTarget
361 : * Returns the relation's toast_tuple_target. Note multiple eval of argument!
362 : */
363 : #define RelationGetToastTupleTarget(relation, defaulttarg) \
364 : ((relation)->rd_options ? \
365 : ((StdRdOptions *) (relation)->rd_options)->toast_tuple_target : (defaulttarg))
366 :
367 : /*
368 : * RelationGetFillFactor
369 : * Returns the relation's fillfactor. Note multiple eval of argument!
370 : */
371 : #define RelationGetFillFactor(relation, defaultff) \
372 : ((relation)->rd_options ? \
373 : ((StdRdOptions *) (relation)->rd_options)->fillfactor : (defaultff))
374 :
375 : /*
376 : * RelationGetTargetPageUsage
377 : * Returns the relation's desired space usage per page in bytes.
378 : */
379 : #define RelationGetTargetPageUsage(relation, defaultff) \
380 : (BLCKSZ * RelationGetFillFactor(relation, defaultff) / 100)
381 :
382 : /*
383 : * RelationGetTargetPageFreeSpace
384 : * Returns the relation's desired freespace per page in bytes.
385 : */
386 : #define RelationGetTargetPageFreeSpace(relation, defaultff) \
387 : (BLCKSZ * (100 - RelationGetFillFactor(relation, defaultff)) / 100)
388 :
389 : /*
390 : * RelationIsUsedAsCatalogTable
391 : * Returns whether the relation should be treated as a catalog table
392 : * from the pov of logical decoding. Note multiple eval of argument!
393 : */
394 : #define RelationIsUsedAsCatalogTable(relation) \
395 : ((relation)->rd_options && \
396 : ((relation)->rd_rel->relkind == RELKIND_RELATION || \
397 : (relation)->rd_rel->relkind == RELKIND_MATVIEW) ? \
398 : ((StdRdOptions *) (relation)->rd_options)->user_catalog_table : false)
399 :
400 : /*
401 : * RelationGetParallelWorkers
402 : * Returns the relation's parallel_workers reloption setting.
403 : * Note multiple eval of argument!
404 : */
405 : #define RelationGetParallelWorkers(relation, defaultpw) \
406 : ((relation)->rd_options ? \
407 : ((StdRdOptions *) (relation)->rd_options)->parallel_workers : (defaultpw))
408 :
409 : /* ViewOptions->check_option values */
410 : typedef enum ViewOptCheckOption
411 : {
412 : VIEW_OPTION_CHECK_OPTION_NOT_SET,
413 : VIEW_OPTION_CHECK_OPTION_LOCAL,
414 : VIEW_OPTION_CHECK_OPTION_CASCADED,
415 : } ViewOptCheckOption;
416 :
417 : /*
418 : * ViewOptions
419 : * Contents of rd_options for views
420 : */
421 : typedef struct ViewOptions
422 : {
423 : int32 vl_len_; /* varlena header (do not touch directly!) */
424 : bool security_barrier;
425 : bool security_invoker;
426 : ViewOptCheckOption check_option;
427 : } ViewOptions;
428 :
429 : /*
430 : * RelationIsSecurityView
431 : * Returns whether the relation is security view, or not. Note multiple
432 : * eval of argument!
433 : */
434 : #define RelationIsSecurityView(relation) \
435 : (AssertMacro(relation->rd_rel->relkind == RELKIND_VIEW), \
436 : (relation)->rd_options ? \
437 : ((ViewOptions *) (relation)->rd_options)->security_barrier : false)
438 :
439 : /*
440 : * RelationHasSecurityInvoker
441 : * Returns true if the relation has the security_invoker property set.
442 : * Note multiple eval of argument!
443 : */
444 : #define RelationHasSecurityInvoker(relation) \
445 : (AssertMacro(relation->rd_rel->relkind == RELKIND_VIEW), \
446 : (relation)->rd_options ? \
447 : ((ViewOptions *) (relation)->rd_options)->security_invoker : false)
448 :
449 : /*
450 : * RelationHasCheckOption
451 : * Returns true if the relation is a view defined with either the local
452 : * or the cascaded check option. Note multiple eval of argument!
453 : */
454 : #define RelationHasCheckOption(relation) \
455 : (AssertMacro(relation->rd_rel->relkind == RELKIND_VIEW), \
456 : (relation)->rd_options && \
457 : ((ViewOptions *) (relation)->rd_options)->check_option != \
458 : VIEW_OPTION_CHECK_OPTION_NOT_SET)
459 :
460 : /*
461 : * RelationHasLocalCheckOption
462 : * Returns true if the relation is a view defined with the local check
463 : * option. Note multiple eval of argument!
464 : */
465 : #define RelationHasLocalCheckOption(relation) \
466 : (AssertMacro(relation->rd_rel->relkind == RELKIND_VIEW), \
467 : (relation)->rd_options && \
468 : ((ViewOptions *) (relation)->rd_options)->check_option == \
469 : VIEW_OPTION_CHECK_OPTION_LOCAL)
470 :
471 : /*
472 : * RelationHasCascadedCheckOption
473 : * Returns true if the relation is a view defined with the cascaded check
474 : * option. Note multiple eval of argument!
475 : */
476 : #define RelationHasCascadedCheckOption(relation) \
477 : (AssertMacro(relation->rd_rel->relkind == RELKIND_VIEW), \
478 : (relation)->rd_options && \
479 : ((ViewOptions *) (relation)->rd_options)->check_option == \
480 : VIEW_OPTION_CHECK_OPTION_CASCADED)
481 :
482 : /*
483 : * RelationIsValid
484 : * True iff relation descriptor is valid.
485 : */
486 : #define RelationIsValid(relation) PointerIsValid(relation)
487 :
488 : #define InvalidRelation ((Relation) NULL)
489 :
490 : /*
491 : * RelationHasReferenceCountZero
492 : * True iff relation reference count is zero.
493 : *
494 : * Note:
495 : * Assumes relation descriptor is valid.
496 : */
497 : #define RelationHasReferenceCountZero(relation) \
498 : ((bool)((relation)->rd_refcnt == 0))
499 :
500 : /*
501 : * RelationGetForm
502 : * Returns pg_class tuple for a relation.
503 : *
504 : * Note:
505 : * Assumes relation descriptor is valid.
506 : */
507 : #define RelationGetForm(relation) ((relation)->rd_rel)
508 :
509 : /*
510 : * RelationGetRelid
511 : * Returns the OID of the relation
512 : */
513 : #define RelationGetRelid(relation) ((relation)->rd_id)
514 :
515 : /*
516 : * RelationGetNumberOfAttributes
517 : * Returns the total number of attributes in a relation.
518 : */
519 : #define RelationGetNumberOfAttributes(relation) ((relation)->rd_rel->relnatts)
520 :
521 : /*
522 : * IndexRelationGetNumberOfAttributes
523 : * Returns the number of attributes in an index.
524 : */
525 : #define IndexRelationGetNumberOfAttributes(relation) \
526 : ((relation)->rd_index->indnatts)
527 :
528 : /*
529 : * IndexRelationGetNumberOfKeyAttributes
530 : * Returns the number of key attributes in an index.
531 : */
532 : #define IndexRelationGetNumberOfKeyAttributes(relation) \
533 : ((relation)->rd_index->indnkeyatts)
534 :
535 : /*
536 : * RelationGetDescr
537 : * Returns tuple descriptor for a relation.
538 : */
539 : #define RelationGetDescr(relation) ((relation)->rd_att)
540 :
541 : /*
542 : * RelationGetRelationName
543 : * Returns the rel's name.
544 : *
545 : * Note that the name is only unique within the containing namespace.
546 : */
547 : #define RelationGetRelationName(relation) \
548 : (NameStr((relation)->rd_rel->relname))
549 :
550 : /*
551 : * RelationGetNamespace
552 : * Returns the rel's namespace OID.
553 : */
554 : #define RelationGetNamespace(relation) \
555 : ((relation)->rd_rel->relnamespace)
556 :
557 : /*
558 : * RelationIsMapped
559 : * True if the relation uses the relfilenumber map. Note multiple eval
560 : * of argument!
561 : */
562 : #define RelationIsMapped(relation) \
563 : (RELKIND_HAS_STORAGE((relation)->rd_rel->relkind) && \
564 : ((relation)->rd_rel->relfilenode == InvalidRelFileNumber))
565 :
566 : #ifndef FRONTEND
567 : /*
568 : * RelationGetSmgr
569 : * Returns smgr file handle for a relation, opening it if needed.
570 : *
571 : * Very little code is authorized to touch rel->rd_smgr directly. Instead
572 : * use this function to fetch its value.
573 : */
574 : static inline SMgrRelation
575 122054230 : RelationGetSmgr(Relation rel)
576 : {
577 122054230 : if (unlikely(rel->rd_smgr == NULL))
578 : {
579 1844376 : rel->rd_smgr = smgropen(rel->rd_locator, rel->rd_backend);
580 1844376 : smgrpin(rel->rd_smgr);
581 : }
582 122054230 : return rel->rd_smgr;
583 : }
584 :
585 : /*
586 : * RelationCloseSmgr
587 : * Close the relation at the smgr level, if not already done.
588 : */
589 : static inline void
590 2905550 : RelationCloseSmgr(Relation relation)
591 : {
592 2905550 : if (relation->rd_smgr != NULL)
593 : {
594 421166 : smgrunpin(relation->rd_smgr);
595 421166 : smgrclose(relation->rd_smgr);
596 421166 : relation->rd_smgr = NULL;
597 : }
598 2905550 : }
599 : #endif /* !FRONTEND */
600 :
601 : /*
602 : * RelationGetTargetBlock
603 : * Fetch relation's current insertion target block.
604 : *
605 : * Returns InvalidBlockNumber if there is no current target block. Note
606 : * that the target block status is discarded on any smgr-level invalidation,
607 : * so there's no need to re-open the smgr handle if it's not currently open.
608 : */
609 : #define RelationGetTargetBlock(relation) \
610 : ( (relation)->rd_smgr != NULL ? (relation)->rd_smgr->smgr_targblock : InvalidBlockNumber )
611 :
612 : /*
613 : * RelationSetTargetBlock
614 : * Set relation's current insertion target block.
615 : */
616 : #define RelationSetTargetBlock(relation, targblock) \
617 : do { \
618 : RelationGetSmgr(relation)->smgr_targblock = (targblock); \
619 : } while (0)
620 :
621 : /*
622 : * RelationIsPermanent
623 : * True if relation is permanent.
624 : */
625 : #define RelationIsPermanent(relation) \
626 : ((relation)->rd_rel->relpersistence == RELPERSISTENCE_PERMANENT)
627 :
628 : /*
629 : * RelationNeedsWAL
630 : * True if relation needs WAL.
631 : *
632 : * Returns false if wal_level = minimal and this relation is created or
633 : * truncated in the current transaction. See "Skipping WAL for New
634 : * RelFileLocator" in src/backend/access/transam/README.
635 : */
636 : #define RelationNeedsWAL(relation) \
637 : (RelationIsPermanent(relation) && (XLogIsNeeded() || \
638 : (relation->rd_createSubid == InvalidSubTransactionId && \
639 : relation->rd_firstRelfilelocatorSubid == InvalidSubTransactionId)))
640 :
641 : /*
642 : * RelationUsesLocalBuffers
643 : * True if relation's pages are stored in local buffers.
644 : */
645 : #define RelationUsesLocalBuffers(relation) \
646 : ((relation)->rd_rel->relpersistence == RELPERSISTENCE_TEMP)
647 :
648 : /*
649 : * RELATION_IS_LOCAL
650 : * If a rel is either temp or newly created in the current transaction,
651 : * it can be assumed to be accessible only to the current backend.
652 : * This is typically used to decide that we can skip acquiring locks.
653 : *
654 : * Beware of multiple eval of argument
655 : */
656 : #define RELATION_IS_LOCAL(relation) \
657 : ((relation)->rd_islocaltemp || \
658 : (relation)->rd_createSubid != InvalidSubTransactionId)
659 :
660 : /*
661 : * RELATION_IS_OTHER_TEMP
662 : * Test for a temporary relation that belongs to some other session.
663 : *
664 : * Beware of multiple eval of argument
665 : */
666 : #define RELATION_IS_OTHER_TEMP(relation) \
667 : ((relation)->rd_rel->relpersistence == RELPERSISTENCE_TEMP && \
668 : !(relation)->rd_islocaltemp)
669 :
670 :
671 : /*
672 : * RelationIsScannable
673 : * Currently can only be false for a materialized view which has not been
674 : * populated by its query. This is likely to get more complicated later,
675 : * so use a macro which looks like a function.
676 : */
677 : #define RelationIsScannable(relation) ((relation)->rd_rel->relispopulated)
678 :
679 : /*
680 : * RelationIsPopulated
681 : * Currently, we don't physically distinguish the "populated" and
682 : * "scannable" properties of matviews, but that may change later.
683 : * Hence, use the appropriate one of these macros in code tests.
684 : */
685 : #define RelationIsPopulated(relation) ((relation)->rd_rel->relispopulated)
686 :
687 : /*
688 : * RelationIsAccessibleInLogicalDecoding
689 : * True if we need to log enough information to have access via
690 : * decoding snapshot.
691 : */
692 : #define RelationIsAccessibleInLogicalDecoding(relation) \
693 : (XLogLogicalInfoActive() && \
694 : RelationNeedsWAL(relation) && \
695 : (IsCatalogRelation(relation) || RelationIsUsedAsCatalogTable(relation)))
696 :
697 : /*
698 : * RelationIsLogicallyLogged
699 : * True if we need to log enough information to extract the data from the
700 : * WAL stream.
701 : *
702 : * We don't log information for unlogged tables (since they don't WAL log
703 : * anyway), for foreign tables (since they don't WAL log, either),
704 : * and for system tables (their content is hard to make sense of, and
705 : * it would complicate decoding slightly for little gain). Note that we *do*
706 : * log information for user defined catalog tables since they presumably are
707 : * interesting to the user...
708 : */
709 : #define RelationIsLogicallyLogged(relation) \
710 : (XLogLogicalInfoActive() && \
711 : RelationNeedsWAL(relation) && \
712 : (relation)->rd_rel->relkind != RELKIND_FOREIGN_TABLE && \
713 : !IsCatalogRelation(relation))
714 :
715 : /* routines in utils/cache/relcache.c */
716 : extern void RelationIncrementReferenceCount(Relation rel);
717 : extern void RelationDecrementReferenceCount(Relation rel);
718 :
719 : #endif /* REL_H */
|
