1996-07-09 08:22:35 +02:00
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
*
|
1999-02-14 00:22:53 +01:00
|
|
|
* tqual.c
|
1997-11-02 16:27:14 +01:00
|
|
|
* POSTGRES "time" qualification code.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
* Copyright (c) 1994, Regents of the University of California
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* IDENTIFICATION
|
1999-02-14 00:22:53 +01:00
|
|
|
* $Header: /cvsroot/pgsql/src/backend/utils/time/tqual.c,v 1.25 1999/02/13 23:20:19 momjian Exp $
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* #define TQUALDEBUG 1 */
|
|
|
|
|
|
|
|
#include "postgres.h"
|
|
|
|
|
|
|
|
#include "access/htup.h"
|
|
|
|
#include "access/xact.h"
|
|
|
|
#include "storage/bufmgr.h"
|
|
|
|
#include "access/transam.h"
|
|
|
|
#include "utils/elog.h"
|
|
|
|
#include "utils/palloc.h"
|
|
|
|
#include "utils/tqual.h"
|
|
|
|
|
1997-09-08 04:41:22 +02:00
|
|
|
extern bool PostgresIsInitialized;
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1998-12-15 13:47:01 +01:00
|
|
|
SnapshotData SnapshotDirtyData;
|
|
|
|
Snapshot SnapshotDirty = &SnapshotDirtyData;
|
|
|
|
|
1998-12-16 12:53:55 +01:00
|
|
|
Snapshot QuerySnapshot = NULL;
|
1998-12-18 10:10:39 +01:00
|
|
|
Snapshot SerializableSnapshot = NULL;
|
1998-12-16 12:53:55 +01:00
|
|
|
|
1996-07-09 08:22:35 +02:00
|
|
|
/*
|
|
|
|
* XXX Transaction system override hacks start here
|
|
|
|
*/
|
1997-09-07 07:04:48 +02:00
|
|
|
#ifndef GOODAMI
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1998-04-24 16:43:33 +02:00
|
|
|
TransactionId HeapSpecialTransactionId = InvalidTransactionId;
|
1998-09-01 06:40:42 +02:00
|
|
|
CommandId HeapSpecialCommandId = FirstCommandId;
|
1996-07-09 08:22:35 +02:00
|
|
|
|
|
|
|
void
|
|
|
|
setheapoverride(bool on)
|
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
if (on)
|
|
|
|
{
|
|
|
|
TransactionIdStore(GetCurrentTransactionId(),
|
1998-09-01 06:40:42 +02:00
|
|
|
&HeapSpecialTransactionId);
|
1997-09-07 07:04:48 +02:00
|
|
|
HeapSpecialCommandId = GetCurrentCommandId();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
HeapSpecialTransactionId = InvalidTransactionId;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
1998-09-01 06:40:42 +02:00
|
|
|
#endif /* !defined(GOODAMI) */
|
1996-07-09 08:22:35 +02:00
|
|
|
/*
|
|
|
|
* XXX Transaction system override hacks end here
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
1999-02-14 00:22:53 +01:00
|
|
|
* HeapTupleSatisfiesItself
|
1997-09-07 07:04:48 +02:00
|
|
|
* True iff heap tuple is valid for "itself."
|
|
|
|
* "{it}self" means valid as of everything that's happened
|
|
|
|
* in the current transaction, _including_ the current command.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
* Note:
|
1997-09-07 07:04:48 +02:00
|
|
|
* Assumes heap tuple is valid.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
|
|
|
/*
|
|
|
|
* The satisfaction of "itself" requires the following:
|
|
|
|
*
|
1997-09-07 07:04:48 +02:00
|
|
|
* ((Xmin == my-transaction && the row was updated by the current transaction, and
|
|
|
|
* (Xmax is null it was not deleted
|
|
|
|
* [|| Xmax != my-transaction)]) [or it was deleted by another transaction]
|
1996-07-09 08:22:35 +02:00
|
|
|
* ||
|
|
|
|
*
|
1997-09-07 07:04:48 +02:00
|
|
|
* (Xmin is committed && the row was modified by a committed transaction, and
|
|
|
|
* (Xmax is null || the row has not been deleted, or
|
|
|
|
* (Xmax != my-transaction && the row was deleted by another transaction
|
|
|
|
* Xmax is not committed))) that has not been committed
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1998-04-24 16:43:33 +02:00
|
|
|
bool
|
1998-11-27 20:52:36 +01:00
|
|
|
HeapTupleSatisfiesItself(HeapTupleHeader tuple)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
From: Dan McGuirk <mcguirk@indirect.com>
Reply-To: hackers@hub.org, Dan McGuirk <mcguirk@indirect.com>
To: hackers@hub.org
Subject: [HACKERS] tmin writeback optimization
I was doing some profiling of the backend, and noticed that during a certain
benchmark I was running somewhere between 30% and 75% of the backend's CPU
time was being spent in calls to TransactionIdDidCommit() from
HeapTupleSatisfiesNow() or HeapTupleSatisfiesItself() to determine that
changed rows' transactions had in fact been committed even though the rows'
tmin values had not yet been set.
When a query looks at a given row, it needs to figure out whether the
transaction that changed the row has been committed and hence it should pay
attention to the row, or whether on the other hand the transaction is still
in progress or has been aborted and hence the row should be ignored. If
a tmin value is set, it is known definitively that the row's transaction
has been committed. However, if tmin is not set, the transaction
referred to in xmin must be looked up in pg_log, and this is what the
backend was spending a lot of time doing during my benchmark.
So, implementing a method suggested by Vadim, I created the following
patch that, the first time a query finds a committed row whose tmin value
is not set, sets it, and marks the buffer where the row is stored as
dirty. (It works for tmax, too.) This doesn't result in the boost in
real time performance I was hoping for, however it does decrease backend
CPU usage by up to two-thirds in certain situations, so it could be
rather beneficial in high-concurrency settings.
1997-03-28 08:06:53 +01:00
|
|
|
|
1997-11-02 16:27:14 +01:00
|
|
|
if (!(tuple->t_infomask & HEAP_XMIN_COMMITTED))
|
1997-09-07 07:04:48 +02:00
|
|
|
{
|
1998-02-26 05:46:47 +01:00
|
|
|
if (tuple->t_infomask & HEAP_XMIN_INVALID) /* xid invalid or
|
|
|
|
* aborted */
|
1998-09-01 05:29:17 +02:00
|
|
|
return false;
|
1998-02-26 05:46:47 +01:00
|
|
|
|
1997-11-02 16:27:14 +01:00
|
|
|
if (TransactionIdIsCurrentTransactionId(tuple->t_xmin))
|
1997-09-07 07:04:48 +02:00
|
|
|
{
|
1997-11-02 16:27:14 +01:00
|
|
|
if (tuple->t_infomask & HEAP_XMAX_INVALID) /* xid invalid */
|
1998-09-01 05:29:17 +02:00
|
|
|
return true;
|
1998-12-15 13:47:01 +01:00
|
|
|
if (tuple->t_infomask & HEAP_MARKED_FOR_UPDATE)
|
|
|
|
return true;
|
|
|
|
return false;
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
|
|
|
|
1997-11-02 16:27:14 +01:00
|
|
|
if (!TransactionIdDidCommit(tuple->t_xmin))
|
1997-09-07 07:04:48 +02:00
|
|
|
{
|
1997-11-02 16:27:14 +01:00
|
|
|
if (TransactionIdDidAbort(tuple->t_xmin))
|
1998-02-26 05:46:47 +01:00
|
|
|
tuple->t_infomask |= HEAP_XMIN_INVALID; /* aborted */
|
1998-09-01 05:29:17 +02:00
|
|
|
return false;
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
|
|
|
|
1997-11-02 16:27:14 +01:00
|
|
|
tuple->t_infomask |= HEAP_XMIN_COMMITTED;
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
|
|
|
/* the tuple was inserted validly */
|
From: Dan McGuirk <mcguirk@indirect.com>
Reply-To: hackers@hub.org, Dan McGuirk <mcguirk@indirect.com>
To: hackers@hub.org
Subject: [HACKERS] tmin writeback optimization
I was doing some profiling of the backend, and noticed that during a certain
benchmark I was running somewhere between 30% and 75% of the backend's CPU
time was being spent in calls to TransactionIdDidCommit() from
HeapTupleSatisfiesNow() or HeapTupleSatisfiesItself() to determine that
changed rows' transactions had in fact been committed even though the rows'
tmin values had not yet been set.
When a query looks at a given row, it needs to figure out whether the
transaction that changed the row has been committed and hence it should pay
attention to the row, or whether on the other hand the transaction is still
in progress or has been aborted and hence the row should be ignored. If
a tmin value is set, it is known definitively that the row's transaction
has been committed. However, if tmin is not set, the transaction
referred to in xmin must be looked up in pg_log, and this is what the
backend was spending a lot of time doing during my benchmark.
So, implementing a method suggested by Vadim, I created the following
patch that, the first time a query finds a committed row whose tmin value
is not set, sets it, and marks the buffer where the row is stored as
dirty. (It works for tmax, too.) This doesn't result in the boost in
real time performance I was hoping for, however it does decrease backend
CPU usage by up to two-thirds in certain situations, so it could be
rather beneficial in high-concurrency settings.
1997-03-28 08:06:53 +01:00
|
|
|
|
1997-11-02 16:27:14 +01:00
|
|
|
if (tuple->t_infomask & HEAP_XMAX_INVALID) /* xid invalid or aborted */
|
1998-09-01 05:29:17 +02:00
|
|
|
return true;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1997-11-02 16:27:14 +01:00
|
|
|
if (tuple->t_infomask & HEAP_XMAX_COMMITTED)
|
1998-12-15 13:47:01 +01:00
|
|
|
{
|
|
|
|
if (tuple->t_infomask & HEAP_MARKED_FOR_UPDATE)
|
|
|
|
return true;
|
|
|
|
return false; /* updated by other */
|
|
|
|
}
|
1997-11-02 16:27:14 +01:00
|
|
|
|
|
|
|
if (TransactionIdIsCurrentTransactionId(tuple->t_xmax))
|
1998-12-15 13:47:01 +01:00
|
|
|
{
|
|
|
|
if (tuple->t_infomask & HEAP_MARKED_FOR_UPDATE)
|
|
|
|
return true;
|
1998-09-01 05:29:17 +02:00
|
|
|
return false;
|
1998-12-15 13:47:01 +01:00
|
|
|
}
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1997-11-02 16:27:14 +01:00
|
|
|
if (!TransactionIdDidCommit(tuple->t_xmax))
|
1997-09-07 07:04:48 +02:00
|
|
|
{
|
1997-11-02 16:27:14 +01:00
|
|
|
if (TransactionIdDidAbort(tuple->t_xmax))
|
|
|
|
tuple->t_infomask |= HEAP_XMAX_INVALID; /* aborted */
|
1998-09-01 05:29:17 +02:00
|
|
|
return true;
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* by here, deleting transaction has committed */
|
1997-11-02 16:27:14 +01:00
|
|
|
tuple->t_infomask |= HEAP_XMAX_COMMITTED;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1998-12-15 13:47:01 +01:00
|
|
|
if (tuple->t_infomask & HEAP_MARKED_FOR_UPDATE)
|
|
|
|
return true;
|
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return false;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1999-02-14 00:22:53 +01:00
|
|
|
* HeapTupleSatisfiesNow
|
1997-09-07 07:04:48 +02:00
|
|
|
* True iff heap tuple is valid "now."
|
|
|
|
* "now" means valid including everything that's happened
|
|
|
|
* in the current transaction _up to, but not including,_
|
|
|
|
* the current command.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
* Note:
|
1997-09-07 07:04:48 +02:00
|
|
|
* Assumes heap tuple is valid.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
|
|
|
/*
|
|
|
|
* The satisfaction of "now" requires the following:
|
|
|
|
*
|
1997-09-07 07:04:48 +02:00
|
|
|
* ((Xmin == my-transaction && changed by the current transaction
|
|
|
|
* Cmin != my-command && but not by this command, and
|
|
|
|
* (Xmax is null || the row has not been deleted, or
|
|
|
|
* (Xmax == my-transaction && it was deleted by the current transaction
|
|
|
|
* Cmax != my-command))) but not by this command,
|
|
|
|
* || or
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
1997-09-07 07:04:48 +02:00
|
|
|
* (Xmin is committed && the row was modified by a committed transaction, and
|
|
|
|
* (Xmax is null || the row has not been deleted, or
|
|
|
|
* (Xmax == my-transaction && the row is being deleted by this command, or
|
|
|
|
* Cmax == my-command) ||
|
|
|
|
* (Xmax is not committed && the row was deleted by another transaction
|
|
|
|
* Xmax != my-transaction)))) that has not been committed
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
1997-09-07 07:04:48 +02:00
|
|
|
* 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
|
|
|
|
* check commit time against the start time of this transaction
|
|
|
|
* because 2ph locking protects us from doing the wrong thing.
|
|
|
|
* if you mess around here, you'll break serializability. the only
|
|
|
|
* problem with this code is that it does the wrong thing for system
|
|
|
|
* catalog updates, because the catalogs aren't subject to 2ph, so
|
|
|
|
* the serializability guarantees we provide don't extend to xacts
|
|
|
|
* that do catalog accesses. this is unfortunate, but not critical.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1998-04-24 16:43:33 +02:00
|
|
|
bool
|
1998-11-27 20:52:36 +01:00
|
|
|
HeapTupleSatisfiesNow(HeapTupleHeader tuple)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
if (AMI_OVERRIDE)
|
|
|
|
return true;
|
|
|
|
|
1996-07-09 08:22:35 +02:00
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* If the transaction system isn't yet initialized, then we assume
|
|
|
|
* that transactions committed. We only look at system catalogs
|
|
|
|
* during startup, so this is less awful than it seems, but it's still
|
|
|
|
* pretty awful.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
From: Dan McGuirk <mcguirk@indirect.com>
Reply-To: hackers@hub.org, Dan McGuirk <mcguirk@indirect.com>
To: hackers@hub.org
Subject: [HACKERS] tmin writeback optimization
I was doing some profiling of the backend, and noticed that during a certain
benchmark I was running somewhere between 30% and 75% of the backend's CPU
time was being spent in calls to TransactionIdDidCommit() from
HeapTupleSatisfiesNow() or HeapTupleSatisfiesItself() to determine that
changed rows' transactions had in fact been committed even though the rows'
tmin values had not yet been set.
When a query looks at a given row, it needs to figure out whether the
transaction that changed the row has been committed and hence it should pay
attention to the row, or whether on the other hand the transaction is still
in progress or has been aborted and hence the row should be ignored. If
a tmin value is set, it is known definitively that the row's transaction
has been committed. However, if tmin is not set, the transaction
referred to in xmin must be looked up in pg_log, and this is what the
backend was spending a lot of time doing during my benchmark.
So, implementing a method suggested by Vadim, I created the following
patch that, the first time a query finds a committed row whose tmin value
is not set, sets it, and marks the buffer where the row is stored as
dirty. (It works for tmax, too.) This doesn't result in the boost in
real time performance I was hoping for, however it does decrease backend
CPU usage by up to two-thirds in certain situations, so it could be
rather beneficial in high-concurrency settings.
1997-03-28 08:06:53 +01:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
if (!PostgresIsInitialized)
|
1997-11-02 16:27:14 +01:00
|
|
|
return ((bool) (TransactionIdIsValid(tuple->t_xmin) &&
|
1998-02-26 05:46:47 +01:00
|
|
|
!TransactionIdIsValid(tuple->t_xmax)));
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1997-11-02 16:27:14 +01:00
|
|
|
if (!(tuple->t_infomask & HEAP_XMIN_COMMITTED))
|
1997-09-07 07:04:48 +02:00
|
|
|
{
|
1998-02-26 05:46:47 +01:00
|
|
|
if (tuple->t_infomask & HEAP_XMIN_INVALID) /* xid invalid or
|
|
|
|
* aborted */
|
1998-09-01 05:29:17 +02:00
|
|
|
return false;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1997-11-02 16:27:14 +01:00
|
|
|
if (TransactionIdIsCurrentTransactionId(tuple->t_xmin))
|
1997-09-07 07:04:48 +02:00
|
|
|
{
|
1997-11-02 16:27:14 +01:00
|
|
|
if (CommandIdGEScanCommandId(tuple->t_cmin))
|
1998-09-01 06:40:42 +02:00
|
|
|
return false; /* inserted after scan started */
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1997-11-02 16:27:14 +01:00
|
|
|
if (tuple->t_infomask & HEAP_XMAX_INVALID) /* xid invalid */
|
1998-09-01 05:29:17 +02:00
|
|
|
return true;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1997-11-02 16:27:14 +01:00
|
|
|
Assert(TransactionIdIsCurrentTransactionId(tuple->t_xmax));
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1998-12-15 13:47:01 +01:00
|
|
|
if (tuple->t_infomask & HEAP_MARKED_FOR_UPDATE)
|
|
|
|
return true;
|
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
if (CommandIdGEScanCommandId(tuple->t_cmax))
|
1998-09-01 05:29:17 +02:00
|
|
|
return true; /* deleted after scan started */
|
1997-11-02 16:27:14 +01:00
|
|
|
else
|
1998-09-01 06:40:42 +02:00
|
|
|
return false; /* deleted before scan started */
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* this call is VERY expensive - requires a log table lookup.
|
|
|
|
*/
|
|
|
|
|
1997-11-02 16:27:14 +01:00
|
|
|
if (!TransactionIdDidCommit(tuple->t_xmin))
|
1997-09-07 07:04:48 +02:00
|
|
|
{
|
1997-11-02 16:27:14 +01:00
|
|
|
if (TransactionIdDidAbort(tuple->t_xmin))
|
1998-02-26 05:46:47 +01:00
|
|
|
tuple->t_infomask |= HEAP_XMIN_INVALID; /* aborted */
|
1998-09-01 05:29:17 +02:00
|
|
|
return false;
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
|
|
|
|
1997-11-02 16:27:14 +01:00
|
|
|
tuple->t_infomask |= HEAP_XMIN_COMMITTED;
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
From: Dan McGuirk <mcguirk@indirect.com>
Reply-To: hackers@hub.org, Dan McGuirk <mcguirk@indirect.com>
To: hackers@hub.org
Subject: [HACKERS] tmin writeback optimization
I was doing some profiling of the backend, and noticed that during a certain
benchmark I was running somewhere between 30% and 75% of the backend's CPU
time was being spent in calls to TransactionIdDidCommit() from
HeapTupleSatisfiesNow() or HeapTupleSatisfiesItself() to determine that
changed rows' transactions had in fact been committed even though the rows'
tmin values had not yet been set.
When a query looks at a given row, it needs to figure out whether the
transaction that changed the row has been committed and hence it should pay
attention to the row, or whether on the other hand the transaction is still
in progress or has been aborted and hence the row should be ignored. If
a tmin value is set, it is known definitively that the row's transaction
has been committed. However, if tmin is not set, the transaction
referred to in xmin must be looked up in pg_log, and this is what the
backend was spending a lot of time doing during my benchmark.
So, implementing a method suggested by Vadim, I created the following
patch that, the first time a query finds a committed row whose tmin value
is not set, sets it, and marks the buffer where the row is stored as
dirty. (It works for tmax, too.) This doesn't result in the boost in
real time performance I was hoping for, however it does decrease backend
CPU usage by up to two-thirds in certain situations, so it could be
rather beneficial in high-concurrency settings.
1997-03-28 08:06:53 +01:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
/* by here, the inserting transaction has committed */
|
From: Dan McGuirk <mcguirk@indirect.com>
Reply-To: hackers@hub.org, Dan McGuirk <mcguirk@indirect.com>
To: hackers@hub.org
Subject: [HACKERS] tmin writeback optimization
I was doing some profiling of the backend, and noticed that during a certain
benchmark I was running somewhere between 30% and 75% of the backend's CPU
time was being spent in calls to TransactionIdDidCommit() from
HeapTupleSatisfiesNow() or HeapTupleSatisfiesItself() to determine that
changed rows' transactions had in fact been committed even though the rows'
tmin values had not yet been set.
When a query looks at a given row, it needs to figure out whether the
transaction that changed the row has been committed and hence it should pay
attention to the row, or whether on the other hand the transaction is still
in progress or has been aborted and hence the row should be ignored. If
a tmin value is set, it is known definitively that the row's transaction
has been committed. However, if tmin is not set, the transaction
referred to in xmin must be looked up in pg_log, and this is what the
backend was spending a lot of time doing during my benchmark.
So, implementing a method suggested by Vadim, I created the following
patch that, the first time a query finds a committed row whose tmin value
is not set, sets it, and marks the buffer where the row is stored as
dirty. (It works for tmax, too.) This doesn't result in the boost in
real time performance I was hoping for, however it does decrease backend
CPU usage by up to two-thirds in certain situations, so it could be
rather beneficial in high-concurrency settings.
1997-03-28 08:06:53 +01:00
|
|
|
|
1997-11-02 16:27:14 +01:00
|
|
|
if (tuple->t_infomask & HEAP_XMAX_INVALID) /* xid invalid or aborted */
|
1998-09-01 05:29:17 +02:00
|
|
|
return true;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1997-11-02 16:27:14 +01:00
|
|
|
if (tuple->t_infomask & HEAP_XMAX_COMMITTED)
|
1998-12-15 13:47:01 +01:00
|
|
|
{
|
|
|
|
if (tuple->t_infomask & HEAP_MARKED_FOR_UPDATE)
|
|
|
|
return true;
|
1998-09-01 05:29:17 +02:00
|
|
|
return false;
|
1998-12-15 13:47:01 +01:00
|
|
|
}
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1997-11-02 16:27:14 +01:00
|
|
|
if (TransactionIdIsCurrentTransactionId(tuple->t_xmax))
|
1997-09-07 07:04:48 +02:00
|
|
|
{
|
1998-12-15 13:47:01 +01:00
|
|
|
if (tuple->t_infomask & HEAP_MARKED_FOR_UPDATE)
|
|
|
|
return true;
|
1997-11-02 16:27:14 +01:00
|
|
|
if (CommandIdGEScanCommandId(tuple->t_cmax))
|
1998-09-01 05:29:17 +02:00
|
|
|
return true; /* deleted after scan started */
|
1997-11-02 16:27:14 +01:00
|
|
|
else
|
1998-09-01 05:29:17 +02:00
|
|
|
return false; /* deleted before scan started */
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
|
|
|
|
1997-11-02 16:27:14 +01:00
|
|
|
if (!TransactionIdDidCommit(tuple->t_xmax))
|
1997-09-07 07:04:48 +02:00
|
|
|
{
|
1997-11-02 16:27:14 +01:00
|
|
|
if (TransactionIdDidAbort(tuple->t_xmax))
|
|
|
|
tuple->t_infomask |= HEAP_XMAX_INVALID; /* aborted */
|
1998-09-01 05:29:17 +02:00
|
|
|
return true;
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
|
|
|
|
1997-11-02 16:27:14 +01:00
|
|
|
/* xmax transaction committed */
|
|
|
|
tuple->t_infomask |= HEAP_XMAX_COMMITTED;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1998-12-15 13:47:01 +01:00
|
|
|
if (tuple->t_infomask & HEAP_MARKED_FOR_UPDATE)
|
|
|
|
return true;
|
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return false;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
1998-12-15 13:47:01 +01:00
|
|
|
|
|
|
|
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;
|
1999-01-29 10:23:17 +01:00
|
|
|
ItemPointerSetInvalid(&(SnapshotDirty->tid));
|
1998-12-15 13:47:01 +01:00
|
|
|
|
|
|
|
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;
|
1999-01-29 10:23:17 +01:00
|
|
|
SnapshotDirty->tid = tuple->t_ctid;
|
1998-12-15 13:47:01 +01:00
|
|
|
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;
|
|
|
|
|
1999-01-29 10:23:17 +01:00
|
|
|
SnapshotDirty->tid = tuple->t_ctid;
|
1998-12-15 13:47:01 +01:00
|
|
|
return false; /* updated by other */
|
|
|
|
}
|
1998-12-16 12:53:55 +01:00
|
|
|
|
|
|
|
bool
|
|
|
|
HeapTupleSatisfiesSnapshot(HeapTupleHeader tuple, Snapshot snapshot)
|
|
|
|
{
|
|
|
|
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 (CommandIdGEScanCommandId(tuple->t_cmin))
|
|
|
|
return false; /* inserted after scan started */
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
if (CommandIdGEScanCommandId(tuple->t_cmax))
|
|
|
|
return true; /* deleted after scan started */
|
|
|
|
else
|
|
|
|
return false; /* deleted before scan started */
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* this call is VERY expensive - requires a log table lookup.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (!TransactionIdDidCommit(tuple->t_xmin))
|
|
|
|
{
|
|
|
|
if (TransactionIdDidAbort(tuple->t_xmin))
|
|
|
|
tuple->t_infomask |= HEAP_XMIN_INVALID; /* aborted */
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
tuple->t_infomask |= HEAP_XMIN_COMMITTED;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* By here, the inserting transaction has committed -
|
|
|
|
* have to check when...
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (tuple->t_xmin >= snapshot->xmax)
|
|
|
|
return false;
|
|
|
|
if (tuple->t_xmin >= snapshot->xmin)
|
|
|
|
{
|
|
|
|
uint32 i;
|
|
|
|
|
|
|
|
for (i = 0; i < snapshot->xcnt; i++)
|
|
|
|
{
|
|
|
|
if (tuple->t_xmin == snapshot->xip[i])
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tuple->t_infomask & HEAP_XMAX_INVALID) /* xid invalid or aborted */
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (tuple->t_infomask & HEAP_MARKED_FOR_UPDATE)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (!(tuple->t_infomask & HEAP_XMAX_COMMITTED))
|
|
|
|
{
|
|
|
|
if (TransactionIdIsCurrentTransactionId(tuple->t_xmax))
|
|
|
|
{
|
|
|
|
if (CommandIdGEScanCommandId(tuple->t_cmax))
|
|
|
|
return true; /* deleted after scan started */
|
|
|
|
else
|
|
|
|
return false; /* deleted before scan started */
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!TransactionIdDidCommit(tuple->t_xmax))
|
|
|
|
{
|
|
|
|
if (TransactionIdDidAbort(tuple->t_xmax))
|
|
|
|
tuple->t_infomask |= HEAP_XMAX_INVALID; /* aborted */
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* xmax transaction committed */
|
|
|
|
tuple->t_infomask |= HEAP_XMAX_COMMITTED;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tuple->t_xmax >= snapshot->xmax)
|
|
|
|
return true;
|
|
|
|
if (tuple->t_xmax >= snapshot->xmin)
|
|
|
|
{
|
|
|
|
uint32 i;
|
|
|
|
|
|
|
|
for (i = 0; i < snapshot->xcnt; i++)
|
|
|
|
{
|
|
|
|
if (tuple->t_xmax == snapshot->xip[i])
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
SetQuerySnapshot(void)
|
|
|
|
{
|
|
|
|
|
|
|
|
/* 1st call in xaction */
|
1998-12-18 10:10:39 +01:00
|
|
|
if (SerializableSnapshot == NULL)
|
1998-12-16 12:53:55 +01:00
|
|
|
{
|
1998-12-18 10:10:39 +01:00
|
|
|
SerializableSnapshot = GetSnapshotData(true);
|
|
|
|
QuerySnapshot = SerializableSnapshot;
|
1998-12-16 12:53:55 +01:00
|
|
|
Assert(QuerySnapshot != NULL);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
1998-12-18 10:10:39 +01:00
|
|
|
if (QuerySnapshot != SerializableSnapshot)
|
1998-12-16 12:53:55 +01:00
|
|
|
{
|
|
|
|
free(QuerySnapshot->xip);
|
|
|
|
free(QuerySnapshot);
|
|
|
|
}
|
|
|
|
|
1998-12-18 10:10:39 +01:00
|
|
|
if (XactIsoLevel == XACT_SERIALIZABLE)
|
|
|
|
QuerySnapshot = SerializableSnapshot;
|
1998-12-16 12:53:55 +01:00
|
|
|
else
|
1998-12-18 10:10:39 +01:00
|
|
|
QuerySnapshot = GetSnapshotData(false);
|
1998-12-16 12:53:55 +01:00
|
|
|
|
|
|
|
Assert(QuerySnapshot != NULL);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
FreeXactSnapshot(void)
|
|
|
|
{
|
|
|
|
|
1998-12-18 10:10:39 +01:00
|
|
|
if (QuerySnapshot != NULL && QuerySnapshot != SerializableSnapshot)
|
1998-12-16 12:53:55 +01:00
|
|
|
{
|
|
|
|
free(QuerySnapshot->xip);
|
|
|
|
free(QuerySnapshot);
|
|
|
|
}
|
|
|
|
|
|
|
|
QuerySnapshot = NULL;
|
|
|
|
|
1998-12-18 10:10:39 +01:00
|
|
|
if (SerializableSnapshot != NULL)
|
1998-12-16 12:53:55 +01:00
|
|
|
{
|
1998-12-18 10:10:39 +01:00
|
|
|
free(SerializableSnapshot->xip);
|
|
|
|
free(SerializableSnapshot);
|
1998-12-16 12:53:55 +01:00
|
|
|
}
|
|
|
|
|
1998-12-18 10:10:39 +01:00
|
|
|
SerializableSnapshot = NULL;
|
1998-12-16 12:53:55 +01:00
|
|
|
|
|
|
|
}
|