Back out LOCKTAG changes by Rod Taylor, pending code review. Sorry.

src/backend/commands/typecmds.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/commands/typecmds.c,v 1.31 2003/02/19 04:02:53 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/commands/typecmds.c,v 1.32 2003/02/19 23:41:15 momjian Exp $
  *
  * DESCRIPTION
  *	  The "DefineFoo" routines take the parse tree and pick out the
@@ -353,12 +353,6 @@ RemoveType(List *names, DropBehavior behavior)
 		elog(ERROR, "Type \"%s\" does not exist",
 			 TypeNameToString(typename));
 
-	/*
-	 * Grab an exclusive lock on the type id, the SearchSysCache confirms
-	 * the type still exists after locking
-	 */
-	LockObject(typeoid, RelOid_pg_type, AccessExclusiveLock);
-
 	tup = SearchSysCache(TYPEOID,
 						 ObjectIdGetDatum(typeoid),
 						 0, 0, 0);
@@ -382,9 +376,6 @@ RemoveType(List *names, DropBehavior behavior)
 	object.objectSubId = 0;
 
 	performDeletion(&object, behavior);
-
-	/* Hold the lock until the end of the transaction */
-	UnlockObject(typeoid, RelOid_pg_type, NoLock);
 }
 
 
@@ -689,7 +680,7 @@ void
 RemoveDomain(List *names, DropBehavior behavior)
 {
 	TypeName   *typename;
-	Oid			domainoid;
+	Oid			typeoid;
 	HeapTuple	tup;
 	char		typtype;
 	ObjectAddress object;
@@ -701,26 +692,20 @@ RemoveDomain(List *names, DropBehavior behavior)
 	typename->arrayBounds = NIL;
 
 	/* Use LookupTypeName here so that shell types can be removed. */
-	domainoid = LookupTypeName(typename);
-	if (!OidIsValid(domainoid))
+	typeoid = LookupTypeName(typename);
+	if (!OidIsValid(typeoid))
 		elog(ERROR, "Type \"%s\" does not exist",
 			 TypeNameToString(typename));
 
-	/*
-	 * Lock the domain.  The SearchSysCache confirms the domain still exists
-	 * after locking
-	 */
-	LockObject(domainoid, RelOid_pg_type, AccessExclusiveLock);
-
 	tup = SearchSysCache(TYPEOID,
-						 ObjectIdGetDatum(domainoid),
+						 ObjectIdGetDatum(typeoid),
 						 0, 0, 0);
 	if (!HeapTupleIsValid(tup))
 		elog(ERROR, "RemoveDomain: type \"%s\" does not exist",
 			 TypeNameToString(typename));
 
 	/* Permission check: must own type or its namespace */
-	if (!pg_type_ownercheck(domainoid, GetUserId()) &&
+	if (!pg_type_ownercheck(typeoid, GetUserId()) &&
 		!pg_namespace_ownercheck(((Form_pg_type) GETSTRUCT(tup))->typnamespace,
 								 GetUserId()))
 		aclcheck_error(ACLCHECK_NOT_OWNER, TypeNameToString(typename));
@@ -738,13 +723,10 @@ RemoveDomain(List *names, DropBehavior behavior)
 	 * Do the deletion
 	 */
 	object.classId = RelOid_pg_type;
-	object.objectId = domainoid;
+	object.objectId = typeoid;
 	object.objectSubId = 0;
 
 	performDeletion(&object, behavior);
-
-	/* Hold the lock until the end of the transaction */
-	UnlockObject(domainoid, RelOid_pg_type, NoLock);
 }
 
 
@@ -959,12 +941,6 @@ AlterDomainDefault(List *names, Node *defaultRaw)
 		elog(ERROR, "Type \"%s\" does not exist",
 			 TypeNameToString(typename));
 
-	/*
-	 * Lock the domain.  The SearchSysCacheCopy confirms the type
-	 * still exists after locking
-	 */
-	LockObject(domainoid, RelOid_pg_type, AccessExclusiveLock);
-
 	tup = SearchSysCacheCopy(TYPEOID,
 							 ObjectIdGetDatum(domainoid),
 							 0, 0, 0);
@@ -1049,7 +1025,6 @@ AlterDomainDefault(List *names, Node *defaultRaw)
 	/* Clean up */
 	heap_close(rel, NoLock);
 	heap_freetuple(newtuple);
-	UnlockObject(domainoid, RelOid_pg_type, NoLock);
 };
 
 /*
@@ -1081,12 +1056,6 @@ AlterDomainNotNull(List *names, bool notNull)
 		elog(ERROR, "Type \"%s\" does not exist",
 			 TypeNameToString(typename));
 
-	/*
-	 * Lock the domain.  The SearchSysCacheCopy confirms the domain
-	 * still exists after locking
-	 */
-	LockObject(domainoid, RelOid_pg_type, AccessExclusiveLock);
-
 	tup = SearchSysCacheCopy(TYPEOID,
 							 ObjectIdGetDatum(domainoid),
 							 0, 0, 0);
