| 1 |
/*------------------------------------------------------------------------- |
| 2 |
* |
| 3 |
* relation.c |
| 4 |
* Generic relation related routines. |
| 5 |
* |
| 6 |
* Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group |
| 7 |
* Portions Copyright (c) 1994, Regents of the University of California |
| 8 |
* |
| 9 |
* |
| 10 |
* IDENTIFICATION |
| 11 |
* src/backend/access/common/relation.c |
| 12 |
* |
| 13 |
* NOTES |
| 14 |
* This file contains relation_ routines that implement access to relations |
| 15 |
* (tables, indexes, etc). Support that's specific to subtypes of relations |
| 16 |
* should go into their respective files, not here. |
| 17 |
* |
| 18 |
*------------------------------------------------------------------------- |
| 19 |
*/ |
| 20 |
|
| 21 |
#include "postgres.h" |
| 22 |
|
| 23 |
#include "access/relation.h" |
| 24 |
#include "access/xact.h" |
| 25 |
#include "catalog/namespace.h" |
| 26 |
#include "pgstat.h" |
| 27 |
#include "storage/lmgr.h" |
| 28 |
#include "utils/inval.h" |
| 29 |
#include "utils/syscache.h" |
| 30 |
|
| 31 |
|
| 32 |
/* ---------------- |
| 33 |
* relation_open - open any relation by relation OID |
| 34 |
* |
| 35 |
* If lockmode is not "NoLock", the specified kind of lock is |
| 36 |
* obtained on the relation. (Generally, NoLock should only be |
| 37 |
* used if the caller knows it has some appropriate lock on the |
| 38 |
* relation already.) |
| 39 |
* |
| 40 |
* An error is raised if the relation does not exist. |
| 41 |
* |
| 42 |
* NB: a "relation" is anything with a pg_class entry. The caller is |
| 43 |
* expected to check whether the relkind is something it can handle. |
| 44 |
* ---------------- |
| 45 |
*/ |
| 46 |
Relation |
| 47 |
relation_open(Oid relationId, LOCKMODE lockmode) |
| 48 |
{ |
| 49 |
Relation r; |
| 50 |
|
| 51 |
Assert(lockmode >= NoLock && lockmode < MAX_LOCKMODES); |
| 52 |
|
| 53 |
/* Get the lock before trying to open the relcache entry */ |
| 54 |
if (lockmode != NoLock) |
| 55 |
LockRelationOid(relationId, lockmode); |
| 56 |
|
| 57 |
/* The relcache does all the real work... */ |
| 58 |
r = RelationIdGetRelation(relationId); |
| 59 |
|
| 60 |
if (!RelationIsValid(r)) |
| 61 |
elog(ERROR, "could not open relation with OID %u", relationId); |
| 62 |
|
| 63 |
/* |
| 64 |
* If we didn't get the lock ourselves, assert that caller holds one, |
| 65 |
* except in bootstrap mode where no locks are used. |
| 66 |
*/ |
| 67 |
Assert(lockmode != NoLock || |
| 68 |
IsBootstrapProcessingMode() || |
| 69 |
CheckRelationLockedByMe(r, AccessShareLock, true)); |
| 70 |
|
| 71 |
/* Make note that we've accessed a temporary relation */ |
| 72 |
if (RelationUsesLocalBuffers(r)) |
| 73 |
MyXactFlags |= XACT_FLAGS_ACCESSEDTEMPNAMESPACE; |
| 74 |
|
| 75 |
pgstat_init_relation(r); |
| 76 |
|
| 77 |
return r; |
| 78 |
} |
| 79 |
|
| 80 |
/* ---------------- |
| 81 |
* try_relation_open - open any relation by relation OID |
| 82 |
* |
| 83 |
* Same as relation_open, except return NULL instead of failing |
| 84 |
* if the relation does not exist. |
| 85 |
* ---------------- |
| 86 |
*/ |
| 87 |
Relation |
| 88 |
try_relation_open(Oid relationId, LOCKMODE lockmode) |
| 89 |
{ |
| 90 |
Relation r; |
| 91 |
|
| 92 |
Assert(lockmode >= NoLock && lockmode < MAX_LOCKMODES); |
| 93 |
|
| 94 |
/* Get the lock first */ |
| 95 |
if (lockmode != NoLock) |
| 96 |
LockRelationOid(relationId, lockmode); |
| 97 |
|
| 98 |
/* |
| 99 |
* Now that we have the lock, probe to see if the relation really exists |
| 100 |
* or not. |
| 101 |
*/ |
| 102 |
if (!SearchSysCacheExists1(RELOID, ObjectIdGetDatum(relationId))) |
| 103 |
{ |
| 104 |
/* Release useless lock */ |
| 105 |
if (lockmode != NoLock) |
| 106 |
UnlockRelationOid(relationId, lockmode); |
| 107 |
|
| 108 |
return NULL; |
| 109 |
} |
| 110 |
|
| 111 |
/* Should be safe to do a relcache load */ |
| 112 |
r = RelationIdGetRelation(relationId); |
| 113 |
|
| 114 |
if (!RelationIsValid(r)) |
| 115 |
elog(ERROR, "could not open relation with OID %u", relationId); |
| 116 |
|
| 117 |
/* If we didn't get the lock ourselves, assert that caller holds one */ |
| 118 |
Assert(lockmode != NoLock || |
| 119 |
CheckRelationLockedByMe(r, AccessShareLock, true)); |
| 120 |
|
| 121 |
/* Make note that we've accessed a temporary relation */ |
| 122 |
if (RelationUsesLocalBuffers(r)) |
| 123 |
MyXactFlags |= XACT_FLAGS_ACCESSEDTEMPNAMESPACE; |
| 124 |
|
| 125 |
pgstat_init_relation(r); |
| 126 |
|
| 127 |
return r; |
| 128 |
} |
| 129 |
|
| 130 |
/* ---------------- |
| 131 |
* relation_openrv - open any relation specified by a RangeVar |
| 132 |
* |
| 133 |
* Same as relation_open, but the relation is specified by a RangeVar. |
| 134 |
* ---------------- |
| 135 |
*/ |
| 136 |
Relation |
| 137 |
relation_openrv(const RangeVar *relation, LOCKMODE lockmode) |
| 138 |
{ |
| 139 |
Oid relOid; |
| 140 |
|
| 141 |
/* |
| 142 |
* Check for shared-cache-inval messages before trying to open the |
| 143 |
* relation. This is needed even if we already hold a lock on the |
| 144 |
* relation, because GRANT/REVOKE are executed without taking any lock on |
| 145 |
* the target relation, and we want to be sure we see current ACL |
| 146 |
* information. We can skip this if asked for NoLock, on the assumption |
| 147 |
* that such a call is not the first one in the current command, and so we |
| 148 |
* should be reasonably up-to-date already. (XXX this all could stand to |
| 149 |
* be redesigned, but for the moment we'll keep doing this like it's been |
| 150 |
* done historically.) |
| 151 |
*/ |
| 152 |
if (lockmode != NoLock) |
| 153 |
AcceptInvalidationMessages(); |
| 154 |
|
| 155 |
/* Look up and lock the appropriate relation using namespace search */ |
| 156 |
relOid = RangeVarGetRelid(relation, lockmode, false); |
| 157 |
|
| 158 |
/* Let relation_open do the rest */ |
| 159 |
return relation_open(relOid, NoLock); |
| 160 |
} |
| 161 |
|
| 162 |
/* ---------------- |
| 163 |
* relation_openrv_extended - open any relation specified by a RangeVar |
| 164 |
* |
| 165 |
* Same as relation_openrv, but with an additional missing_ok argument |
| 166 |
* allowing a NULL return rather than an error if the relation is not |
| 167 |
* found. (Note that some other causes, such as permissions problems, |
| 168 |
* will still result in an ereport.) |
| 169 |
* ---------------- |
| 170 |
*/ |
| 171 |
Relation |
| 172 |
relation_openrv_extended(const RangeVar *relation, LOCKMODE lockmode, |
| 173 |
bool missing_ok) |
| 174 |
{ |
| 175 |
Oid relOid; |
| 176 |
|
| 177 |
/* |
| 178 |
* Check for shared-cache-inval messages before trying to open the |
| 179 |
* relation. See comments in relation_openrv(). |
| 180 |
*/ |
| 181 |
if (lockmode != NoLock) |
| 182 |
AcceptInvalidationMessages(); |
| 183 |
|
| 184 |
/* Look up and lock the appropriate relation using namespace search */ |
| 185 |
relOid = RangeVarGetRelid(relation, lockmode, missing_ok); |
| 186 |
|
| 187 |
/* Return NULL on not-found */ |
| 188 |
if (!OidIsValid(relOid)) |
| 189 |
return NULL; |
| 190 |
|
| 191 |
/* Let relation_open do the rest */ |
| 192 |
return relation_open(relOid, NoLock); |
| 193 |
} |
| 194 |
|
| 195 |
/* ---------------- |
| 196 |
* relation_close - close any relation |
| 197 |
* |
| 198 |
* If lockmode is not "NoLock", we then release the specified lock. |
| 199 |
* |
| 200 |
* Note that it is often sensible to hold a lock beyond relation_close; |
| 201 |
* in that case, the lock is released automatically at xact end. |
| 202 |
* ---------------- |
| 203 |
*/ |
| 204 |
void |
| 205 |
relation_close(Relation relation, LOCKMODE lockmode) |
| 206 |
{ |
| 207 |
LockRelId relid = relation->rd_lockInfo.lockRelId; |
| 208 |
|
| 209 |
Assert(lockmode >= NoLock && lockmode < MAX_LOCKMODES); |
| 210 |
|
| 211 |
/* The relcache does the real work... */ |
| 212 |
RelationClose(relation); |
| 213 |
|
| 214 |
if (lockmode != NoLock) |
| 215 |
UnlockRelationId(&relid, lockmode); |
| 216 |
} |