1996-07-09 08:22:35 +02:00
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
*
|
|
|
|
* tqual.c--
|
1997-09-07 07:04:48 +02:00
|
|
|
* POSTGRES time qualification code.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
* Copyright (c) 1994, Regents of the University of California
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* IDENTIFICATION
|
1997-09-12 06:09:08 +02:00
|
|
|
* $Header: /cvsroot/pgsql/src/backend/utils/time/tqual.c,v 1.8 1997/09/12 04:08:57 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/nabstime.h"
|
|
|
|
|
|
|
|
#include "utils/tqual.h"
|
|
|
|
|
1997-08-19 23:40:56 +02:00
|
|
|
static AbsoluteTime TimeQualGetEndTime(TimeQual qual);
|
|
|
|
static AbsoluteTime TimeQualGetSnapshotTime(TimeQual qual);
|
|
|
|
static AbsoluteTime TimeQualGetStartTime(TimeQual qual);
|
1997-09-08 04:41:22 +02:00
|
|
|
static bool TimeQualIncludesNow(TimeQual qual);
|
|
|
|
static bool TimeQualIndicatesDisableValidityChecking(TimeQual qual);
|
|
|
|
static bool TimeQualIsLegal(TimeQual qual);
|
1997-09-12 06:09:08 +02:00
|
|
|
#ifndef NO_ASSERT_CHECKING
|
1997-09-08 04:41:22 +02:00
|
|
|
static bool TimeQualIsRanged(TimeQual qual);
|
|
|
|
static bool TimeQualIsValid(TimeQual qual);
|
1997-09-12 06:09:08 +02:00
|
|
|
#endif
|
|
|
|
static bool TimeQualIsSnapshot(TimeQual qual);
|
1997-08-19 23:40:56 +02:00
|
|
|
|
1996-07-09 08:22:35 +02:00
|
|
|
/*
|
|
|
|
* TimeQualMode --
|
1997-09-07 07:04:48 +02:00
|
|
|
* Mode indicator for treatment of time qualifications.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-09-08 04:41:22 +02:00
|
|
|
typedef uint16 TimeQualMode;
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
#define TimeQualAt 0x1
|
1996-07-09 08:22:35 +02:00
|
|
|
#define TimeQualNewer 0x2
|
|
|
|
#define TimeQualOlder 0x4
|
1997-09-07 07:04:48 +02:00
|
|
|
#define TimeQualAll 0x8
|
1996-07-09 08:22:35 +02:00
|
|
|
|
|
|
|
#define TimeQualMask 0xf
|
|
|
|
|
|
|
|
#define TimeQualEvery 0x0
|
|
|
|
#define TimeQualRange (TimeQualNewer | TimeQualOlder)
|
|
|
|
#define TimeQualAllAt (TimeQualAt | TimeQualAll)
|
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
typedef struct TimeQualData
|
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
AbsoluteTime start;
|
|
|
|
AbsoluteTime end;
|
|
|
|
TimeQualMode mode;
|
1997-09-08 23:56:23 +02:00
|
|
|
} TimeQualData;
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
typedef TimeQualData *InternalTimeQual;
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
static TimeQualData SelfTimeQualData;
|
1997-09-08 23:56:23 +02:00
|
|
|
TimeQual SelfTimeQual = (Pointer) &SelfTimeQualData;
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1997-09-08 04:41:22 +02:00
|
|
|
extern bool PostgresIsInitialized;
|
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
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
static TransactionId HeapSpecialTransactionId = InvalidTransactionId;
|
|
|
|
static 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(),
|
|
|
|
&HeapSpecialTransactionId);
|
|
|
|
HeapSpecialCommandId = GetCurrentCommandId();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
HeapSpecialTransactionId = InvalidTransactionId;
|
|
|
|
}
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* static */
|
|
|
|
bool
|
|
|
|
heapisoverride()
|
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
if (!TransactionIdIsValid(HeapSpecialTransactionId))
|
|
|
|
{
|
|
|
|
return (false);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!TransactionIdEquals(GetCurrentTransactionId(),
|
|
|
|
HeapSpecialTransactionId) ||
|
|
|
|
GetCurrentCommandId() != HeapSpecialCommandId)
|
|
|
|
{
|
|
|
|
HeapSpecialTransactionId = InvalidTransactionId;
|
|
|
|
|
|
|
|
return (false);
|
|
|
|
}
|
|
|
|
return (true);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
#endif /* !defined(GOODAMI) */
|
1996-07-09 08:22:35 +02:00
|
|
|
/*
|
|
|
|
* XXX Transaction system override hacks end here
|
|
|
|
*/
|
|
|
|
|
1997-09-08 04:41:22 +02:00
|
|
|
static bool HeapTupleSatisfiesItself(HeapTuple tuple);
|
|
|
|
static bool HeapTupleSatisfiesNow(HeapTuple tuple);
|
1997-09-07 07:04:48 +02:00
|
|
|
static bool
|
|
|
|
HeapTupleSatisfiesSnapshotInternalTimeQual(HeapTuple tuple,
|
|
|
|
InternalTimeQual qual);
|
|
|
|
static bool
|
|
|
|
HeapTupleSatisfiesUpperBoundedInternalTimeQual(HeapTuple tuple,
|
|
|
|
InternalTimeQual qual);
|
|
|
|
static bool
|
|
|
|
HeapTupleSatisfiesUpperUnboundedInternalTimeQual(HeapTuple tuple,
|
|
|
|
InternalTimeQual qual);
|
|
|
|
|
1996-07-09 08:22:35 +02:00
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* TimeQualIsValid --
|
1997-09-07 07:04:48 +02:00
|
|
|
* True iff time qualification is valid.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-09-12 06:09:08 +02:00
|
|
|
#ifndef NO_ASSERT_CHECKING
|
1997-09-08 04:41:22 +02:00
|
|
|
static bool
|
1996-07-09 08:22:35 +02:00
|
|
|
TimeQualIsValid(TimeQual qual)
|
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
bool hasStartTime;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
if (!PointerIsValid(qual) || qual == SelfTimeQual)
|
|
|
|
{
|
|
|
|
return (true);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (((InternalTimeQual) qual)->mode & ~TimeQualMask)
|
|
|
|
{
|
|
|
|
return (false);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (((InternalTimeQual) qual)->mode & TimeQualAt)
|
|
|
|
{
|
|
|
|
return (AbsoluteTimeIsBackwardCompatiblyValid(((InternalTimeQual) qual)->start));
|
|
|
|
}
|
|
|
|
|
|
|
|
hasStartTime = false;
|
|
|
|
|
|
|
|
if (((InternalTimeQual) qual)->mode & TimeQualNewer)
|
|
|
|
{
|
|
|
|
if (!AbsoluteTimeIsBackwardCompatiblyValid(((InternalTimeQual) qual)->start))
|
|
|
|
{
|
|
|
|
return (false);
|
|
|
|
}
|
|
|
|
hasStartTime = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (((InternalTimeQual) qual)->mode & TimeQualOlder)
|
|
|
|
{
|
|
|
|
if (!AbsoluteTimeIsBackwardCompatiblyValid(((InternalTimeQual) qual)->end))
|
|
|
|
{
|
|
|
|
return (false);
|
|
|
|
}
|
|
|
|
if (hasStartTime)
|
|
|
|
{
|
1997-09-08 23:56:23 +02:00
|
|
|
return ((bool) !AbsoluteTimeIsBefore(
|
1997-09-07 07:04:48 +02:00
|
|
|
((InternalTimeQual) qual)->end,
|
|
|
|
((InternalTimeQual) qual)->start));
|
|
|
|
}
|
|
|
|
}
|
1996-07-09 08:22:35 +02:00
|
|
|
return (true);
|
|
|
|
}
|
1997-09-12 06:09:08 +02:00
|
|
|
#endif
|
1996-07-09 08:22:35 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* TimeQualIsLegal --
|
1997-09-07 07:04:48 +02:00
|
|
|
* True iff time qualification is legal.
|
|
|
|
* I.e., true iff time qualification does not intersects the future,
|
|
|
|
* relative to the transaction start time.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
* Note:
|
1997-09-07 07:04:48 +02:00
|
|
|
* Assumes time qualification is valid.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-09-08 04:41:22 +02:00
|
|
|
static bool
|
1996-07-09 08:22:35 +02:00
|
|
|
TimeQualIsLegal(TimeQual qual)
|
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
Assert(TimeQualIsValid(qual));
|
|
|
|
|
|
|
|
if (qual == NowTimeQual || qual == SelfTimeQual)
|
|
|
|
{
|
|
|
|
return (true);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* TimeQualAt */
|
|
|
|
if (((InternalTimeQual) qual)->mode & TimeQualAt)
|
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
AbsoluteTime a,
|
|
|
|
b;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
a = ((InternalTimeQual) qual)->start;
|
|
|
|
b = GetCurrentTransactionStartTime();
|
|
|
|
|
|
|
|
if (AbsoluteTimeIsAfter(a, b))
|
|
|
|
return (false);
|
|
|
|
else
|
|
|
|
return (true);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* TimeQualOlder or TimeQualRange */
|
|
|
|
if (((InternalTimeQual) qual)->mode & TimeQualOlder)
|
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
AbsoluteTime a,
|
|
|
|
b;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
a = ((InternalTimeQual) qual)->end;
|
|
|
|
b = GetCurrentTransactionStartTime();
|
|
|
|
|
|
|
|
if (AbsoluteTimeIsAfter(a, b))
|
|
|
|
return (false);
|
|
|
|
else
|
|
|
|
return (true);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* TimeQualNewer */
|
|
|
|
if (((InternalTimeQual) qual)->mode & TimeQualNewer)
|
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
AbsoluteTime a,
|
|
|
|
b;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
a = ((InternalTimeQual) qual)->start;
|
|
|
|
b = GetCurrentTransactionStartTime();
|
|
|
|
|
|
|
|
if (AbsoluteTimeIsAfter(a, b))
|
|
|
|
return (false);
|
|
|
|
else
|
|
|
|
return (true);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* TimeQualEvery */
|
1996-07-09 08:22:35 +02:00
|
|
|
return (true);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* TimeQualIncludesNow --
|
1997-09-07 07:04:48 +02:00
|
|
|
* True iff time qualification includes "now."
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
* Note:
|
1997-09-07 07:04:48 +02:00
|
|
|
* Assumes time qualification is valid.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-09-08 04:41:22 +02:00
|
|
|
static bool
|
1996-07-09 08:22:35 +02:00
|
|
|
TimeQualIncludesNow(TimeQual qual)
|
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
Assert(TimeQualIsValid(qual));
|
|
|
|
|
|
|
|
if (qual == NowTimeQual || qual == SelfTimeQual)
|
|
|
|
{
|
|
|
|
return (true);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (((InternalTimeQual) qual)->mode & TimeQualAt)
|
|
|
|
{
|
|
|
|
return (false);
|
|
|
|
}
|
|
|
|
if (((InternalTimeQual) qual)->mode & TimeQualOlder &&
|
|
|
|
!AbsoluteTimeIsAfter(
|
|
|
|
((InternalTimeQual) qual)->end,
|
|
|
|
GetCurrentTransactionStartTime()))
|
|
|
|
{
|
|
|
|
|
|
|
|
return (false);
|
|
|
|
}
|
1996-07-09 08:22:35 +02:00
|
|
|
return (true);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* TimeQualIncludesPast --
|
1997-09-07 07:04:48 +02:00
|
|
|
* True iff time qualification includes some time in the past.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
* Note:
|
1997-09-07 07:04:48 +02:00
|
|
|
* Assumes time qualification is valid.
|
|
|
|
* XXX may not be needed?
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-08-19 23:40:56 +02:00
|
|
|
#ifdef NOT_USED
|
1996-07-09 08:22:35 +02:00
|
|
|
bool
|
|
|
|
TimeQualIncludesPast(TimeQual qual)
|
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
Assert(TimeQualIsValid(qual));
|
|
|
|
|
|
|
|
if (qual == NowTimeQual || qual == SelfTimeQual)
|
|
|
|
{
|
|
|
|
return (false);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* otherwise, must check archive (setting locks as appropriate) */
|
|
|
|
return (true);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1997-08-19 23:40:56 +02:00
|
|
|
#endif
|
1996-07-09 08:22:35 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* TimeQualIsSnapshot --
|
1997-09-07 07:04:48 +02:00
|
|
|
* True iff time qualification is a snapshot qualification.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
* Note:
|
1997-09-07 07:04:48 +02:00
|
|
|
* Assumes time qualification is valid.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-09-08 04:41:22 +02:00
|
|
|
static bool
|
1996-07-09 08:22:35 +02:00
|
|
|
TimeQualIsSnapshot(TimeQual qual)
|
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
Assert(TimeQualIsValid(qual));
|
|
|
|
|
|
|
|
if (qual == NowTimeQual || qual == SelfTimeQual)
|
|
|
|
{
|
|
|
|
return (false);
|
|
|
|
}
|
|
|
|
|
1997-09-08 23:56:23 +02:00
|
|
|
return ((bool) !!(((InternalTimeQual) qual)->mode & TimeQualAt));
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* TimeQualIsRanged --
|
1997-09-07 07:04:48 +02:00
|
|
|
* True iff time qualification is a ranged qualification.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
* Note:
|
1997-09-07 07:04:48 +02:00
|
|
|
* Assumes time qualification is valid.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-09-12 06:09:08 +02:00
|
|
|
#ifndef NO_ASSERT_CHECKING
|
1997-09-08 04:41:22 +02:00
|
|
|
static bool
|
1996-07-09 08:22:35 +02:00
|
|
|
TimeQualIsRanged(TimeQual qual)
|
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
Assert(TimeQualIsValid(qual));
|
|
|
|
|
|
|
|
if (qual == NowTimeQual || qual == SelfTimeQual)
|
|
|
|
{
|
|
|
|
return (false);
|
|
|
|
}
|
|
|
|
|
1997-09-08 23:56:23 +02:00
|
|
|
return ((bool) !(((InternalTimeQual) qual)->mode & TimeQualAt));
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
1997-09-12 06:09:08 +02:00
|
|
|
#endif
|
1996-07-09 08:22:35 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* TimeQualIndicatesDisableValidityChecking --
|
1997-09-07 07:04:48 +02:00
|
|
|
* True iff time qualification indicates validity checking should be
|
|
|
|
* disabled.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
* Note:
|
1997-09-07 07:04:48 +02:00
|
|
|
* XXX This should not be implemented since this does not make sense.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-09-08 04:41:22 +02:00
|
|
|
static bool
|
1996-07-09 08:22:35 +02:00
|
|
|
TimeQualIndicatesDisableValidityChecking(TimeQual qual)
|
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
Assert(TimeQualIsValid(qual));
|
|
|
|
|
|
|
|
if (qual == NowTimeQual || qual == SelfTimeQual)
|
|
|
|
{
|
|
|
|
return (false);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (((InternalTimeQual) qual)->mode & TimeQualAll)
|
|
|
|
{
|
|
|
|
return (true);
|
|
|
|
}
|
1996-07-09 08:22:35 +02:00
|
|
|
return (false);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* TimeQualGetSnapshotTime --
|
1997-09-07 07:04:48 +02:00
|
|
|
* Returns time for a snapshot time qual.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
* Note:
|
1997-09-07 07:04:48 +02:00
|
|
|
* Assumes time qual is valid snapshot time qual.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-09-08 04:41:22 +02:00
|
|
|
static AbsoluteTime
|
1996-07-09 08:22:35 +02:00
|
|
|
TimeQualGetSnapshotTime(TimeQual qual)
|
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
Assert(TimeQualIsSnapshot(qual));
|
|
|
|
|
|
|
|
return (((InternalTimeQual) qual)->start);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* TimeQualGetStartTime --
|
1997-09-07 07:04:48 +02:00
|
|
|
* Returns start time for a ranged time qual.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
* Note:
|
1997-09-07 07:04:48 +02:00
|
|
|
* Assumes time qual is valid ranged time qual.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-09-08 04:41:22 +02:00
|
|
|
static AbsoluteTime
|
1996-07-09 08:22:35 +02:00
|
|
|
TimeQualGetStartTime(TimeQual qual)
|
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
Assert(TimeQualIsRanged(qual));
|
|
|
|
|
|
|
|
return (((InternalTimeQual) qual)->start);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* TimeQualGetEndTime --
|
1997-09-07 07:04:48 +02:00
|
|
|
* Returns end time for a ranged time qual.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
* Note:
|
1997-09-07 07:04:48 +02:00
|
|
|
* Assumes time qual is valid ranged time qual.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-09-08 04:41:22 +02:00
|
|
|
static AbsoluteTime
|
1996-07-09 08:22:35 +02:00
|
|
|
TimeQualGetEndTime(TimeQual qual)
|
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
Assert(TimeQualIsRanged(qual));
|
|
|
|
|
|
|
|
return (((InternalTimeQual) qual)->end);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* TimeFormSnapshotTimeQual --
|
1997-09-07 07:04:48 +02:00
|
|
|
* Returns snapshot time qual for a time.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
* Note:
|
1997-09-07 07:04:48 +02:00
|
|
|
* Assumes time is valid.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
|
|
|
TimeQual
|
|
|
|
TimeFormSnapshotTimeQual(AbsoluteTime time)
|
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
InternalTimeQual qual;
|
|
|
|
|
|
|
|
Assert(AbsoluteTimeIsBackwardCompatiblyValid(time));
|
|
|
|
|
|
|
|
qual = (InternalTimeQual) palloc(sizeof *qual);
|
|
|
|
|
|
|
|
qual->start = time;
|
|
|
|
qual->end = INVALID_ABSTIME;
|
|
|
|
qual->mode = TimeQualAt;
|
|
|
|
|
|
|
|
return ((TimeQual) qual);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* TimeFormRangedTimeQual --
|
1997-09-07 07:04:48 +02:00
|
|
|
* Returns ranged time qual for a pair of times.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
* Note:
|
1997-09-07 07:04:48 +02:00
|
|
|
* If start time is invalid, it is regarded as the epoch.
|
|
|
|
* If end time is invalid, it is regarded as "now."
|
|
|
|
* Assumes start time is before (or the same as) end time.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
|
|
|
TimeQual
|
|
|
|
TimeFormRangedTimeQual(AbsoluteTime startTime,
|
1997-09-07 07:04:48 +02:00
|
|
|
AbsoluteTime endTime)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
InternalTimeQual qual;
|
|
|
|
|
|
|
|
qual = (InternalTimeQual) palloc(sizeof *qual);
|
|
|
|
|
|
|
|
qual->start = startTime;
|
|
|
|
qual->end = endTime;
|
|
|
|
qual->mode = TimeQualEvery;
|
|
|
|
|
|
|
|
if (AbsoluteTimeIsBackwardCompatiblyValid(startTime))
|
|
|
|
{
|
|
|
|
qual->mode |= TimeQualNewer;
|
|
|
|
}
|
|
|
|
if (AbsoluteTimeIsBackwardCompatiblyValid(endTime))
|
|
|
|
{
|
|
|
|
qual->mode |= TimeQualOlder;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ((TimeQual) qual);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* HeapTupleSatisfiesTimeQual --
|
1997-09-07 07:04:48 +02:00
|
|
|
* True iff heap tuple satsifies a time qual.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
* Note:
|
1997-09-07 07:04:48 +02:00
|
|
|
* Assumes heap tuple is valid.
|
|
|
|
* Assumes time qual is valid.
|
|
|
|
* XXX Many of the checks may be simplified and still remain correct.
|
|
|
|
* XXX Partial answers to the checks may be cached in an ItemId.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
|
|
|
bool
|
|
|
|
HeapTupleSatisfiesTimeQual(HeapTuple tuple, TimeQual qual)
|
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
/* extern TransactionId AmiTransactionId; */
|
|
|
|
|
|
|
|
Assert(HeapTupleIsValid(tuple));
|
|
|
|
Assert(TimeQualIsValid(qual));
|
|
|
|
|
|
|
|
if (TransactionIdEquals(tuple->t_xmax, AmiTransactionId))
|
|
|
|
return (false);
|
|
|
|
|
|
|
|
if (qual == SelfTimeQual || heapisoverride())
|
|
|
|
{
|
|
|
|
return (HeapTupleSatisfiesItself(tuple));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (qual == NowTimeQual)
|
|
|
|
{
|
|
|
|
return (HeapTupleSatisfiesNow(tuple));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!TimeQualIsLegal(qual))
|
|
|
|
{
|
|
|
|
elog(WARN, "HeapTupleSatisfiesTimeQual: illegal time qual");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (TimeQualIndicatesDisableValidityChecking(qual))
|
|
|
|
{
|
|
|
|
elog(WARN, "HeapTupleSatisfiesTimeQual: no disabled validity checking (yet)");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (TimeQualIsSnapshot(qual))
|
|
|
|
{
|
|
|
|
return (HeapTupleSatisfiesSnapshotInternalTimeQual(tuple,
|
|
|
|
(InternalTimeQual) qual));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (TimeQualIncludesNow(qual))
|
|
|
|
{
|
|
|
|
return (HeapTupleSatisfiesUpperUnboundedInternalTimeQual(tuple,
|
|
|
|
(InternalTimeQual) qual));
|
|
|
|
}
|
|
|
|
|
|
|
|
return (HeapTupleSatisfiesUpperBoundedInternalTimeQual(tuple,
|
|
|
|
(InternalTimeQual) qual));
|
1996-07-09 08:22:35 +02: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
|
|
|
*/
|
1997-09-08 04:41:22 +02:00
|
|
|
static bool
|
1996-07-09 08:22:35 +02:00
|
|
|
HeapTupleSatisfiesItself(HeapTuple tuple)
|
|
|
|
{
|
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
|
|
|
/*
|
|
|
|
* XXX Several evil casts are made in this routine. Casting XID to be
|
|
|
|
* TransactionId works only because TransactionId->data is the first
|
|
|
|
* (and only) field of the structure.
|
|
|
|
*/
|
|
|
|
if (!AbsoluteTimeIsBackwardCompatiblyValid(tuple->t_tmin))
|
|
|
|
{
|
|
|
|
if (TransactionIdIsCurrentTransactionId((TransactionId) tuple->t_xmin) &&
|
|
|
|
!TransactionIdIsValid((TransactionId) tuple->t_xmax))
|
|
|
|
{
|
|
|
|
return (true);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!TransactionIdDidCommit((TransactionId) tuple->t_xmin))
|
|
|
|
{
|
|
|
|
return (false);
|
|
|
|
}
|
|
|
|
|
|
|
|
tuple->t_tmin = TransactionIdGetCommitTime(tuple->t_xmin);
|
|
|
|
}
|
|
|
|
/* 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-09-07 07:04:48 +02:00
|
|
|
if (AbsoluteTimeIsBackwardCompatiblyReal(tuple->t_tmax))
|
|
|
|
{
|
|
|
|
return (false);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!TransactionIdIsValid((TransactionId) tuple->t_xmax))
|
|
|
|
{
|
|
|
|
return (true);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (TransactionIdIsCurrentTransactionId((TransactionId) tuple->t_xmax))
|
|
|
|
{
|
|
|
|
return (false);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!TransactionIdDidCommit((TransactionId) tuple->t_xmax))
|
|
|
|
{
|
|
|
|
return (true);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* by here, deleting transaction has committed */
|
|
|
|
tuple->t_tmax = TransactionIdGetCommitTime(tuple->t_xmax);
|
|
|
|
|
|
|
|
return (false);
|
1996-07-09 08:22:35 +02: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-08-29 11:05:25 +02:00
|
|
|
* XXX
|
1997-09-07 07:04:48 +02:00
|
|
|
* 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
|
|
|
|
* 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
|
|
|
*/
|
1997-09-08 04:41:22 +02:00
|
|
|
static bool
|
1996-07-09 08:22:35 +02:00
|
|
|
HeapTupleSatisfiesNow(HeapTuple tuple)
|
|
|
|
{
|
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)
|
|
|
|
return ((bool) (TransactionIdIsValid((TransactionId) tuple->t_xmin) &&
|
|
|
|
!TransactionIdIsValid((TransactionId) tuple->t_xmax)));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* XXX Several evil casts are made in this routine. Casting XID to be
|
|
|
|
* TransactionId works only because TransactionId->data is the first
|
|
|
|
* (and only) field of the structure.
|
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 (!AbsoluteTimeIsBackwardCompatiblyValid(tuple->t_tmin))
|
|
|
|
{
|
|
|
|
|
|
|
|
if (TransactionIdIsCurrentTransactionId((TransactionId) tuple->t_xmin)
|
|
|
|
&& CommandIdGEScanCommandId(tuple->t_cmin))
|
|
|
|
{
|
|
|
|
|
|
|
|
return (false);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (TransactionIdIsCurrentTransactionId((TransactionId) tuple->t_xmin)
|
|
|
|
&& !CommandIdGEScanCommandId(tuple->t_cmin))
|
|
|
|
{
|
|
|
|
|
|
|
|
if (!TransactionIdIsValid((TransactionId) tuple->t_xmax))
|
|
|
|
{
|
|
|
|
return (true);
|
|
|
|
}
|
|
|
|
|
|
|
|
Assert(TransactionIdIsCurrentTransactionId((TransactionId) tuple->t_xmax));
|
|
|
|
|
|
|
|
if (CommandIdGEScanCommandId(tuple->t_cmax))
|
|
|
|
{
|
|
|
|
return (true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* this call is VERY expensive - requires a log table lookup.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (!TransactionIdDidCommit((TransactionId) tuple->t_xmin))
|
|
|
|
{
|
|
|
|
return (false);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* the transaction has been committed--store the commit time _now_
|
|
|
|
* instead of waiting for a vacuum so we avoid the expensive call
|
|
|
|
* next time.
|
|
|
|
*/
|
|
|
|
tuple->t_tmin = TransactionIdGetCommitTime(tuple->t_xmin);
|
|
|
|
}
|
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 */
|
|
|
|
if (!TransactionIdIsValid((TransactionId) tuple->t_xmax))
|
|
|
|
{
|
|
|
|
return (true);
|
|
|
|
}
|
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 (TransactionIdIsCurrentTransactionId((TransactionId) tuple->t_xmax))
|
|
|
|
{
|
|
|
|
return (false);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (AbsoluteTimeIsBackwardCompatiblyReal(tuple->t_tmax))
|
|
|
|
{
|
|
|
|
return (false);
|
|
|
|
}
|
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 (!TransactionIdDidCommit((TransactionId) tuple->t_xmax))
|
|
|
|
{
|
|
|
|
return (true);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* xmax transaction committed, but no tmax set. so set it. */
|
|
|
|
tuple->t_tmax = TransactionIdGetCommitTime(tuple->t_xmax);
|
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
|
|
|
return (false);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* HeapTupleSatisfiesSnapshotInternalTimeQual --
|
1997-09-07 07:04:48 +02:00
|
|
|
* True iff heap tuple is valid at the snapshot time qualification.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
* Note:
|
1997-09-07 07:04:48 +02:00
|
|
|
* Assumes heap tuple is valid.
|
|
|
|
* Assumes internal time qualification is valid snapshot qualification.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
|
|
|
/*
|
|
|
|
* The satisfaction of Rel[T] requires the following:
|
|
|
|
*
|
|
|
|
* (Xmin is committed && Tmin <= T &&
|
1997-09-07 07:04:48 +02:00
|
|
|
* (Xmax is null || (Xmax is not committed && Xmax != my-transaction) ||
|
|
|
|
* Tmax >= T))
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-09-08 04:41:22 +02:00
|
|
|
static bool
|
1996-07-09 08:22:35 +02:00
|
|
|
HeapTupleSatisfiesSnapshotInternalTimeQual(HeapTuple tuple,
|
1997-09-07 07:04:48 +02:00
|
|
|
InternalTimeQual qual)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* XXX Several evil casts are made in this routine. Casting XID to be
|
|
|
|
* TransactionId works only because TransactionId->data is the first
|
|
|
|
* (and only) field of the structure.
|
|
|
|
*/
|
|
|
|
if (!AbsoluteTimeIsBackwardCompatiblyValid(tuple->t_tmin))
|
|
|
|
{
|
|
|
|
|
|
|
|
if (!TransactionIdDidCommit((TransactionId) tuple->t_xmin))
|
|
|
|
{
|
|
|
|
return (false);
|
|
|
|
}
|
|
|
|
|
|
|
|
tuple->t_tmin = TransactionIdGetCommitTime(tuple->t_xmin);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (AbsoluteTimeIsBefore(TimeQualGetSnapshotTime((TimeQual) qual), tuple->t_tmin))
|
|
|
|
{
|
|
|
|
return (false);
|
|
|
|
}
|
|
|
|
/* the tuple was inserted validly before the snapshot time */
|
|
|
|
|
|
|
|
if (!AbsoluteTimeIsBackwardCompatiblyReal(tuple->t_tmax))
|
|
|
|
{
|
|
|
|
|
|
|
|
if (!TransactionIdIsValid((TransactionId) tuple->t_xmax) ||
|
|
|
|
!TransactionIdDidCommit((TransactionId) tuple->t_xmax))
|
|
|
|
{
|
|
|
|
|
|
|
|
return (true);
|
|
|
|
}
|
|
|
|
|
|
|
|
tuple->t_tmax = TransactionIdGetCommitTime(tuple->t_xmax);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ((bool)
|
|
|
|
AbsoluteTimeIsAfter(tuple->t_tmax,
|
|
|
|
TimeQualGetSnapshotTime((TimeQual) qual)));
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* HeapTupleSatisfiesUpperBoundedInternalTimeQual --
|
1997-09-07 07:04:48 +02:00
|
|
|
* True iff heap tuple is valid within a upper bounded time qualification.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
* Note:
|
1997-09-07 07:04:48 +02:00
|
|
|
* Assumes heap tuple is valid.
|
|
|
|
* Assumes time qualification is valid ranged qualification with fixed
|
|
|
|
* upper bound.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
|
|
|
/*
|
|
|
|
* The satisfaction of [T1,T2] requires the following:
|
|
|
|
*
|
|
|
|
* (Xmin is committed && Tmin <= T2 &&
|
1997-09-07 07:04:48 +02:00
|
|
|
* (Xmax is null || (Xmax is not committed && Xmax != my-transaction) ||
|
|
|
|
* T1 is null || Tmax >= T1))
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-09-08 04:41:22 +02:00
|
|
|
static bool
|
1996-07-09 08:22:35 +02:00
|
|
|
HeapTupleSatisfiesUpperBoundedInternalTimeQual(HeapTuple tuple,
|
1997-09-07 07:04:48 +02:00
|
|
|
InternalTimeQual qual)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* XXX Several evil casts are made in this routine. Casting XID to be
|
|
|
|
* TransactionId works only because TransactionId->data is the first
|
|
|
|
* (and only) field of the structure.
|
|
|
|
*/
|
|
|
|
if (!AbsoluteTimeIsBackwardCompatiblyValid(tuple->t_tmin))
|
|
|
|
{
|
|
|
|
|
|
|
|
if (!TransactionIdDidCommit((TransactionId) tuple->t_xmin))
|
|
|
|
{
|
|
|
|
return (false);
|
|
|
|
}
|
|
|
|
|
|
|
|
tuple->t_tmin = TransactionIdGetCommitTime(tuple->t_xmin);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (AbsoluteTimeIsBefore(TimeQualGetEndTime((TimeQual) qual), tuple->t_tmin))
|
|
|
|
{
|
|
|
|
return (false);
|
|
|
|
}
|
|
|
|
/* the tuple was inserted validly before the range end */
|
|
|
|
|
|
|
|
if (!AbsoluteTimeIsBackwardCompatiblyValid(TimeQualGetStartTime((TimeQual) qual)))
|
|
|
|
{
|
|
|
|
return (true);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!AbsoluteTimeIsBackwardCompatiblyReal(tuple->t_tmax))
|
|
|
|
{
|
|
|
|
|
|
|
|
if (!TransactionIdIsValid((TransactionId) tuple->t_xmax) ||
|
|
|
|
!TransactionIdDidCommit((TransactionId) tuple->t_xmax))
|
|
|
|
{
|
|
|
|
|
|
|
|
return (true);
|
|
|
|
}
|
|
|
|
|
|
|
|
tuple->t_tmax = TransactionIdGetCommitTime(tuple->t_xmax);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ((bool) AbsoluteTimeIsAfter(tuple->t_tmax,
|
|
|
|
TimeQualGetStartTime((TimeQual) qual)));
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* HeapTupleSatisfiesUpperUnboundedInternalTimeQual --
|
1997-09-07 07:04:48 +02:00
|
|
|
* True iff heap tuple is valid within a upper bounded time qualification.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
* Note:
|
1997-09-07 07:04:48 +02:00
|
|
|
* Assumes heap tuple is valid.
|
|
|
|
* Assumes time qualification is valid ranged qualification with no
|
|
|
|
* upper bound.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
|
|
|
/*
|
|
|
|
* The satisfaction of [T1,] requires the following:
|
|
|
|
*
|
|
|
|
* ((Xmin == my-transaction && Cmin != my-command &&
|
1997-09-07 07:04:48 +02:00
|
|
|
* (Xmax is null || (Xmax == my-transaction && Cmax != my-command)))
|
1996-07-09 08:22:35 +02:00
|
|
|
* ||
|
|
|
|
*
|
|
|
|
* (Xmin is committed &&
|
1997-09-07 07:04:48 +02:00
|
|
|
* (Xmax is null || (Xmax == my-transaction && Cmax == my-command) ||
|
|
|
|
* (Xmax is not committed && Xmax != my-transaction) ||
|
|
|
|
* T1 is null || Tmax >= T1)))
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
1997-09-08 04:41:22 +02:00
|
|
|
static bool
|
1996-07-09 08:22:35 +02:00
|
|
|
HeapTupleSatisfiesUpperUnboundedInternalTimeQual(HeapTuple tuple,
|
1997-09-07 07:04:48 +02:00
|
|
|
InternalTimeQual qual)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
if (!AbsoluteTimeIsBackwardCompatiblyValid(tuple->t_tmin))
|
|
|
|
{
|
|
|
|
|
|
|
|
if (TransactionIdIsCurrentTransactionId((TransactionId) tuple->t_xmin) &&
|
|
|
|
CommandIdGEScanCommandId(tuple->t_cmin))
|
|
|
|
{
|
|
|
|
|
|
|
|
return (false);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (TransactionIdIsCurrentTransactionId((TransactionId) tuple->t_xmin) &&
|
|
|
|
!CommandIdGEScanCommandId(tuple->t_cmin))
|
|
|
|
{
|
|
|
|
|
|
|
|
if (!TransactionIdIsValid((TransactionId) tuple->t_xmax))
|
|
|
|
{
|
|
|
|
return (true);
|
|
|
|
}
|
|
|
|
|
|
|
|
Assert(TransactionIdIsCurrentTransactionId((TransactionId) tuple->t_xmax));
|
|
|
|
|
1997-09-08 23:56:23 +02:00
|
|
|
return ((bool) !CommandIdGEScanCommandId(tuple->t_cmax));
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!TransactionIdDidCommit((TransactionId) tuple->t_xmin))
|
|
|
|
{
|
|
|
|
return (false);
|
|
|
|
}
|
|
|
|
|
|
|
|
tuple->t_tmin = TransactionIdGetCommitTime(tuple->t_xmin);
|
|
|
|
}
|
|
|
|
/* the tuple was inserted validly */
|
|
|
|
|
|
|
|
if (!AbsoluteTimeIsBackwardCompatiblyValid(TimeQualGetStartTime((TimeQual) qual)))
|
|
|
|
{
|
1996-07-09 08:22:35 +02:00
|
|
|
return (true);
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!AbsoluteTimeIsBackwardCompatiblyReal(tuple->t_tmax))
|
|
|
|
{
|
|
|
|
|
|
|
|
if (!TransactionIdIsValid((TransactionId) tuple->t_xmax))
|
|
|
|
{
|
|
|
|
return (true);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (TransactionIdIsCurrentTransactionId((TransactionId) tuple->t_xmax))
|
|
|
|
{
|
|
|
|
return (CommandIdGEScanCommandId(tuple->t_cmin));
|
|
|
|
/* it looks like error ^^^^ */
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!TransactionIdDidCommit((TransactionId) tuple->t_xmax))
|
|
|
|
{
|
|
|
|
return (true);
|
|
|
|
}
|
|
|
|
|
|
|
|
tuple->t_tmax = TransactionIdGetCommitTime(tuple->t_xmax);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ((bool) AbsoluteTimeIsAfter(tuple->t_tmax,
|
|
|
|
TimeQualGetStartTime((TimeQual) qual)));
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|