@@ -1168,7 +1137,6 @@ AlterDomainNotNull(List *names, bool notNull)
 	/* Clean up */
 	heap_freetuple(tup);
 	heap_close(typrel, RowExclusiveLock);
-	UnlockObject(domainoid, RelOid_pg_type, NoLock);
 }
 
 /*
@@ -1204,12 +1172,6 @@ AlterDomainDropConstraint(List *names, const char *constrName, DropBehavior beha
 		elog(ERROR, "Type \"%s\" does not exist",
 			 TypeNameToString(typename));
 
-	/*
-	 * Lock the domain.  The SearchSysCacheCopy confirms the type still
-	 * exists after locking.
-	 */
-	LockObject(domainoid, RelOid_pg_type, AccessExclusiveLock);
-
 	tup = SearchSysCacheCopy(TYPEOID,
 							 ObjectIdGetDatum(domainoid),
 							 0, 0, 0);
@@ -1257,7 +1219,6 @@ AlterDomainDropConstraint(List *names, const char *constrName, DropBehavior beha
 	heap_close(conrel, RowExclusiveLock);
 
 	heap_close(rel, NoLock);
-	UnlockObject(domainoid, RelOid_pg_type, NoLock);
 };
 
 /*
@@ -1298,12 +1259,6 @@ AlterDomainAddConstraint(List *names, Node *newConstraint)
 		elog(ERROR, "Type \"%s\" does not exist",
 			 TypeNameToString(typename));
 
-	/*
-	 * Lock the domain.  The SearchSysCacheCopy confirms the domain
-	 * still exists after locking.
-	 */
-	LockObject(domainoid, RelOid_pg_type, AccessExclusiveLock);
-
 	tup = SearchSysCacheCopy(TYPEOID,
 							 ObjectIdGetDatum(domainoid),
 							 0, 0, 0);
@@ -1438,7 +1393,6 @@ AlterDomainAddConstraint(List *names, Node *newConstraint)
 
 	/* Clean up */
 	heap_close(typrel, RowExclusiveLock);
-	UnlockObject(domainoid, RelOid_pg_type, NoLock);
 }
 
 /*
@@ -1742,10 +1696,7 @@ GetDomainConstraints(Oid typeOid)
 		Form_pg_type typTup;
 		ScanKeyData key[1];
 		SysScanDesc scan;
-
-		/* Lock the domain */
-		LockObject(typeOid, RelOid_pg_type, AccessShareLock);
-
+		
 		tup = SearchSysCache(TYPEOID,
 							 ObjectIdGetDatum(typeOid),
 							 0, 0, 0);
@@ -1873,12 +1824,6 @@ AlterTypeOwner(List *names, AclId newOwnerSysId)
 		elog(ERROR, "Type \"%s\" does not exist",
 			 TypeNameToString(typename));
 
-	/*
-	 * Lock the type.  The SearchSysCacheCopy serves to confirm the
-	 * domain still exists after locking
-	 */
-	LockObject(typeOid, RelOid_pg_type, AccessExclusiveLock);
-
 	tup = SearchSysCacheCopy(TYPEOID,
 							 ObjectIdGetDatum(typeOid),
 							 0, 0, 0);
@@ -1901,5 +1846,4 @@ AlterTypeOwner(List *names, AclId newOwnerSysId)
 
 	/* Clean up */
 	heap_close(rel, RowExclusiveLock);
-	UnlockObject(typeOid, RelOid_pg_type, NoLock);
 }

src/backend/parser/parse_type.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_type.c,v 1.52 2003/02/19 04:02:53 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_type.c,v 1.53 2003/02/19 23:41:15 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -23,7 +23,6 @@
 #include "parser/parser.h"
 #include "parser/parse_expr.h"
 #include "parser/parse_type.h"
