New code for locking buffer' context.
Buffer buffer = InvalidBuffer;
bool *compvec;
- /* GiSTs only know how to do stupid locking now */
- RelationSetLockForWrite(index);
+ /* no locking is needed */
setheapoverride(true); /* so we can see the new pg_index tuple */
initGISTstate(&giststate, index);
/* okay, all heap tuples are indexed */
heap_endscan(scan);
- RelationUnsetLockForWrite(index);
if (pred != NULL || oldPred != NULL)
{
itup = index_formtuple(RelationGetDescr(r), datum, nulls);
itup->t_tid = *ht_ctid;
+ /*
+ * Notes in ExecUtils:ExecOpenIndices()
+ *
RelationSetLockForWrite(r);
+ */
+
res = gistdoinsert(r, itup, &giststate);
for (i = 0; i < r->rd_att->natts; i++)
if (compvec[i] == TRUE)
pfree(itup);
pfree(compvec);
- /* XXX two-phase locking -- don't unlock the relation until EOT */
return res;
}
Buffer buf;
Page page;
- /* must write-lock on delete */
+ /*
+ * Notes in ExecUtils:ExecOpenIndices()
+ * Also note that only vacuum deletes index tuples now...
+ *
RelationSetLockForWrite(r);
+ */
blkno = ItemPointerGetBlockNumber(tid);
offnum = ItemPointerGetOffsetNumber(tid);
WriteBuffer(buf);
- /* XXX -- two-phase locking, don't release the write lock */
}
void
{
IndexScanDesc s;
+ /*
+ * Let index_beginscan does its work...
+ *
RelationSetLockForRead(r);
+ */
+
s = RelationGetIndexScan(r, fromEnd, nkeys, key);
gistregscan(s);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/hash/hashpage.c,v 1.17 1998/09/01 03:20:58 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/hash/hashpage.c,v 1.18 1998/12/15 12:45:10 vadim Exp $
*
* NOTES
* Postgres hash pages look like ordinary relation pages. The opaque
/* can't be sharing this with anyone, now... */
if (USELOCKING)
- RelationSetLockForWrite(rel);
+ LockRelation(rel, AccessExclusiveLock);
if ((nblocks = RelationGetNumberOfBlocks(rel)) != 0)
{
_hash_relbuf(rel, metabuf, HASH_WRITE);
if (USELOCKING)
- RelationUnsetLockForWrite(rel);
+ UnlockRelation(rel, AccessExclusiveLock);
}
/*
BlockNumber blkno,
int access)
{
- ItemPointerData iptr;
if (USELOCKING)
{
- ItemPointerSet(&iptr, blkno, 1);
-
switch (access)
{
case HASH_WRITE:
- RelationSetSingleWLockPage(rel, &iptr);
+ LockPage(rel, blkno, ExclusiveLock);
break;
case HASH_READ:
- RelationSetSingleRLockPage(rel, &iptr);
+ LockPage(rel, blkno, ShareLock);
break;
default:
elog(ERROR, "_hash_setpagelock: invalid access (%d) on blk %x: %s",
BlockNumber blkno,
int access)
{
- ItemPointerData iptr;
if (USELOCKING)
{
- ItemPointerSet(&iptr, blkno, 1);
-
switch (access)
{
case HASH_WRITE:
- RelationUnsetSingleWLockPage(rel, &iptr);
+ UnlockPage(rel, blkno, ExclusiveLock);
break;
case HASH_READ:
- RelationUnsetSingleRLockPage(rel, &iptr);
+ UnlockPage(rel, blkno, ShareLock);
break;
default:
elog(ERROR, "_hash_unsetpagelock: invalid access (%d) on blk %x: %s",
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/heap/heapam.c,v 1.38 1998/11/27 19:51:36 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/heap/heapam.c,v 1.39 1998/12/15 12:45:13 vadim Exp $
*
*
* INTERFACE ROUTINES
#include
#include
-
#ifndef HAVE_MEMMOVE
#include
#else
#include
#endif
-static void doinsert(Relation relation, HeapTuple tup);
-
/* ----------------------------------------------------------------
* heap support routines
* ----------------------------------------------------------------
heapgettup(Relation relation,
HeapTuple tuple,
int dir,
- Buffer *buf,
+ Buffer *buffer,
Snapshot snapshot,
int nkeys,
ScanKey key)
elog(DEBUG, "heapgettup(%s, tid=0x%x, dir=%d, ...)",
RelationGetRelationName(relation), tid, dir);
}
- elog(DEBUG, "heapgettup(..., b=0x%x, nkeys=%d, key=0x%x", buf, nkeys, key);
+ elog(DEBUG, "heapgettup(..., b=0x%x, nkeys=%d, key=0x%x", buffer, nkeys, key);
elog(DEBUG, "heapgettup: relation(%c)=`%s', %p",
relation->rd_rel->relkind, &relation->rd_rel->relname,
/* assume it is a valid TID XXX */
if (ItemPointerIsValid(tid) == false)
{
- *buf = InvalidBuffer;
+ *buffer = InvalidBuffer;
tuple->t_data = NULL;
return;
}
- *buf = RelationGetBufferWithBuffer(relation,
+ *buffer = RelationGetBufferWithBuffer(relation,
ItemPointerGetBlockNumber(tid),
- *buf);
+ *buffer);
-#ifndef NO_BUFFERISVALID
- if (!BufferIsValid(*buf))
+ if (!BufferIsValid(*buffer))
elog(ERROR, "heapgettup: failed ReadBuffer");
-#endif
- dp = (Page) BufferGetPage(*buf);
+ LockBuffer(*buffer, BUFFER_LOCK_SHARE);
+
+ dp = (Page) BufferGetPage(*buffer);
lineoff = ItemPointerGetOffsetNumber(tid);
lpp = PageGetItemId(dp, lineoff);
tuple->t_data = (HeapTupleHeader) PageGetItem((Page) dp, lpp);
tuple->t_len = ItemIdGetLength(lpp);
+ LockBuffer(*buffer, BUFFER_LOCK_UNLOCK);
return;
}
}
if (page < 0)
{
- *buf = InvalidBuffer;
+ *buffer = InvalidBuffer;
tuple->t_data = NULL;
return;
}
- *buf = RelationGetBufferWithBuffer(relation, page, *buf);
-#ifndef NO_BUFFERISVALID
- if (!BufferIsValid(*buf))
+ *buffer = RelationGetBufferWithBuffer(relation, page, *buffer);
+ if (!BufferIsValid(*buffer))
elog(ERROR, "heapgettup: failed ReadBuffer");
-#endif
- dp = (Page) BufferGetPage(*buf);
+ LockBuffer(*buffer, BUFFER_LOCK_SHARE);
+
+ dp = (Page) BufferGetPage(*buffer);
lines = PageGetMaxOffsetNumber(dp);
if (tid == NULL)
{
if (page >= pages)
{
- *buf = InvalidBuffer;
+ *buffer = InvalidBuffer;
tuple->t_data = NULL;
return;
}
/* page and lineoff now reference the physically next tid */
- *buf = RelationGetBufferWithBuffer(relation, page, *buf);
-#ifndef NO_BUFFERISVALID
- if (!BufferIsValid(*buf))
+ *buffer = RelationGetBufferWithBuffer(relation, page, *buffer);
+ if (!BufferIsValid(*buffer))
elog(ERROR, "heapgettup: failed ReadBuffer");
-#endif
- dp = (Page) BufferGetPage(*buf);
+ LockBuffer(*buffer, BUFFER_LOCK_SHARE);
+
+ dp = (Page) BufferGetPage(*buffer);
lines = PageGetMaxOffsetNumber(dp);
}
* if current tuple qualifies, return it.
* ----------------
*/
- HeapTupleSatisfies(tuple, relation, *buf, (PageHeader) dp,
+ HeapTupleSatisfies(tuple, relation, *buffer, (PageHeader) dp,
snapshot, nkeys, key);
if (tuple->t_data != NULL)
+ {
+ LockBuffer(*buffer, BUFFER_LOCK_UNLOCK);
return;
+ }
}
/* ----------------
* this page and it's time to move to the next..
* ----------------
*/
+ LockBuffer(*buffer, BUFFER_LOCK_UNLOCK);
page = nextpage(page, dir);
/* ----------------
*/
if (page < 0 || page >= pages)
{
- if (BufferIsValid(*buf))
- ReleaseBuffer(*buf);
- *buf = InvalidBuffer;
+ if (BufferIsValid(*buffer))
+ ReleaseBuffer(*buffer);
+ *buffer = InvalidBuffer;
tuple->t_data = NULL;
return;
}
- *buf = ReleaseAndReadBuffer(*buf, relation, page);
+ *buffer = ReleaseAndReadBuffer(*buffer, relation, page);
-#ifndef NO_BUFFERISVALID
- if (!BufferIsValid(*buf))
+ if (!BufferIsValid(*buffer))
elog(ERROR, "heapgettup: failed ReadBuffer");
-#endif
- dp = (Page) BufferGetPage(*buf);
+ LockBuffer(*buffer, BUFFER_LOCK_SHARE);
+ dp = (Page) BufferGetPage(*buffer);
lines = PageGetMaxOffsetNumber((Page) dp);
linesleft = lines - 1;
if (dir < 0)
}
}
-static void
-doinsert(Relation relation, HeapTuple tup)
-{
- RelationPutHeapTupleAtEnd(relation, tup);
- return;
-}
-
/* ----------------------------------------------------------------
* heap access method interface
if (RelationIsValid(relation) == false)
elog(ERROR, "heap_beginscan: !RelationIsValid(relation)");
- /* ----------------
- * set relation level read lock
- * ----------------
- */
- RelationSetLockForRead(relation);
+ LockRelation(relation, AccessShareLock);
/* XXX someday assert SelfTimeQual if relkind == RELKIND_UNCATALOGED */
if (relation->rd_rel->relkind == RELKIND_UNCATALOGED)
*/
RelationDecrementReferenceCount(scan->rs_rd);
- /* ----------------
- * Non 2-phase read locks on catalog relations
- * ----------------
- */
- if (IsSystemRelationName(RelationGetRelationName(scan->rs_rd)->data))
-
- RelationUnsetLockForRead(scan->rs_rd);
+ UnlockRelation(scan->rs_rd, AccessShareLock);
pfree(scan); /* XXX */
}
IncrHeapAccessStat(local_fetch);
IncrHeapAccessStat(global_fetch);
- /*
- * Note: This is collosally expensive - does two system calls per
- * indexscan tuple fetch. Not good, and since we should be doing page
- * level locking by the scanner anyway, it is commented out.
- */
-
- /* RelationSetLockForTupleRead(relation, tid); */
-
/* ----------------
* get the buffer from the relation descriptor
* Note that this does a buffer pin.
buffer = ReadBuffer(relation, ItemPointerGetBlockNumber(tid));
-#ifndef NO_BUFFERISVALID
if (!BufferIsValid(buffer))
- {
elog(ERROR, "heap_fetch: %s relation: ReadBuffer(%lx) failed",
&relation->rd_rel->relname, (long) tid);
- }
-#endif
+
+ LockBuffer(buffer, BUFFER_LOCK_SHARE);
/* ----------------
* get the item line pointer corresponding to the requested tid
HeapTupleSatisfies(tuple, relation, buffer, dp,
snapshot, 0, (ScanKey) NULL);
+ LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
+
if (tuple->t_data == NULL)
{
ReleaseBuffer(buffer);
IncrHeapAccessStat(local_insert);
IncrHeapAccessStat(global_insert);
- /* ----------------
- * set relation level write lock. If this is a "local" relation (not
- * visible to others), we don't need to set a write lock.
- * ----------------
- */
- if (!relation->rd_islocal)
- RelationSetLockForWrite(relation);
-
/* ----------------
* If the object id of this tuple has already been assigned, trust
* the caller. There are a couple of ways this can happen. At initial
tup->t_data->t_infomask &= ~(HEAP_XACT_MASK);
tup->t_data->t_infomask |= HEAP_XMAX_INVALID;
- doinsert(relation, tup);
+ RelationPutHeapTupleAtEnd(relation, tup);
if (IsSystemRelationName(RelationGetRelationName(relation)->data))
{
- RelationUnsetLockForWrite(relation);
-
- /* ----------------
- * invalidate caches (only works for system relations)
- * ----------------
- */
RelationInvalidateHeapTuple(relation, tup);
}
return tup->t_data->t_oid;
}
-/* ----------------
- * heap_delete - delete a tuple
- *
- * Must decide how to handle errors.
- * ----------------
+/*
+ * heap_delete - delete a tuple
*/
int
-heap_delete(Relation relation, ItemPointer tid)
+heap_delete(Relation relation, ItemPointer tid, ItemPointer ctid)
{
ItemId lp;
HeapTupleData tp;
PageHeader dp;
- Buffer buf;
+ Buffer buffer;
+ int result;
- /* ----------------
- * increment access statistics
- * ----------------
- */
+ /* increment access statistics */
IncrHeapAccessStat(local_delete);
IncrHeapAccessStat(global_delete);
- /* ----------------
- * sanity check
- * ----------------
- */
Assert(ItemPointerIsValid(tid));
- /* ----------------
- * set relation level write lock
- * ----------------
- */
- RelationSetLockForWrite(relation);
-
- buf = ReadBuffer(relation, ItemPointerGetBlockNumber(tid));
+ buffer = ReadBuffer(relation, ItemPointerGetBlockNumber(tid));
-#ifndef NO_BUFFERISVALID
- if (!BufferIsValid(buf))
- { /* XXX L_SH better ??? */
+ if (!BufferIsValid(buffer))
elog(ERROR, "heap_delete: failed ReadBuffer");
- }
-#endif /* NO_BUFFERISVALID */
- dp = (PageHeader) BufferGetPage(buf);
- lp = PageGetItemId(dp, ItemPointerGetOffsetNumber(tid));
+ LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
- /*
- * Just like test against non-functional updates we try to catch
- * non-functional delete attempts. - vadim 05/05/97
- */
+ dp = (PageHeader) BufferGetPage(buffer);
+ lp = PageGetItemId(dp, ItemPointerGetOffsetNumber(tid));
tp.t_data = (HeapTupleHeader) PageGetItem((Page) dp, lp);
tp.t_len = ItemIdGetLength(lp);
tp.t_self = *tid;
- if (TupleUpdatedByCurXactAndCmd(&tp))
+l1:
+ result = HeapTupleSatisfiesUpdate(&tp);
+
+ if (result == HeapTupleInvisible)
{
-
- /*
- * Vadim says this is no longer needed 1998/6/15 elog(NOTICE,
- * "Non-functional delete, tuple already deleted");
- */
- if (IsSystemRelationName(RelationGetRelationName(relation)->data))
- RelationUnsetLockForWrite(relation);
- ReleaseBuffer(buf);
- return 1;
+ LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
+ ReleaseBuffer(buffer);
+ elog(ERROR, "heap_delete: (am)invalid tid");
}
- /* ----------------
- * check that we're deleteing a valid item
- * ----------------
- */
- HeapTupleSatisfies((&tp), relation, buf, dp,
- false, 0, (ScanKey) NULL);
- if (!(tp.t_data))
+ else if (result == HeapTupleBeingUpdated)
{
-
- /* XXX call something else */
- ReleaseBuffer(buf);
-
- elog(ERROR, "heap_delete: (am)invalid tid");
+ TransactionId xwait = tp.t_data->t_xmax;
+
+ /* sleep untill concurrent transaction ends */
+ LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
+ XactLockTableWait(xwait);
+
+ LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
+ if (TransactionIdDidAbort(xwait))
+ goto l1;
+ /* concurrent xact committed */
+ Assert(tp.t_data->t_xmax == xwait);
+ if (!(tp.t_data->t_infomask & HEAP_XMAX_COMMITTED))
+ {
+ tp.t_data->t_infomask |= HEAP_XMAX_COMMITTED;
+ SetBufferCommitInfoNeedsSave(buffer);
+ }
+ /* if tuple was marked for update but not updated... */
+ if (tp.t_data->t_infomask & HEAP_MARKED_FOR_UPDATE)
+ result = HeapTupleMayBeUpdated;
+ else
+ result = HeapTupleUpdated;
+ }
+ if (result != HeapTupleMayBeUpdated)
+ {
+ Assert(result == HeapTupleSelfUpdated || result == HeapTupleUpdated);
+ if (ctid != NULL)
+ *ctid = tp.t_data->t_ctid;
+ LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
+ ReleaseBuffer(buffer);
+ return result;
}
- /* ----------------
- * get the tuple and lock tell the buffer manager we want
- * exclusive access to the page
- * ----------------
- */
-
- /* ----------------
- * store transaction information of xact deleting the tuple
- * ----------------
- */
+ /* store transaction information of xact deleting the tuple */
TransactionIdStore(GetCurrentTransactionId(), &(tp.t_data->t_xmax));
tp.t_data->t_cmax = GetCurrentCommandId();
- tp.t_data->t_infomask &= ~(HEAP_XMAX_COMMITTED | HEAP_XMAX_INVALID);
+ tp.t_data->t_infomask &= ~(HEAP_XMAX_COMMITTED |
+ HEAP_XMAX_INVALID | HEAP_MARKED_FOR_UPDATE);
- /* ----------------
- * invalidate caches
- * ----------------
- */
+ LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
+
+ /* invalidate caches */
RelationInvalidateHeapTuple(relation, &tp);
- WriteBuffer(buf);
- if (IsSystemRelationName(RelationGetRelationName(relation)->data))
- RelationUnsetLockForWrite(relation);
+ WriteBuffer(buffer);
- return 0;
+ return HeapTupleMayBeUpdated;
}
-/* ----------------
- * heap_replace - replace a tuple
- *
- * Must decide how to handle errors.
- *
- * Fix arguments, work with indexes.
- *
- * 12/30/93 - modified the return value to be 1 when
- * a non-functional update is detected. This
- * prevents the calling routine from updating
- * indices unnecessarily. -kw
- *
- * ----------------
+/*
+ * heap_replace - replace a tuple
*/
int
-heap_replace(Relation relation, ItemPointer otid, HeapTuple newtup)
+heap_replace(Relation relation, ItemPointer otid, HeapTuple newtup,
+ ItemPointer ctid)
{
ItemId lp;
HeapTupleData oldtup;
- Page dp;
+ PageHeader dp;
Buffer buffer;
+ int result;
- /* ----------------
- * increment access statistics
- * ----------------
- */
+ /* increment access statistics */
IncrHeapAccessStat(local_replace);
IncrHeapAccessStat(global_replace);
- /* ----------------
- * sanity checks
- * ----------------
- */
Assert(ItemPointerIsValid(otid));
- /* ----------------
- * set relation level write lock
- * ----------------
- */
- if (!relation->rd_islocal)
- RelationSetLockForWrite(relation);
-
buffer = ReadBuffer(relation, ItemPointerGetBlockNumber(otid));
if (!BufferIsValid(buffer))
elog(ERROR, "amreplace: failed ReadBuffer");
+ LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
- dp = (Page) BufferGetPage(buffer);
+ dp = (PageHeader) BufferGetPage(buffer);
lp = PageGetItemId(dp, ItemPointerGetOffsetNumber(otid));
- /* ----------------
- * logically delete old item
- * ----------------
- */
-
oldtup.t_data = (HeapTupleHeader) PageGetItem(dp, lp);
oldtup.t_len = ItemIdGetLength(lp);
oldtup.t_self = *otid;
- /* -----------------
- * the following test should be able to catch all non-functional
- * update attempts and shut out all ghost tuples.
- * XXX In the future, Spyros may need to update the rule lock on a tuple
- * more than once within the same command and same transaction.
- * He will have to introduce a new flag to override the following check.
- * -- Wei
- *
- * -----------------
- */
-
- if (TupleUpdatedByCurXactAndCmd(&oldtup))
+l2:
+ result = HeapTupleSatisfiesUpdate(&oldtup);
+
+ if (result == HeapTupleInvisible)
{
- elog(NOTICE, "Non-functional update, only first update is performed");
- if (IsSystemRelationName(RelationGetRelationName(relation)->data))
- RelationUnsetLockForWrite(relation);
+ LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
ReleaseBuffer(buffer);
- return 1;
+ elog(ERROR, "heap_replace: (am)invalid tid");
}
-
- /* ----------------
- * check that we're replacing a valid item -
- *
- * NOTE that this check must follow the non-functional update test
- * above as it can happen that we try to 'replace' the same tuple
- * twice in a single transaction. The second time around the
- * tuple will fail the NowTimeQual. We don't want to abort the
- * xact, we only want to flag the 'non-functional' NOTICE. -mer
- * ----------------
- */
- HeapTupleSatisfies((&oldtup),
- relation,
- buffer,
- (PageHeader) dp,
- false,
- 0,
- (ScanKey) NULL);
- if (!(oldtup.t_data))
+ else if (result == HeapTupleBeingUpdated)
{
+ TransactionId xwait = oldtup.t_data->t_xmax;
+
+ /* sleep untill concurrent transaction ends */
+ LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
+ XactLockTableWait(xwait);
+
+ LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
+ if (TransactionIdDidAbort(xwait))
+ goto l2;
+ /* concurrent xact committed */
+ Assert(oldtup.t_data->t_xmax == xwait);
+ if (!(oldtup.t_data->t_infomask & HEAP_XMAX_COMMITTED))
+ {
+ oldtup.t_data->t_infomask |= HEAP_XMAX_COMMITTED;
+ SetBufferCommitInfoNeedsSave(buffer);
+ }
+ /* if tuple was marked for update but not updated... */
+ if (oldtup.t_data->t_infomask & HEAP_MARKED_FOR_UPDATE)
+ result = HeapTupleMayBeUpdated;
+ else
+ result = HeapTupleUpdated;
+ }
+ if (result != HeapTupleMayBeUpdated)
+ {
+ Assert(result == HeapTupleSelfUpdated || result == HeapTupleUpdated);
+ if (ctid != NULL)
+ *ctid = oldtup.t_data->t_ctid;
+ LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
ReleaseBuffer(buffer);
- elog(ERROR, "heap_replace: (am)invalid otid");
+ return result;
}
/* XXX order problems if not atomic assignment ??? */
newtup->t_data->t_infomask &= ~(HEAP_XACT_MASK);
newtup->t_data->t_infomask |= HEAP_XMAX_INVALID;
- /* ----------------
- * insert new item
- * ----------------
- */
+ /* logically delete old item */
+ TransactionIdStore(GetCurrentTransactionId(), &(oldtup.t_data->t_xmax));
+ oldtup.t_data->t_cmax = GetCurrentCommandId();
+ oldtup.t_data->t_infomask &= ~(HEAP_XMAX_COMMITTED |
+ HEAP_XMAX_INVALID | HEAP_MARKED_FOR_UPDATE);
+
+ /* insert new item */
if ((unsigned) DOUBLEALIGN(newtup->t_len) <= PageGetFreeSpace((Page) dp))
- RelationPutHeapTuple(relation, BufferGetBlockNumber(buffer), newtup);
+ RelationPutHeapTuple(relation, buffer, newtup);
else
{
- /* ----------------
- * new item won't fit on same page as old item, have to look
- * for a new place to put it.
- * ----------------
+ /*
+ * New item won't fit on same page as old item, have to look
+ * for a new place to put it. Note that we have to unlock
+ * current buffer context - not good but RelationPutHeapTupleAtEnd
+ * uses extend lock.
*/
- doinsert(relation, newtup);
+ LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
+ RelationPutHeapTupleAtEnd(relation, newtup);
+ LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
}
- /* ----------------
- * new item in place, now record transaction information
- * ----------------
+ /*
+ * New item in place, now record address of new tuple in
+ * t_ctid of old one.
*/
- TransactionIdStore(GetCurrentTransactionId(), &(oldtup.t_data->t_xmax));
- oldtup.t_data->t_cmax = GetCurrentCommandId();
- oldtup.t_data->t_infomask &= ~(HEAP_XMAX_COMMITTED | HEAP_XMAX_INVALID);
+ oldtup.t_data->t_ctid = newtup->t_self;
- /* ----------------
- * invalidate caches
- * ----------------
- */
+ LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
+
+ /* invalidate caches */
RelationInvalidateHeapTuple(relation, &oldtup);
WriteBuffer(buffer);
- if (IsSystemRelationName(RelationGetRelationName(relation)->data))
- RelationUnsetLockForWrite(relation);
+ return HeapTupleMayBeUpdated;
+}
+
+/*
+ * heap_mark4update - mark a tuple for update
+ */
+int
+heap_mark4update(Relation relation, HeapTuple tuple, Buffer *buffer)
+{
+ ItemPointer tid = &(tuple->t_self);
+ ItemId lp;
+ PageHeader dp;
+ int result;
+
+ /* increment access statistics */
+ IncrHeapAccessStat(local_mark4update);
+ IncrHeapAccessStat(global_mark4update);
+
+ *buffer = ReadBuffer(relation, ItemPointerGetBlockNumber(tid));
+
+ if (!BufferIsValid(*buffer))
+ elog(ERROR, "heap_mark4update: failed ReadBuffer");
+
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
+
+ dp = (PageHeader) BufferGetPage(*buffer);
+ lp = PageGetItemId(dp, ItemPointerGetOffsetNumber(tid));
+ tuple->t_data = (HeapTupleHeader) PageGetItem((Page) dp, lp);
+ tuple->t_len = ItemIdGetLength(lp);
+
+l3:
+ result = HeapTupleSatisfiesUpdate(tuple);
+
+ if (result == HeapTupleInvisible)
+ {
+ LockBuffer(*buffer, BUFFER_LOCK_UNLOCK);
+ ReleaseBuffer(*buffer);
+ elog(ERROR, "heap_mark4update: (am)invalid tid");
+ }
+ else if (result == HeapTupleBeingUpdated)
+ {
+ TransactionId xwait = tuple->t_data->t_xmax;
+
+ /* sleep untill concurrent transaction ends */
+ LockBuffer(*buffer, BUFFER_LOCK_UNLOCK);
+ XactLockTableWait(xwait);
+
+ LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
+ if (TransactionIdDidAbort(xwait))
+ goto l3;
+ /* concurrent xact committed */
+ Assert(tuple->t_data->t_xmax == xwait);
+ if (!(tuple->t_data->t_infomask & HEAP_XMAX_COMMITTED))
+ {
+ tuple->t_data->t_infomask |= HEAP_XMAX_COMMITTED;
+ SetBufferCommitInfoNeedsSave(*buffer);
+ }
+ /* if tuple was marked for update but not updated... */
+ if (tuple->t_data->t_infomask & HEAP_MARKED_FOR_UPDATE)
+ result = HeapTupleMayBeUpdated;
+ else
+ result = HeapTupleUpdated;
+ }
+ if (result != HeapTupleMayBeUpdated)
+ {
+ Assert(result == HeapTupleSelfUpdated || result == HeapTupleUpdated);
+ LockBuffer(*buffer, BUFFER_LOCK_UNLOCK);
+ return result;
+ }
+
+ /* store transaction information of xact marking the tuple */
+ TransactionIdStore(GetCurrentTransactionId(), &(tuple->t_data->t_xmax));
+ tuple->t_data->t_cmax = GetCurrentCommandId();
+ tuple->t_data->t_infomask &= ~(HEAP_XMAX_COMMITTED | HEAP_XMAX_INVALID);
+ tuple->t_data->t_infomask |= HEAP_MARKED_FOR_UPDATE;
+
+ LockBuffer(*buffer, BUFFER_LOCK_UNLOCK);
+
+ WriteNoReleaseBuffer(*buffer);
- return 0;
+ return HeapTupleMayBeUpdated;
}
/* ----------------
*
*
* IDENTIFICATION
- * $Id: hio.c,v 1.14 1998/11/27 19:51:36 vadim Exp $
+ * $Id: hio.c,v 1.15 1998/12/15 12:45:14 vadim Exp $
*
*-------------------------------------------------------------------------
*/
#include
#include
#include
* Probably needs to have an amdelunique to allow for
* internal index records to be deleted and reordered as needed.
* For the heap AM, this should never be needed.
+ *
+ * Note - we assume that caller hold BUFFER_LOCK_EXCLUSIVE on the buffer.
+ *
*/
void
RelationPutHeapTuple(Relation relation,
- BlockNumber blockIndex,
+ Buffer buffer,
HeapTuple tuple)
{
- Buffer buffer;
- Page pageHeader;
- BlockNumber numberOfBlocks;
- OffsetNumber offnum;
- unsigned int len;
- ItemId itemId;
- Item item;
+ Page pageHeader;
+ OffsetNumber offnum;
+ unsigned int len;
+ ItemId itemId;
+ Item item;
/* ----------------
* increment access statistics
IncrHeapAccessStat(local_RelationPutHeapTuple);
IncrHeapAccessStat(global_RelationPutHeapTuple);
- Assert(RelationIsValid(relation));
- Assert(HeapTupleIsValid(tuple));
-
- numberOfBlocks = RelationGetNumberOfBlocks(relation);
- Assert(blockIndex < numberOfBlocks);
-
- buffer = ReadBuffer(relation, blockIndex);
-#ifndef NO_BUFFERISVALID
- if (!BufferIsValid(buffer))
- {
- elog(ERROR, "RelationPutHeapTuple: no buffer for %ld in %s",
- blockIndex, &relation->rd_rel->relname);
- }
-#endif
-
pageHeader = (Page) BufferGetPage(buffer);
len = (unsigned) DOUBLEALIGN(tuple->t_len); /* be conservative */
Assert((int) len <= PageGetFreeSpace(pageHeader));
itemId = PageGetItemId((Page) pageHeader, offnum);
item = PageGetItem((Page) pageHeader, itemId);
- ItemPointerSet(&((HeapTupleHeader) item)->t_ctid, blockIndex, offnum);
+ ItemPointerSet(&((HeapTupleHeader) item)->t_ctid,
+ BufferGetBlockNumber(buffer), offnum);
+ /*
+ * Let the caller do this!
+ *
WriteBuffer(buffer);
+ */
+
/* return an accurate tuple */
- ItemPointerSet(&tuple->t_self, blockIndex, offnum);
+ ItemPointerSet(&tuple->t_self, BufferGetBlockNumber(buffer), offnum);
}
/*
* RelationGetNumberOfBlocks to be useful.
*
* NOTE: This code presumes that we have a write lock on the relation.
+ * Not now - we use extend locking...
*
* Also note that this routine probably shouldn't have to exist, and does
* screw up the call graph rather badly, but we are wasting so much time and
ItemId itemId;
Item item;
- Assert(RelationIsValid(relation));
- Assert(HeapTupleIsValid(tuple));
+ if (!relation->rd_islocal)
+ LockRelation(relation, ExtendLock);
/*
* XXX This does an lseek - VERY expensive - but at the moment it is
{
buffer = ReadBuffer(relation, lastblock);
pageHeader = (Page) BufferGetPage(buffer);
- if (PageIsNew((PageHeader) pageHeader))
- {
- buffer = ReleaseAndReadBuffer(buffer, relation, P_NEW);
- pageHeader = (Page) BufferGetPage(buffer);
- PageInit(pageHeader, BufferGetPageSize(buffer), 0);
- }
+ /*
+ * There was IF instead of ASSERT here ?!
+ */
+ Assert(PageIsNew((PageHeader) pageHeader));
+ buffer = ReleaseAndReadBuffer(buffer, relation, P_NEW);
+ pageHeader = (Page) BufferGetPage(buffer);
+ PageInit(pageHeader, BufferGetPageSize(buffer), 0);
}
else
buffer = ReadBuffer(relation, lastblock - 1);
+ LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
pageHeader = (Page) BufferGetPage(buffer);
len = (unsigned) DOUBLEALIGN(tuple->t_len); /* be conservative */
if (len > PageGetFreeSpace(pageHeader))
{
+ LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
buffer = ReleaseAndReadBuffer(buffer, relation, P_NEW);
+ LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
pageHeader = (Page) BufferGetPage(buffer);
PageInit(pageHeader, BufferGetPageSize(buffer), 0);
elog(ERROR, "Tuple is too big: size %d", len);
}
+ if (!relation->rd_islocal)
+ UnlockRelation(relation, ExtendLock);
+
offnum = PageAddItem((Page) pageHeader, (Item) tuple->t_data,
tuple->t_len, InvalidOffsetNumber, LP_USED);
/* return an accurate tuple */
ItemPointerSet(&tuple->t_self, lastblock, offnum);
+ LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
WriteBuffer(buffer);
+
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/heap/Attic/stats.c,v 1.13 1997/09/08 02:20:31 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/heap/Attic/stats.c,v 1.14 1998/12/15 12:45:15 vadim Exp $
*
* NOTES
* initam should be moved someplace else.
stats->global_insert = 0;
stats->global_delete = 0;
stats->global_replace = 0;
+ stats->global_mark4update = 0;
stats->global_markpos = 0;
stats->global_restrpos = 0;
stats->global_BufferGetRelation = 0;
stats->local_insert = 0;
stats->local_delete = 0;
stats->local_replace = 0;
+ stats->local_mark4update = 0;
stats->local_markpos = 0;
stats->local_restrpos = 0;
stats->local_BufferGetRelation = 0;
stats->local_insert = 0;
stats->local_delete = 0;
stats->local_replace = 0;
+ stats->local_mark4update = 0;
stats->local_markpos = 0;
stats->local_restrpos = 0;
stats->local_BufferGetRelation = 0;
printf("local/global_replace: %6d/%6d\n",
stats->local_replace, stats->global_replace);
+ printf("local/global_mark4update: %6d/%6d\n",
+ stats->local_mark4update, stats->global_mark4update);
+
printf("local/global_markpos: %6d/%6d\n",
stats->local_markpos, stats->global_markpos);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/index/indexam.c,v 1.28 1998/10/02 16:27:43 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/index/indexam.c,v 1.29 1998/12/15 12:45:15 vadim Exp $
*
* INTERFACE ROUTINES
* index_open - open an index relation by relationId
RELATION_CHECKS;
GET_REL_PROCEDURE(beginscan, ambeginscan);
- RelationSetRIntentLock(relation);
+ LockRelation(relation, AccessShareLock);
scandesc = (IndexScanDesc)
fmgr(procedure, relation, scanFromEnd, numberOfKeys, key);
fmgr(procedure, scan);
- RelationUnsetRIntentLock(scan->relation);
+ UnlockRelation(scan->relation, AccessShareLock);
}
/* ----------------
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtinsert.c,v 1.31 1998/11/27 19:51:40 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtinsert.c,v 1.32 1998/12/15 12:45:20 vadim Exp $
*
*-------------------------------------------------------------------------
*/
#include
#include
#include
/* trade in our read lock for a write lock */
_bt_relbuf(rel, buf, BT_READ);
+
+l1:
buf = _bt_getbuf(rel, blkno, BT_WRITE);
/*
{ /* they're equal */
btitem = (BTItem) PageGetItem(page, PageGetItemId(page, offset));
htup.t_self = btitem->bti_itup.t_tid;
- heap_fetch(heapRel, SnapshotSelf, &htup, &buffer);
- if (htup.t_data != NULL)
- { /* it is a duplicate */
+ heap_fetch(heapRel, SnapshotDirty, &htup, &buffer);
+ if (htup.t_data != NULL) /* it is a duplicate */
+ {
+ TransactionId xwait =
+ (TransactionIdIsValid(SnapshotDirty->xmin)) ?
+ SnapshotDirty->xmin : SnapshotDirty->xmax;
+
+ /*
+ * If this tuple is being updated by other transaction
+ * then we have to wait for its commit/abort.
+ */
+ if (TransactionIdIsValid(xwait))
+ {
+ if (nbuf != InvalidBuffer)
+ _bt_relbuf(rel, nbuf, BT_READ);
+ _bt_relbuf(rel, buf, BT_WRITE);
+ XactLockTableWait(xwait);
+ goto l1; /* continue from the begin */
+ }
elog(ERROR, "Cannot insert a duplicate key into a unique index");
}
/* htup null so no buffer to release */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtpage.c,v 1.16 1998/09/01 03:21:14 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtpage.c,v 1.17 1998/12/15 12:45:23 vadim Exp $
*
* NOTES
* Postgres btree pages look like ordinary relation pages. The opaque
/* can't be sharing this with anyone, now... */
if (USELOCKING)
- RelationSetLockForWrite(rel);
+ LockRelation(rel, AccessExclusiveLock);
if ((nblocks = RelationGetNumberOfBlocks(rel)) != 0)
{
/* all done */
if (USELOCKING)
- RelationUnsetLockForWrite(rel);
+ UnlockRelation(rel, AccessExclusiveLock);
}
#ifdef NOT_USED
static void
_bt_setpagelock(Relation rel, BlockNumber blkno, int access)
{
- ItemPointerData iptr;
if (USELOCKING)
{
- ItemPointerSet(&iptr, blkno, P_HIKEY);
-
if (access == BT_WRITE)
- RelationSetSingleWLockPage(rel, &iptr);
+ LockPage(rel, blkno, ExclusiveLock);
else
- RelationSetSingleRLockPage(rel, &iptr);
+ LockPage(rel, blkno, ShareLock);
}
}
static void
_bt_unsetpagelock(Relation rel, BlockNumber blkno, int access)
{
- ItemPointerData iptr;
if (USELOCKING)
{
- ItemPointerSet(&iptr, blkno, P_HIKEY);
-
if (access == BT_WRITE)
- RelationUnsetSingleWLockPage(rel, &iptr);
+ UnlockPage(rel, blkno, ExclusiveLock);
else
- RelationUnsetSingleRLockPage(rel, &iptr);
+ UnlockPage(rel, blkno, ShareLock);
}
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtree.c,v 1.29 1998/11/27 19:51:41 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtree.c,v 1.30 1998/12/15 12:45:25 vadim Exp $
*
*-------------------------------------------------------------------------
*/
initRtstate(&rtState, index);
- /* rtrees only know how to do stupid locking now */
- RelationSetLockForWrite(index);
-
pred = predInfo->pred;
oldPred = predInfo->oldPred;
/* okay, all heap tuples are indexed */
heap_endscan(scan);
- RelationUnsetLockForWrite(index);
if (pred != NULL || oldPred != NULL)
{
itup->t_tid = *ht_ctid;
initRtstate(&rtState, r);
+ /*
+ * Notes in ExecUtils:ExecOpenIndices()
+ *
RelationSetLockForWrite(r);
+ */
+
res = rtdoinsert(r, itup, &rtState);
- /* XXX two-phase locking -- don't unlock the relation until EOT */
return res;
}
Buffer buf;
Page page;
- /* must write-lock on delete */
+ /*
+ * Notes in ExecUtils:ExecOpenIndices()
+ * Also note that only vacuum deletes index tuples now...
+ *
RelationSetLockForWrite(r);
+ */
blkno = ItemPointerGetBlockNumber(tid);
offnum = ItemPointerGetOffsetNumber(tid);
WriteBuffer(buf);
- /* XXX -- two-phase locking, don't release the write lock */
return (char *) NULL;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtscan.c,v 1.19 1998/09/01 04:27:12 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtscan.c,v 1.20 1998/12/15 12:45:29 vadim Exp $
*
*-------------------------------------------------------------------------
*/
{
IndexScanDesc s;
+ /*
+ * Let index_beginscan does its work...
+ *
RelationSetLockForRead(r);
+ */
+
s = RelationGetIndexScan(r, fromEnd, nkeys, key);
rtregscan(s);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/transam/transam.c,v 1.19 1998/09/01 04:27:15 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/transam/transam.c,v 1.20 1998/12/15 12:45:30 vadim Exp $
*
* NOTES
* This file contains the high level access-method interface to the
if (!fail)
{
- TransactionIdStore(transactionId, &cachedTestXid);
- cachedTestXidStatus = xidstatus;
+ /* must not cache status of running xaction !!! */
+ if (xidstatus != XID_INPROGRESS)
+ {
+ TransactionIdStore(transactionId, &cachedTestXid);
+ cachedTestXidStatus = xidstatus;
+ }
return (bool)
(status == xidstatus);
}
status,
&fail);
- /* ----------------
- * update (invalidate) our single item TransactionLogTest cache.
- * ----------------
- */
+ /*
+ * update (invalidate) our single item TransactionLogTest cache.
+ *
if (status != XID_COMMIT)
+ *
+ * What's the hell ?! Why != XID_COMMIT ?!
+ */
+ if (status != XID_INPROGRESS)
{
TransactionIdStore(transactionId, &cachedTestXid);
cachedTestXidStatus = status;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/transam/Attic/transsup.c,v 1.17 1998/09/01 04:27:16 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/transam/Attic/transsup.c,v 1.18 1998/12/15 12:45:33 vadim Exp $
*
* NOTES
* This file contains support functions for the high
XidStatus xstatus; /* recorded status of xid */
bool localfail; /* bool used if failP = NULL */
- /* ----------------
- * SOMEDAY place a read lock on the log relation
- * That someday is today 5 Aug 1991 -mer
- * ----------------
- */
- RelationSetLockForRead(relation);
-
/* ----------------
* get the page containing the transaction information
* ----------------
*/
buffer = ReadBuffer(relation, blockNumber);
+ LockBuffer(buffer, BUFFER_LOCK_SHARE);
block = BufferGetBlock(buffer);
/* ----------------
* release the buffer and return the status
* ----------------
*/
+ LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
ReleaseBuffer(buffer);
- /* ----------------
- * SOMEDAY release our lock on the log relation
- * ----------------
- */
- RelationUnsetLockForRead(relation);
-
return
xstatus;
}
Block block; /* block containing xstatus */
bool localfail; /* bool used if failP = NULL */
- /* ----------------
- * SOMEDAY gain exclusive access to the log relation
- *
- * That someday is today 5 Aug 1991 -mer
- * ----------------
- */
- RelationSetLockForWrite(relation);
-
/* ----------------
* get the block containing the transaction status
* ----------------
*/
buffer = ReadBuffer(relation, blockNumber);
+ LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
block = BufferGetBlock(buffer);
/* ----------------
TransBlockSetXidStatus(block, xid, xstatus);
+ LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
if ((*failP) == false)
WriteBuffer(buffer);
else
ReleaseBuffer(buffer);
-
- /* ----------------
- * SOMEDAY release our lock on the log relation
- * ----------------
- */
- RelationUnsetLockForWrite(relation);
}
/* --------------------------------
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/transam/xact.c,v 1.25 1998/10/08 18:29:15 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/transam/xact.c,v 1.26 1998/12/15 12:45:35 vadim Exp $
*
* NOTES
* Transaction aborts can now occur two ways:
TransactionState CurrentTransactionState =
&CurrentTransactionStateData;
+int XactIsoLevel = XACT_SERIALIZED;
+
/* ----------------
* info returned when the system is disabled
*
*/
GetNewTransactionId(&(s->transactionIdData));
+ XactLockTableInsert(s->transactionIdData);
+
/* ----------------
* initialize current transaction state fields
* ----------------
* do abort processing
* ----------------
*/
+ UnlockBuffers();
AtAbort_Notify();
CloseSequences();
AtEOXact_portals();
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/aclchk.c,v 1.17 1998/11/27 19:51:46 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/aclchk.c,v 1.18 1998/12/15 12:45:39 vadim Exp $
*
* NOTES
* See acl.h.
tuple = heap_modifytuple(tuple, relation, values, nulls, replaces);
/* XXX handle index on pg_class? */
setheapoverride(true);
- heap_replace(relation, &tuple->t_self, tuple);
+ heap_replace(relation, &tuple->t_self, tuple, NULL);
setheapoverride(false);
/* keep the catalog indices up to date */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/heap.c,v 1.69 1998/12/14 05:18:37 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/heap.c,v 1.70 1998/12/15 12:45:40 vadim Exp $
*
* INTERFACE ROUTINES
* heap_create() - Create an uncataloged heap relation
while (HeapTupleIsValid(tuple = heap_getnext(scan, 0)))
{
- heap_delete(catalogRelation, &tuple->t_self);
+ heap_delete(catalogRelation, &tuple->t_self, NULL);
found = true;
}
&entry);
while (HeapTupleIsValid(tuple = heap_getnext(scan, 0)))
- heap_delete(catalogRelation, &tuple->t_self);
+ heap_delete(catalogRelation, &tuple->t_self, NULL);
heap_endscan(scan);
heap_close(catalogRelation);
* delete the relation tuple from pg_class, and finish up.
* ----------------
*/
- heap_delete(pg_class_desc, &tup->t_self);
+ heap_delete(pg_class_desc, &tup->t_self, NULL);
pfree(tup);
heap_close(pg_class_desc);
* Get a write lock _before_ getting the read lock in the scan
* ----------------
*/
- RelationSetLockForWrite(pg_attribute_desc);
+ LockRelation(pg_attribute_desc, AccessExclusiveLock);
for (attnum = FirstLowInvalidHeapAttributeNumber + 1;
attnum <= rel->rd_att->natts;
Int16GetDatum(attnum),
0, 0)))
{
- heap_delete(pg_attribute_desc, &tup->t_self);
+ heap_delete(pg_attribute_desc, &tup->t_self, NULL);
pfree(tup);
}
}
* Release the write lock
* ----------------
*/
- RelationUnsetLockForWrite(pg_attribute_desc);
+ UnlockRelation(pg_attribute_desc, AccessExclusiveLock);
heap_close(pg_attribute_desc);
}
* we release the read lock on pg_type. -mer 13 Aug 1991
* ----------------
*/
- heap_delete(pg_type_desc, &tup->t_self);
+ heap_delete(pg_type_desc, &tup->t_self, NULL);
heap_endscan(pg_type_scan);
heap_close(pg_type_desc);
if (rel == NULL)
elog(ERROR, "Relation %s Does Not Exist!", relname);
- RelationSetLockForWrite(rel);
+ LockRelation(rel, AccessExclusiveLock);
rid = rel->rd_id;
/* ----------------
rel->rd_tmpunlinked = TRUE;
- RelationUnsetLockForWrite(rel);
+ UnlockRelation(rel, AccessExclusiveLock);
heap_close(rel);
ScanKeyEntryInitialize(&key, 0, Anum_pg_attrdef_adrelid,
F_OIDEQ, rel->rd_id);
- RelationSetLockForWrite(adrel);
+ LockRelation(adrel, AccessExclusiveLock);
adscan = heap_beginscan(adrel, 0, SnapshotNow, 1, &key);
while (HeapTupleIsValid(tup = heap_getnext(adscan, 0)))
- heap_delete(adrel, &tup->t_self);
+ heap_delete(adrel, &tup->t_self, NULL);
heap_endscan(adscan);
- RelationUnsetLockForWrite(adrel);
+ UnlockRelation(adrel, AccessExclusiveLock);
heap_close(adrel);
}
ScanKeyEntryInitialize(&key, 0, Anum_pg_relcheck_rcrelid,
F_OIDEQ, rel->rd_id);
- RelationSetLockForWrite(rcrel);
+ LockRelation(rcrel, AccessExclusiveLock);
rcscan = heap_beginscan(rcrel, 0, SnapshotNow, 1, &key);
while (HeapTupleIsValid(tup = heap_getnext(rcscan, 0)))
- heap_delete(rcrel, &tup->t_self);
+ heap_delete(rcrel, &tup->t_self, NULL);
heap_endscan(rcscan);
- RelationUnsetLockForWrite(rcrel);
+ UnlockRelation(rcrel, AccessExclusiveLock);
heap_close(rcrel);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/index.c,v 1.65 1998/12/13 04:37:50 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/index.c,v 1.66 1998/12/15 12:45:43 vadim Exp $
*
*
* INTERFACE ROUTINES
newtup = heap_modifytuple(tuple, pg_index, values, nulls, replace);
- heap_replace(pg_index, &newtup->t_self, newtup);
+ heap_replace(pg_index, &newtup->t_self, newtup, NULL);
pfree(newtup);
heap_close(pg_index);
heapRelation = heap_open(heapoid);
- /* ----------------
- * write lock heap to guarantee exclusive access
- * ----------------
- RelationSetLockForWrite(heapRelation);
- * ^^^^^
- * Does it have any sense ? - vadim 10/27/97
+ /*
+ * Only SELECT ... FOR UPDATE are allowed
*/
- RelationSetLockForRead(heapRelation);
+ LockRelation(heapRelation, ShareLock);
/* ----------------
* construct new tuple descriptor
AssertState(HeapTupleIsValid(tuple));
- heap_delete(relationRelation, &tuple->t_self);
+ heap_delete(relationRelation, &tuple->t_self, NULL);
pfree(tuple);
heap_close(relationRelation);
Int16GetDatum(attnum),
0, 0)))
{
- heap_delete(attributeRelation, &tuple->t_self);
+ heap_delete(attributeRelation, &tuple->t_self, NULL);
pfree(tuple);
attnum++;
}
indexRelation = heap_openr(IndexRelationName);
- heap_delete(indexRelation, &tuple->t_self);
+ heap_delete(indexRelation, &tuple->t_self, NULL);
pfree(tuple);
heap_close(indexRelation);
values[Anum_pg_class_relhasindex - 1] = CharGetDatum(hasindex);
newtup = heap_modifytuple(tuple, pg_class, values, nulls, replace);
- heap_replace(pg_class, &tuple->t_self, newtup);
+ heap_replace(pg_class, &tuple->t_self, newtup, NULL);
CatalogOpenIndices(Num_pg_class_indices, Name_pg_class_indices, idescs);
CatalogIndexInsert(idescs, Num_pg_class_indices, pg_class, newtup);
CatalogCloseIndices(Num_pg_class_indices, idescs);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/pg_operator.c,v 1.30 1998/11/27 19:51:50 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/pg_operator.c,v 1.31 1998/12/15 12:45:45 vadim Exp $
*
* NOTES
* these routines moved here from commands/define.c and somewhat cleaned up.
replaces);
setheapoverride(true);
- heap_replace(pg_operator_desc, &tup->t_self, tup);
+ heap_replace(pg_operator_desc, &tup->t_self, tup, NULL);
setheapoverride(false);
}
else
replaces);
setheapoverride(true);
- heap_replace(pg_operator_desc, &tup->t_self, tup);
+ heap_replace(pg_operator_desc, &tup->t_self, tup, NULL);
setheapoverride(false);
}
replaces);
setheapoverride(true);
- heap_replace(pg_operator_desc, &tup->t_self, tup);
+ heap_replace(pg_operator_desc, &tup->t_self, tup, NULL);
setheapoverride(false);
values[Anum_pg_operator_oprcom - 1] = (Datum) NULL;
replaces);
setheapoverride(true);
- heap_replace(pg_operator_desc, &tup->t_self, tup);
+ heap_replace(pg_operator_desc, &tup->t_self, tup, NULL);
setheapoverride(false);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/pg_type.c,v 1.31 1998/11/27 19:51:51 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/pg_type.c,v 1.32 1998/12/15 12:45:47 vadim Exp $
*
*-------------------------------------------------------------------------
*/
* when the heap_insert() or heap_replace() is called.
* -----------------
*/
- RelationSetLockForWrite(pg_type_desc);
+ LockRelation(pg_type_desc, AccessExclusiveLock);
typeKey[0].sk_argument = PointerGetDatum(typeName);
pg_type_scan = heap_beginscan(pg_type_desc,
replaces);
setheapoverride(true);
- heap_replace(pg_type_desc, &tup->t_self, tup);
+ heap_replace(pg_type_desc, &tup->t_self, tup, NULL);
setheapoverride(false);
typeObjectId = tup->t_data->t_oid;
CatalogIndexInsert(idescs, Num_pg_type_indices, pg_type_desc, tup);
CatalogCloseIndices(Num_pg_type_indices, idescs);
}
- RelationUnsetLockForWrite(pg_type_desc);
+ UnlockRelation(pg_type_desc, AccessExclusiveLock);
heap_close(pg_type_desc);
return typeObjectId;
namestrcpy(&(((Form_pg_type) GETSTRUCT(oldtup))->typname), newTypeName);
setheapoverride(true);
- heap_replace(pg_type_desc, &oldtup->t_self, oldtup);
+ heap_replace(pg_type_desc, &oldtup->t_self, oldtup, NULL);
setheapoverride(false);
/* update the system catalog indices */
* Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/async.c,v 1.42 1998/11/27 19:51:53 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/async.c,v 1.43 1998/12/15 12:45:50 vadim Exp $
*
*-------------------------------------------------------------------------
*/
TPRINTF(TRACE_NOTIFY, "Async_Listen: %s", relname);
lRel = heap_openr(ListenerRelationName);
- RelationSetLockForWrite(lRel);
+ LockRelation(lRel, AccessExclusiveLock);
tdesc = RelationGetDescr(lRel);
/* Detect whether we are already listening on this relname */
if (alreadyListener)
{
elog(NOTICE, "Async_Listen: We are already listening on %s", relname);
- RelationUnsetLockForWrite(lRel);
+ UnlockRelation(lRel, AccessExclusiveLock);
heap_close(lRel);
return;
}
heap_insert(lRel, newtup);
pfree(newtup);
- RelationUnsetLockForWrite(lRel);
+ UnlockRelation(lRel, AccessExclusiveLock);
heap_close(lRel);
/*
if (lTuple != NULL)
{
lRel = heap_openr(ListenerRelationName);
- RelationSetLockForWrite(lRel);
- heap_delete(lRel, &lTuple->t_self);
- RelationUnsetLockForWrite(lRel);
+ LockRelation(lRel, AccessExclusiveLock);
+ heap_delete(lRel, &lTuple->t_self, NULL);
+ UnlockRelation(lRel, AccessExclusiveLock);
heap_close(lRel);
}
/* We do not complain about unlistening something not being listened;
TPRINTF(TRACE_NOTIFY, "Async_UnlistenAll");
lRel = heap_openr(ListenerRelationName);
- RelationSetLockForWrite(lRel);
+ LockRelation(lRel, AccessExclusiveLock);
tdesc = RelationGetDescr(lRel);
/* Find and delete all entries with my listenerPID */
sRel = heap_beginscan(lRel, 0, SnapshotNow, 1, key);
while (HeapTupleIsValid(lTuple = heap_getnext(sRel, 0)))
- heap_delete(lRel, &lTuple->t_self);
+ heap_delete(lRel, &lTuple->t_self, NULL);
heap_endscan(sRel);
- RelationUnsetLockForWrite(lRel);
+ UnlockRelation(lRel, AccessExclusiveLock);
heap_close(lRel);
}
TPRINTF(TRACE_NOTIFY, "AtCommit_Notify");
lRel = heap_openr(ListenerRelationName);
- RelationSetLockForWrite(lRel);
+ LockRelation(lRel, AccessExclusiveLock);
tdesc = RelationGetDescr(lRel);
sRel = heap_beginscan(lRel, 0, SnapshotNow, 0, (ScanKey) NULL);
* but as far as I can see we should just do it for any
* failure (certainly at least for EPERM too...)
*/
- heap_delete(lRel, &lTuple->t_self);
+ heap_delete(lRel, &lTuple->t_self, NULL);
}
else
#endif
{
rTuple = heap_modifytuple(lTuple, lRel,
value, nulls, repl);
- heap_replace(lRel, &lTuple->t_self, rTuple);
+ heap_replace(lRel, &lTuple->t_self, rTuple, NULL);
}
}
}
StartTransactionCommand();
lRel = heap_openr(ListenerRelationName);
- RelationSetLockForWrite(lRel);
+ LockRelation(lRel, AccessExclusiveLock);
tdesc = RelationGetDescr(lRel);
/* Scan only entries with my listenerPID */
NotifyMyFrontEnd(relname, sourcePID);
/* Rewrite the tuple with 0 in notification column */
rTuple = heap_modifytuple(lTuple, lRel, value, nulls, repl);
- heap_replace(lRel, &lTuple->t_self, rTuple);
+ heap_replace(lRel, &lTuple->t_self, rTuple, NULL);
}
}
heap_endscan(sRel);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/Attic/command.c,v 1.33 1998/11/27 19:51:54 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/Attic/command.c,v 1.34 1998/12/15 12:45:52 vadim Exp $
*
* NOTES
* The PortalExecutorHeapMemory crap needs to be eliminated
heap_close(attrdesc);
((Form_pg_class) GETSTRUCT(reltup))->relnatts = maxatts;
- heap_replace(rel, &reltup->t_self, reltup);
+ heap_replace(rel, &reltup->t_self, reltup, NULL);
/* keep catalog indices current */
CatalogOpenIndices(Num_pg_class_indices, Name_pg_class_indices, ridescs);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/copy.c,v 1.64 1998/11/27 19:51:54 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/copy.c,v 1.65 1998/12/15 12:45:53 vadim Exp $
*
*-------------------------------------------------------------------------
*/
pfree(typmod);
}
pfree(byval);
+
+ /* comments in execUtils.c */
+ if (has_index)
+ {
+ for (i = 0; i < n_indices; i++)
+ {
+ if (index_rels[i] == NULL)
+ continue;
+ if ((index_rels[i])->rd_rel->relam != BTREE_AM_OID &&
+ (index_rels[i])->rd_rel->relam != HASH_AM_OID)
+ UnlockRelation(index_rels[i], AccessExclusiveLock);
+ index_close(index_rels[i]);
+ }
+ }
heap_close(rel);
}
*index_rels = (Relation *) palloc(*n_indices * sizeof(Relation));
for (i = 0, scan = head; i < *n_indices; i++, scan = scan->next)
+ {
(*index_rels)[i] = index_open(scan->index_rel_oid);
+ /* comments in execUtils.c */
+ if ((*index_rels)[i] != NULL &&
+ ((*index_rels)[i])->rd_rel->relam != BTREE_AM_OID &&
+ ((*index_rels)[i])->rd_rel->relam != HASH_AM_OID)
+ LockRelation((*index_rels)[i], AccessExclusiveLock);
+ }
for (i = 0, scan = head; i < *n_indices + 1; i++)
{
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/dbcommands.c,v 1.27 1998/12/14 05:18:43 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/dbcommands.c,v 1.28 1998/12/15 12:45:55 vadim Exp $
*
*-------------------------------------------------------------------------
*/
* delays when multiple 'createdb's or 'destroydb's are run simult.
* -mer 7/3/91
*/
- RelationSetLockForWrite(dbrel);
+ LockRelation(dbrel, AccessExclusiveLock);
dbtup = get_pg_dbtup(command, dbname, dbrel);
dbfound = HeapTupleIsValid(dbtup);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/Attic/defind.c,v 1.28 1998/11/27 19:51:56 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/Attic/defind.c,v 1.29 1998/12/15 12:45:56 vadim Exp $
*
*-------------------------------------------------------------------------
*/
heapRelation = heap_open(relationId);
indexRelation = index_open(indexId);
- RelationSetLockForWrite(heapRelation);
+ LockRelation(heapRelation, ShareLock);
InitIndexStrategy(numberOfAttributes, indexRelation, accessMethodId);
}
rel = heap_openr(LanguageRelationName);
- heap_delete(rel, &langTup->t_self);
+ heap_delete(rel, &langTup->t_self, NULL);
pfree(langTup);
heap_close(rel);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/Attic/remove.c,v 1.30 1998/11/27 19:51:57 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/Attic/remove.c,v 1.31 1998/12/15 12:45:57 vadim Exp $
*
*-------------------------------------------------------------------------
*/
elog(ERROR, "RemoveOperator: operator '%s': permission denied",
operatorName);
#endif
- heap_delete(relation, &tup->t_self);
+ heap_delete(relation, &tup->t_self, NULL);
}
else
{
key[0].sk_attno = attnums[i];
scan = heap_beginscan(rel, 0, SnapshotNow, 1, key);
while (HeapTupleIsValid(tup = heap_getnext(scan, 0)))
- heap_delete(rel, &tup->t_self);
+ heap_delete(rel, &tup->t_self, NULL);
heap_endscan(scan);
}
heap_close(rel);
relation = heap_openr(TypeRelationName);
typeOid = tup->t_data->t_oid;
- heap_delete(relation, &tup->t_self);
+ heap_delete(relation, &tup->t_self, NULL);
/* Now, Delete the "array of" that type */
shadow_type = makeArrayTypeName(typeName);
}
typeOid = tup->t_data->t_oid;
- heap_delete(relation, &tup->t_self);
+ heap_delete(relation, &tup->t_self, NULL);
heap_close(relation);
}
elog(ERROR, "RemoveFunction: function \"%s\" is built-in", functionName);
}
- heap_delete(relation, &tup->t_self);
+ heap_delete(relation, &tup->t_self, NULL);
heap_close(relation);
}
aggName);
}
}
- heap_delete(relation, &tup->t_self);
+ heap_delete(relation, &tup->t_self, NULL);
heap_close(relation);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/Attic/rename.c,v 1.18 1998/11/27 19:51:57 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/Attic/rename.c,v 1.19 1998/12/15 12:45:58 vadim Exp $
*
*-------------------------------------------------------------------------
*/
newattname, NAMEDATALEN);
attrelation = heap_openr(AttributeRelationName);
- heap_replace(attrelation, &oldatttup->t_self, oldatttup);
+ heap_replace(attrelation, &oldatttup->t_self, oldatttup, NULL);
/* keep system catalog indices current */
CatalogOpenIndices(Num_pg_attr_indices, Name_pg_attr_indices, irelations);
/* insert fixed rel tuple */
relrelation = heap_openr(RelationRelationName);
- heap_replace(relrelation, &oldreltup->t_self, oldreltup);
+ heap_replace(relrelation, &oldreltup->t_self, oldreltup, NULL);
/* keep the system catalog indices current */
CatalogOpenIndices(Num_pg_class_indices, Name_pg_class_indices, irelations);
rel = heap_openr(seq->seqname);
Assert(RelationIsValid(rel));
- RelationSetLockForWrite(rel);
+ LockRelation(rel, AccessExclusiveLock);
tupDesc = RelationGetDescr(rel);
if (WriteBuffer(buf) == STATUS_ERROR)
elog(ERROR, "DefineSequence: WriteBuffer failed");
- RelationUnsetLockForWrite(rel);
+ UnlockRelation(rel, AccessExclusiveLock);
heap_close(rel);
return;
SeqTable elm;
Buffer buf;
Form_pg_sequence seq;
- ItemPointerData iptr;
int4 incby,
maxv,
minv,
next,
rescnt = 0;
- /* open and WIntentLock sequence */
+ /* open and AccessShareLock sequence */
elm = init_sequence("nextval", seqname);
pfree(seqname);
return elm->last;
}
- seq = read_info("nextval", elm, &buf); /* lock page and read
+ seq = read_info("nextval", elm, &buf); /* lock page' buffer and read
* tuple */
next = result = seq->last_value;
seq->last_value = next; /* last fetched number */
seq->is_called = 't';
+ LockBuffer(buf, BUFFER_LOCK_UNLOCK);
+
if (WriteBuffer(buf) == STATUS_ERROR)
elog(ERROR, "%s.nextval: WriteBuffer failed", elm->name);
- ItemPointerSet(&iptr, 0, FirstOffsetNumber);
- RelationUnsetSingleWLockPage(elm->rel, &iptr);
-
return result;
}
SeqTable elm;
int4 result;
- /* open and WIntentLock sequence */
+ /* open and AccessShareLock sequence */
elm = init_sequence("currval", seqname);
pfree(seqname);
SeqTable elm;
Buffer buf;
Form_pg_sequence seq;
- ItemPointerData iptr;
#ifndef NO_SECURITY
if (pg_aclcheck(seqname, getpgusername(), ACL_WR) != ACLCHECK_OK)
seqname, seqname);
#endif
- /* open and WIntentLock sequence */
+ /* open and AccessShareLock sequence */
elm = init_sequence("setval", seqname);
- seq = read_info("setval", elm, &buf); /* lock page and read
+ seq = read_info("setval", elm, &buf); /* lock page' buffer and read
* tuple */
if (seq->cache_value != 1)
seq->last_value = next; /* last fetched number */
seq->is_called = 't';
+ LockBuffer(buf, BUFFER_LOCK_UNLOCK);
+
if (WriteBuffer(buf) == STATUS_ERROR)
elog(ERROR, "%s.settval: WriteBuffer failed", seqname);
- ItemPointerSet(&iptr, 0, FirstOffsetNumber);
- RelationUnsetSingleWLockPage(elm->rel, &iptr);
-
return next;
}
static Form_pg_sequence
read_info(char *caller, SeqTable elm, Buffer *buf)
{
- ItemPointerData iptr;
- PageHeader page;
- ItemId lp;
+ PageHeader page;
+ ItemId lp;
HeapTupleData tuple;
sequence_magic *sm;
- Form_pg_sequence seq;
-
- ItemPointerSet(&iptr, 0, FirstOffsetNumber);
- RelationSetSingleWLockPage(elm->rel, &iptr);
+ Form_pg_sequence seq;
if (RelationGetNumberOfBlocks(elm->rel) != 1)
elog(ERROR, "%s.%s: invalid number of blocks in sequence",
if (!BufferIsValid(*buf))
elog(ERROR, "%s.%s: ReadBuffer failed", elm->name, caller);
+ LockBuffer(*buf, BUFFER_LOCK_EXCLUSIVE);
+
page = (PageHeader) BufferGetPage(*buf);
sm = (sequence_magic *) PageGetSpecialPointer(page);
if (!RelationIsValid(temp->rel))
elog(ERROR, "%s.%s: sequence does not exist", name, caller);
- RelationSetWIntentLock(temp->rel);
+ LockRelation(temp->rel, AccessShareLock);
if (temp->rel->rd_rel->relkind != RELKIND_SEQUENCE)
elog(ERROR, "%s.%s: %s is not sequence !", name, caller, name);
{
rel = elm->rel;
elm->rel = (Relation) NULL;
- RelationUnsetWIntentLock(rel);
+ UnlockRelation(rel, AccessShareLock);
heap_close(rel);
}
elm = elm->next;
void FreeTriggerDesc(Relation relation);
static void DescribeTrigger(TriggerDesc *trigdesc, Trigger *trigger);
-static HeapTuple GetTupleForTrigger(Relation relation, ItemPointer tid,
+static HeapTuple GetTupleForTrigger(EState *estate, ItemPointer tid,
bool before);
extern GlobalMemory CacheCxt;
if (!RelationIsValid(rel))
elog(ERROR, "CreateTrigger: there is no relation %s", stmt->relname);
- RelationSetLockForWrite(rel);
+ LockRelation(rel, AccessExclusiveLock);
TRIGGER_CLEAR_TYPE(tgtype);
if (stmt->before)
/* Scan pg_trigger */
tgrel = heap_openr(TriggerRelationName);
- RelationSetLockForWrite(tgrel);
+ LockRelation(tgrel, AccessExclusiveLock);
ScanKeyEntryInitialize(&key, 0, Anum_pg_trigger_tgrelid,
F_OIDEQ, RelationGetRelid(rel));
tgscan = heap_beginscan(tgrel, 0, SnapshotNow, 1, &key);
CatalogIndexInsert(idescs, Num_pg_trigger_indices, tgrel, tuple);
CatalogCloseIndices(Num_pg_trigger_indices, idescs);
pfree(tuple);
- RelationUnsetLockForWrite(tgrel);
+ UnlockRelation(tgrel, AccessExclusiveLock);
heap_close(tgrel);
pfree(DatumGetPointer(values[Anum_pg_trigger_tgname - 1]));
pgrel = heap_openr(RelationRelationName);
((Form_pg_class) GETSTRUCT(tuple))->reltriggers = found + 1;
RelationInvalidateHeapTuple(pgrel, tuple);
- heap_replace(pgrel, &tuple->t_self, tuple);
+ heap_replace(pgrel, &tuple->t_self, tuple, NULL);
CatalogOpenIndices(Num_pg_class_indices, Name_pg_class_indices, ridescs);
CatalogIndexInsert(ridescs, Num_pg_class_indices, pgrel, tuple);
CatalogCloseIndices(Num_pg_class_indices, ridescs);
if (!RelationIsValid(rel))
elog(ERROR, "DropTrigger: there is no relation %s", stmt->relname);
- RelationSetLockForWrite(rel);
+ LockRelation(rel, AccessExclusiveLock);
tgrel = heap_openr(TriggerRelationName);
- RelationSetLockForWrite(tgrel);
+ LockRelation(tgrel, AccessExclusiveLock);
ScanKeyEntryInitialize(&key, 0, Anum_pg_trigger_tgrelid,
F_OIDEQ, RelationGetRelid(rel));
tgscan = heap_beginscan(tgrel, 0, SnapshotNow, 1, &key);
if (namestrcmp(&(pg_trigger->tgname), stmt->trigname) == 0)
{
- heap_delete(tgrel, &tuple->t_self);
+ heap_delete(tgrel, &tuple->t_self, NULL);
tgfound++;
}
else
elog(NOTICE, "DropTrigger: found (and deleted) %d trigger %s on relation %s",
tgfound, stmt->trigname, stmt->relname);
heap_endscan(tgscan);
- RelationUnsetLockForWrite(tgrel);
+ UnlockRelation(tgrel, AccessExclusiveLock);
heap_close(tgrel);
tuple = SearchSysCacheTupleCopy(RELNAME,
pgrel = heap_openr(RelationRelationName);
((Form_pg_class) GETSTRUCT(tuple))->reltriggers = found;
RelationInvalidateHeapTuple(pgrel, tuple);
- heap_replace(pgrel, &tuple->t_self, tuple);
+ heap_replace(pgrel, &tuple->t_self, tuple, NULL);
CatalogOpenIndices(Num_pg_class_indices, Name_pg_class_indices, ridescs);
CatalogIndexInsert(ridescs, Num_pg_class_indices, pgrel, tuple);
CatalogCloseIndices(Num_pg_class_indices, ridescs);
HeapTuple tup;
tgrel = heap_openr(TriggerRelationName);
- RelationSetLockForWrite(tgrel);
+ LockRelation(tgrel, AccessExclusiveLock);
ScanKeyEntryInitialize(&key, 0, Anum_pg_trigger_tgrelid,
F_OIDEQ, RelationGetRelid(rel));
tgscan = heap_beginscan(tgrel, 0, SnapshotNow, 1, &key);
while (HeapTupleIsValid(tup = heap_getnext(tgscan, 0)))
- heap_delete(tgrel, &tup->t_self);
+ heap_delete(tgrel, &tup->t_self, NULL);
heap_endscan(tgscan);
- RelationUnsetLockForWrite(tgrel);
+ UnlockRelation(tgrel, AccessExclusiveLock);
heap_close(tgrel);
}
ObjectIdGetDatum(RelationGetRelid(relation)));
tgrel = heap_openr(TriggerRelationName);
- RelationSetLockForRead(tgrel);
irel = index_openr(TriggerRelidIndex);
sd = index_beginscan(irel, false, 1, &skey);
index_endscan(sd);
pfree(sd);
index_close(irel);
- RelationUnsetLockForRead(tgrel);
heap_close(tgrel);
/* Build trigdesc */
}
bool
-ExecBRDeleteTriggers(Relation rel, ItemPointer tupleid)
+ExecBRDeleteTriggers(EState *estate, ItemPointer tupleid)
{
- TriggerData *SaveTriggerData;
- int ntrigs = rel->trigdesc->n_before_row[TRIGGER_EVENT_DELETE];
- Trigger **trigger = rel->trigdesc->tg_before_row[TRIGGER_EVENT_DELETE];
- HeapTuple trigtuple;
- HeapTuple newtuple = NULL;
- int i;
-
- trigtuple = GetTupleForTrigger(rel, tupleid, true);
+ Relation rel = estate->es_result_relation_info->ri_RelationDesc;
+ TriggerData *SaveTriggerData;
+ int ntrigs = rel->trigdesc->n_before_row[TRIGGER_EVENT_DELETE];
+ Trigger **trigger = rel->trigdesc->tg_before_row[TRIGGER_EVENT_DELETE];
+ HeapTuple trigtuple;
+ HeapTuple newtuple = NULL;
+ int i;
+
+ trigtuple = GetTupleForTrigger(estate, tupleid, true);
if (trigtuple == NULL)
return false;
}
void
-ExecARDeleteTriggers(Relation rel, ItemPointer tupleid)
+ExecARDeleteTriggers(EState *estate, ItemPointer tupleid)
{
+ Relation rel = estate->es_result_relation_info->ri_RelationDesc;
TriggerData *SaveTriggerData;
int ntrigs = rel->trigdesc->n_after_row[TRIGGER_EVENT_DELETE];
Trigger **trigger = rel->trigdesc->tg_after_row[TRIGGER_EVENT_DELETE];
HeapTuple trigtuple;
int i;
- trigtuple = GetTupleForTrigger(rel, tupleid, false);
+ trigtuple = GetTupleForTrigger(estate, tupleid, false);
Assert(trigtuple != NULL);
SaveTriggerData = (TriggerData *) palloc(sizeof(TriggerData));
}
HeapTuple
-ExecBRUpdateTriggers(Relation rel, ItemPointer tupleid, HeapTuple newtuple)
+ExecBRUpdateTriggers(EState *estate, ItemPointer tupleid, HeapTuple newtuple)
{
- TriggerData *SaveTriggerData;
- int ntrigs = rel->trigdesc->n_before_row[TRIGGER_EVENT_UPDATE];
- Trigger **trigger = rel->trigdesc->tg_before_row[TRIGGER_EVENT_UPDATE];
- HeapTuple trigtuple;
- HeapTuple oldtuple;
- HeapTuple intuple = newtuple;
- int i;
-
- trigtuple = GetTupleForTrigger(rel, tupleid, true);
+ Relation rel = estate->es_result_relation_info->ri_RelationDesc;
+ TriggerData *SaveTriggerData;
+ int ntrigs = rel->trigdesc->n_before_row[TRIGGER_EVENT_UPDATE];
+ Trigger **trigger = rel->trigdesc->tg_before_row[TRIGGER_EVENT_UPDATE];
+ HeapTuple trigtuple;
+ HeapTuple oldtuple;
+ HeapTuple intuple = newtuple;
+ int i;
+
+ trigtuple = GetTupleForTrigger(estate, tupleid, true);
if (trigtuple == NULL)
return NULL;
}
void
-ExecARUpdateTriggers(Relation rel, ItemPointer tupleid, HeapTuple newtuple)
+ExecARUpdateTriggers(EState *estate, ItemPointer tupleid, HeapTuple newtuple)
{
+ Relation rel = estate->es_result_relation_info->ri_RelationDesc;
TriggerData *SaveTriggerData;
int ntrigs = rel->trigdesc->n_after_row[TRIGGER_EVENT_UPDATE];
Trigger **trigger = rel->trigdesc->tg_after_row[TRIGGER_EVENT_UPDATE];
HeapTuple trigtuple;
int i;
- trigtuple = GetTupleForTrigger(rel, tupleid, false);
+ trigtuple = GetTupleForTrigger(estate, tupleid, false);
Assert(trigtuple != NULL);
SaveTriggerData = (TriggerData *) palloc(sizeof(TriggerData));
}
static HeapTuple
-GetTupleForTrigger(Relation relation, ItemPointer tid, bool before)
+GetTupleForTrigger(EState *estate, ItemPointer tid, bool before)
{
- ItemId lp;
+ Relation relation = estate->es_result_relation_info->ri_RelationDesc;
HeapTupleData tuple;
HeapTuple result;
- PageHeader dp;
- Buffer b;
+ Buffer buffer;
- b = ReadBuffer(relation, ItemPointerGetBlockNumber(tid));
+ if (before)
+ {
+ int test;
+
+ /*
+ * mark tuple for update
+ */
+ tuple.t_self = *tid;
+ test = heap_mark4update(relation, &tuple, &buffer);
+ switch (test)
+ {
+ case HeapTupleSelfUpdated:
+ ReleaseBuffer(buffer);
+ return(NULL);
- if (!BufferIsValid(b))
- elog(ERROR, "GetTupleForTrigger: failed ReadBuffer");
+ case HeapTupleMayBeUpdated:
+ break;
- dp = (PageHeader) BufferGetPage(b);
- lp = PageGetItemId(dp, ItemPointerGetOffsetNumber(tid));
+ case HeapTupleUpdated:
+ ReleaseBuffer(buffer);
+ if (XactIsoLevel == XACT_SERIALIZED)
+ elog(ERROR, "Serialize access failed due to concurrent update");
+ else
+ elog(ERROR, "Isolation level %u is not supported", XactIsoLevel);
+ return(NULL);
- Assert(ItemIdIsUsed(lp));
+ default:
+ ReleaseBuffer(buffer);
+ elog(ERROR, "Unknown status %u from heap_mark4update", test);
+ return(NULL);
+ }
+ }
+ else
+ {
+ PageHeader dp;
+ ItemId lp;
- tuple.t_data = (HeapTupleHeader) PageGetItem((Page) dp, lp);
- tuple.t_len = ItemIdGetLength(lp);
- tuple.t_self = *tid;
+ buffer = ReadBuffer(relation, ItemPointerGetBlockNumber(tid));
- if (before)
- {
- if (TupleUpdatedByCurXactAndCmd(&tuple))
- {
- elog(NOTICE, "GetTupleForTrigger: Non-functional delete/update");
- ReleaseBuffer(b);
- return NULL;
- }
+ if (!BufferIsValid(buffer))
+ elog(ERROR, "GetTupleForTrigger: failed ReadBuffer");
- HeapTupleSatisfies(&tuple, relation, b, dp,
- false, 0, (ScanKey) NULL);
- if (!tuple.t_data)
- {
- ReleaseBuffer(b);
- elog(ERROR, "GetTupleForTrigger: (am)invalid tid");
- }
+ dp = (PageHeader) BufferGetPage(buffer);
+ lp = PageGetItemId(dp, ItemPointerGetOffsetNumber(tid));
+
+ Assert(ItemIdIsUsed(lp));
+
+ tuple.t_data = (HeapTupleHeader) PageGetItem((Page) dp, lp);
+ tuple.t_len = ItemIdGetLength(lp);
+ tuple.t_self = *tid;
}
result = heap_copytuple(&tuple);
- ReleaseBuffer(b);
+ ReleaseBuffer(buffer);
return result;
}
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: user.c,v 1.22 1998/12/14 08:11:00 scrappy Exp $
+ * $Id: user.c,v 1.23 1998/12/15 12:46:00 vadim Exp $
*
*-------------------------------------------------------------------------
*/
* Secure a write lock on pg_shadow so we can be sure of what the next
* usesysid should be.
*/
- RelationSetLockForWrite(pg_shadow_rel);
+ LockRelation(pg_shadow_rel, AccessExclusiveLock);
scan = heap_beginscan(pg_shadow_rel, false, SnapshotNow, 0, NULL);
while (HeapTupleIsValid(tuple = heap_getnext(scan, 0)))
if (exists)
{
- RelationUnsetLockForWrite(pg_shadow_rel);
+ UnlockRelation(pg_shadow_rel, AccessExclusiveLock);
heap_close(pg_shadow_rel);
UserAbortTransactionBlock();
elog(ERROR,
* This goes after the UpdatePgPwdFile to be certain that two backends
* to not attempt to write to the pg_pwd file at the same time.
*/
- RelationUnsetLockForWrite(pg_shadow_rel);
+ UnlockRelation(pg_shadow_rel, AccessExclusiveLock);
heap_close(pg_shadow_rel);
if (IsTransactionBlock() && !inblock)
* dump of the pg_pwd file is done, there is not another backend doing
* the same.
*/
- RelationSetLockForWrite(pg_shadow_rel);
+ LockRelation(pg_shadow_rel, AccessExclusiveLock);
tuple = SearchSysCacheTuple(USENAME,
PointerGetDatum(stmt->user),
0, 0, 0);
if (!HeapTupleIsValid(tuple))
{
- RelationUnsetLockForWrite(pg_shadow_rel);
+ UnlockRelation(pg_shadow_rel, AccessExclusiveLock);
heap_close(pg_shadow_rel);
UserAbortTransactionBlock(); /* needed? */
elog(ERROR, "alterUser: user \"%s\" does not exist", stmt->user);
UpdatePgPwdFile(sql);
- RelationUnsetLockForWrite(pg_shadow_rel);
+ UnlockRelation(pg_shadow_rel, AccessExclusiveLock);
heap_close(pg_shadow_rel);
if (IsTransactionBlock() && !inblock)
* dump of the pg_pwd file is done, there is not another backend doing
* the same.
*/
- RelationSetLockForWrite(pg_shadow_rel);
+ LockRelation(pg_shadow_rel, AccessExclusiveLock);
tuple = SearchSysCacheTuple(USENAME,
PointerGetDatum(user),
0, 0, 0);
if (!HeapTupleIsValid(tuple))
{
- RelationUnsetLockForWrite(pg_shadow_rel);
+ UnlockRelation(pg_shadow_rel, AccessExclusiveLock);
heap_close(pg_shadow_rel);
UserAbortTransactionBlock();
elog(ERROR, "removeUser: user \"%s\" does not exist", user);
UpdatePgPwdFile(sql);
- RelationUnsetLockForWrite(pg_shadow_rel);
+ UnlockRelation(pg_shadow_rel, AccessExclusiveLock);
heap_close(pg_shadow_rel);
if (IsTransactionBlock() && !inblock)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/vacuum.c,v 1.91 1998/11/27 19:51:58 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/vacuum.c,v 1.92 1998/12/15 12:46:01 vadim Exp $
*
*-------------------------------------------------------------------------
*/
}
/* we require the relation to be locked until the indices are cleaned */
- RelationSetLockForWrite(onerel);
+ LockRelation(onerel, AccessExclusiveLock);
/* scan it */
vacuum_pages.vpl_num_pages = fraged_pages.vpl_num_pages = 0;
if (i >= attcnt)
continue; /* don't delete it */
}
- heap_delete(pgstatistic, &tuple->t_self);
+ heap_delete(pgstatistic, &tuple->t_self, NULL);
}
heap_endscan(scan);
static void
vc_setpagelock(Relation rel, BlockNumber blkno)
{
- ItemPointerData itm;
-
- ItemPointerSet(&itm, blkno, 1);
-
- RelationSetLockForWritePage(rel, &itm);
+ LockPage(rel, blkno, ExclusiveLock);
}
/*
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/execMain.c,v 1.59 1998/11/27 19:51:59 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/execMain.c,v 1.60 1998/12/15 12:46:04 vadim Exp $
*
*-------------------------------------------------------------------------
*/
/* #include "access/localam.h" */
#include "optimizer/var.h"
#include "access/heapam.h"
+#include "access/xact.h"
#include "catalog/heap.h"
#include "commands/trigger.h"
{
/******************
* if we have a result relation, open it and
-
* initialize the result relation info stuff.
******************
*/
elog(ERROR, "You can't change sequence relation %s",
resultRelationDesc->rd_rel->relname.data);
- /*
- * Write-lock the result relation right away: if the relation is
- * used in a subsequent scan, we won't have to elevate the
- * read-lock set by heap_beginscan to a write-lock (needed by
- * heap_insert, heap_delete and heap_replace). This will hopefully
- * prevent some deadlocks. - 01/24/94
- */
- RelationSetLockForWrite(resultRelationDesc);
+ LockRelation(resultRelationDesc, RowExclusiveLock);
resultRelationInfo = makeNode(RelationInfo);
resultRelationInfo->ri_RangeTableIndex = resultRelationIndex;
* in the result relation information..
******************
*/
- ExecOpenIndices(resultRelationOid, resultRelationInfo);
+ if (operation != CMD_DELETE)
+ ExecOpenIndices(resultRelationOid, resultRelationInfo);
estate->es_result_relation_info = resultRelationInfo;
}
ItemPointer tupleid,
EState *estate)
{
- RelationInfo *resultRelationInfo;
- Relation resultRelationDesc;
+ RelationInfo *resultRelationInfo;
+ Relation resultRelationDesc;
+ ItemPointerData ctid;
+ int result;
/******************
* get the result relation information
{
bool dodelete;
- dodelete = ExecBRDeleteTriggers(resultRelationDesc, tupleid);
+ dodelete = ExecBRDeleteTriggers(estate, tupleid);
if (!dodelete) /* "do nothing" */
return;
}
- /******************
+ /*
* delete the tuple
- ******************
*/
- if (heap_delete(resultRelationDesc, /* relation desc */
- tupleid)) /* item pointer to tuple */
- return;
+ result = heap_delete(resultRelationDesc, tupleid, &ctid);
+ switch (result)
+ {
+ case HeapTupleSelfUpdated:
+ return;
+
+ case HeapTupleMayBeUpdated:
+ break;
+
+ case HeapTupleUpdated:
+ if (XactIsoLevel == XACT_SERIALIZED)
+ elog(ERROR, "Serialize access failed due to concurrent update");
+ else
+ elog(ERROR, "Isolation level %u is not supported", XactIsoLevel);
+ return;
+
+ default:
+ elog(ERROR, "Unknown status %u from heap_delete", result);
+ return;
+ }
IncrDeleted();
(estate->es_processed)++;
/* AFTER ROW DELETE Triggers */
if (resultRelationDesc->trigdesc &&
resultRelationDesc->trigdesc->n_after_row[TRIGGER_EVENT_DELETE] > 0)
- ExecARDeleteTriggers(resultRelationDesc, tupleid);
+ ExecARDeleteTriggers(estate, tupleid);
}
EState *estate,
Query *parseTree)
{
- HeapTuple tuple;
- RelationInfo *resultRelationInfo;
- Relation resultRelationDesc;
- int numIndices;
+ HeapTuple tuple;
+ RelationInfo *resultRelationInfo;
+ Relation resultRelationDesc;
+ ItemPointerData ctid;
+ int result;
+ int numIndices;
/******************
* abort the operation if not running transactions
{
HeapTuple newtuple;
- newtuple = ExecBRUpdateTriggers(resultRelationDesc, tupleid, tuple);
+ newtuple = ExecBRUpdateTriggers(estate, tupleid, tuple);
if (newtuple == NULL) /* "do nothing" */
return;
ExecConstraints("ExecReplace", resultRelationDesc, tuple);
}
- /******************
+ /*
* replace the heap tuple
- *
- * Don't want to continue if our heap_replace didn't actually
- * do a replace. This would be the case if heap_replace
- * detected a non-functional update. -kw 12/30/93
- ******************
*/
- if (heap_replace(resultRelationDesc, /* relation desc */
- tupleid, /* item ptr of tuple to replace */
- tuple))
- { /* replacement heap tuple */
- return;
+ result = heap_replace(resultRelationDesc, tupleid, tuple, &ctid);
+ switch (result)
+ {
+ case HeapTupleSelfUpdated:
+ return;
+
+ case HeapTupleMayBeUpdated:
+ break;
+
+ case HeapTupleUpdated:
+ if (XactIsoLevel == XACT_SERIALIZED)
+ elog(ERROR, "Serialize access failed due to concurrent update");
+ else
+ elog(ERROR, "Isolation level %u is not supported", XactIsoLevel);
+ return;
+
+ default:
+ elog(ERROR, "Unknown status %u from heap_replace", result);
+ return;
}
IncrReplaced();
/* AFTER ROW UPDATE Triggers */
if (resultRelationDesc->trigdesc &&
resultRelationDesc->trigdesc->n_after_row[TRIGGER_EVENT_UPDATE] > 0)
- ExecARUpdateTriggers(resultRelationDesc, tupleid, tuple);
+ ExecARUpdateTriggers(estate, tupleid, tuple);
}
#if 0
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/execUtils.c,v 1.40 1998/11/27 19:52:01 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/execUtils.c,v 1.41 1998/12/15 12:46:05 vadim Exp $
*
*-------------------------------------------------------------------------
*/
indexOid = lfirsti(indexoid);
indexDesc = index_open(indexOid);
if (indexDesc != NULL)
+ {
relationDescs[i++] = indexDesc;
+ /*
+ * Hack for not btree and hash indices: they use relation level
+ * exclusive locking on updation (i.e. - they are not ready
+ * for MVCC) and so we have to exclusively lock indices here
+ * to prevent deadlocks if we will scan them - index_beginscan
+ * places AccessShareLock, indices update methods don't use
+ * locks at all. We release this lock in ExecCloseIndices.
+ * Note, that hashes use page level locking - i.e. are not
+ * deadlock-free, - let's them be on their way -:))
+ * vadim 03-12-1998
+ */
+ if (indexDesc->rd_rel->relam != BTREE_AM_OID &&
+ indexDesc->rd_rel->relam != HASH_AM_OID)
+ LockRelation(indexDesc, AccessExclusiveLock);
+ }
}
/* ----------------
relationDescs = resultRelationInfo->ri_IndexRelationDescs;
for (i = 0; i < numIndices; i++)
- if (relationDescs[i] != NULL)
- index_close(relationDescs[i]);
+ {
+ if (relationDescs[i] == NULL)
+ continue;
+ /*
+ * Notes in ExecOpenIndices.
+ */
+ if (relationDescs[i]->rd_rel->relam != BTREE_AM_OID &&
+ relationDescs[i]->rd_rel->relam != HASH_AM_OID)
+ UnlockRelation(relationDescs[i], AccessExclusiveLock);
+ index_close(relationDescs[i]);
+ }
/*
* XXX should free indexInfo array here too.
*/
* Copyright (c) 1994, Regents of the University of California
*
*
- * $Id: nodeHash.c,v 1.27 1998/12/14 08:11:02 scrappy Exp $
+ * $Id: nodeHash.c,v 1.28 1998/12/15 12:46:06 vadim Exp $
*
*-------------------------------------------------------------------------
*/
else
heapTuple = (HeapTuple)
LONGALIGN(((char *) curtuple + curtuple->t_len + HEAPTUPLESIZE));
-
- heapTuple->t_data = (HeapTupleHeader)
- ((char *) heapTuple + HEAPTUPLESIZE);
while (heapTuple < (HeapTuple) ABSADDR(bucket->bottom))
{
+ heapTuple->t_data = (HeapTupleHeader)
+ ((char *) heapTuple + HEAPTUPLESIZE);
+
inntuple = ExecStoreTuple(heapTuple, /* tuple to store */
hjstate->hj_HashTupleSlot, /* slot */
InvalidBuffer, /* tuple has no buffer */
heapTuple = (HeapTuple)
LONGALIGN(((char *) heapTuple + heapTuple->t_len + HEAPTUPLESIZE));
- heapTuple->t_data = (HeapTupleHeader)
- ((char *) heapTuple + HEAPTUPLESIZE);
}
if (firstotuple == NULL)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/Attic/gram.c,v 2.51 1998/12/14 05:18:57 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/Attic/gram.c,v 2.52 1998/12/15 12:46:08 vadim Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_func.c,v 1.34 1998/12/13 23:54:40 thomas Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_func.c,v 1.35 1998/12/15 12:46:14 vadim Exp $
*
*-------------------------------------------------------------------------
*/
inhrel = heap_openr(InheritsRelationName);
- RelationSetLockForRead(inhrel);
inhtupdesc = RelationGetDescr(inhrel);
/*
}
} while (qentry != (SuperQE *) NULL);
- RelationUnsetLockForRead(inhrel);
heap_close(inhrel);
if (nvisited > 0)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteRemove.c,v 1.20 1998/12/14 00:02:17 thomas Exp $
+ * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteRemove.c,v 1.21 1998/12/15 12:46:16 vadim Exp $
*
*-------------------------------------------------------------------------
*/
/*
* Now delete the tuple...
*/
- heap_delete(RewriteRelation, &tuple->t_self);
+ heap_delete(RewriteRelation, &tuple->t_self, NULL);
pfree(tuple);
heap_close(RewriteRelation);
0, SnapshotNow, 1, &scanKeyData);
while (HeapTupleIsValid(tuple = heap_getnext(scanDesc, 0)))
- heap_delete(RewriteRelation, &tuple->t_self);
+ heap_delete(RewriteRelation, &tuple->t_self, NULL);
heap_endscan(scanDesc);
heap_close(RewriteRelation);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteSupport.c,v 1.29 1998/11/27 19:52:18 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteSupport.c,v 1.30 1998/12/15 12:46:18 vadim Exp $
*
*-------------------------------------------------------------------------
*/
relationRelation = heap_openr(RelationRelationName);
((Form_pg_class) GETSTRUCT(tuple))->relhasrules = relhasrules;
- heap_replace(relationRelation, &tuple->t_self, tuple);
+ heap_replace(relationRelation, &tuple->t_self, tuple, NULL);
/* keep the catalog indices up to date */
CatalogOpenIndices(Num_pg_class_indices, Name_pg_class_indices, idescs);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/buffer/buf_init.c,v 1.19 1998/09/01 04:31:39 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/buffer/buf_init.c,v 1.20 1998/12/15 12:46:18 vadim Exp $
*
*-------------------------------------------------------------------------
*/
#ifndef HAS_TEST_AND_SET
long *NWaitIOBackendP;
-
#endif
extern IpcSemaphoreId WaitIOSemId;
long *PrivateRefCount; /* also used in freelist.c */
long *LastRefCount; /* refcounts of last ExecMain level */
+bits8 *BufferLocks; /* */
long *CommitInfoNeedsSave;/* to write buffers where we have filled
* in t_infomask */
foundDescs;
int i;
- /* check padding of BufferDesc and BufferHdr */
-
- /*
- * we need both checks because a sbufdesc_padded >
- * PADDED_SBUFDESC_SIZE will shrink sbufdesc to the required size,
- * which is bad
- */
- if (sizeof(struct sbufdesc) != PADDED_SBUFDESC_SIZE ||
- sizeof(struct sbufdesc_unpadded) > PADDED_SBUFDESC_SIZE)
- elog(ERROR, "Internal error: sbufdesc does not have the proper size, "
- "contact the Postgres developers");
- if (sizeof(struct sbufdesc_unpadded) <= PADDED_SBUFDESC_SIZE / 2)
- elog(ERROR, "Internal error: sbufdesc is greatly over-sized, "
- "contact the Postgres developers");
-
Data_Descriptors = NBuffers;
Free_List_Descriptor = Data_Descriptors;
Lookup_List_Descriptor = Data_Descriptors + 1;
buf->buf_id = i;
#ifdef HAS_TEST_AND_SET
S_INIT_LOCK(&(buf->io_in_progress_lock));
+ S_INIT_LOCK(&(buf->cntx_lock));
#endif
}
WaitIOSemId = IpcSemaphoreCreate(IPCKeyGetWaitIOSemaphoreKey(key),
1, IPCProtection, 0, 1, &status);
+ WaitCLSemId = IpcSemaphoreCreate(IPCKeyGetWaitCLSemaphoreKey(key),
+ 1, IPCProtection,
+ IpcSemaphoreDefaultStartValue,
+ 1, &status);
}
#endif
PrivateRefCount = (long *) calloc(NBuffers, sizeof(long));
LastRefCount = (long *) calloc(NBuffers, sizeof(long));
+ BufferLocks = (bits8*) calloc (NBuffers, sizeof(bits8));
CommitInfoNeedsSave = (long *) calloc(NBuffers, sizeof(long));
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/buffer/bufmgr.c,v 1.44 1998/10/08 18:29:54 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/buffer/bufmgr.c,v 1.45 1998/12/15 12:46:19 vadim Exp $
*
*-------------------------------------------------------------------------
*/
#ifndef HAS_TEST_AND_SET
static void SignalIO(BufferDesc *buf);
extern long *NWaitIOBackendP; /* defined in buf_init.c */
-
#endif /* HAS_TEST_AND_SET */
static Buffer ReadBufferWithBufferLock(Relation relation, BlockNumber blockNum,
if (buf->refcount > 1)
SignalIO(buf);
#endif /* !HAS_TEST_AND_SET */
-
/* give up the buffer since we don't need it any more */
buf->refcount--;
PrivateRefCount[BufferDescriptorGetBuffer(buf) - 1] = 0;
#else /* HAS_TEST_AND_SET */
IpcSemaphoreId WaitIOSemId;
+IpcSemaphoreId WaitCLSemId;
static void
WaitIO(BufferDesc *buf, SPINLOCK spinlock)
if (!BufferIsLocal(buffer))
CommitInfoNeedsSave[buffer - 1]++;
}
+
+void
+UnlockBuffers()
+{
+ BufferDesc *buf;
+ int i;
+
+ for (i = 0; i < NBuffers; i++)
+ {
+ if (BufferLocks[i] == 0)
+ continue;
+
+ Assert(BufferIsValid(i+1));
+ buf = &(BufferDescriptors[i]);
+
+#ifdef HAS_TEST_AND_SET
+ S_LOCK(&(buf->cntx_lock));
+#else
+ IpcSemaphoreLock(WaitCLSemId, 0, IpcExclusiveLock);
+#endif
+
+ if (BufferLocks[i] & BL_R_LOCK)
+ {
+ Assert(buf->r_locks > 0);
+ (buf->r_locks)--;
+ }
+ if (BufferLocks[i] & BL_RI_LOCK)
+ {
+ Assert(buf->ri_lock);
+ buf->ri_lock = false;
+ }
+ if (BufferLocks[i] & BL_W_LOCK)
+ {
+ Assert(buf->w_lock);
+ buf->w_lock = false;
+ }
+#ifdef HAS_TEST_AND_SET
+ S_UNLOCK(&(buf->cntx_lock));
+#else
+ IpcSemaphoreUnlock(WaitCLSemId, 0, IpcExclusiveLock);
+#endif
+ BufferLocks[i] = 0;
+ }
+}
+
+void
+LockBuffer (Buffer buffer, int mode)
+{
+ BufferDesc *buf;
+
+ Assert(BufferIsValid(buffer));
+ if (BufferIsLocal(buffer))
+ return;
+
+ buf = &(BufferDescriptors[buffer-1]);
+
+#ifdef HAS_TEST_AND_SET
+ S_LOCK(&(buf->cntx_lock));
+#else
+ IpcSemaphoreLock(WaitCLSemId, 0, IpcExclusiveLock);
+#endif
+
+ if (mode == BUFFER_LOCK_UNLOCK)
+ {
+ if (BufferLocks[buffer-1] & BL_R_LOCK)
+ {
+ Assert(buf->r_locks > 0);
+ Assert(!(buf->w_lock));
+ Assert(!(BufferLocks[buffer-1] & (BL_W_LOCK | BL_RI_LOCK)))
+ (buf->r_locks)--;
+ BufferLocks[buffer-1] &= ~BL_R_LOCK;
+ }
+ else if (BufferLocks[buffer-1] & BL_W_LOCK)
+ {
+ Assert(buf->w_lock);
+ Assert(buf->r_locks == 0 && !buf->ri_lock);
+ Assert(!(BufferLocks[buffer-1] & (BL_R_LOCK | BL_RI_LOCK)))
+ buf->w_lock = false;
+ BufferLocks[buffer-1] &= ~BL_W_LOCK;
+ }
+ else
+ elog(ERROR, "UNLockBuffer: buffer %u is not locked", buffer);
+ }
+ else if (mode == BUFFER_LOCK_SHARE)
+ {
+ unsigned i = 0;
+
+ Assert(!(BufferLocks[buffer-1] & (BL_R_LOCK | BL_W_LOCK | BL_RI_LOCK)));
+ while (buf->ri_lock || buf->w_lock)
+ {
+#ifdef HAS_TEST_AND_SET
+ S_UNLOCK(&(buf->cntx_lock));
+ s_lock_sleep(i++);
+ S_LOCK(&(buf->cntx_lock));
+#else
+ IpcSemaphoreUnlock(WaitCLSemId, 0, IpcExclusiveLock);
+ s_lock_sleep(i++)
+ IpcSemaphoreLock(WaitCLSemId, 0, IpcExclusiveLock);
+#endif
+ }
+ (buf->r_locks)++;
+ BufferLocks[buffer-1] |= BL_R_LOCK;
+ }
+ else if (mode == BUFFER_LOCK_EXCLUSIVE)
+ {
+ unsigned i = 0;
+
+ Assert(!(BufferLocks[buffer-1] & (BL_R_LOCK | BL_W_LOCK | BL_RI_LOCK)));
+ while (buf->r_locks > 0 || buf->w_lock)
+ {
+ if (buf->r_locks > 3)
+ {
+ if (!(BufferLocks[buffer-1] & BL_RI_LOCK))
+ BufferLocks[buffer-1] |= BL_RI_LOCK;
+ buf->ri_lock = true;
+ }
+#ifdef HAS_TEST_AND_SET
+ S_UNLOCK(&(buf->cntx_lock));
+ s_lock_sleep(i++);
+ S_LOCK(&(buf->cntx_lock));
+#else
+ IpcSemaphoreUnlock(WaitCLSemId, 0, IpcExclusiveLock);
+ s_lock_sleep(i++)
+ IpcSemaphoreLock(WaitCLSemId, 0, IpcExclusiveLock);
+#endif
+ }
+ buf->w_lock = true;
+ BufferLocks[buffer-1] |= BL_W_LOCK;
+ if (BufferLocks[buffer-1] & BL_RI_LOCK)
+ {
+ buf->ri_lock = false;
+ BufferLocks[buffer-1] &= ~BL_RI_LOCK;
+ }
+ }
+ else
+ elog(ERROR, "LockBuffer: unknown lock mode %d", mode);
+
+#ifdef HAS_TEST_AND_SET
+ S_UNLOCK(&(buf->cntx_lock));
+#else
+ IpcSemaphoreUnlock(WaitCLSemId, 0, IpcExclusiveLock);
+#endif
+
+}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/buffer/Attic/s_lock.c,v 1.12 1998/09/18 17:18:39 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/buffer/Attic/s_lock.c,v 1.13 1998/12/15 12:46:21 vadim Exp $
*
*-------------------------------------------------------------------------
*/
#include
#include
+#include
#include "config.h"
#include "c.h"
}
+void
+s_lock_sleep(unsigned spin)
+{
+ struct timeval delay;
+
+ delay.tv_sec = 0;
+ delay.tv_usec = s_spincycle[spin % S_NSPINCYCLE];
+ (void) select(0, NULL, NULL, NULL, &delay);
+}
+
/*
* s_lock(lock) - take a spinlock with backoff
void
s_lock(volatile slock_t *lock, const char *file, const int line)
{
- int spins = 0;
+ unsigned spins = 0;
while (TAS(lock))
{
- struct timeval delay;
-
- delay.tv_sec = 0;
- delay.tv_usec = s_spincycle[spins % S_NSPINCYCLE];
- (void) select(0, NULL, NULL, NULL, &delay);
+ s_lock_sleep(spins);
if (++spins > S_MAX_BUSY)
{
/* It's been over a minute... */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/ipc/ipci.c,v 1.16 1998/09/01 03:25:10 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/ipc/ipci.c,v 1.17 1998/12/15 12:46:24 vadim Exp $
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
#include "storage/ipc.h"
-#include "storage/multilev.h"
#include "storage/sinval.h"
#include "storage/bufmgr.h"
#include "storage/proc.h"
* ----------------
*/
InitLocks();
- if (InitMultiLevelLocks() == INVALID_TABLEID)
+ if (InitLockTable() == INVALID_TABLEID)
elog(FATAL, "Couldn't create the lock table");
/* ----------------
* ----------------
*/
InitLocks();
- if (InitMultiLevelLocks() == INVALID_TABLEID)
+ if (InitLockTable() == INVALID_TABLEID)
elog(FATAL, "Couldn't attach to the lock table");
AttachSharedInvalidationState(key);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/ipc/shmem.c,v 1.31 1998/09/01 04:31:49 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/ipc/shmem.c,v 1.32 1998/12/15 12:46:24 vadim Exp $
*
*-------------------------------------------------------------------------
*/
#include "utils/dynahash.h"
#include "utils/hsearch.h"
#include "utils/memutils.h"
-#include "access/transam.h"
+#include "access/xact.h"
+#include "utils/tqual.h"
/* shared memory global variables */
return false;
}
-#ifdef LowLevelLocking
/*
* GetSnapshotData -- returns information about running transactions.
*
GetSnapshotData(bool serialized)
{
Snapshot snapshot = (Snapshot) malloc(sizeof(SnapshotData));
- TransactionId snapshot->xip = (TransactionId *)
- malloc(32 * sizeof(TransactionId));
ShmemIndexEnt *result;
PROC *proc;
TransactionId cid = GetCurrentTransactionId();
- uint count = 0;
- unit free = 31;
+ uint32 count = 0;
+ uint32 have = 31;
Assert(ShmemIndex);
+ snapshot->xip = (TransactionId *) malloc(32 * sizeof(TransactionId));
snapshot->xmax = cid;
snapshot->xmin = cid;
continue;
proc = (PROC *) MAKE_PTR(result->location);
if (proc == MyProc || proc->xid < FirstTransactionId ||
- serialized && proc->xid >= cid)
+ (serialized && proc->xid >= cid))
continue;
if (proc->xid < snapshot->xmin)
snapshot->xmin = proc->xid;
else if (proc->xid > snapshot->xmax)
snapshot->xmax = proc->xid;
- if (free == 0)
+ if (have == 0)
{
snapshot->xip = (TransactionId *) realloc(snapshot->xip,
(count + 33) * sizeof(TransactionId));
- free = 32;
+ have = 32;
}
snapshot->xip[count] = proc->xid;
- free--;
+ have--;
count++;
}
elog(ERROR, "GetSnapshotData: ShmemIndex corrupted");
return NULL;
}
-
-#endif
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/large_object/inv_api.c,v 1.43 1998/12/13 05:07:50 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/large_object/inv_api.c,v 1.44 1998/12/15 12:46:26 vadim Exp $
*
*-------------------------------------------------------------------------
*/
if (flags & INV_WRITE)
{
- RelationSetLockForWrite(r);
+ LockRelation(r, ExclusiveLock);
retval->flags = IFS_WRLOCK | IFS_RDLOCK;
}
else if (flags & INV_READ)
{
- RelationSetLockForRead(r);
+ LockRelation(r, ShareLock);
retval->flags = IFS_RDLOCK;
}
retval->flags |= IFS_ATEOF;
if (flags & INV_WRITE)
{
- RelationSetLockForWrite(r);
+ LockRelation(r, ExclusiveLock);
retval->flags = IFS_WRLOCK | IFS_RDLOCK;
}
else if (flags & INV_READ)
{
- RelationSetLockForRead(r);
+ LockRelation(r, ShareLock);
retval->flags = IFS_RDLOCK;
}
/* need read lock for stat */
if (!(obj_desc->flags & IFS_RDLOCK))
{
- RelationSetLockForRead(obj_desc->heap_r);
+ LockRelation(obj_desc->heap_r, ShareLock);
obj_desc->flags |= IFS_RDLOCK;
}
/* need read lock for getsize */
if (!(obj_desc->flags & IFS_RDLOCK))
{
- RelationSetLockForRead(obj_desc->heap_r);
+ LockRelation(obj_desc->heap_r, ShareLock);
obj_desc->flags |= IFS_RDLOCK;
}
offset += _inv_getsize(obj_desc->heap_r,
/* make sure we obey two-phase locking */
if (!(obj_desc->flags & IFS_RDLOCK))
{
- RelationSetLockForRead(obj_desc->heap_r);
+ LockRelation(obj_desc->heap_r, ShareLock);
obj_desc->flags |= IFS_RDLOCK;
}
if (!(obj_desc->flags & IFS_WRLOCK))
{
- RelationSetLockForRead(obj_desc->heap_r);
+ LockRelation(obj_desc->heap_r, ShareLock);
obj_desc->flags |= (IFS_WRLOCK | IFS_RDLOCK);
}
# Makefile for storage/lmgr
#
# IDENTIFICATION
-# $Header: /cvsroot/pgsql/src/backend/storage/lmgr/Makefile,v 1.8 1998/07/26 04:30:40 scrappy Exp $
+# $Header: /cvsroot/pgsql/src/backend/storage/lmgr/Makefile,v 1.9 1998/12/15 12:46:29 vadim Exp $
#
#-------------------------------------------------------------------------
CFLAGS+= $(MBFLAGS)
endif
-OBJS = lmgr.o lock.o multi.o proc.o single.o
+OBJS = lmgr.o lock.o proc.o
all: SUBSYS.o
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lmgr.c,v 1.19 1998/09/01 04:31:58 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lmgr.c,v 1.20 1998/12/15 12:46:30 vadim Exp $
*
*-------------------------------------------------------------------------
*/
extern Oid MyDatabaseId;
+static MASK LockConflicts[] = {
+ (int) NULL,
+
+/* AccessShareLock */
+ (1 << AccessExclusiveLock),
+
+/* RowShareLock */
+ (1 << ExclusiveLock) | (1 << AccessExclusiveLock),
+
+/* RowExclusiveLock */
+ (1 << ExclusiveLock) | (1 << ShareRowExclusiveLock) | (1 << ShareLock) |
+ (1 << AccessExclusiveLock),
+
+/* ShareLock */
+ (1 << ExclusiveLock) | (1 << ShareRowExclusiveLock) |
+ (1 << RowExclusiveLock) | (1 << AccessExclusiveLock),
+
+/* ShareRowExclusiveLock */
+ (1 << ExclusiveLock) | (1 << ShareRowExclusiveLock) |
+ (1 << ShareLock) | (1 << RowExclusiveLock) | (1 << AccessExclusiveLock),
+
+/* ExclusiveLock */
+ (1 << ExclusiveLock) | (1 << ShareRowExclusiveLock) | (1 << ShareLock) |
+ (1 << RowExclusiveLock) | (1 << RowShareLock) | (1 << AccessExclusiveLock),
+
+/* AccessExclusiveLock */
+ (1 << ExclusiveLock) | (1 << ShareRowExclusiveLock) | (1 << ShareLock) |
+ (1 << RowExclusiveLock) | (1 << RowShareLock) | (1 << AccessExclusiveLock) |
+ (1 << AccessShareLock),
+
+/* ExtendLock */
+ (1 << ExtendLock)
+
+};
+
+static int LockPrios[] = {
+ (int) NULL,
+ 1,
+ 2,
+ 3,
+ 4,
+ 5,
+ 6,
+ 7,
+ 1
+};
+
+LOCKMETHOD LockTableId = (LOCKMETHOD) NULL;
+LOCKMETHOD LongTermTableId = (LOCKMETHOD) NULL;
+
+/*
+ * Create the lock table described by LockConflicts and LockPrios.
+ */
+LOCKMETHOD
+InitLockTable()
+{
+ int lockmethod;
+
+ lockmethod = LockMethodTableInit("LockTable",
+ LockConflicts, LockPrios, MAX_LOCKMODES - 1);
+ LockTableId = lockmethod;
+ if (!(LockTableId))
+ elog(ERROR, "InitLockTable: couldnt initialize lock table");
+
+#ifdef USER_LOCKS
+ /*
+ * Allocate another tableId for long-term locks
+ */
+ LongTermTableId = LockMethodTableRename(LockTableId);
+ if (!(LongTermTableId))
+ {
+ elog(ERROR,
+ "InitLockTable: couldn't rename long-term lock table");
+ }
+#endif
+
+ return LockTableId;
+}
+
/*
* RelationInitLockInfo --
* Initializes the lock information in a relation descriptor.
else
info->lockRelId.dbId = MyDatabaseId;
-#ifdef LowLevelLocking
- memset(info->lockHeld, 0, sizeof(info->lockHeld));
-#endif
-
relation->lockInfo = (Pointer) info;
}
/*
- * RelationSetLockForDescriptorOpen --
- * Sets read locks for a relation descriptor.
- */
-#ifdef LOCKDEBUGALL
-#define LOCKDEBUGALL_30 \
-elog(DEBUG, "RelationSetLockForDescriptorOpen(%s[%d,%d]) called", \
- RelationGetRelationName(relation), lockRelId.dbId, lockRelId.relId)
-#else
-#define LOCKDEBUGALL_30
-#endif /* LOCKDEBUGALL */
-
-void
-RelationSetLockForDescriptorOpen(Relation relation)
-{
- /* ----------------
- * sanity checks
- * ----------------
- */
- Assert(RelationIsValid(relation));
- if (LockingDisabled())
- return;
-
- LOCKDEBUGALL_30;
-
- /* ----------------
- * read lock catalog tuples which compose the relation descriptor
- * XXX race condition? XXX For now, do nothing.
- * ----------------
- */
-}
-
-/* ----------------
- * RelationSetLockForRead
- * ----------------
- */
-#ifdef LOCKDEBUG
-#define LOCKDEBUG_40 \
-elog(DEBUG, "RelationSetLockForRead(%s[%d,%d]) called", \
- RelationGetRelationName(relation), lockRelId.dbId, lockRelId.relId)
-#else
-#define LOCKDEBUG_40
-#endif /* LOCKDEBUG */
-
-/*
- * RelationSetLockForRead --
- * Sets relation level read lock.
+ * LockRelation
*/
void
-RelationSetLockForRead(Relation relation)
+LockRelation(Relation relation, LOCKMODE lockmode)
{
LockInfo lockinfo;
+ LOCKTAG tag;
- /* ----------------
- * sanity checks
- * ----------------
- */
- Assert(RelationIsValid(relation));
if (LockingDisabled())
return;
- LOCKDEBUG_40;
-
- /* ----------------
- * If we don't have lock info on the reln just go ahead and
- * lock it without trying to short circuit the lock manager.
- * ----------------
- */
if (!LockInfoIsValid(relation->lockInfo))
- {
RelationInitLockInfo(relation);
- lockinfo = (LockInfo) relation->lockInfo;
- MultiLockReln(lockinfo, READ_LOCK);
- return;
- }
- else
- lockinfo = (LockInfo) relation->lockInfo;
- MultiLockReln(lockinfo, READ_LOCK);
-}
+ lockinfo = (LockInfo) relation->lockInfo;
-/* ----------------
- * RelationUnsetLockForRead
- * ----------------
- */
-#ifdef LOCKDEBUG
-#define LOCKDEBUG_50 \
-elog(DEBUG, "RelationUnsetLockForRead(%s[%d,%d]) called", \
- RelationGetRelationName(relation), lockRelId.dbId, lockRelId.relId)
-#else
-#define LOCKDEBUG_50
-#endif /* LOCKDEBUG */
+ MemSet(&tag, 0, sizeof(tag));
+ tag.relId = lockinfo->lockRelId.relId;
+ tag.dbId = lockinfo->lockRelId.dbId;
+ tag.objId.blkno = InvalidBlockNumber;
+
+ LockAcquire(LockTableId, &tag, lockmode);
+ return;
+}
/*
- * RelationUnsetLockForRead --
- * Unsets relation level read lock.
+ * UnlockRelation
*/
void
-RelationUnsetLockForRead(Relation relation)
+UnlockRelation(Relation relation, LOCKMODE lockmode)
{
LockInfo lockinfo;
+ LOCKTAG tag;
- /* ----------------
- * sanity check
- * ----------------
- */
- Assert(RelationIsValid(relation));
if (LockingDisabled())
return;
lockinfo = (LockInfo) relation->lockInfo;
- /* ----------------
- * If we don't have lock info on the reln just go ahead and
- * release it.
- * ----------------
- */
if (!LockInfoIsValid(lockinfo))
{
elog(ERROR,
RelationGetRelationName(relation));
}
- MultiReleaseReln(lockinfo, READ_LOCK);
-}
+ MemSet(&tag, 0, sizeof(tag));
+ tag.relId = lockinfo->lockRelId.relId;
+ tag.dbId = lockinfo->lockRelId.dbId;
+ tag.objId.blkno = InvalidBlockNumber;
-/* ----------------
- * RelationSetLockForWrite(relation)
- * ----------------
- */
-#ifdef LOCKDEBUG
-#define LOCKDEBUG_60 \
-elog(DEBUG, "RelationSetLockForWrite(%s[%d,%d]) called", \
- RelationGetRelationName(relation), lockRelId.dbId, lockRelId.relId)
-#else
-#define LOCKDEBUG_60
-#endif /* LOCKDEBUG */
+ LockRelease(LockTableId, &tag, lockmode);
+ return;
+}
/*
- * RelationSetLockForWrite --
- * Sets relation level write lock.
+ * LockPage
*/
void
-RelationSetLockForWrite(Relation relation)
+LockPage(Relation relation, BlockNumber blkno, LOCKMODE lockmode)
{
LockInfo lockinfo;
+ LOCKTAG tag;
- /* ----------------
- * sanity checks
- * ----------------
- */
- Assert(RelationIsValid(relation));
if (LockingDisabled())
return;
- LOCKDEBUG_60;
-
- /* ----------------
- * If we don't have lock info on the reln just go ahead and
- * lock it without trying to short circuit the lock manager.
- * ----------------
- */
if (!LockInfoIsValid(relation->lockInfo))
- {
RelationInitLockInfo(relation);
- lockinfo = (LockInfo) relation->lockInfo;
- MultiLockReln(lockinfo, WRITE_LOCK);
- return;
- }
- else
- lockinfo = (LockInfo) relation->lockInfo;
- MultiLockReln(lockinfo, WRITE_LOCK);
-}
+ lockinfo = (LockInfo) relation->lockInfo;
-/* ----------------
- * RelationUnsetLockForWrite
- * ----------------
- */
-#ifdef LOCKDEBUG
-#define LOCKDEBUG_70 \
-elog(DEBUG, "RelationUnsetLockForWrite(%s[%d,%d]) called", \
- RelationGetRelationName(relation), lockRelId.dbId, lockRelId.relId)
-#else
-#define LOCKDEBUG_70
-#endif /* LOCKDEBUG */
+ MemSet(&tag, 0, sizeof(tag));
+ tag.relId = lockinfo->lockRelId.relId;
+ tag.dbId = lockinfo->lockRelId.dbId;
+ tag.objId.blkno = blkno;
+
+ LockAcquire(LockTableId, &tag, lockmode);
+ return;
+}
/*
- * RelationUnsetLockForWrite --
- * Unsets relation level write lock.
+ * UnlockPage
*/
void
-RelationUnsetLockForWrite(Relation relation)
+UnlockPage(Relation relation, BlockNumber blkno, LOCKMODE lockmode)
{
LockInfo lockinfo;
+ LOCKTAG tag;
- /* ----------------
- * sanity checks
- * ----------------
- */
- Assert(RelationIsValid(relation));
if (LockingDisabled())
return;
RelationGetRelationName(relation));
}
- MultiReleaseReln(lockinfo, WRITE_LOCK);
-}
+ MemSet(&tag, 0, sizeof(tag));
+ tag.relId = lockinfo->lockRelId.relId;
+ tag.dbId = lockinfo->lockRelId.dbId;
+ tag.objId.blkno = blkno;
-/* ----------------
- * RelationSetLockForReadPage
- * ----------------
- */
-#ifdef LOCKDEBUG
-#define LOCKDEBUG_90 \
-elog(DEBUG, "RelationSetLockForReadPage(%s[%d,%d], @%d) called", \
- RelationGetRelationName(relation), lockRelId.dbId, lockRelId.relId, page)
-#else
-#define LOCKDEBUG_90
-#endif /* LOCKDEBUG */
-
-/* ----------------
- * RelationSetLockForWritePage
- * ----------------
- */
-#ifdef LOCKDEBUG
-#define LOCKDEBUG_100 \
-elog(DEBUG, "RelationSetLockForWritePage(%s[%d,%d], @%d) called", \
- RelationGetRelationName(relation), lockRelId.dbId, lockRelId.relId, page)
-#else
-#define LOCKDEBUG_100
-#endif /* LOCKDEBUG */
-
-/*
- * RelationSetLockForWritePage --
- * Sets write lock on a page.
- */
-void
-RelationSetLockForWritePage(Relation relation,
- ItemPointer itemPointer)
-{
- /* ----------------
- * sanity checks
- * ----------------
- */
- Assert(RelationIsValid(relation));
- if (LockingDisabled())
- return;
-
- /* ---------------
- * Make sure lockinfo is initialized
- * ---------------
- */
- if (!LockInfoIsValid(relation->lockInfo))
- RelationInitLockInfo(relation);
-
- /* ----------------
- * attempt to set lock
- * ----------------
- */
- MultiLockPage((LockInfo) relation->lockInfo, itemPointer, WRITE_LOCK);
+ LockRelease(LockTableId, &tag, lockmode);
+ return;
}
-/* ----------------
- * RelationUnsetLockForReadPage
- * ----------------
- */
-#ifdef LOCKDEBUG
-#define LOCKDEBUG_110 \
-elog(DEBUG, "RelationUnsetLockForReadPage(%s[%d,%d], @%d) called", \
- RelationGetRelationName(relation), lockRelId.dbId, lockRelId.relId, page)
-#else
-#define LOCKDEBUG_110
-#endif /* LOCKDEBUG */
-
-/* ----------------
- * RelationUnsetLockForWritePage
- * ----------------
- */
-#ifdef LOCKDEBUG
-#define LOCKDEBUG_120 \
-elog(DEBUG, "RelationUnsetLockForWritePage(%s[%d,%d], @%d) called", \
- RelationGetRelationName(relation), lockRelId.dbId, lockRelId.relId, page)
-#else
-#define LOCKDEBUG_120
-#endif /* LOCKDEBUG */
-
-/*
- * Set a single level write page lock. Assumes that you already
- * have a write intent lock on the relation.
- */
void
-RelationSetSingleWLockPage(Relation relation,
- ItemPointer itemPointer)
+XactLockTableInsert(TransactionId xid)
{
+ LOCKTAG tag;
- /* ----------------
- * sanity checks
- * ----------------
- */
- Assert(RelationIsValid(relation));
if (LockingDisabled())
return;
- if (!LockInfoIsValid(relation->lockInfo))
- RelationInitLockInfo(relation);
+ MemSet(&tag, 0, sizeof(tag));
+ tag.relId = XactLockTableId;
+ tag.dbId = InvalidOid;
+ tag.objId.xid = xid;
- SingleLockPage((LockInfo) relation->lockInfo, itemPointer, WRITE_LOCK, !UNLOCK);
+ LockAcquire(LockTableId, &tag, ExclusiveLock);
+ return;
}
-/*
- * Unset a single level write page lock
- */
void
-RelationUnsetSingleWLockPage(Relation relation,
- ItemPointer itemPointer)
+XactLockTableDelete(TransactionId xid)
{
+ LOCKTAG tag;
- /* ----------------
- * sanity checks
- * ----------------
- */
- Assert(RelationIsValid(relation));
if (LockingDisabled())
return;
- if (!LockInfoIsValid(relation->lockInfo))
- elog(ERROR,
- "Releasing a lock on %s with invalid lock information",
- RelationGetRelationName(relation));
-
- SingleLockPage((LockInfo) relation->lockInfo, itemPointer, WRITE_LOCK, UNLOCK);
-}
-
-/*
- * Set a single level read page lock. Assumes you already have a read
- * intent lock set on the relation.
- */
-void
-RelationSetSingleRLockPage(Relation relation,
- ItemPointer itemPointer)
-{
-
- /* ----------------
- * sanity checks
- * ----------------
- */
- Assert(RelationIsValid(relation));
- if (LockingDisabled())
- return;
-
- if (!LockInfoIsValid(relation->lockInfo))
- RelationInitLockInfo(relation);
-
- SingleLockPage((LockInfo) relation->lockInfo, itemPointer, READ_LOCK, !UNLOCK);
-}
-
-/*
- * Unset a single level read page lock.
- */
-void
-RelationUnsetSingleRLockPage(Relation relation,
- ItemPointer itemPointer)
-{
-
- /* ----------------
- * sanity checks
- * ----------------
- */
- Assert(RelationIsValid(relation));
- if (LockingDisabled())
- return;
-
- if (!LockInfoIsValid(relation->lockInfo))
- elog(ERROR,
- "Releasing a lock on %s with invalid lock information",
- RelationGetRelationName(relation));
-
- SingleLockPage((LockInfo) relation->lockInfo, itemPointer, READ_LOCK, UNLOCK);
-}
-
-/*
- * Set a read intent lock on a relation.
- *
- * Usually these are set in a multi-level table when you acquiring a
- * page level lock. i.e. To acquire a lock on a page you first acquire
- * an intent lock on the entire relation. Acquiring an intent lock along
- * allows one to use the single level locking routines later. Good for
- * index scans that do a lot of page level locking.
- */
-void
-RelationSetRIntentLock(Relation relation)
-{
- /* -----------------
- * Sanity check
- * -----------------
- */
- Assert(RelationIsValid(relation));
- if (LockingDisabled())
- return;
-
- if (!LockInfoIsValid(relation->lockInfo))
- RelationInitLockInfo(relation);
-
- SingleLockReln((LockInfo) relation->lockInfo, READ_LOCK + INTENT, !UNLOCK);
-}
-
-/*
- * Unset a read intent lock on a relation
- */
-void
-RelationUnsetRIntentLock(Relation relation)
-{
- /* -----------------
- * Sanity check
- * -----------------
- */
- Assert(RelationIsValid(relation));
- if (LockingDisabled())
- return;
-
- if (!LockInfoIsValid(relation->lockInfo))
- RelationInitLockInfo(relation);
+ MemSet(&tag, 0, sizeof(tag));
+ tag.relId = XactLockTableId;
+ tag.dbId = InvalidOid;
+ tag.objId.xid = xid;
- SingleLockReln((LockInfo) relation->lockInfo, READ_LOCK + INTENT, UNLOCK);
+ LockRelease(LockTableId, &tag, ExclusiveLock);
+ return;
}
-/*
- * Set a write intent lock on a relation. For a more complete explanation
- * see RelationSetRIntentLock()
- */
void
-RelationSetWIntentLock(Relation relation)
+XactLockTableWait(TransactionId xid)
{
- /* -----------------
- * Sanity check
- * -----------------
- */
- Assert(RelationIsValid(relation));
- if (LockingDisabled())
- return;
-
- if (!LockInfoIsValid(relation->lockInfo))
- RelationInitLockInfo(relation);
+ LOCKTAG tag;
- SingleLockReln((LockInfo) relation->lockInfo, WRITE_LOCK + INTENT, !UNLOCK);
-}
-
-/*
- * Unset a write intent lock.
- */
-void
-RelationUnsetWIntentLock(Relation relation)
-{
- /* -----------------
- * Sanity check
- * -----------------
- */
- Assert(RelationIsValid(relation));
if (LockingDisabled())
return;
- if (!LockInfoIsValid(relation->lockInfo))
- RelationInitLockInfo(relation);
+ MemSet(&tag, 0, sizeof(tag));
+ tag.relId = XactLockTableId;
+ tag.dbId = InvalidOid;
+ tag.objId.xid = xid;
- SingleLockReln((LockInfo) relation->lockInfo, WRITE_LOCK + INTENT, UNLOCK);
-}
+ LockAcquire(LockTableId, &tag, ShareLock);
-/*
- * Extend locks are used primarily in tertiary storage devices such as
- * a WORM disk jukebox. Sometimes need exclusive access to extend a
- * file by a block.
- */
-#ifdef NOT_USED
-void
-RelationSetLockForExtend(Relation relation)
-{
- /* -----------------
- * Sanity check
- * -----------------
+ /*
+ * Transaction was committed/aborted/crashed -
+ * we have to update pg_log if transaction is still
+ * marked as running.
*/
- Assert(RelationIsValid(relation));
- if (LockingDisabled())
- return;
-
- if (!LockInfoIsValid(relation->lockInfo))
- RelationInitLockInfo(relation);
+ if (!TransactionIdDidCommit(xid) && !TransactionIdDidAbort(xid))
+ TransactionIdAbort(xid);
- MultiLockReln((LockInfo) relation->lockInfo, EXTEND_LOCK);
+ return;
}
-
-#endif
-
-#ifdef NOT_USED
-void
-RelationUnsetLockForExtend(Relation relation)
-{
- /* -----------------
- * Sanity check
- * -----------------
- */
- Assert(RelationIsValid(relation));
- if (LockingDisabled())
- return;
-
- if (!LockInfoIsValid(relation->lockInfo))
- RelationInitLockInfo(relation);
-
- MultiReleaseReln((LockInfo) relation->lockInfo, EXTEND_LOCK);
-}
-
-#endif
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lock.c,v 1.38 1998/10/08 18:29:57 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lock.c,v 1.39 1998/12/15 12:46:30 vadim Exp $
*
* NOTES
* Outside modules can create a lock table and acquire/release
#define LOCK_PRINT_AUX(where,lock,type) \
TPRINTF(TRACE_ALL, \
- "%s: lock(%x) tbl(%d) rel(%d) db(%d) tid(%d,%d) mask(%x) " \
+ "%s: lock(%x) tbl(%d) rel(%d) db(%d) obj(%u) mask(%x) " \
"hold(%d,%d,%d,%d,%d)=%d " \
"act(%d,%d,%d,%d,%d)=%d wait(%d) type(%s)", \
where, \
lock->tag.lockmethod, \
lock->tag.relId, \
lock->tag.dbId, \
- ((lock->tag.tupleId.ip_blkid.bi_hi<<16)+ \
- lock->tag.tupleId.ip_blkid.bi_lo), \
- lock->tag.tupleId.ip_posid, \
+ lock->tag.objId.blkno, \
lock->mask, \
lock->holders[1], \
lock->holders[2], \
if (is_user_lock)
{
#ifdef USER_LOCKS_DEBUG
- TPRINTF(TRACE_USERLOCKS, "LockAcquire: user lock [%u,%u] %s",
- locktag->tupleId.ip_posid,
- ((locktag->tupleId.ip_blkid.bi_hi << 16) +
- locktag->tupleId.ip_blkid.bi_lo),
+ TPRINTF(TRACE_USERLOCKS, "LockAcquire: user lock [%u] %s",
+ locktag->objId.blkno,
lock_types[lockmode]);
#endif
}
MemSet((char *) lock->holders, 0, sizeof(int) * MAX_LOCKMODES);
MemSet((char *) lock->activeHolders, 0, sizeof(int) * MAX_LOCKMODES);
ProcQueueInit(&(lock->waitProcs));
- Assert(BlockIdEquals(&(lock->tag.tupleId.ip_blkid),
- &(locktag->tupleId.ip_blkid)));
+ Assert(lock->tag.objId.blkno == locktag->objId.blkno);
LOCK_PRINT("LockAcquire: new", lock, lockmode);
}
else
is_user_lock = (lockmethod == USER_LOCKMETHOD);
if (is_user_lock)
{
- TPRINTF(TRACE_USERLOCKS, "LockRelease: user lock tag [%u,%u] %d",
- locktag->tupleId.ip_posid,
- ((locktag->tupleId.ip_blkid.bi_hi << 16) +
- locktag->tupleId.ip_blkid.bi_lo),
+ TPRINTF(TRACE_USERLOCKS, "LockRelease: user lock tag [%u] %d",
+ locktag->objId.blkno,
lockmode);
}
#endif
{
/* Should never happen */
elog(NOTICE,
- "LockReleaseAll: INVALID PID: [%u,%u] [%d,%d,%d]",
- lock->tag.tupleId.ip_posid,
- ((lock->tag.tupleId.ip_blkid.bi_hi << 16) +
- lock->tag.tupleId.ip_blkid.bi_lo),
+ "LockReleaseAll: INVALID PID: [%u] [%d,%d,%d]",
+ lock->tag.objId.blkno,
xidLook->tag.lock, xidLook->tag.pid, xidLook->tag.xid);
nleft++;
goto next_item;
}
TPRINTF(TRACE_USERLOCKS,
- "LockReleaseAll: releasing user lock [%u,%u] [%d,%d,%d]",
- lock->tag.tupleId.ip_posid,
- ((lock->tag.tupleId.ip_blkid.bi_hi << 16) +
- lock->tag.tupleId.ip_blkid.bi_lo),
+ "LockReleaseAll: releasing user lock [%u] [%d,%d,%d]",
+ lock->tag.objId.blkno,
xidLook->tag.lock, xidLook->tag.pid, xidLook->tag.xid);
}
else
if (xidLook->tag.pid != 0)
{
TPRINTF(TRACE_LOCKS,
- "LockReleaseAll: skiping user lock [%u,%u] [%d,%d,%d]",
- lock->tag.tupleId.ip_posid,
- ((lock->tag.tupleId.ip_blkid.bi_hi << 16) +
- lock->tag.tupleId.ip_blkid.bi_lo),
+ "LockReleaseAll: skiping user lock [%u] [%d,%d,%d]",
+ lock->tag.objId.blkno,
xidLook->tag.lock, xidLook->tag.pid, xidLook->tag.xid);
nleft++;
goto next_item;
*/
Assert(skip_check);
- Assert(MyProc->prio == 2);
+ Assert(MyProc->prio >= 2);
lockMethodTable = LockMethodTable[1];
xidTable = lockMethodTable->xidHash;
is_user_lock = (lockmethod == USER_LOCKMETHOD);
if (is_user_lock)
{
- TPRINTF(TRACE_USERLOCKS, "LockOwners: user lock tag [%u,%u]",
- locktag->tupleId.ip_posid,
- ((locktag->tupleId.ip_blkid.bi_hi << 16) +
- locktag->tupleId.ip_blkid.bi_lo));
+ TPRINTF(TRACE_USERLOCKS, "LockOwners: user lock tag [%u]",
+ locktag->objId.blkno;,
}
#endif
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/sets.c,v 1.19 1998/11/27 19:52:23 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/sets.c,v 1.20 1998/12/15 12:46:34 vadim Exp $
*
*-------------------------------------------------------------------------
*/
/* change the pg_proc tuple */
procrel = heap_openr(ProcedureRelationName);
- RelationSetLockForWrite(procrel);
+ LockRelation(procrel, AccessExclusiveLock);
tup = SearchSysCacheTuple(PROOID,
ObjectIdGetDatum(setoid),
repl);
setheapoverride(true);
- heap_replace(procrel, &tup->t_self, newtup);
+ heap_replace(procrel, &tup->t_self, newtup, NULL);
setheapoverride(false);
setoid = newtup->t_data->t_oid;
CatalogIndexInsert(idescs, Num_pg_proc_indices, procrel, newtup);
CatalogCloseIndices(Num_pg_proc_indices, idescs);
}
- RelationUnsetLockForWrite(procrel);
+ UnlockRelation(procrel, AccessExclusiveLock);
heap_close(procrel);
}
return setoid;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/cache/relcache.c,v 1.51 1998/11/27 19:52:28 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/relcache.c,v 1.52 1998/12/15 12:46:37 vadim Exp $
*
*-------------------------------------------------------------------------
*/
* ----------------
*/
pg_class_desc = heap_openr(RelationRelationName);
- if (!IsInitProcessingMode())
- RelationSetLockForRead(pg_class_desc);
pg_class_scan = heap_beginscan(pg_class_desc, 0, SnapshotNow, 1, &key);
pg_class_tuple = heap_getnext(pg_class_scan, 0);
/* all done */
heap_endscan(pg_class_scan);
- if (!IsInitProcessingMode())
- RelationUnsetLockForRead(pg_class_desc);
heap_close(pg_class_desc);
return return_tuple;
pg_class_desc = heap_openr(RelationRelationName);
if (!IsInitProcessingMode())
- RelationSetLockForRead(pg_class_desc);
+ LockRelation(pg_class_desc, AccessShareLock);
switch (buildinfo.infotype)
{
/* all done */
if (!IsInitProcessingMode())
- RelationUnsetLockForRead(pg_class_desc);
+ UnlockRelation(pg_class_desc, AccessShareLock);
heap_close(pg_class_desc);
return return_tuple;
}
RelationIncrementReferenceCount(rd);
- RelationSetLockForDescriptorOpen(rd);
}
}
RelationIncrementReferenceCount(rd);
- RelationSetLockForDescriptorOpen(rd);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/time/tqual.c,v 1.20 1998/11/27 19:52:36 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/time/tqual.c,v 1.21 1998/12/15 12:46:40 vadim Exp $
*
*-------------------------------------------------------------------------
*/
extern bool PostgresIsInitialized;
+SnapshotData SnapshotDirtyData;
+Snapshot SnapshotDirty = &SnapshotDirtyData;
+
/*
* XXX Transaction system override hacks start here
*/
{
if (tuple->t_infomask & HEAP_XMAX_INVALID) /* xid invalid */
return true;
- else
- return false;
+ if (tuple->t_infomask & HEAP_MARKED_FOR_UPDATE)
+ return true;
+ return false;
}
if (!TransactionIdDidCommit(tuple->t_xmin))
return true;
if (tuple->t_infomask & HEAP_XMAX_COMMITTED)
- return false;
+ {
+ if (tuple->t_infomask & HEAP_MARKED_FOR_UPDATE)
+ return true;
+ return false; /* updated by other */
+ }
if (TransactionIdIsCurrentTransactionId(tuple->t_xmax))
+ {
+ if (tuple->t_infomask & HEAP_MARKED_FOR_UPDATE)
+ return true;
return false;
+ }
if (!TransactionIdDidCommit(tuple->t_xmax))
{
/* by here, deleting transaction has committed */
tuple->t_infomask |= HEAP_XMAX_COMMITTED;
+ if (tuple->t_infomask & HEAP_MARKED_FOR_UPDATE)
+ return true;
+
return false;
}
* (Xmax is not committed && the row was deleted by another transaction
* Xmax != my-transaction)))) that has not been committed
*
- * XXX
- * CommandId stuff didn't work properly if one used SQL-functions in
- * UPDATE/INSERT(fromSELECT)/DELETE scans: SQL-funcs call
- * CommandCounterIncrement and made tuples changed/inserted by
- * current command visible to command itself (so we had multiple
- * update of updated tuples, etc). - vadim 08/29/97
- *
* mao says 17 march 1993: the tests in this routine are correct;
* if you think they're not, you're wrong, and you should think
* about it again. i know, it happened to me. we don't need to
Assert(TransactionIdIsCurrentTransactionId(tuple->t_xmax));
+ if (tuple->t_infomask & HEAP_MARKED_FOR_UPDATE)
+ return true;
+
if (CommandIdGEScanCommandId(tuple->t_cmax))
return true; /* deleted after scan started */
else
return true;
if (tuple->t_infomask & HEAP_XMAX_COMMITTED)
+ {
+ if (tuple->t_infomask & HEAP_MARKED_FOR_UPDATE)
+ return true;
return false;
+ }
if (TransactionIdIsCurrentTransactionId(tuple->t_xmax))
{
+ if (tuple->t_infomask & HEAP_MARKED_FOR_UPDATE)
+ return true;
if (CommandIdGEScanCommandId(tuple->t_cmax))
return true; /* deleted after scan started */
else
/* xmax transaction committed */
tuple->t_infomask |= HEAP_XMAX_COMMITTED;
+ if (tuple->t_infomask & HEAP_MARKED_FOR_UPDATE)
+ return true;
+
return false;
}
+
+int
+HeapTupleSatisfiesUpdate(HeapTuple tuple)
+{
+ HeapTupleHeader th = tuple->t_data;
+
+ if (AMI_OVERRIDE)
+ return HeapTupleMayBeUpdated;
+
+ if (!(th->t_infomask & HEAP_XMIN_COMMITTED))
+ {
+ if (th->t_infomask & HEAP_XMIN_INVALID) /* xid invalid or aborted */
+ return HeapTupleInvisible;
+
+ if (TransactionIdIsCurrentTransactionId(th->t_xmin))
+ {
+ if (CommandIdGEScanCommandId(th->t_cmin) && !heapisoverride())
+ return HeapTupleInvisible; /* inserted after scan started */
+
+ if (th->t_infomask & HEAP_XMAX_INVALID) /* xid invalid */
+ return HeapTupleMayBeUpdated;
+
+ Assert(TransactionIdIsCurrentTransactionId(th->t_xmax));
+
+ if (th->t_infomask & HEAP_MARKED_FOR_UPDATE)
+ return HeapTupleMayBeUpdated;
+
+ if (CommandIdGEScanCommandId(th->t_cmax))
+ return HeapTupleSelfUpdated;/* updated after scan started */
+ else
+ return HeapTupleInvisible; /* updated before scan started */
+ }
+
+ /*
+ * This call is VERY expensive - requires a log table lookup.
+ * Actually, this should be done by query before...
+ */
+
+ if (!TransactionIdDidCommit(th->t_xmin))
+ {
+ if (TransactionIdDidAbort(th->t_xmin))
+ th->t_infomask |= HEAP_XMIN_INVALID; /* aborted */
+ return HeapTupleInvisible;
+ }
+
+ th->t_infomask |= HEAP_XMIN_COMMITTED;
+ }
+
+ /* by here, the inserting transaction has committed */
+
+ if (th->t_infomask & HEAP_XMAX_INVALID) /* xid invalid or aborted */
+ return HeapTupleMayBeUpdated;
+
+ if (th->t_infomask & HEAP_XMAX_COMMITTED)
+ {
+ if (th->t_infomask & HEAP_MARKED_FOR_UPDATE)
+ return HeapTupleMayBeUpdated;
+ return HeapTupleUpdated; /* updated by other */
+ }
+
+ if (TransactionIdIsCurrentTransactionId(th->t_xmax))
+ {
+ if (th->t_infomask & HEAP_MARKED_FOR_UPDATE)
+ return HeapTupleMayBeUpdated;
+ if (CommandIdGEScanCommandId(th->t_cmax))
+ return HeapTupleSelfUpdated;/* updated after scan started */
+ else
+ return HeapTupleInvisible; /* updated before scan started */
+ }
+
+ if (!TransactionIdDidCommit(th->t_xmax))
+ {
+ if (TransactionIdDidAbort(th->t_xmax))
+ {
+ th->t_infomask |= HEAP_XMAX_INVALID; /* aborted */
+ return HeapTupleMayBeUpdated;
+ }
+ /* running xact */
+ return HeapTupleBeingUpdated; /* in updation by other */
+ }
+
+ /* xmax transaction committed */
+ th->t_infomask |= HEAP_XMAX_COMMITTED;
+
+ if (th->t_infomask & HEAP_MARKED_FOR_UPDATE)
+ return HeapTupleMayBeUpdated;
+
+ return HeapTupleUpdated; /* updated by other */
+}
+
+bool
+HeapTupleSatisfiesDirty(HeapTupleHeader tuple)
+{
+ SnapshotDirty->xmin = SnapshotDirty->xmax = InvalidTransactionId;
+
+ if (AMI_OVERRIDE)
+ return true;
+
+ if (!(tuple->t_infomask & HEAP_XMIN_COMMITTED))
+ {
+ if (tuple->t_infomask & HEAP_XMIN_INVALID) /* xid invalid or aborted */
+ return false;
+
+ if (TransactionIdIsCurrentTransactionId(tuple->t_xmin))
+ {
+ if (tuple->t_infomask & HEAP_XMAX_INVALID) /* xid invalid */
+ return true;
+
+ Assert(TransactionIdIsCurrentTransactionId(tuple->t_xmax));
+
+ if (tuple->t_infomask & HEAP_MARKED_FOR_UPDATE)
+ return true;
+
+ return false;
+ }
+
+ if (!TransactionIdDidCommit(tuple->t_xmin))
+ {
+ if (TransactionIdDidAbort(tuple->t_xmin))
+ {
+ tuple->t_infomask |= HEAP_XMIN_INVALID; /* aborted */
+ return false;
+ }
+ SnapshotDirty->xmin = tuple->t_xmin;
+ return true; /* in insertion by other */
+ }
+
+ tuple->t_infomask |= HEAP_XMIN_COMMITTED;
+ }
+
+ /* by here, the inserting transaction has committed */
+
+ if (tuple->t_infomask & HEAP_XMAX_INVALID) /* xid invalid or aborted */
+ return true;
+
+ if (tuple->t_infomask & HEAP_XMAX_COMMITTED)
+ {
+ if (tuple->t_infomask & HEAP_MARKED_FOR_UPDATE)
+ return true;
+ return false; /* updated by other */
+ }
+
+ if (TransactionIdIsCurrentTransactionId(tuple->t_xmax))
+ return false;
+
+ if (!TransactionIdDidCommit(tuple->t_xmax))
+ {
+ if (TransactionIdDidAbort(tuple->t_xmax))
+ {
+ tuple->t_infomask |= HEAP_XMAX_INVALID; /* aborted */
+ return true;
+ }
+ /* running xact */
+ SnapshotDirty->xmax = tuple->t_xmax;
+ return true; /* in updation by other */
+ }
+
+ /* xmax transaction committed */
+ tuple->t_infomask |= HEAP_XMAX_COMMITTED;
+
+ if (tuple->t_infomask & HEAP_MARKED_FOR_UPDATE)
+ return true;
+
+ return false; /* updated by other */
+}
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: heapam.h,v 1.39 1998/11/27 19:33:31 vadim Exp $
+ * $Id: heapam.h,v 1.40 1998/12/15 12:46:44 vadim Exp $
*
*-------------------------------------------------------------------------
*/
int global_insert;
int global_delete;
int global_replace;
+ int global_mark4update;
int global_markpos;
int global_restrpos;
int global_BufferGetRelation;
int local_insert;
int local_delete;
int local_replace;
+ int local_mark4update;
int local_markpos;
int local_restrpos;
int local_BufferGetRelation;
extern HeapTuple heap_getnext(HeapScanDesc scandesc, int backw);
extern void heap_fetch(Relation relation, Snapshot snapshot, HeapTuple tup, Buffer *userbuf);
extern Oid heap_insert(Relation relation, HeapTuple tup);
-extern int heap_delete(Relation relation, ItemPointer tid);
-extern int heap_replace(Relation relation, ItemPointer otid,
- HeapTuple tup);
+extern int heap_delete(Relation relation, ItemPointer tid, ItemPointer ctid);
+extern int heap_replace(Relation relation, ItemPointer otid, HeapTuple tup,
+ ItemPointer ctid);
+extern int heap_mark4update(Relation relation, HeapTuple tup, Buffer *userbuf);
extern void heap_markpos(HeapScanDesc scan);
extern void heap_restrpos(HeapScanDesc scan);
extern void PrintHeapAccessStatistics(HeapAccessStatistics stats);
extern void initam(void);
-/* hio.c */
-extern void RelationPutHeapTuple(Relation relation, BlockNumber blockIndex,
- HeapTuple tuple);
-extern void RelationPutHeapTupleAtEnd(Relation relation, HeapTuple tuple);
-
#endif /* HEAPAM_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: hio.h,v 1.8 1998/09/01 04:34:13 momjian Exp $
+ * $Id: hio.h,v 1.9 1998/12/15 12:46:45 vadim Exp $
*
*-------------------------------------------------------------------------
*/
#include
-extern void RelationPutHeapTuple(Relation relation, BlockNumber blockIndex,
- HeapTuple tuple);
+extern void RelationPutHeapTuple(Relation relation, Buffer buffer,
+ HeapTuple tuple);
extern void RelationPutHeapTupleAtEnd(Relation relation, HeapTuple tuple);
#endif /* HIO_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: htup.h,v 1.11 1998/11/27 19:33:31 vadim Exp $
+ * $Id: htup.h,v 1.12 1998/12/15 12:46:46 vadim Exp $
*
*-------------------------------------------------------------------------
*/
#define HEAP_XMIN_INVALID 0x0200 /* t_xmin invalid/aborted */
#define HEAP_XMAX_COMMITTED 0x0400 /* t_xmax committed */
#define HEAP_XMAX_INVALID 0x0800 /* t_xmax invalid/aborted */
+#define HEAP_MARKED_FOR_UPDATE 0x1000 /* marked for UPDATE */
#define HEAP_XACT_MASK 0x0F00 /* */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: xact.h,v 1.17 1998/10/08 18:30:23 momjian Exp $
+ * $Id: xact.h,v 1.18 1998/12/15 12:46:47 vadim Exp $
*
*-------------------------------------------------------------------------
*/
#define XACT_REPEATABLE_READ 2 /* not implemented */
#define XACT_SERIALIZED 3
+extern int XactIsoLevel;
+
/* ----------------
* transaction states
* ----------------
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: pg_am.h,v 1.9 1998/09/01 04:34:47 momjian Exp $
+ * $Id: pg_am.h,v 1.10 1998/12/15 12:46:49 vadim Exp $
*
* NOTES
* the genbki.sh script reads this file and generates .bki
#define BTREE_AM_OID 403
DATA(insert OID = 405 ( hash PGUID "o" 1 1 hashgettuple hashinsert hashdelete - - - - hashbeginscan hashrescan hashendscan hashmarkpos hashrestrpos - - hashbuild - - ));
DESCR("");
+#define HASH_AM_OID 405
DATA(insert OID = 783 ( gist PGUID "o" 100 7 gistgettuple gistinsert gistdelete - - - - gistbeginscan gistrescan gistendscan gistmarkpos gistrestrpos - - gistbuild - - ));
DESCR("");
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: pg_class.h,v 1.25 1998/09/10 15:32:31 vadim Exp $
+ * $Id: pg_class.h,v 1.26 1998/12/15 12:46:50 vadim Exp $
*
* NOTES
* ``pg_relation'' is being replaced by ``pg_class''. currently
DESCR("");
DATA(insert OID = 1269 ( pg_log 99 PGUID 0 0 0 f t s 1 0 0 0 0 0 f f _null_ ));
DESCR("");
+DATA(insert OID = 376 ( pg_xactlock 0 PGUID 0 0 0 f t s 1 0 0 0 0 0 f f _null_ ));
+DESCR("");
DATA(insert OID = 1215 ( pg_attrdef 109 PGUID 0 0 0 t t r 4 0 0 0 0 0 f f _null_ ));
DESCR("");
DATA(insert OID = 1216 ( pg_relcheck 110 PGUID 0 0 0 t t r 4 0 0 0 0 0 f f _null_ ));
#define RelOid_pg_relcheck 1216
#define RelOid_pg_trigger 1219
+/* Xact lock pseudo-table */
+#define XactLockTableId 376
+
#define RELKIND_INDEX 'i' /* secondary index */
#define RELKIND_LOBJECT 'l' /* large objects */
#define RELKIND_RELATION 'r' /* cataloged heap */
#include "access/tupdesc.h"
#include "access/htup.h"
#include "nodes/parsenodes.h"
+#include "nodes/execnodes.h"
#include "utils/rel.h"
typedef uint32 TriggerEvent;
extern HeapTuple ExecBRInsertTriggers(Relation rel, HeapTuple tuple);
extern void ExecARInsertTriggers(Relation rel, HeapTuple tuple);
-extern bool ExecBRDeleteTriggers(Relation rel, ItemPointer tupleid);
-extern void ExecARDeleteTriggers(Relation rel, ItemPointer tupleid);
-extern HeapTuple ExecBRUpdateTriggers(Relation rel, ItemPointer tupleid, HeapTuple tuple);
-extern void ExecARUpdateTriggers(Relation rel, ItemPointer tupleid, HeapTuple tuple);
+extern bool ExecBRDeleteTriggers(EState *estate, ItemPointer tupleid);
+extern void ExecARDeleteTriggers(EState *estate, ItemPointer tupleid);
+extern HeapTuple ExecBRUpdateTriggers(EState *estate, ItemPointer tupleid, HeapTuple tuple);
+extern void ExecARUpdateTriggers(EState *estate, ItemPointer tupleid, HeapTuple tuple);
#endif /* TRIGGER_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: buf_internals.h,v 1.26 1998/09/01 04:38:10 momjian Exp $
+ * $Id: buf_internals.h,v 1.27 1998/12/15 12:46:55 vadim Exp $
*
* NOTE
* If BUFFERPAGE0 is defined, then 0 will be used as a
* Dbname, relname, dbid, and relid are enough to determine where
* to put the buffer, for all storage managers.
*/
-
-#define PADDED_SBUFDESC_SIZE 128
-
-/* DO NOT CHANGE THIS NEXT STRUCTURE:
- It is used only to get padding information for the real sbufdesc structure
- It should match the sbufdesc structure exactly except for a missing sb_pad
-*/
-struct sbufdesc_unpadded
-{
- Buffer freeNext;
- Buffer freePrev;
- SHMEM_OFFSET data;
- BufferTag tag;
- int buf_id;
- BufFlags flags;
- unsigned refcount;
-#ifdef HAS_TEST_AND_SET
- slock_t io_in_progress_lock;
-#endif /* HAS_TEST_AND_SET */
- char sb_dbname[NAMEDATALEN];
-
- /* NOTE NO PADDING OF THE MEMBER HERE */
- char sb_relname[NAMEDATALEN];
-};
-
-/* THE REAL STRUCTURE - the structure above must match it, minus sb_pad */
struct sbufdesc
{
Buffer freeNext; /* link for freelist chain */
#ifdef HAS_TEST_AND_SET
/* can afford a dedicated lock if test-and-set locks are available */
slock_t io_in_progress_lock;
+ slock_t cntx_lock; /* to lock access to page context */
#endif /* HAS_TEST_AND_SET */
+ unsigned r_locks; /* # of shared locks */
+ bool ri_lock; /* read-intent lock */
+ bool w_lock; /* context exclusively locked */
char sb_dbname[NAMEDATALEN]; /* name of db in which buf belongs */
-
- /*
- * I padded this structure to a power of 2 (PADDED_SBUFDESC_SIZE)
- * because BufferDescriptorGetBuffer is called a billion times and it
- * does an C pointer subtraction (i.e., "x - y" -> array index of x
- * relative to y, which is calculated using division by struct size).
- * Integer ".div" hits you for 35 cycles, as opposed to a 1-cycle
- * "sra" ... this hack cut 10% off of the time to create the Wisconsin
- * database! It eats up more shared memory, of course, but we're
- * (allegedly) going to make some of these types bigger soon anyway...
- * -pma 1/2/93
- */
-
- /*
- * please, don't take the sizeof() this member and use it for
- * something important
- */
-
- char sb_relname[NAMEDATALEN + /* name of reln */
- PADDED_SBUFDESC_SIZE - sizeof(struct sbufdesc_unpadded)];
+ char sb_relname[NAMEDATALEN];/* name of reln */
};
+/*
+ * Buffer lock infos in BufferLocks below.
+ * We have to free these locks in elog(ERROR)...
+ */
+#define BL_IO_IN_PROGRESS (1 << 0) /* unimplemented */
+#define BL_R_LOCK (1 << 1)
+#define BL_RI_LOCK (1 << 2)
+#define BL_W_LOCK (1 << 3)
+
/*
* mao tracing buffer allocation
*/
extern BufferBlock BufferBlocks;
extern long *PrivateRefCount;
extern long *LastRefCount;
+extern bits8 *BufferLocks;
extern long *CommitInfoNeedsSave;
extern SPINLOCK BufMgrLock;
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: bufmgr.h,v 1.23 1998/10/08 18:30:43 momjian Exp $
+ * $Id: bufmgr.h,v 1.24 1998/12/15 12:46:56 vadim Exp $
*
*-------------------------------------------------------------------------
*/
#define BUFFER_FLUSH_WRITE 0 /* immediate write */
#define BUFFER_LATE_WRITE 1 /* delayed write: mark as DIRTY */
+/*
+ * Buffer context lock modes
+ */
+#define BUFFER_LOCK_UNLOCK 0
+#define BUFFER_LOCK_SHARE 1
+#define BUFFER_LOCK_EXCLUSIVE 2
+
+
/*
* BufferIsValid --
* True iff the refcnt of the local buffer is > 0
extern int SetBufferWriteMode(int mode);
extern void SetBufferCommitInfoNeedsSave(Buffer buffer);
+extern void UnlockBuffers(void);
+extern void LockBuffer(Buffer buffer, int mode);
+
#endif /* !defined(BufMgrIncluded) */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: ipc.h,v 1.30 1998/09/01 04:38:16 momjian Exp $
+ * $Id: ipc.h,v 1.31 1998/12/15 12:46:57 vadim Exp $
*
* NOTES
* This file is very architecture-specific. This stuff should actually
((key == PrivateIPCKey) ? key : 11 + (key))
#define IPCKeyGetWaitIOSemaphoreKey(key) \
((key == PrivateIPCKey) ? key : 12 + (key))
+#define IPCKeyGetWaitCLSemaphoreKey(key) \
+ ((key == PrivateIPCKey) ? key : 13 + (key))
/* --------------------------
* NOTE: This macro must always give the highest numbered key as every backend
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: lmgr.h,v 1.15 1998/09/01 04:38:23 momjian Exp $
+ * $Id: lmgr.h,v 1.16 1998/12/15 12:46:57 vadim Exp $
*
*-------------------------------------------------------------------------
*/
#include
#include
-/*
- * This was moved from pladt.h for the new lock manager. Want to obsolete
- * all of the old code.
- */
+#define AccessShareLock 1 /* SELECT */
+#define RowShareLock 2 /* SELECT FOR UPDATE */
+#define RowExclusiveLock 3 /* INSERT, UPDATE, DELETE */
+#define ShareLock 4
+#define ShareRowExclusiveLock 5
+#define ExclusiveLock 6
+#define AccessExclusiveLock 7
+
+#define ExtendLock 8
+
+extern LOCKMETHOD LockTableId;
+
+
typedef struct LockRelId
{
Oid relId; /* a relation identifier */
Oid dbId; /* a database identifier */
} LockRelId;
-#ifdef LowLevelLocking
typedef struct LockInfoData
{
LockRelId lockRelId;
- bool lockHeld[MAX_LOCKMODES]; /* on table level */
} LockInfoData;
-#else
-typedef struct LockInfoData
-{
- LockRelId lockRelId;
-} LockInfoData;
-
-#endif
-
typedef LockInfoData *LockInfo;
#define LockInfoIsValid(lockinfo) PointerIsValid(lockinfo)
+extern LOCKMETHOD InitLockTable(void);
extern void RelationInitLockInfo(Relation relation);
-extern void RelationSetLockForDescriptorOpen(Relation relation);
-extern void RelationSetLockForRead(Relation relation);
-extern void RelationUnsetLockForRead(Relation relation);
-extern void RelationSetLockForWrite(Relation relation);
-extern void RelationUnsetLockForWrite(Relation relation);
-/* used in vaccum.c */
-extern void RelationSetLockForWritePage(Relation relation,
- ItemPointer itemPointer);
+extern void LockRelation(Relation relation, LOCKMODE lockmode);
+extern void UnlockRelation(Relation relation, LOCKMODE lockmode);
-/* used in nbtpage.c, hashpage.c */
-extern void RelationSetSingleWLockPage(Relation relation,
- ItemPointer itemPointer);
-extern void RelationUnsetSingleWLockPage(Relation relation,
- ItemPointer itemPointer);
-extern void RelationSetSingleRLockPage(Relation relation,
- ItemPointer itemPointer);
-extern void RelationUnsetSingleRLockPage(Relation relation,
- ItemPointer itemPointer);
-extern void RelationSetRIntentLock(Relation relation);
-extern void RelationUnsetRIntentLock(Relation relation);
-extern void RelationSetWIntentLock(Relation relation);
-extern void RelationUnsetWIntentLock(Relation relation);
+/* this is for indices */
+extern void LockPage(Relation relation, BlockNumber blkno, LOCKMODE lockmode);
+extern void UnlockPage(Relation relation, BlockNumber blkno, LOCKMODE lockmode);
-/* single.c */
-extern bool SingleLockReln(LockInfo lockinfo, LOCKMODE lockmode, int action);
-extern bool SingleLockPage(LockInfo lockinfo, ItemPointer tidPtr,
- LOCKMODE lockmode, int action);
+/* and this is for transactions */
+extern void XactLockTableInsert(TransactionId xid);
+extern void XactLockTableDelete(TransactionId xid);
+extern void XactLockTableWait(TransactionId xid);
/* proc.c */
extern void InitProcGlobal(IPCKey key);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: lock.h,v 1.19 1998/10/08 18:30:45 momjian Exp $
+ * $Id: lock.h,v 1.20 1998/12/15 12:46:58 vadim Exp $
*
*-------------------------------------------------------------------------
*/
typedef int LOCKMETHOD;
/* MAX_LOCKMODES cannot be larger than the bits in MASK */
-#ifdef LowLevelLocking
#define MAX_LOCKMODES 9
-#else
-#define MAX_LOCKMODES 6
-#endif
/*
* MAX_LOCK_METHODS corresponds to the number of spin locks allocated in
{
Oid relId;
Oid dbId;
- ItemPointerData tupleId;
+ union
+ {
+ BlockNumber blkno;
+ TransactionId xid;
+ } objId;
uint16 lockmethod; /* needed by user locks */
} LOCKTAG;
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: proc.h,v 1.15 1998/09/01 04:38:31 momjian Exp $
+ * $Id: proc.h,v 1.16 1998/12/15 12:46:59 vadim Exp $
*
*-------------------------------------------------------------------------
*/
TransactionId xid; /* transaction currently being executed by
* this proc */
-#ifdef LowLevelLocking
TransactionId xmin; /* minimal running XID as it was when we
* were starting our xact: vacuum must not
* remove tuples deleted by xid >= xmin ! */
-#endif
LOCK *waitLock; /* Lock we're sleeping on */
int token; /* info for proc wakeup routines */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/include/storage/s_lock.h,v 1.56 1998/10/31 02:06:08 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/include/storage/s_lock.h,v 1.57 1998/12/15 12:46:59 vadim Exp $
*
*-------------------------------------------------------------------------
*/
#include "storage/ipc.h"
+extern void s_lock_sleep(unsigned spin);
+
#if defined(HAS_TEST_AND_SET)
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: tqual.h,v 1.15 1998/11/27 19:33:35 vadim Exp $
+ * $Id: tqual.h,v 1.16 1998/12/15 12:47:01 vadim Exp $
*
*-------------------------------------------------------------------------
*/
typedef struct SnapshotData
{
- TransactionId xmin; /* XID < xmin are visible to me */
- TransactionId xmax; /* XID > xmax are invisible to me */
- TransactionId *xip; /* array of xacts in progress */
+ TransactionId xmin; /* XID < xmin are visible to me */
+ TransactionId xmax; /* XID > xmax are invisible to me */
+ TransactionId *xip; /* array of xacts in progress */
} SnapshotData;
typedef SnapshotData *Snapshot;
-#define IsSnapshotNow(snapshot) ((Snapshot) snapshot == (Snapshot) 0x0)
-#define IsSnapshotSelf(snapshot) ((Snapshot) snapshot == (Snapshot) 0x1)
#define SnapshotNow ((Snapshot) 0x0)
#define SnapshotSelf ((Snapshot) 0x1)
+extern Snapshot SnapshotDirty;
+
+#define IsSnapshotNow(snapshot) ((Snapshot) snapshot == SnapshotNow)
+#define IsSnapshotSelf(snapshot) ((Snapshot) snapshot == SnapshotSelf)
+#define IsSnapshotDirty(snapshot) ((Snapshot) snapshot == SnapshotDirty)
extern TransactionId HeapSpecialTransactionId;
extern CommandId HeapSpecialCommandId;
(IsSnapshotSelf(snapshot) || heapisoverride()) ? \
HeapTupleSatisfiesItself((tuple)->t_data) \
: \
- HeapTupleSatisfiesNow((tuple)->t_data) \
+ ((IsSnapshotDirty(snapshot)) ? \
+ HeapTupleSatisfiesDirty((tuple)->t_data) \
+ : \
+ HeapTupleSatisfiesNow((tuple)->t_data) \
+ ) \
) \
)
) \
)
-extern bool HeapTupleSatisfiesItself(HeapTupleHeader tuple);
-extern bool HeapTupleSatisfiesNow(HeapTupleHeader tuple);
+#define HeapTupleMayBeUpdated 0
+#define HeapTupleInvisible 1
+#define HeapTupleSelfUpdated 2
+#define HeapTupleUpdated 3
+#define HeapTupleBeingUpdated 4
-extern void setheapoverride(bool on);
+extern bool HeapTupleSatisfiesItself(HeapTupleHeader tuple);
+extern bool HeapTupleSatisfiesNow(HeapTupleHeader tuple);
+extern bool HeapTupleSatisfiesDirty(HeapTupleHeader tuple);
+extern int HeapTupleSatisfiesUpdate(HeapTuple tuple);
+extern void setheapoverride(bool on);
+extern Snapshot GetSnapshotData(bool serialized);
#endif /* TQUAL_H */
projects / postgresql.git / commitdiff