From e1289c76cb0e2208a8544d9f5fbd8f586d078081 Mon Sep 17 00:00:00 2001 From: Andres Freund Date: Sat, 12 Jan 2019 17:14:49 -0800 Subject: [PATCH v1 1/3] WIP: Introduce access/table.h access/relation.h. --- src/backend/access/Makefile | 2 +- src/backend/access/common/Makefile | 2 +- src/backend/access/common/relation.c | 216 +++++++++++++ src/backend/access/heap/heapam.c | 289 ------------------ src/backend/access/{common => table}/Makefile | 9 +- src/backend/access/table/table.c | 137 +++++++++ src/include/access/heapam.h | 16 +- src/include/access/relation.h | 29 ++ src/include/access/table.h | 38 +++ 9 files changed, 428 insertions(+), 310 deletions(-) create mode 100644 src/backend/access/common/relation.c copy src/backend/access/{common => table}/Makefile (56%) create mode 100644 src/backend/access/table/table.c create mode 100644 src/include/access/relation.h create mode 100644 src/include/access/table.h diff --git a/src/backend/access/Makefile b/src/backend/access/Makefile index bd93a6a8d1e..0880e0a8bbb 100644 --- a/src/backend/access/Makefile +++ b/src/backend/access/Makefile @@ -9,6 +9,6 @@ top_builddir = ../../.. include $(top_builddir)/src/Makefile.global SUBDIRS = brin common gin gist hash heap index nbtree rmgrdesc spgist \ - tablesample transam + table tablesample transam include $(top_srcdir)/src/backend/common.mk diff --git a/src/backend/access/common/Makefile b/src/backend/access/common/Makefile index f130b6e3501..d4695043377 100644 --- a/src/backend/access/common/Makefile +++ b/src/backend/access/common/Makefile @@ -13,6 +13,6 @@ top_builddir = ../../../.. include $(top_builddir)/src/Makefile.global OBJS = bufmask.o heaptuple.o indextuple.o printsimple.o printtup.o \ - reloptions.o scankey.o session.o tupconvert.o tupdesc.o + relation.o reloptions.o scankey.o session.o tupconvert.o tupdesc.o include $(top_srcdir)/src/backend/common.mk diff --git a/src/backend/access/common/relation.c b/src/backend/access/common/relation.c new file mode 100644 index 00000000000..4b65a47f6f9 --- /dev/null +++ b/src/backend/access/common/relation.c @@ -0,0 +1,216 @@ +/*------------------------------------------------------------------------- + * + * relation.c + * generic relation related code + * + * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * + * IDENTIFICATION + * src/backend/access/common/relation.c + * + * NOTES + * This file contains relation_ routines that implement access to relations + * (tables, indexes, etc). Support that's specific to subtypes of relations + * should go into their respective headers, not here. + * + *------------------------------------------------------------------------- + */ + +#include "postgres.h" + +#include "access/relation.h" +#include "access/xact.h" +#include "catalog/namespace.h" +#include "miscadmin.h" +#include "pgstat.h" +#include "storage/lmgr.h" +#include "utils/inval.h" +#include "utils/syscache.h" + +/* ---------------- + * relation_open - open any relation by relation OID + * + * If lockmode is not "NoLock", the specified kind of lock is + * obtained on the relation. (Generally, NoLock should only be + * used if the caller knows it has some appropriate lock on the + * relation already.) + * + * An error is raised if the relation does not exist. + * + * NB: a "relation" is anything with a pg_class entry. The caller is + * expected to check whether the relkind is something it can handle. + * ---------------- + */ +Relation +relation_open(Oid relationId, LOCKMODE lockmode) +{ + Relation r; + + Assert(lockmode >= NoLock && lockmode < MAX_LOCKMODES); + + /* Get the lock before trying to open the relcache entry */ + if (lockmode != NoLock) + LockRelationOid(relationId, lockmode); + + /* The relcache does all the real work... */ + r = RelationIdGetRelation(relationId); + + if (!RelationIsValid(r)) + elog(ERROR, "could not open relation with OID %u", relationId); + + /* + * If we didn't get the lock ourselves, assert that caller holds one, + * except in bootstrap mode where no locks are used. + */ + Assert(lockmode != NoLock || + IsBootstrapProcessingMode() || + CheckRelationLockedByMe(r, AccessShareLock, true)); + + /* Make note that we've accessed a temporary relation */ + if (RelationUsesLocalBuffers(r)) + MyXactFlags |= XACT_FLAGS_ACCESSEDTEMPREL; + + pgstat_initstats(r); + + return r; +} + +/* ---------------- + * try_relation_open - open any relation by relation OID + * + * Same as relation_open, except return NULL instead of failing + * if the relation does not exist. + * ---------------- + */ +Relation +try_relation_open(Oid relationId, LOCKMODE lockmode) +{ + Relation r; + + Assert(lockmode >= NoLock && lockmode < MAX_LOCKMODES); + + /* Get the lock first */ + if (lockmode != NoLock) + LockRelationOid(relationId, lockmode); + + /* + * Now that we have the lock, probe to see if the relation really exists + * or not. + */ + if (!SearchSysCacheExists1(RELOID, ObjectIdGetDatum(relationId))) + { + /* Release useless lock */ + if (lockmode != NoLock) + UnlockRelationOid(relationId, lockmode); + + return NULL; + } + + /* Should be safe to do a relcache load */ + r = RelationIdGetRelation(relationId); + + if (!RelationIsValid(r)) + elog(ERROR, "could not open relation with OID %u", relationId); + + /* If we didn't get the lock ourselves, assert that caller holds one */ + Assert(lockmode != NoLock || + CheckRelationLockedByMe(r, AccessShareLock, true)); + + /* Make note that we've accessed a temporary relation */ + if (RelationUsesLocalBuffers(r)) + MyXactFlags |= XACT_FLAGS_ACCESSEDTEMPREL; + + pgstat_initstats(r); + + return r; +} + +/* ---------------- + * relation_openrv - open any relation specified by a RangeVar + * + * Same as relation_open, but the relation is specified by a RangeVar. + * ---------------- + */ +Relation +relation_openrv(const RangeVar *relation, LOCKMODE lockmode) +{ + Oid relOid; + + /* + * Check for shared-cache-inval messages before trying to open the + * relation. This is needed even if we already hold a lock on the + * relation, because GRANT/REVOKE are executed without taking any lock on + * the target relation, and we want to be sure we see current ACL + * information. We can skip this if asked for NoLock, on the assumption + * that such a call is not the first one in the current command, and so we + * should be reasonably up-to-date already. (XXX this all could stand to + * be redesigned, but for the moment we'll keep doing this like it's been + * done historically.) + */ + if (lockmode != NoLock) + AcceptInvalidationMessages(); + + /* Look up and lock the appropriate relation using namespace search */ + relOid = RangeVarGetRelid(relation, lockmode, false); + + /* Let relation_open do the rest */ + return relation_open(relOid, NoLock); +} + +/* ---------------- + * relation_openrv_extended - open any relation specified by a RangeVar + * + * Same as relation_openrv, but with an additional missing_ok argument + * allowing a NULL return rather than an error if the relation is not + * found. (Note that some other causes, such as permissions problems, + * will still result in an ereport.) + * ---------------- + */ +Relation +relation_openrv_extended(const RangeVar *relation, LOCKMODE lockmode, + bool missing_ok) +{ + Oid relOid; + + /* + * Check for shared-cache-inval messages before trying to open the + * relation. See comments in relation_openrv(). + */ + if (lockmode != NoLock) + AcceptInvalidationMessages(); + + /* Look up and lock the appropriate relation using namespace search */ + relOid = RangeVarGetRelid(relation, lockmode, missing_ok); + + /* Return NULL on not-found */ + if (!OidIsValid(relOid)) + return NULL; + + /* Let relation_open do the rest */ + return relation_open(relOid, NoLock); +} + +/* ---------------- + * relation_close - close any relation + * + * If lockmode is not "NoLock", we then release the specified lock. + * + * Note that it is often sensible to hold a lock beyond relation_close; + * in that case, the lock is released automatically at xact end. + * ---------------- + */ +void +relation_close(Relation relation, LOCKMODE lockmode) +{ + LockRelId relid = relation->rd_lockInfo.lockRelId; + + Assert(lockmode >= NoLock && lockmode < MAX_LOCKMODES); + + /* The relcache does the real work... */ + RelationClose(relation); + + if (lockmode != NoLock) + UnlockRelationId(&relid, lockmode); +} diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c index 3a184f2eccb..3415a697398 100644 --- a/src/backend/access/heap/heapam.c +++ b/src/backend/access/heap/heapam.c @@ -12,12 +12,6 @@ * * * INTERFACE ROUTINES - * relation_open - open any relation by relation OID - * relation_openrv - open any relation specified by a RangeVar - * relation_close - close any relation - * heap_open - open a heap relation by relation OID - * heap_openrv - open a heap relation specified by a RangeVar - * heap_close - (now just a macro for relation_close) * heap_beginscan - begin relation scan * heap_rescan - restart a relation scan * heap_endscan - end relation scan @@ -56,7 +50,6 @@ #include "access/xloginsert.h" #include "access/xlogutils.h" #include "catalog/catalog.h" -#include "catalog/namespace.h" #include "catalog/index.h" #include "miscadmin.h" #include "pgstat.h" @@ -74,7 +67,6 @@ #include "utils/lsyscache.h" #include "utils/relcache.h" #include "utils/snapmgr.h" -#include "utils/syscache.h" #include "utils/tqual.h" #include "utils/memutils.h" #include "nodes/execnodes.h" @@ -1107,287 +1099,6 @@ fastgetattr(HeapTuple tup, int attnum, TupleDesc tupleDesc, * ---------------------------------------------------------------- */ -/* ---------------- - * relation_open - open any relation by relation OID - * - * If lockmode is not "NoLock", the specified kind of lock is - * obtained on the relation. (Generally, NoLock should only be - * used if the caller knows it has some appropriate lock on the - * relation already.) - * - * An error is raised if the relation does not exist. - * - * NB: a "relation" is anything with a pg_class entry. The caller is - * expected to check whether the relkind is something it can handle. - * ---------------- - */ -Relation -relation_open(Oid relationId, LOCKMODE lockmode) -{ - Relation r; - - Assert(lockmode >= NoLock && lockmode < MAX_LOCKMODES); - - /* Get the lock before trying to open the relcache entry */ - if (lockmode != NoLock) - LockRelationOid(relationId, lockmode); - - /* The relcache does all the real work... */ - r = RelationIdGetRelation(relationId); - - if (!RelationIsValid(r)) - elog(ERROR, "could not open relation with OID %u", relationId); - - /* - * If we didn't get the lock ourselves, assert that caller holds one, - * except in bootstrap mode where no locks are used. - */ - Assert(lockmode != NoLock || - IsBootstrapProcessingMode() || - CheckRelationLockedByMe(r, AccessShareLock, true)); - - /* Make note that we've accessed a temporary relation */ - if (RelationUsesLocalBuffers(r)) - MyXactFlags |= XACT_FLAGS_ACCESSEDTEMPREL; - - pgstat_initstats(r); - - return r; -} - -/* ---------------- - * try_relation_open - open any relation by relation OID - * - * Same as relation_open, except return NULL instead of failing - * if the relation does not exist. - * ---------------- - */ -Relation -try_relation_open(Oid relationId, LOCKMODE lockmode) -{ - Relation r; - - Assert(lockmode >= NoLock && lockmode < MAX_LOCKMODES); - - /* Get the lock first */ - if (lockmode != NoLock) - LockRelationOid(relationId, lockmode); - - /* - * Now that we have the lock, probe to see if the relation really exists - * or not. - */ - if (!SearchSysCacheExists1(RELOID, ObjectIdGetDatum(relationId))) - { - /* Release useless lock */ - if (lockmode != NoLock) - UnlockRelationOid(relationId, lockmode); - - return NULL; - } - - /* Should be safe to do a relcache load */ - r = RelationIdGetRelation(relationId); - - if (!RelationIsValid(r)) - elog(ERROR, "could not open relation with OID %u", relationId); - - /* If we didn't get the lock ourselves, assert that caller holds one */ - Assert(lockmode != NoLock || - CheckRelationLockedByMe(r, AccessShareLock, true)); - - /* Make note that we've accessed a temporary relation */ - if (RelationUsesLocalBuffers(r)) - MyXactFlags |= XACT_FLAGS_ACCESSEDTEMPREL; - - pgstat_initstats(r); - - return r; -} - -/* ---------------- - * relation_openrv - open any relation specified by a RangeVar - * - * Same as relation_open, but the relation is specified by a RangeVar. - * ---------------- - */ -Relation -relation_openrv(const RangeVar *relation, LOCKMODE lockmode) -{ - Oid relOid; - - /* - * Check for shared-cache-inval messages before trying to open the - * relation. This is needed even if we already hold a lock on the - * relation, because GRANT/REVOKE are executed without taking any lock on - * the target relation, and we want to be sure we see current ACL - * information. We can skip this if asked for NoLock, on the assumption - * that such a call is not the first one in the current command, and so we - * should be reasonably up-to-date already. (XXX this all could stand to - * be redesigned, but for the moment we'll keep doing this like it's been - * done historically.) - */ - if (lockmode != NoLock) - AcceptInvalidationMessages(); - - /* Look up and lock the appropriate relation using namespace search */ - relOid = RangeVarGetRelid(relation, lockmode, false); - - /* Let relation_open do the rest */ - return relation_open(relOid, NoLock); -} - -/* ---------------- - * relation_openrv_extended - open any relation specified by a RangeVar - * - * Same as relation_openrv, but with an additional missing_ok argument - * allowing a NULL return rather than an error if the relation is not - * found. (Note that some other causes, such as permissions problems, - * will still result in an ereport.) - * ---------------- - */ -Relation -relation_openrv_extended(const RangeVar *relation, LOCKMODE lockmode, - bool missing_ok) -{ - Oid relOid; - - /* - * Check for shared-cache-inval messages before trying to open the - * relation. See comments in relation_openrv(). - */ - if (lockmode != NoLock) - AcceptInvalidationMessages(); - - /* Look up and lock the appropriate relation using namespace search */ - relOid = RangeVarGetRelid(relation, lockmode, missing_ok); - - /* Return NULL on not-found */ - if (!OidIsValid(relOid)) - return NULL; - - /* Let relation_open do the rest */ - return relation_open(relOid, NoLock); -} - -/* ---------------- - * relation_close - close any relation - * - * If lockmode is not "NoLock", we then release the specified lock. - * - * Note that it is often sensible to hold a lock beyond relation_close; - * in that case, the lock is released automatically at xact end. - * ---------------- - */ -void -relation_close(Relation relation, LOCKMODE lockmode) -{ - LockRelId relid = relation->rd_lockInfo.lockRelId; - - Assert(lockmode >= NoLock && lockmode < MAX_LOCKMODES); - - /* The relcache does the real work... */ - RelationClose(relation); - - if (lockmode != NoLock) - UnlockRelationId(&relid, lockmode); -} - - -/* ---------------- - * heap_open - open a heap relation by relation OID - * - * This is essentially relation_open plus check that the relation - * is not an index nor a composite type. (The caller should also - * check that it's not a view or foreign table before assuming it has - * storage.) - * ---------------- - */ -Relation -heap_open(Oid relationId, LOCKMODE lockmode) -{ - Relation r; - - r = relation_open(relationId, lockmode); - - if (r->rd_rel->relkind == RELKIND_INDEX || - r->rd_rel->relkind == RELKIND_PARTITIONED_INDEX) - ereport(ERROR, - (errcode(ERRCODE_WRONG_OBJECT_TYPE), - errmsg("\"%s\" is an index", - RelationGetRelationName(r)))); - else if (r->rd_rel->relkind == RELKIND_COMPOSITE_TYPE) - ereport(ERROR, - (errcode(ERRCODE_WRONG_OBJECT_TYPE), - errmsg("\"%s\" is a composite type", - RelationGetRelationName(r)))); - - return r; -} - -/* ---------------- - * heap_openrv - open a heap relation specified - * by a RangeVar node - * - * As above, but relation is specified by a RangeVar. - * ---------------- - */ -Relation -heap_openrv(const RangeVar *relation, LOCKMODE lockmode) -{ - Relation r; - - r = relation_openrv(relation, lockmode); - - if (r->rd_rel->relkind == RELKIND_INDEX || - r->rd_rel->relkind == RELKIND_PARTITIONED_INDEX) - ereport(ERROR, - (errcode(ERRCODE_WRONG_OBJECT_TYPE), - errmsg("\"%s\" is an index", - RelationGetRelationName(r)))); - else if (r->rd_rel->relkind == RELKIND_COMPOSITE_TYPE) - ereport(ERROR, - (errcode(ERRCODE_WRONG_OBJECT_TYPE), - errmsg("\"%s\" is a composite type", - RelationGetRelationName(r)))); - - return r; -} - -/* ---------------- - * heap_openrv_extended - open a heap relation specified - * by a RangeVar node - * - * As above, but optionally return NULL instead of failing for - * relation-not-found. - * ---------------- - */ -Relation -heap_openrv_extended(const RangeVar *relation, LOCKMODE lockmode, - bool missing_ok) -{ - Relation r; - - r = relation_openrv_extended(relation, lockmode, missing_ok); - - if (r) - { - if (r->rd_rel->relkind == RELKIND_INDEX || - r->rd_rel->relkind == RELKIND_PARTITIONED_INDEX) - ereport(ERROR, - (errcode(ERRCODE_WRONG_OBJECT_TYPE), - errmsg("\"%s\" is an index", - RelationGetRelationName(r)))); - else if (r->rd_rel->relkind == RELKIND_COMPOSITE_TYPE) - ereport(ERROR, - (errcode(ERRCODE_WRONG_OBJECT_TYPE), - errmsg("\"%s\" is a composite type", - RelationGetRelationName(r)))); - } - - return r; -} - /* ---------------- * heap_beginscan - begin relation scan diff --git a/src/backend/access/common/Makefile b/src/backend/access/table/Makefile similarity index 56% copy from src/backend/access/common/Makefile copy to src/backend/access/table/Makefile index f130b6e3501..ac1de5a52b0 100644 --- a/src/backend/access/common/Makefile +++ b/src/backend/access/table/Makefile @@ -1,18 +1,17 @@ #------------------------------------------------------------------------- # # Makefile-- -# Makefile for access/common +# Makefile for access/table # # IDENTIFICATION -# src/backend/access/common/Makefile +# src/backend/access/table/Makefile # #------------------------------------------------------------------------- -subdir = src/backend/access/common +subdir = src/backend/access/table top_builddir = ../../../.. include $(top_builddir)/src/Makefile.global -OBJS = bufmask.o heaptuple.o indextuple.o printsimple.o printtup.o \ - reloptions.o scankey.o session.o tupconvert.o tupdesc.o +OBJS = table.o include $(top_srcdir)/src/backend/common.mk diff --git a/src/backend/access/table/table.c b/src/backend/access/table/table.c new file mode 100644 index 00000000000..dad86ee37ba --- /dev/null +++ b/src/backend/access/table/table.c @@ -0,0 +1,137 @@ +/*------------------------------------------------------------------------- + * + * table.c + * Generic routines for table related code. + * + * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * + * IDENTIFICATION + * src/backend/access/table/table.c + * + * + * NOTES + * This file contains table_ routines that implement access to tables (in + * contrast to other relation types like indexes) that are independent of + * individual table access methods. + * + *------------------------------------------------------------------------- + */ + +#include "postgres.h" + +#include "access/relation.h" +#include "access/table.h" +#include "access/xact.h" +#include "storage/lmgr.h" + + +/* ---------------- + * table_open - open a table relation by relation OID + * + * This is essentially relation_open plus check that the relation + * is not an index nor a composite type. (The caller should also + * check that it's not a view or foreign table before assuming it has + * storage.) + * ---------------- + */ +Relation +table_open(Oid relationId, LOCKMODE lockmode) +{ + Relation r; + + r = relation_open(relationId, lockmode); + + if (r->rd_rel->relkind == RELKIND_INDEX || + r->rd_rel->relkind == RELKIND_PARTITIONED_INDEX) + ereport(ERROR, + (errcode(ERRCODE_WRONG_OBJECT_TYPE), + errmsg("\"%s\" is an index", + RelationGetRelationName(r)))); + else if (r->rd_rel->relkind == RELKIND_COMPOSITE_TYPE) + ereport(ERROR, + (errcode(ERRCODE_WRONG_OBJECT_TYPE), + errmsg("\"%s\" is a composite type", + RelationGetRelationName(r)))); + + return r; +} + +/* ---------------- + * table_openrv - open a table relation specified + * by a RangeVar node + * + * As above, but relation is specified by a RangeVar. + * ---------------- + */ +Relation +table_openrv(const RangeVar *relation, LOCKMODE lockmode) +{ + Relation r; + + r = relation_openrv(relation, lockmode); + + if (r->rd_rel->relkind == RELKIND_INDEX || + r->rd_rel->relkind == RELKIND_PARTITIONED_INDEX) + ereport(ERROR, + (errcode(ERRCODE_WRONG_OBJECT_TYPE), + errmsg("\"%s\" is an index", + RelationGetRelationName(r)))); + else if (r->rd_rel->relkind == RELKIND_COMPOSITE_TYPE) + ereport(ERROR, + (errcode(ERRCODE_WRONG_OBJECT_TYPE), + errmsg("\"%s\" is a composite type", + RelationGetRelationName(r)))); + + return r; +} + +/* ---------------- + * table_openrv_extended - open a table relation specified + * by a RangeVar node + * + * As above, but optionally return NULL instead of failing for + * relation-not-found. + * ---------------- + */ +Relation +table_openrv_extended(const RangeVar *relation, LOCKMODE lockmode, + bool missing_ok) +{ + Relation r; + + r = relation_openrv_extended(relation, lockmode, missing_ok); + + if (r) + { + if (r->rd_rel->relkind == RELKIND_INDEX || + r->rd_rel->relkind == RELKIND_PARTITIONED_INDEX) + ereport(ERROR, + (errcode(ERRCODE_WRONG_OBJECT_TYPE), + errmsg("\"%s\" is an index", + RelationGetRelationName(r)))); + else if (r->rd_rel->relkind == RELKIND_COMPOSITE_TYPE) + ereport(ERROR, + (errcode(ERRCODE_WRONG_OBJECT_TYPE), + errmsg("\"%s\" is a composite type", + RelationGetRelationName(r)))); + } + + return r; +} + +/* ---------------- + * table_close - close a table + * + * If lockmode is not "NoLock", we then release the specified lock. + * + * Note that it is often sensible to hold a lock beyond relation_close; + * in that case, the lock is released automatically at xact end. + * ---------------- + */ +void +table_close(Relation relation, LOCKMODE lockmode) +{ + relation_close(relation, lockmode); +} diff --git a/src/include/access/heapam.h b/src/include/access/heapam.h index cf2ac151241..f80dc416eb1 100644 --- a/src/include/access/heapam.h +++ b/src/include/access/heapam.h @@ -14,8 +14,10 @@ #ifndef HEAPAM_H #define HEAPAM_H +#include "access/relation.h" #include "access/sdir.h" #include "access/skey.h" +#include "access/table.h" #include "nodes/lockoptions.h" #include "nodes/primnodes.h" #include "storage/bufpage.h" @@ -67,20 +69,6 @@ typedef struct HeapUpdateFailureData * ---------------- */ -/* in heap/heapam.c */ -extern Relation relation_open(Oid relationId, LOCKMODE lockmode); -extern Relation try_relation_open(Oid relationId, LOCKMODE lockmode); -extern Relation relation_openrv(const RangeVar *relation, LOCKMODE lockmode); -extern Relation relation_openrv_extended(const RangeVar *relation, - LOCKMODE lockmode, bool missing_ok); -extern void relation_close(Relation relation, LOCKMODE lockmode); - -extern Relation heap_open(Oid relationId, LOCKMODE lockmode); -extern Relation heap_openrv(const RangeVar *relation, LOCKMODE lockmode); -extern Relation heap_openrv_extended(const RangeVar *relation, - LOCKMODE lockmode, bool missing_ok); - -#define heap_close(r,l) relation_close(r,l) /* struct definitions appear in relscan.h */ typedef struct HeapScanDescData *HeapScanDesc; diff --git a/src/include/access/relation.h b/src/include/access/relation.h new file mode 100644 index 00000000000..1d46e52eacc --- /dev/null +++ b/src/include/access/relation.h @@ -0,0 +1,29 @@ +/*------------------------------------------------------------------------- + * + * relation.h + * POSTGRES relation interface. + * + * + * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/access/relation.h + * + *------------------------------------------------------------------------- + */ +#ifndef ACCESS_RELATION_H +#define ACCESS_RELATION_H + +#include "nodes/primnodes.h" +#include "utils/relcache.h" +#include "storage/lockdefs.h" + + +extern Relation relation_open(Oid relationId, LOCKMODE lockmode); +extern Relation try_relation_open(Oid relationId, LOCKMODE lockmode); +extern Relation relation_openrv(const RangeVar *relation, LOCKMODE lockmode); +extern Relation relation_openrv_extended(const RangeVar *relation, + LOCKMODE lockmode, bool missing_ok); +extern void relation_close(Relation relation, LOCKMODE lockmode); + +#endif /* ACCESS_RELATION_H */ diff --git a/src/include/access/table.h b/src/include/access/table.h new file mode 100644 index 00000000000..453f4dd6a1a --- /dev/null +++ b/src/include/access/table.h @@ -0,0 +1,38 @@ +/*------------------------------------------------------------------------- + * + * table.h + * Generic routines for table related code. + * + * + * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/access/table.h + * + *------------------------------------------------------------------------- + */ +#ifndef TABLE_H +#define TABLE_H + +#include "nodes/primnodes.h" +#include "utils/relcache.h" +#include "storage/lockdefs.h" + + +extern Relation table_open(Oid relationId, LOCKMODE lockmode); +extern Relation table_openrv(const RangeVar *relation, LOCKMODE lockmode); +extern Relation table_openrv_extended(const RangeVar *relation, + LOCKMODE lockmode, bool missing_ok); +extern void table_close(Relation relation, LOCKMODE lockmode); + +/* + * heap_ used to be the prefix for these routines, and a lot of code will just + * continue to work without adaptions after the introduction of pluggable + * storage, therefore just map these names. + */ +#define heap_open(r, l) table_open(r, l) +#define heap_openrv(r, l) table_openrv(r, l) +#define heap_openrv_extended(r, l, m) table_openrv_extended(r, l, m) +#define heap_close(r, l) table_close(r, l) + +#endif /* TABLE_H */ -- 2.18.0.rc2.dirty