-#include "storage/lmgr.h"
 #include "utils/builtins.h"
 #include "utils/lsyscache.h"
 #include "utils/syscache.h"
@@ -128,15 +127,6 @@ LookupTypeName(const TypeName *typename)
 		}
 	}
 
-	/*
-	 * Lock the type as having been read for remainder of the transaction
-	 *
-	 * XXX: There is a small time between the above and now when the type
-	 *		could dissapear.  We *should* recheck to confirm the type still
-	 *		exists, but won't for speed.
-	 */
-	LockObject(restype, RelOid_pg_type, AccessShareLock);
-
 	return restype;
 }
 

src/backend/storage/lmgr/deadlock.c

@@ -12,7 +12,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/storage/lmgr/deadlock.c,v 1.18 2003/02/19 04:02:53 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/storage/lmgr/deadlock.c,v 1.19 2003/02/19 23:41:15 momjian Exp $
  *
  *	Interface:
  *
@@ -855,25 +855,22 @@ DeadLockReport(void)
 		else
 			nextpid = deadlockDetails[0].pid;
 
-		if (info->locktag.objId == InvalidOid
-			&& info->locktag.classId == XactLockTableId
-			&& info->locktag.dbId == InvalidOid)
+		if (info->locktag.relId == XactLockTableId && info->locktag.dbId == 0)
 		{
 			/* Lock is for transaction ID */
 			elog(NOTICE, "Proc %d waits for %s on transaction %u; blocked by %d",
 				 info->pid,
 				 GetLockmodeName(info->lockmode),
-				 info->locktag.objsubId.xid,
+				 info->locktag.objId.xid,
 				 nextpid);
 		}
 		else
 		{
 			/* Lock is for a relation */
-			elog(NOTICE, "Proc %d waits for %s on object %u class %u database %u; blocked by %d",
+			elog(NOTICE, "Proc %d waits for %s on relation %u database %u; blocked by %d",
 				 info->pid,
 				 GetLockmodeName(info->lockmode),
-				 info->locktag.objId,
-				 info->locktag.classId,
+				 info->locktag.relId,
 				 info->locktag.dbId,
 				 nextpid);
 		}

src/backend/storage/lmgr/lmgr.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lmgr.c,v 1.55 2003/02/19 04:02:53 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lmgr.c,v 1.56 2003/02/19 23:41:15 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -126,10 +126,9 @@ LockRelation(Relation relation, LOCKMODE lockmode)
 	LOCKTAG		tag;
 
 	MemSet(&tag, 0, sizeof(tag));
-	tag.objId = relation->rd_lockInfo.lockRelId.relId;
-	tag.classId = RelOid_pg_class;
+	tag.relId = relation->rd_lockInfo.lockRelId.relId;
 	tag.dbId = relation->rd_lockInfo.lockRelId.dbId;
-	tag.objsubId.blkno = InvalidBlockNumber;
+	tag.objId.blkno = InvalidBlockNumber;
 
 	if (!LockAcquire(LockTableId, &tag, GetCurrentTransactionId(),
 					 lockmode, false))
@@ -161,10 +160,9 @@ ConditionalLockRelation(Relation relation, LOCKMODE lockmode)
 	LOCKTAG		tag;
 
 	MemSet(&tag, 0, sizeof(tag));
-	tag.objId = relation->rd_lockInfo.lockRelId.relId;
-	tag.classId = RelOid_pg_class;
+	tag.relId = relation->rd_lockInfo.lockRelId.relId;
 	tag.dbId = relation->rd_lockInfo.lockRelId.dbId;
-	tag.objsubId.blkno = InvalidBlockNumber;
+	tag.objId.blkno = InvalidBlockNumber;
 
 	if (!LockAcquire(LockTableId, &tag, GetCurrentTransactionId(),
 					 lockmode, true))
@@ -192,10 +190,9 @@ UnlockRelation(Relation relation, LOCKMODE lockmode)
 	LOCKTAG		tag;
 
 	MemSet(&tag, 0, sizeof(tag));
-	tag.objId = relation->rd_lockInfo.lockRelId.relId;
-	tag.classId = RelOid_pg_class;
+	tag.relId = relation->rd_lockInfo.lockRelId.relId;
 	tag.dbId = relation->rd_lockInfo.lockRelId.dbId;
-	tag.objsubId.blkno = InvalidBlockNumber;
+	tag.objId.blkno = InvalidBlockNumber;
 
 	LockRelease(LockTableId, &tag, GetCurrentTransactionId(), lockmode);
 }
