1996-07-09 08:22:35 +02:00
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
*
|
1999-02-14 00:22:53 +01:00
|
|
|
* catalog.c
|
2006-07-31 22:09:10 +02:00
|
|
|
* routines concerned with catalog naming conventions and other
|
|
|
|
* bits of hard-wired knowledge
|
1997-09-07 07:04:48 +02:00
|
|
|
*
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
2013-01-01 23:15:01 +01:00
|
|
|
* Portions Copyright (c) 1996-2013, PostgreSQL Global Development Group
|
2000-01-26 06:58:53 +01:00
|
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
*
|
|
|
|
* IDENTIFICATION
|
2010-09-20 22:08:53 +02:00
|
|
|
* src/backend/catalog/catalog.c
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
*/
|
1997-01-10 21:19:49 +01:00
|
|
|
|
1999-07-16 01:04:24 +02:00
|
|
|
#include "postgres.h"
|
1996-11-04 00:27:08 +01:00
|
|
|
|
2005-08-12 03:36:05 +02:00
|
|
|
#include <fcntl.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
|
|
|
|
#include "access/genam.h"
|
2008-05-12 02:00:54 +02:00
|
|
|
#include "access/sysattr.h"
|
1999-07-16 07:00:38 +02:00
|
|
|
#include "access/transam.h"
|
|
|
|
#include "catalog/catalog.h"
|
2006-07-31 22:09:10 +02:00
|
|
|
#include "catalog/indexing.h"
|
2007-07-26 00:16:18 +02:00
|
|
|
#include "catalog/namespace.h"
|
2006-07-31 22:09:10 +02:00
|
|
|
#include "catalog/pg_auth_members.h"
|
|
|
|
#include "catalog/pg_authid.h"
|
|
|
|
#include "catalog/pg_database.h"
|
2002-04-12 22:38:31 +02:00
|
|
|
#include "catalog/pg_namespace.h"
|
2006-07-31 22:09:10 +02:00
|
|
|
#include "catalog/pg_pltemplate.h"
|
2009-10-08 00:14:26 +02:00
|
|
|
#include "catalog/pg_db_role_setting.h"
|
2006-07-31 22:09:10 +02:00
|
|
|
#include "catalog/pg_shdepend.h"
|
|
|
|
#include "catalog/pg_shdescription.h"
|
2011-07-20 19:18:24 +02:00
|
|
|
#include "catalog/pg_shseclabel.h"
|
2004-06-18 08:14:31 +02:00
|
|
|
#include "catalog/pg_tablespace.h"
|
2006-07-31 22:09:10 +02:00
|
|
|
#include "catalog/toasting.h"
|
2013-02-22 02:46:17 +01:00
|
|
|
#include "common/relpath.h"
|
1999-07-16 07:00:38 +02:00
|
|
|
#include "miscadmin.h"
|
2005-08-12 03:36:05 +02:00
|
|
|
#include "storage/fd.h"
|
|
|
|
#include "utils/fmgroids.h"
|
2008-06-19 02:46:06 +02:00
|
|
|
#include "utils/rel.h"
|
2008-03-26 17:20:48 +01:00
|
|
|
#include "utils/tqual.h"
|
2002-04-12 22:38:31 +02:00
|
|
|
|
1996-07-09 08:22:35 +02:00
|
|
|
|
2008-10-06 16:13:17 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* forkname_to_number - look up fork number by name
|
|
|
|
*/
|
|
|
|
ForkNumber
|
|
|
|
forkname_to_number(char *forkName)
|
|
|
|
{
|
2009-06-11 16:49:15 +02:00
|
|
|
ForkNumber forkNum;
|
2008-10-06 16:13:17 +02:00
|
|
|
|
|
|
|
for (forkNum = 0; forkNum <= MAX_FORKNUM; forkNum++)
|
|
|
|
if (strcmp(forkNames[forkNum], forkName) == 0)
|
|
|
|
return forkNum;
|
|
|
|
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
|
|
|
|
errmsg("invalid fork name"),
|
2009-03-25 15:11:48 +01:00
|
|
|
errhint("Valid fork names are \"main\", \"fsm\", and \"vm\".")));
|
2009-06-11 16:49:15 +02:00
|
|
|
return InvalidForkNumber; /* keep compiler quiet */
|
2008-10-06 16:13:17 +02:00
|
|
|
}
|
2004-06-18 08:14:31 +02:00
|
|
|
|
2000-10-16 16:52:28 +02:00
|
|
|
/*
|
|
|
|
* GetDatabasePath - construct path to a database dir
|
|
|
|
*
|
|
|
|
* Result is a palloc'd string.
|
2004-06-18 08:14:31 +02:00
|
|
|
*
|
|
|
|
* XXX this must agree with relpath()!
|
2000-10-16 16:52:28 +02:00
|
|
|
*/
|
|
|
|
char *
|
2004-06-18 08:14:31 +02:00
|
|
|
GetDatabasePath(Oid dbNode, Oid spcNode)
|
2000-10-16 16:52:28 +02:00
|
|
|
{
|
2004-06-18 08:14:31 +02:00
|
|
|
if (spcNode == GLOBALTABLESPACE_OID)
|
2000-10-16 16:52:28 +02:00
|
|
|
{
|
|
|
|
/* Shared system relations live in {datadir}/global */
|
2004-06-18 08:14:31 +02:00
|
|
|
Assert(dbNode == 0);
|
2013-10-13 06:09:18 +02:00
|
|
|
return pstrdup("global");
|
2004-06-18 08:14:31 +02:00
|
|
|
}
|
|
|
|
else if (spcNode == DEFAULTTABLESPACE_OID)
|
|
|
|
{
|
|
|
|
/* The default tablespace is {datadir}/base */
|
2013-10-13 06:09:18 +02:00
|
|
|
return psprintf("base/%u", dbNode);
|
2000-10-16 16:52:28 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2004-06-18 08:14:31 +02:00
|
|
|
/* All other tablespaces are accessed via symlinks */
|
2013-10-13 06:09:18 +02:00
|
|
|
return psprintf("pg_tblspc/%u/%s/%u",
|
|
|
|
spcNode, TABLESPACE_VERSION_DIRECTORY, dbNode);
|
2000-10-16 16:52:28 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2000-04-09 06:43:20 +02:00
|
|
|
|
1996-07-09 08:22:35 +02:00
|
|
|
/*
|
2002-04-12 22:38:31 +02:00
|
|
|
* IsSystemRelation
|
|
|
|
* True iff the relation is a system catalog relation.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
2002-04-12 22:38:31 +02:00
|
|
|
* NB: TOAST relations are considered system relations by this test
|
|
|
|
* for compatibility with the old IsSystemRelationName function.
|
2001-11-17 00:30:35 +01:00
|
|
|
* This is appropriate in many places but not all. Where it's not,
|
2002-04-12 22:38:31 +02:00
|
|
|
* also check IsToastRelation.
|
2001-11-17 00:30:35 +01:00
|
|
|
*
|
2002-04-12 22:38:31 +02:00
|
|
|
* We now just test if the relation is in the system catalog namespace;
|
|
|
|
* so it's no longer necessary to forbid user relations from having
|
2004-06-21 06:06:07 +02:00
|
|
|
* names starting with pg_.
|
2002-04-12 22:38:31 +02:00
|
|
|
*/
|
|
|
|
bool
|
|
|
|
IsSystemRelation(Relation relation)
|
|
|
|
{
|
2002-09-04 22:31:48 +02:00
|
|
|
return IsSystemNamespace(RelationGetNamespace(relation)) ||
|
|
|
|
IsToastNamespace(RelationGetNamespace(relation));
|
2002-04-12 22:38:31 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* IsSystemClass
|
|
|
|
* Like the above, but takes a Form_pg_class as argument.
|
|
|
|
* Used when we do not want to open the relation and have to
|
|
|
|
* search pg_class directly.
|
|
|
|
*/
|
|
|
|
bool
|
|
|
|
IsSystemClass(Form_pg_class reltuple)
|
|
|
|
{
|
2002-09-04 22:31:48 +02:00
|
|
|
Oid relnamespace = reltuple->relnamespace;
|
2002-04-12 22:38:31 +02:00
|
|
|
|
2002-09-04 22:31:48 +02:00
|
|
|
return IsSystemNamespace(relnamespace) ||
|
|
|
|
IsToastNamespace(relnamespace);
|
2002-04-12 22:38:31 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* IsToastRelation
|
|
|
|
* True iff relation is a TOAST support relation (or index).
|
|
|
|
*/
|
|
|
|
bool
|
|
|
|
IsToastRelation(Relation relation)
|
|
|
|
{
|
|
|
|
return IsToastNamespace(RelationGetNamespace(relation));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* IsToastClass
|
|
|
|
* Like the above, but takes a Form_pg_class as argument.
|
|
|
|
* Used when we do not want to open the relation and have to
|
|
|
|
* search pg_class directly.
|
|
|
|
*/
|
|
|
|
bool
|
|
|
|
IsToastClass(Form_pg_class reltuple)
|
|
|
|
{
|
2002-09-04 22:31:48 +02:00
|
|
|
Oid relnamespace = reltuple->relnamespace;
|
2002-04-12 22:38:31 +02:00
|
|
|
|
2002-09-04 22:31:48 +02:00
|
|
|
return IsToastNamespace(relnamespace);
|
2002-04-12 22:38:31 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* IsSystemNamespace
|
|
|
|
* True iff namespace is pg_catalog.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
2002-04-12 22:38:31 +02:00
|
|
|
* NOTE: the reason this isn't a macro is to avoid having to include
|
|
|
|
* catalog/pg_namespace.h in a lot of places.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
|
|
|
bool
|
2002-04-12 22:38:31 +02:00
|
|
|
IsSystemNamespace(Oid namespaceId)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
2002-04-12 22:38:31 +02:00
|
|
|
return namespaceId == PG_CATALOG_NAMESPACE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* IsToastNamespace
|
2007-07-26 00:16:18 +02:00
|
|
|
* True iff namespace is pg_toast or my temporary-toast-table namespace.
|
2002-04-12 22:38:31 +02:00
|
|
|
*
|
2007-07-26 00:16:18 +02:00
|
|
|
* Note: this will return false for temporary-toast-table namespaces belonging
|
|
|
|
* to other backends. Those are treated the same as other backends' regular
|
|
|
|
* temp table namespaces, and access is prevented where appropriate.
|
2002-04-12 22:38:31 +02:00
|
|
|
*/
|
|
|
|
bool
|
|
|
|
IsToastNamespace(Oid namespaceId)
|
|
|
|
{
|
2007-07-26 00:16:18 +02:00
|
|
|
return (namespaceId == PG_TOAST_NAMESPACE) ||
|
|
|
|
isTempToastNamespace(namespaceId);
|
2001-11-17 00:30:35 +01:00
|
|
|
}
|
|
|
|
|
2002-04-12 22:38:31 +02:00
|
|
|
|
2001-11-17 00:30:35 +01:00
|
|
|
/*
|
2002-04-12 22:38:31 +02:00
|
|
|
* IsReservedName
|
|
|
|
* True iff name starts with the pg_ prefix.
|
|
|
|
*
|
2004-01-06 19:07:32 +01:00
|
|
|
* For some classes of objects, the prefix pg_ is reserved for
|
2004-08-04 23:34:35 +02:00
|
|
|
* system objects only. As of 8.0, this is only true for
|
2004-06-21 06:06:07 +02:00
|
|
|
* schema and tablespace names.
|
2001-11-17 00:30:35 +01:00
|
|
|
*/
|
|
|
|
bool
|
2002-04-12 22:38:31 +02:00
|
|
|
IsReservedName(const char *name)
|
2001-11-17 00:30:35 +01:00
|
|
|
{
|
2002-04-12 22:38:31 +02:00
|
|
|
/* ugly coding for speed */
|
|
|
|
return (name[0] == 'p' &&
|
|
|
|
name[1] == 'g' &&
|
|
|
|
name[2] == '_');
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
2002-04-12 22:38:31 +02:00
|
|
|
|
2006-07-31 22:09:10 +02:00
|
|
|
/*
|
|
|
|
* IsSharedRelation
|
|
|
|
* Given the OID of a relation, determine whether it's supposed to be
|
|
|
|
* shared across an entire database cluster.
|
|
|
|
*
|
Use an MVCC snapshot, rather than SnapshotNow, for catalog scans.
SnapshotNow scans have the undesirable property that, in the face of
concurrent updates, the scan can fail to see either the old or the new
versions of the row. In many cases, we work around this by requiring
DDL operations to hold AccessExclusiveLock on the object being
modified; in some cases, the existing locking is inadequate and random
failures occur as a result. This commit doesn't change anything
related to locking, but will hopefully pave the way to allowing lock
strength reductions in the future.
The major issue has held us back from making this change in the past
is that taking an MVCC snapshot is significantly more expensive than
using a static special snapshot such as SnapshotNow. However, testing
of various worst-case scenarios reveals that this problem is not
severe except under fairly extreme workloads. To mitigate those
problems, we avoid retaking the MVCC snapshot for each new scan;
instead, we take a new snapshot only when invalidation messages have
been processed. The catcache machinery already requires that
invalidation messages be sent before releasing the related heavyweight
lock; else other backends might rely on locally-cached data rather
than scanning the catalog at all. Thus, making snapshot reuse
dependent on the same guarantees shouldn't break anything that wasn't
already subtly broken.
Patch by me. Review by Michael Paquier and Andres Freund.
2013-07-02 15:47:01 +02:00
|
|
|
* In older releases, this had to be hard-wired so that we could compute the
|
|
|
|
* locktag for a relation and lock it before examining its catalog entry.
|
|
|
|
* Since we now have MVCC catalog access, the race conditions that made that
|
|
|
|
* a hard requirement are gone, so we could look at relaxing this restriction.
|
|
|
|
* However, if we scanned the pg_class entry to find relisshared, and only
|
|
|
|
* then locked the relation, pg_class could get updated in the meantime,
|
|
|
|
* forcing us to scan the relation again, which would definitely be complex
|
|
|
|
* and might have undesirable performance consequences. Fortunately, the set
|
|
|
|
* of shared relations is fairly static, so a hand-maintained list of their
|
|
|
|
* OIDs isn't completely impractical.
|
2006-07-31 22:09:10 +02:00
|
|
|
*/
|
|
|
|
bool
|
|
|
|
IsSharedRelation(Oid relationId)
|
|
|
|
{
|
|
|
|
/* These are the shared catalogs (look for BKI_SHARED_RELATION) */
|
|
|
|
if (relationId == AuthIdRelationId ||
|
|
|
|
relationId == AuthMemRelationId ||
|
|
|
|
relationId == DatabaseRelationId ||
|
|
|
|
relationId == PLTemplateRelationId ||
|
|
|
|
relationId == SharedDescriptionRelationId ||
|
|
|
|
relationId == SharedDependRelationId ||
|
2011-07-20 19:18:24 +02:00
|
|
|
relationId == SharedSecLabelRelationId ||
|
2009-10-08 00:14:26 +02:00
|
|
|
relationId == TableSpaceRelationId ||
|
|
|
|
relationId == DbRoleSettingRelationId)
|
2006-07-31 22:09:10 +02:00
|
|
|
return true;
|
|
|
|
/* These are their indexes (see indexing.h) */
|
|
|
|
if (relationId == AuthIdRolnameIndexId ||
|
|
|
|
relationId == AuthIdOidIndexId ||
|
|
|
|
relationId == AuthMemRoleMemIndexId ||
|
|
|
|
relationId == AuthMemMemRoleIndexId ||
|
|
|
|
relationId == DatabaseNameIndexId ||
|
|
|
|
relationId == DatabaseOidIndexId ||
|
|
|
|
relationId == PLTemplateNameIndexId ||
|
|
|
|
relationId == SharedDescriptionObjIndexId ||
|
|
|
|
relationId == SharedDependDependerIndexId ||
|
|
|
|
relationId == SharedDependReferenceIndexId ||
|
2011-07-20 19:18:24 +02:00
|
|
|
relationId == SharedSecLabelObjectIndexId ||
|
2006-07-31 22:09:10 +02:00
|
|
|
relationId == TablespaceOidIndexId ||
|
2009-10-08 00:14:26 +02:00
|
|
|
relationId == TablespaceNameIndexId ||
|
|
|
|
relationId == DbRoleSettingDatidRolidIndexId)
|
2006-07-31 22:09:10 +02:00
|
|
|
return true;
|
|
|
|
/* These are their toast tables and toast indexes (see toasting.h) */
|
2012-02-29 03:43:36 +01:00
|
|
|
if (relationId == PgShdescriptionToastTable ||
|
2009-10-08 00:14:26 +02:00
|
|
|
relationId == PgShdescriptionToastIndex ||
|
|
|
|
relationId == PgDbRoleSettingToastTable ||
|
|
|
|
relationId == PgDbRoleSettingToastIndex)
|
2006-07-31 22:09:10 +02:00
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1996-07-09 08:22:35 +02:00
|
|
|
/*
|
2005-08-12 03:36:05 +02:00
|
|
|
* GetNewOid
|
|
|
|
* Generate a new OID that is unique within the given relation.
|
|
|
|
*
|
|
|
|
* Caller must have a suitable lock on the relation.
|
|
|
|
*
|
|
|
|
* Uniqueness is promised only if the relation has a unique index on OID.
|
|
|
|
* This is true for all system catalogs that have OIDs, but might not be
|
|
|
|
* true for user tables. Note that we are effectively assuming that the
|
|
|
|
* table has a relatively small number of entries (much less than 2^32)
|
|
|
|
* and there aren't very long runs of consecutive existing OIDs. Again,
|
|
|
|
* this is reasonable for system catalogs but less so for user tables.
|
|
|
|
*
|
|
|
|
* Since the OID is not immediately inserted into the table, there is a
|
|
|
|
* race condition here; but a problem could occur only if someone else
|
|
|
|
* managed to cycle through 2^32 OIDs and generate the same OID before we
|
2005-10-15 04:49:52 +02:00
|
|
|
* finish inserting our row. This seems unlikely to be a problem. Note
|
2005-08-12 03:36:05 +02:00
|
|
|
* that if we had to *commit* the row to end the race condition, the risk
|
|
|
|
* would be rather higher; therefore we use SnapshotDirty in the test,
|
|
|
|
* so that we will see uncommitted rows.
|
|
|
|
*/
|
|
|
|
Oid
|
|
|
|
GetNewOid(Relation relation)
|
|
|
|
{
|
|
|
|
Oid oidIndex;
|
|
|
|
|
|
|
|
/* If relation doesn't have OIDs at all, caller is confused */
|
|
|
|
Assert(relation->rd_rel->relhasoids);
|
|
|
|
|
|
|
|
/* In bootstrap mode, we don't have any indexes to use */
|
|
|
|
if (IsBootstrapProcessingMode())
|
|
|
|
return GetNewObjectId();
|
|
|
|
|
|
|
|
/* The relcache will cache the identity of the OID index for us */
|
|
|
|
oidIndex = RelationGetOidIndex(relation);
|
|
|
|
|
|
|
|
/* If no OID index, just hand back the next OID counter value */
|
|
|
|
if (!OidIsValid(oidIndex))
|
|
|
|
{
|
|
|
|
/*
|
2005-10-15 04:49:52 +02:00
|
|
|
* System catalogs that have OIDs should *always* have a unique OID
|
|
|
|
* index; we should only take this path for user tables. Give a
|
|
|
|
* warning if it looks like somebody forgot an index.
|
2005-08-12 03:36:05 +02:00
|
|
|
*/
|
|
|
|
if (IsSystemRelation(relation))
|
|
|
|
elog(WARNING, "generating possibly-non-unique OID for \"%s\"",
|
|
|
|
RelationGetRelationName(relation));
|
|
|
|
|
|
|
|
return GetNewObjectId();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Otherwise, use the index to find a nonconflicting OID */
|
2008-04-13 01:14:21 +02:00
|
|
|
return GetNewOidWithIndex(relation, oidIndex, ObjectIdAttributeNumber);
|
2005-08-12 03:36:05 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* GetNewOidWithIndex
|
|
|
|
* Guts of GetNewOid: use the supplied index
|
|
|
|
*
|
|
|
|
* This is exported separately because there are cases where we want to use
|
|
|
|
* an index that will not be recognized by RelationGetOidIndex: TOAST tables
|
2012-10-10 23:04:37 +02:00
|
|
|
* have indexes that are usable, but have multiple columns and are on
|
2013-05-29 22:58:43 +02:00
|
|
|
* ordinary columns rather than a true OID column. This code will work
|
2012-10-10 23:04:37 +02:00
|
|
|
* anyway, so long as the OID is the index's first column. The caller must
|
|
|
|
* pass in the actual heap attnum of the OID column, however.
|
2005-08-12 03:36:05 +02:00
|
|
|
*
|
|
|
|
* Caller must have a suitable lock on the relation.
|
|
|
|
*/
|
|
|
|
Oid
|
2008-04-13 01:14:21 +02:00
|
|
|
GetNewOidWithIndex(Relation relation, Oid indexId, AttrNumber oidcolumn)
|
2005-08-12 03:36:05 +02:00
|
|
|
{
|
|
|
|
Oid newOid;
|
2007-03-25 21:45:14 +02:00
|
|
|
SnapshotData SnapshotDirty;
|
2009-06-11 16:49:15 +02:00
|
|
|
SysScanDesc scan;
|
2005-08-12 03:36:05 +02:00
|
|
|
ScanKeyData key;
|
|
|
|
bool collides;
|
|
|
|
|
2007-03-25 21:45:14 +02:00
|
|
|
InitDirtySnapshot(SnapshotDirty);
|
|
|
|
|
2005-08-12 03:36:05 +02:00
|
|
|
/* Generate new OIDs until we find one not in the table */
|
|
|
|
do
|
|
|
|
{
|
2008-02-20 18:44:09 +01:00
|
|
|
CHECK_FOR_INTERRUPTS();
|
|
|
|
|
2005-08-12 03:36:05 +02:00
|
|
|
newOid = GetNewObjectId();
|
|
|
|
|
|
|
|
ScanKeyInit(&key,
|
2008-04-13 01:14:21 +02:00
|
|
|
oidcolumn,
|
2005-08-12 03:36:05 +02:00
|
|
|
BTEqualStrategyNumber, F_OIDEQ,
|
|
|
|
ObjectIdGetDatum(newOid));
|
|
|
|
|
|
|
|
/* see notes above about using SnapshotDirty */
|
2008-04-13 01:14:21 +02:00
|
|
|
scan = systable_beginscan(relation, indexId, true,
|
|
|
|
&SnapshotDirty, 1, &key);
|
2005-08-12 03:36:05 +02:00
|
|
|
|
2008-04-13 01:14:21 +02:00
|
|
|
collides = HeapTupleIsValid(systable_getnext(scan));
|
2005-08-12 03:36:05 +02:00
|
|
|
|
2008-04-13 01:14:21 +02:00
|
|
|
systable_endscan(scan);
|
2005-08-12 03:36:05 +02:00
|
|
|
} while (collides);
|
|
|
|
|
|
|
|
return newOid;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* GetNewRelFileNode
|
|
|
|
* Generate a new relfilenode number that is unique within the given
|
|
|
|
* tablespace.
|
|
|
|
*
|
|
|
|
* If the relfilenode will also be used as the relation's OID, pass the
|
|
|
|
* opened pg_class catalog, and this routine will guarantee that the result
|
|
|
|
* is also an unused OID within pg_class. If the result is to be used only
|
|
|
|
* as a relfilenode for an existing relation, pass NULL for pg_class.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
2005-08-12 03:36:05 +02:00
|
|
|
* As with GetNewOid, there is some theoretical risk of a race condition,
|
|
|
|
* but it doesn't seem worth worrying about.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
2005-08-12 03:36:05 +02:00
|
|
|
* Note: we don't support using this in bootstrap mode. All relations
|
|
|
|
* created by bootstrap have preassigned OIDs, so there's no need.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-09-07 07:04:48 +02:00
|
|
|
Oid
|
2010-12-13 18:34:26 +01:00
|
|
|
GetNewRelFileNode(Oid reltablespace, Relation pg_class, char relpersistence)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
2010-08-13 22:10:54 +02:00
|
|
|
RelFileNodeBackend rnode;
|
2005-08-12 03:36:05 +02:00
|
|
|
char *rpath;
|
|
|
|
int fd;
|
|
|
|
bool collides;
|
2010-12-13 18:34:26 +01:00
|
|
|
BackendId backend;
|
|
|
|
|
|
|
|
switch (relpersistence)
|
|
|
|
{
|
|
|
|
case RELPERSISTENCE_TEMP:
|
|
|
|
backend = MyBackendId;
|
|
|
|
break;
|
2010-12-29 12:48:53 +01:00
|
|
|
case RELPERSISTENCE_UNLOGGED:
|
2010-12-13 18:34:26 +01:00
|
|
|
case RELPERSISTENCE_PERMANENT:
|
|
|
|
backend = InvalidBackendId;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
elog(ERROR, "invalid relpersistence: %c", relpersistence);
|
|
|
|
return InvalidOid; /* placate compiler */
|
|
|
|
}
|
2005-08-12 03:36:05 +02:00
|
|
|
|
2010-02-07 21:48:13 +01:00
|
|
|
/* This logic should match RelationInitPhysicalAddr */
|
2010-08-13 22:10:54 +02:00
|
|
|
rnode.node.spcNode = reltablespace ? reltablespace : MyDatabaseTableSpace;
|
|
|
|
rnode.node.dbNode = (rnode.node.spcNode == GLOBALTABLESPACE_OID) ? InvalidOid : MyDatabaseId;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The relpath will vary based on the backend ID, so we must initialize
|
|
|
|
* that properly here to make sure that any collisions based on filename
|
|
|
|
* are properly detected.
|
|
|
|
*/
|
|
|
|
rnode.backend = backend;
|
2005-08-12 03:36:05 +02:00
|
|
|
|
|
|
|
do
|
|
|
|
{
|
2008-02-20 18:44:09 +01:00
|
|
|
CHECK_FOR_INTERRUPTS();
|
|
|
|
|
2005-08-12 03:36:05 +02:00
|
|
|
/* Generate the OID */
|
|
|
|
if (pg_class)
|
2010-08-13 22:10:54 +02:00
|
|
|
rnode.node.relNode = GetNewOid(pg_class);
|
2005-08-12 03:36:05 +02:00
|
|
|
else
|
2010-08-13 22:10:54 +02:00
|
|
|
rnode.node.relNode = GetNewObjectId();
|
2005-08-12 03:36:05 +02:00
|
|
|
|
|
|
|
/* Check for existing file of same name */
|
2008-08-11 13:05:11 +02:00
|
|
|
rpath = relpath(rnode, MAIN_FORKNUM);
|
2005-08-12 03:36:05 +02:00
|
|
|
fd = BasicOpenFile(rpath, O_RDONLY | PG_BINARY, 0);
|
|
|
|
|
|
|
|
if (fd >= 0)
|
|
|
|
{
|
|
|
|
/* definite collision */
|
|
|
|
close(fd);
|
|
|
|
collides = true;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Here we have a little bit of a dilemma: if errno is something
|
2005-10-15 04:49:52 +02:00
|
|
|
* other than ENOENT, should we declare a collision and loop? In
|
|
|
|
* particular one might think this advisable for, say, EPERM.
|
2005-08-12 03:36:05 +02:00
|
|
|
* However there really shouldn't be any unreadable files in a
|
|
|
|
* tablespace directory, and if the EPERM is actually complaining
|
|
|
|
* that we can't read the directory itself, we'd be in an infinite
|
|
|
|
* loop. In practice it seems best to go ahead regardless of the
|
2005-10-15 04:49:52 +02:00
|
|
|
* errno. If there is a colliding file we will get an smgr
|
|
|
|
* failure when we attempt to create the new relation file.
|
2005-08-12 03:36:05 +02:00
|
|
|
*/
|
|
|
|
collides = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
pfree(rpath);
|
|
|
|
} while (collides);
|
|
|
|
|
2010-08-13 22:10:54 +02:00
|
|
|
return rnode.node.relNode;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|