@@ -218,10 +215,9 @@ LockRelationForSession(LockRelId *relid, LOCKMODE lockmode)
 	LOCKTAG		tag;
 
 	MemSet(&tag, 0, sizeof(tag));
-	tag.objId = relid->relId;
-	tag.classId = RelOid_pg_class;
+	tag.relId = relid->relId;
 	tag.dbId = relid->dbId;
-	tag.objsubId.blkno = InvalidBlockNumber;
+	tag.objId.blkno = InvalidBlockNumber;
 
 	if (!LockAcquire(LockTableId, &tag, InvalidTransactionId,
 					 lockmode, false))
@@ -237,10 +233,9 @@ UnlockRelationForSession(LockRelId *relid, LOCKMODE lockmode)
 	LOCKTAG		tag;
 
 	MemSet(&tag, 0, sizeof(tag));
-	tag.objId = relid->relId;
-	tag.classId = RelOid_pg_class;
+	tag.relId = relid->relId;
 	tag.dbId = relid->dbId;
-	tag.objsubId.blkno = InvalidBlockNumber;
+	tag.objId.blkno = InvalidBlockNumber;
 
 	LockRelease(LockTableId, &tag, InvalidTransactionId, lockmode);
 }
@@ -258,10 +253,9 @@ LockPage(Relation relation, BlockNumber blkno, LOCKMODE lockmode)
 	LOCKTAG		tag;
 
 	MemSet(&tag, 0, sizeof(tag));
-	tag.objId = relation->rd_lockInfo.lockRelId.relId;
-	tag.classId = RelOid_pg_class;
+	tag.relId = relation->rd_lockInfo.lockRelId.relId;
 	tag.dbId = relation->rd_lockInfo.lockRelId.dbId;
-	tag.objsubId.blkno = blkno;
+	tag.objId.blkno = blkno;
 
 	if (!LockAcquire(LockTableId, &tag, GetCurrentTransactionId(),
 					 lockmode, false))
@@ -277,10 +271,9 @@ UnlockPage(Relation relation, BlockNumber blkno, LOCKMODE lockmode)
 	LOCKTAG		tag;
 
 	MemSet(&tag, 0, sizeof(tag));
-	tag.objId = relation->rd_lockInfo.lockRelId.relId;
-	tag.classId = RelOid_pg_class;
+	tag.relId = relation->rd_lockInfo.lockRelId.relId;
 	tag.dbId = relation->rd_lockInfo.lockRelId.dbId;
-	tag.objsubId.blkno = blkno;
+	tag.objId.blkno = blkno;
 
 	LockRelease(LockTableId, &tag, GetCurrentTransactionId(), lockmode);
 }
@@ -301,10 +294,9 @@ XactLockTableInsert(TransactionId xid)
 	LOCKTAG		tag;
 
 	MemSet(&tag, 0, sizeof(tag));
-	tag.objId = InvalidOid;
-	tag.classId = XactLockTableId;
+	tag.relId = XactLockTableId;
 	tag.dbId = InvalidOid;		/* xids are globally unique */
-	tag.objsubId.xid = xid;
+	tag.objId.xid = xid;
 
 	if (!LockAcquire(LockTableId, &tag, xid,
 					 ExclusiveLock, false))
@@ -325,10 +317,9 @@ XactLockTableWait(TransactionId xid)
 	Assert(!TransactionIdEquals(xid, myxid));
 
 	MemSet(&tag, 0, sizeof(tag));
-	tag.objId = InvalidOid;
-	tag.classId = XactLockTableId;
+	tag.relId = XactLockTableId;
 	tag.dbId = InvalidOid;
-	tag.objsubId.xid = xid;
+	tag.objId.xid = xid;
 
 	if (!LockAcquire(LockTableId, &tag, myxid,
 					 ShareLock, false))
@@ -343,59 +334,3 @@ XactLockTableWait(TransactionId xid)
 	if (!TransactionIdDidCommit(xid) && !TransactionIdDidAbort(xid))
 		TransactionIdAbort(xid);
 }
-
-/*
- * LockObject
- *
- * Lock an arbitrary database object.  A standard relation lock would lock the
- * classId of RelOid_pg_class and objId of the relations OID within the pg_class
- * table.  LockObject allows classId to be specified by the caller, thus allowing
- * locks on any row in any system table.
- *
- * If classId is NOT a system table (protected from removal), an additional lock
- * should be held on the relation to prevent it from being dropped.
- */
-void
-LockObject(Oid objId, Oid classId, LOCKMODE lockmode)
-{
-	LOCKTAG		tag;
-
-	MemSet(&tag, 0, sizeof(tag));
-	tag.objId = objId;
-	tag.classId = classId;
-	tag.dbId = MyDatabaseId;
-	tag.objsubId.blkno = InvalidBlockNumber;
-
-	/* Only two reasonable lock types */
-	Assert(lockmode == AccessShareLock || lockmode == AccessExclusiveLock);
-
-	if (!LockAcquire(LockTableId, &tag, GetCurrentTransactionId(),
-					 lockmode, false))
-		elog(ERROR, "LockObject: LockAcquire failed");
-}
-
-/*
- * UnlockObject
- */
-void
-UnlockObject(Oid objId, Oid classId, LOCKMODE lockmode)
-{
-	LOCKTAG		tag;
-
-	/* NoLock is a no-op */
-	if (lockmode == NoLock)
-		return;
-
-	MemSet(&tag, 0, sizeof(tag));
-	tag.objId = objId;
-	tag.classId = classId;
-	tag.dbId = MyDatabaseId;
-	tag.objsubId.blkno = InvalidBlockNumber;
-
-	/* Only two reasonable lock types */
-	Assert(lockmode == AccessShareLock
-		  || lockmode == AccessExclusiveLock);
-
-	LockRelease(LockTableId, &tag, GetCurrentTransactionId(), lockmode);
-}
-

src/backend/storage/lmgr/lock.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lock.c,v 1.121 2003/02/19 04:02:53 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lock.c,v 1.122 2003/02/19 23:41:15 momjian Exp $
  *
  * NOTES
  *	  Outside modules can create a lock table and acquire/release
@@ -97,8 +97,8 @@ LOCK_DEBUG_ENABLED(const LOCK *lock)
 	return
 		(((LOCK_LOCKMETHOD(*lock) == DEFAULT_LOCKMETHOD && Trace_locks)
 	   || (LOCK_LOCKMETHOD(*lock) == USER_LOCKMETHOD && Trace_userlocks))
-		 && (lock->tag.objId >= (Oid) Trace_lock_oidmin))
-		|| (Trace_lock_table && (lock->tag.objId == Trace_lock_table));
+		 && (lock->tag.relId >= (Oid) Trace_lock_oidmin))
+		|| (Trace_lock_table && (lock->tag.relId == Trace_lock_table));
 }
 
 
@@ -107,12 +107,12 @@ LOCK_PRINT(const char *where, const LOCK *lock, LOCKMODE type)
 {
 	if (LOCK_DEBUG_ENABLED(lock))
 		elog(LOG,
-			 "%s: lock(%lx) tbl(%d) obj(%u) class(%u) db(%u) objsub(%u) grantMask(%x) "
+			 "%s: lock(%lx) tbl(%d) rel(%u) db(%u) obj(%u) grantMask(%x) "
 			 "req(%d,%d,%d,%d,%d,%d,%d)=%d "
 			 "grant(%d,%d,%d,%d,%d,%d,%d)=%d wait(%d) type(%s)",
 			 where, MAKE_OFFSET(lock),
-			 lock->tag.lockmethod, lock->tag.objId, lock->tag.classId, lock->tag.dbId,
-			 lock->tag.objsubId.blkno, lock->grantMask,
+			 lock->tag.lockmethod, lock->tag.relId, lock->tag.dbId,
+			 lock->tag.objId.blkno, lock->grantMask,
 			 lock->requested[1], lock->requested[2], lock->requested[3],
 			 lock->requested[4], lock->requested[5], lock->requested[6],
 			 lock->requested[7], lock->nRequested,
@@ -129,16 +129,16 @@ PROCLOCK_PRINT(const char *where, const PROCLOCK *proclockP)
 	if (
 	(((PROCLOCK_LOCKMETHOD(*proclockP) == DEFAULT_LOCKMETHOD && Trace_locks)
 	  || (PROCLOCK_LOCKMETHOD(*proclockP) == USER_LOCKMETHOD && Trace_userlocks))
-	 && (((LOCK *) MAKE_PTR(proclockP->tag.lock))->tag.objId >= (Oid) Trace_lock_oidmin))
-		|| (Trace_lock_table && (((LOCK *) MAKE_PTR(proclockP->tag.lock))->tag.objId == Trace_lock_table))
+	 && (((LOCK *) MAKE_PTR(proclockP->tag.lock))->tag.relId >= (Oid) Trace_lock_oidmin))
+		|| (Trace_lock_table && (((LOCK *) MAKE_PTR(proclockP->tag.lock))->tag.relId == Trace_lock_table))
 		)
 		elog(LOG,
 			 "%s: proclock(%lx) lock(%lx) tbl(%d) proc(%lx) xid(%u) hold(%d,%d,%d,%d,%d,%d,%d)=%d",
 			 where, MAKE_OFFSET(proclockP), proclockP->tag.lock,
 			 PROCLOCK_LOCKMETHOD(*(proclockP)),
 			 proclockP->tag.proc, proclockP->tag.xid,
-			 proclockP->holding[1], proclockP->holding[2], proclockP->holding[3],
-			 proclockP->holding[4], proclockP->holding[5], proclockP->holding[6],
+		   proclockP->holding[1], proclockP->holding[2], proclockP->holding[3],
+		   proclockP->holding[4], proclockP->holding[5], proclockP->holding[6],
 			 proclockP->holding[7], proclockP->nHolding);
 }
 
@@ -417,9 +417,8 @@ LockMethodTableRename(LOCKMETHOD lockmethod)
  *
  *		lockmethod						1				2
  *		tag.dbId						database oid	database oid
- *		tag.classId						class oid		0
- *		tag.objId						rel oid or 0	0
- *		tag.objsubId					block id		lock id2
+ *		tag.relId						rel oid or 0	0
+ *		tag.objId						block id		lock id2
  *										or xact id
  *		tag.offnum						0				lock id1
  *		proclock.xid					xid or 0		0
@@ -450,7 +449,7 @@ LockAcquire(LOCKMETHOD lockmethod, LOCKTAG *locktag,
 #ifdef LOCK_DEBUG
 	if (lockmethod == USER_LOCKMETHOD && Trace_userlocks)
 		elog(LOG, "LockAcquire: user lock [%u] %s",
-			 locktag->objsubId.blkno, lock_mode_names[lockmode]);
+			 locktag->objId.blkno, lock_mode_names[lockmode]);
 #endif
 
 	/* ???????? This must be changed when short term locks will be used */
@@ -573,7 +572,7 @@ LockAcquire(LOCKMETHOD lockmethod, LOCKTAG *locktag,
 				elog(LOG, "Deadlock risk: raising lock level"
 					 " from %s to %s on object %u/%u/%u",
 					 lock_mode_names[i], lock_mode_names[lockmode],
-				 lock->tag.objId, lock->tag.dbId, lock->tag.objsubId.blkno);
+				 lock->tag.relId, lock->tag.dbId, lock->tag.objId.blkno);
 				break;
 			}
 		}
@@ -994,7 +993,7 @@ LockRelease(LOCKMETHOD lockmethod, LOCKTAG *locktag,
 
 #ifdef LOCK_DEBUG
 	if (lockmethod == USER_LOCKMETHOD && Trace_userlocks)
-		elog(LOG, "LockRelease: user lock tag [%u] %d", locktag->objsubId.blkno, lockmode);
+		elog(LOG, "LockRelease: user lock tag [%u] %d", locktag->objId.blkno, lockmode);
 #endif
 
 	/* ???????? This must be changed when short term locks will be used */

src/backend/utils/adt/lockfuncs.c

@@ -6,7 +6,7 @@
  * Copyright (c) 2002, PostgreSQL Global Development Group
  *
  * IDENTIFICATION
- *		$Header: /cvsroot/pgsql/src/backend/utils/adt/lockfuncs.c,v 1.9 2003/02/19 04:02:54 momjian Exp $
+ *		$Header: /cvsroot/pgsql/src/backend/utils/adt/lockfuncs.c,v 1.10 2003/02/19 23:41:15 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -53,20 +53,18 @@ pg_lock_status(PG_FUNCTION_ARGS)
 
 		/* build tupdesc for result tuples */
 		/* this had better match pg_locks view in initdb.sh */
-		tupdesc = CreateTemplateTupleDesc(7, false);
-		TupleDescInitEntry(tupdesc, (AttrNumber) 1, "object",
+		tupdesc = CreateTemplateTupleDesc(6, false);
+		TupleDescInitEntry(tupdesc, (AttrNumber) 1, "relation",
 						   OIDOID, -1, 0, false);
-		TupleDescInitEntry(tupdesc, (AttrNumber) 2, "class",
+		TupleDescInitEntry(tupdesc, (AttrNumber) 2, "database",
 						   OIDOID, -1, 0, false);
-		TupleDescInitEntry(tupdesc, (AttrNumber) 3, "database",
-						   OIDOID, -1, 0, false);
-		TupleDescInitEntry(tupdesc, (AttrNumber) 4, "transaction",
+		TupleDescInitEntry(tupdesc, (AttrNumber) 3, "transaction",
 						   XIDOID, -1, 0, false);
-		TupleDescInitEntry(tupdesc, (AttrNumber) 5, "pid",
+		TupleDescInitEntry(tupdesc, (AttrNumber) 4, "pid",
 						   INT4OID, -1, 0, false);
-		TupleDescInitEntry(tupdesc, (AttrNumber) 6, "mode",
+		TupleDescInitEntry(tupdesc, (AttrNumber) 5, "mode",
 						   TEXTOID, -1, 0, false);
-		TupleDescInitEntry(tupdesc, (AttrNumber) 7, "granted",
+		TupleDescInitEntry(tupdesc, (AttrNumber) 6, "granted",
 						   BOOLOID, -1, 0, false);
 
 		funcctx->slot = TupleDescGetSlot(tupdesc);
@@ -95,8 +93,8 @@ pg_lock_status(PG_FUNCTION_ARGS)
 		PGPROC	   *proc;
 		bool		granted;
 		LOCKMODE	mode;
-		Datum		values[7];
-		char		nulls[7];
+		Datum		values[6];
+		char		nulls[6];
 		HeapTuple	tuple;
 		Datum		result;
 
@@ -154,30 +152,26 @@ pg_lock_status(PG_FUNCTION_ARGS)
 		MemSet(values, 0, sizeof(values));
 		MemSet(nulls, ' ', sizeof(nulls));
 
-		if (lock->tag.objId == InvalidOid
-			&& lock->tag.classId == XactLockTableId
-			&& lock->tag.dbId == InvalidOid)
+		if (lock->tag.relId == XactLockTableId && lock->tag.dbId == 0)
 		{
 			/* Lock is for transaction ID */
 			nulls[0] = 'n';
 			nulls[1] = 'n';
-			nulls[2] = 'n';
-			values[3] = TransactionIdGetDatum(lock->tag.objsubId.xid);
+			values[2] = TransactionIdGetDatum(lock->tag.objId.xid);
 		}
 		else
 		{
 			/* Lock is for a relation */
-			values[0] = ObjectIdGetDatum(lock->tag.objId);
-			values[1] = ObjectIdGetDatum(lock->tag.classId);
-			values[2] = ObjectIdGetDatum(lock->tag.dbId);
-			nulls[3] = 'n';
+			values[0] = ObjectIdGetDatum(lock->tag.relId);
+			values[1] = ObjectIdGetDatum(lock->tag.dbId);
+			nulls[2] = 'n';
 
 		}
 
-		values[4] = Int32GetDatum(proc->pid);
-		values[5] = DirectFunctionCall1(textin,
+		values[3] = Int32GetDatum(proc->pid);
+		values[4] = DirectFunctionCall1(textin,
 								 CStringGetDatum(GetLockmodeName(mode)));
-		values[6] = BoolGetDatum(granted);
+		values[5] = BoolGetDatum(granted);
 
 		tuple = heap_formtuple(funcctx->slot->ttc_tupleDescriptor,
 							   values, nulls);

src/bin/initdb/initdb.sh

@@ -27,7 +27,7 @@
 # Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
 # Portions Copyright (c) 1994, Regents of the University of California
 #
-# $Header: /cvsroot/pgsql/src/bin/initdb/Attic/initdb.sh,v 1.183 2003/02/19 04:02:54 momjian Exp $
+# $Header: /cvsroot/pgsql/src/bin/initdb/Attic/initdb.sh,v 1.184 2003/02/19 23:41:15 momjian Exp $
 #
 #-------------------------------------------------------------------------
 
@@ -974,7 +974,7 @@ CREATE VIEW pg_stat_database AS \
 
 CREATE VIEW pg_locks AS \
     SELECT * \
-    FROM pg_lock_status() AS L(object oid, class oid, database oid, \
+    FROM pg_lock_status() AS L(relation oid, database oid, \
 	transaction xid, pid int4, mode text, granted boolean);
 
 CREATE VIEW pg_settings AS \

src/include/storage/lmgr.h

@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: lmgr.h,v 1.37 2003/02/19 04:02:54 momjian Exp $
+ * $Id: lmgr.h,v 1.38 2003/02/19 23:41:15 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -62,8 +62,4 @@ extern void UnlockPage(Relation relation, BlockNumber blkno, LOCKMODE lockmode);
 extern void XactLockTableInsert(TransactionId xid);
 extern void XactLockTableWait(TransactionId xid);
 
-/* Lock an arbitrary database object in the current database */
-extern void LockObject(Oid objId, Oid classId, LOCKMODE lockmode);
-extern void UnlockObject(Oid objId, Oid classId, LOCKMODE lockmode);
-
 #endif   /* LMGR_H */

src/include/storage/lock.h

@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: lock.h,v 1.70 2003/02/19 04:02:54 momjian Exp $
+ * $Id: lock.h,v 1.71 2003/02/19 23:41:15 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -100,14 +100,13 @@ typedef struct LOCKMETHODTABLE
  */
 typedef struct LOCKTAG
 {
-	Oid			objId;
-	Oid			classId;
+	Oid			relId;
 	Oid			dbId;
 	union
 	{
 		BlockNumber blkno;
 		TransactionId xid;
-	}			objsubId;
+	}			objId;
 
 	/*
 	 * offnum should be part of objId.tupleId above, but would increase

src/test/regress/expected/rules.out

@@ -1271,7 +1271,7 @@ SELECT viewname, definition FROM pg_views WHERE schemaname <> 'information_schem
 --------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  iexit                    | SELECT ih.name, ih.thepath, interpt_pp(ih.thepath, r.thepath) AS exit FROM ihighway ih, ramp r WHERE (ih.thepath ## r.thepath);
  pg_indexes               | SELECT n.nspname AS schemaname, c.relname AS tablename, i.relname AS indexname, pg_get_indexdef(i.oid) AS indexdef FROM (((pg_index x JOIN pg_class c ON ((c.oid = x.indrelid))) JOIN pg_class i ON ((i.oid = x.indexrelid))) LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace))) WHERE ((c.relkind = 'r'::"char") AND (i.relkind = 'i'::"char"));
- pg_locks                 | SELECT l.object, l."class", l."database", l."transaction", l.pid, l."mode", l.granted FROM pg_lock_status() l(object oid, "class" oid, "database" oid, "transaction" xid, pid integer, "mode" text, granted boolean);
+ pg_locks                 | SELECT l.relation, l."database", l."transaction", l.pid, l."mode", l.granted FROM pg_lock_status() l(relation oid, "database" oid, "transaction" xid, pid integer, "mode" text, granted boolean);
  pg_rules                 | SELECT n.nspname AS schemaname, c.relname AS tablename, r.rulename, pg_get_ruledef(r.oid) AS definition FROM ((pg_rewrite r JOIN pg_class c ON ((c.oid = r.ev_class))) LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace))) WHERE (r.rulename <> '_RETURN'::name);
  pg_settings              | SELECT a.name, a.setting FROM pg_show_all_settings() a(name text, setting text);
  pg_stat_activity         | SELECT d.oid AS datid, d.datname, pg_stat_get_backend_pid(s.backendid) AS procpid, pg_stat_get_backend_userid(s.backendid) AS usesysid, u.usename, pg_stat_get_backend_activity(s.backendid) AS current_query FROM pg_database d, (SELECT pg_stat_get_backend_idset() AS backendid) s, pg_shadow u WHERE ((pg_stat_get_backend_dbid(s.backendid) = d.oid) AND (pg_stat_get_backend_userid(s.backendid) = u.usesysid));