mirror of
https://github.com/postgres/postgres.git
synced 2025-11-10 17:42:29 +03:00
Nested transactions. There is still much left to do, especially on the
performance front, but with feature freeze upon us I think it's time to drive a stake in the ground and say that this will be in 7.5. Alvaro Herrera, with some help from Tom Lane.
This commit is contained in:
Tom Lane
@@ -8,7 +8,7 @@
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/access/gist/gistscan.c,v 1.51 2004/01/07 18:56:23 neilc Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/access/gist/gistscan.c,v 1.52 2004/07/01 00:49:27 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -41,6 +41,7 @@ static void adjustiptr(IndexScanDesc s, ItemPointer iptr,
|
||||
typedef struct GISTScanListData
|
||||
{
|
||||
IndexScanDesc gsl_scan;
|
||||
TransactionId gsl_creatingXid;
|
||||
struct GISTScanListData *gsl_next;
|
||||
} GISTScanListData;
|
||||
|
||||
@@ -223,6 +224,7 @@ gistregscan(IndexScanDesc s)
|
||||
|
||||
l = (GISTScanList) palloc(sizeof(GISTScanListData));
|
||||
l->gsl_scan = s;
|
||||
l->gsl_creatingXid = GetCurrentTransactionId();
|
||||
l->gsl_next = GISTScans;
|
||||
GISTScans = l;
|
||||
}
|
||||
@@ -271,6 +273,46 @@ AtEOXact_gist(void)
|
||||
GISTScans = NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
* AtEOSubXact_gist() --- clean up gist subsystem at subxact abort or commit.
|
||||
*
|
||||
* This is here because it needs to touch this module's static var GISTScans.
|
||||
*/
|
||||
void
|
||||
AtEOSubXact_gist(TransactionId childXid)
|
||||
{
|
||||
GISTScanList l;
|
||||
GISTScanList prev;
|
||||
GISTScanList next;
|
||||
|
||||
/*
|
||||
* Note: these actions should only be necessary during xact abort; but
|
||||
* they can't hurt during a commit.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Forget active scans that were started in this subtransaction.
|
||||
*/
|
||||
prev = NULL;
|
||||
|
||||
for (l = GISTScans; l != NULL; l = next)
|
||||
{
|
||||
next = l->gsl_next;
|
||||
if (l->gsl_creatingXid == childXid)
|
||||
{
|
||||
if (prev == NULL)
|
||||
GISTScans = next;
|
||||
else
|
||||
prev->gsl_next = next;
|
||||
|
||||
pfree(l);
|
||||
/* prev does not change */
|
||||
}
|
||||
else
|
||||
prev = l;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
gistadjscans(Relation rel, int op, BlockNumber blkno, OffsetNumber offnum)
|
||||
{
|
||||
|
||||
@@ -8,7 +8,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/access/hash/hashscan.c,v 1.33 2004/01/07 18:56:23 neilc Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/access/hash/hashscan.c,v 1.34 2004/07/01 00:49:29 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -21,6 +21,7 @@
|
||||
typedef struct HashScanListData
|
||||
{
|
||||
IndexScanDesc hashsl_scan;
|
||||
TransactionId hashsl_creatingXid;
|
||||
struct HashScanListData *hashsl_next;
|
||||
} HashScanListData;
|
||||
|
||||
@@ -50,6 +51,46 @@ AtEOXact_hash(void)
|
||||
HashScans = NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
* AtEOSubXact_hash() --- clean up hash subsystem at subxact abort or commit.
|
||||
*
|
||||
* This is here because it needs to touch this module's static var HashScans.
|
||||
*/
|
||||
void
|
||||
AtEOSubXact_hash(TransactionId childXid)
|
||||
{
|
||||
HashScanList l;
|
||||
HashScanList prev;
|
||||
HashScanList next;
|
||||
|
||||
/*
|
||||
* Note: these actions should only be necessary during xact abort; but
|
||||
* they can't hurt during a commit.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Forget active scans that were started in this subtransaction.
|
||||
*/
|
||||
prev = NULL;
|
||||
|
||||
for (l = HashScans; l != NULL; l = next)
|
||||
{
|
||||
next = l->hashsl_next;
|
||||
if (l->hashsl_creatingXid == childXid)
|
||||
{
|
||||
if (prev == NULL)
|
||||
HashScans = next;
|
||||
else
|
||||
prev->hashsl_next = next;
|
||||
|
||||
pfree(l);
|
||||
/* prev does not change */
|
||||
}
|
||||
else
|
||||
prev = l;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* _Hash_regscan() -- register a new scan.
|
||||
*/
|
||||
@@ -60,6 +101,7 @@ _hash_regscan(IndexScanDesc scan)
|
||||
|
||||
new_el = (HashScanList) palloc(sizeof(HashScanListData));
|
||||
new_el->hashsl_scan = scan;
|
||||
new_el->hashsl_creatingXid = GetCurrentTransactionId();
|
||||
new_el->hashsl_next = HashScans;
|
||||
HashScans = new_el;
|
||||
}
|
||||
|
||||
@@ -8,7 +8,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/access/rtree/rtscan.c,v 1.51 2004/01/07 18:56:24 neilc Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/access/rtree/rtscan.c,v 1.52 2004/07/01 00:49:31 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -42,6 +42,7 @@ static void adjustiptr(IndexScanDesc s, ItemPointer iptr,
|
||||
typedef struct RTScanListData
|
||||
{
|
||||
IndexScanDesc rtsl_scan;
|
||||
TransactionId rtsl_creatingXid;
|
||||
struct RTScanListData *rtsl_next;
|
||||
} RTScanListData;
|
||||
|
||||
@@ -240,6 +241,7 @@ rtregscan(IndexScanDesc s)
|
||||
|
||||
l = (RTScanList) palloc(sizeof(RTScanListData));
|
||||
l->rtsl_scan = s;
|
||||
l->rtsl_creatingXid = GetCurrentTransactionId();
|
||||
l->rtsl_next = RTScans;
|
||||
RTScans = l;
|
||||
}
|
||||
@@ -290,6 +292,46 @@ AtEOXact_rtree(void)
|
||||
RTScans = NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
* AtEOSubXact_rtree() --- clean up rtree subsystem at subxact abort or commit.
|
||||
*
|
||||
* This is here because it needs to touch this module's static var RTScans.
|
||||
*/
|
||||
void
|
||||
AtEOSubXact_rtree(TransactionId childXid)
|
||||
{
|
||||
RTScanList l;
|
||||
RTScanList prev;
|
||||
RTScanList next;
|
||||
|
||||
/*
|
||||
* Note: these actions should only be necessary during xact abort; but
|
||||
* they can't hurt during a commit.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Forget active scans that were started in this subtransaction.
|
||||
*/
|
||||
prev = NULL;
|
||||
|
||||
for (l = RTScans; l != NULL; l = next)
|
||||
{
|
||||
next = l->rtsl_next;
|
||||
if (l->rtsl_creatingXid == childXid)
|
||||
{
|
||||
if (prev == NULL)
|
||||
RTScans = next;
|
||||
else
|
||||
prev->rtsl_next = next;
|
||||
|
||||
pfree(l);
|
||||
/* prev does not change */
|
||||
}
|
||||
else
|
||||
prev = l;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
rtadjscans(Relation r, int op, BlockNumber blkno, OffsetNumber offnum)
|
||||
{
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
# Makefile for access/transam
|
||||
#
|
||||
# IDENTIFICATION
|
||||
# $PostgreSQL: pgsql/src/backend/access/transam/Makefile,v 1.18 2003/11/29 19:51:40 pgsql Exp $
|
||||
# $PostgreSQL: pgsql/src/backend/access/transam/Makefile,v 1.19 2004/07/01 00:49:42 tgl Exp $
|
||||
#
|
||||
#-------------------------------------------------------------------------
|
||||
|
||||
@@ -12,7 +12,7 @@ subdir = src/backend/access/transam
|
||||
top_builddir = ../../../..
|
||||
include $(top_builddir)/src/Makefile.global
|
||||
|
||||
OBJS = clog.o transam.o varsup.o xact.o xlog.o xlogutils.o rmgr.o slru.o
|
||||
OBJS = clog.o transam.o varsup.o xact.o xlog.o xlogutils.o rmgr.o slru.o subtrans.o
|
||||
|
||||
all: SUBSYS.o
|
||||
|
||||
|
||||
@@ -13,7 +13,7 @@
|
||||
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $PostgreSQL: pgsql/src/backend/access/transam/clog.c,v 1.20 2004/05/31 03:47:54 tgl Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/access/transam/clog.c,v 1.21 2004/07/01 00:49:42 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -21,14 +21,13 @@
|
||||
|
||||
#include <fcntl.h>
|
||||
#include <dirent.h>
|
||||
#include <errno.h>
|
||||
#include <sys/stat.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include "access/clog.h"
|
||||
#include "access/slru.h"
|
||||
#include "storage/lwlock.h"
|
||||
#include "miscadmin.h"
|
||||
#include "storage/lwlock.h"
|
||||
|
||||
|
||||
/*
|
||||
@@ -65,7 +64,7 @@
|
||||
* is guaranteed flushed through the XLOG commit record before we are called
|
||||
* to log a commit, so the WAL rule "write xlog before data" is satisfied
|
||||
* automatically for commits, and we don't really care for aborts. Therefore,
|
||||
* we don't need to mark XLOG pages with LSN information; we have enough
|
||||
* we don't need to mark CLOG pages with LSN information; we have enough
|
||||
* synchronization already.
|
||||
*----------
|
||||
*/
|
||||
@@ -95,20 +94,22 @@ TransactionIdSetStatus(TransactionId xid, XidStatus status)
|
||||
char *byteptr;
|
||||
|
||||
Assert(status == TRANSACTION_STATUS_COMMITTED ||
|
||||
status == TRANSACTION_STATUS_ABORTED);
|
||||
status == TRANSACTION_STATUS_ABORTED ||
|
||||
status == TRANSACTION_STATUS_SUB_COMMITTED);
|
||||
|
||||
LWLockAcquire(ClogCtl->ControlLock, LW_EXCLUSIVE);
|
||||
|
||||
byteptr = SimpleLruReadPage(ClogCtl, pageno, xid, true);
|
||||
byteptr += byteno;
|
||||
|
||||
/* Current state should be 0 or target state */
|
||||
/* Current state should be 0, subcommitted or target state */
|
||||
Assert(((*byteptr >> bshift) & CLOG_XACT_BITMASK) == 0 ||
|
||||
((*byteptr >> bshift) & CLOG_XACT_BITMASK) == TRANSACTION_STATUS_SUB_COMMITTED ||
|
||||
((*byteptr >> bshift) & CLOG_XACT_BITMASK) == status);
|
||||
|
||||
*byteptr |= (status << bshift);
|
||||
|
||||
/* ...->page_status[slotno] = CLOG_PAGE_DIRTY; already done */
|
||||
/* ...->page_status[slotno] = SLRU_PAGE_DIRTY; already done */
|
||||
|
||||
LWLockRelease(ClogCtl->ControlLock);
|
||||
}
|
||||
@@ -117,7 +118,7 @@ TransactionIdSetStatus(TransactionId xid, XidStatus status)
|
||||
* Interrogate the state of a transaction in the commit log.
|
||||
*
|
||||
* NB: this is a low-level routine and is NOT the preferred entry point
|
||||
* for most uses; TransactionLogTest() in transam.c is the intended caller.
|
||||
* for most uses; TransactionLogFetch() in transam.c is the intended caller.
|
||||
*/
|
||||
XidStatus
|
||||
TransactionIdGetStatus(TransactionId xid)
|
||||
@@ -176,7 +177,7 @@ BootStrapCLOG(void)
|
||||
|
||||
/* Make sure it's written out */
|
||||
SimpleLruWritePage(ClogCtl, slotno, NULL);
|
||||
/* Assert(ClogCtl->page_status[slotno] == CLOG_PAGE_CLEAN); */
|
||||
/* Assert(ClogCtl->page_status[slotno] == SLRU_PAGE_CLEAN); */
|
||||
|
||||
LWLockRelease(ClogCtl->ControlLock);
|
||||
}
|
||||
@@ -211,7 +212,8 @@ StartupCLOG(void)
|
||||
/*
|
||||
* Initialize our idea of the latest page number.
|
||||
*/
|
||||
SimpleLruSetLatestPage(ClogCtl, TransactionIdToPage(ShmemVariableCache->nextXid));
|
||||
SimpleLruSetLatestPage(ClogCtl,
|
||||
TransactionIdToPage(ShmemVariableCache->nextXid));
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -333,51 +335,20 @@ WriteZeroPageXlogRec(int pageno)
|
||||
rdata.data = (char *) (&pageno);
|
||||
rdata.len = sizeof(int);
|
||||
rdata.next = NULL;
|
||||
(void) XLogInsert(RM_CLOG_ID, CLOG_ZEROPAGE | XLOG_NO_TRAN, &rdata);
|
||||
(void) XLogInsert(RM_SLRU_ID, CLOG_ZEROPAGE | XLOG_NO_TRAN, &rdata);
|
||||
}
|
||||
|
||||
/*
|
||||
* CLOG resource manager's routines
|
||||
*/
|
||||
/* Redo a ZEROPAGE action during WAL replay */
|
||||
void
|
||||
clog_redo(XLogRecPtr lsn, XLogRecord *record)
|
||||
clog_zeropage_redo(int pageno)
|
||||
{
|
||||
uint8 info = record->xl_info & ~XLR_INFO_MASK;
|
||||
int slotno;
|
||||
|
||||
if (info == CLOG_ZEROPAGE)
|
||||
{
|
||||
int pageno;
|
||||
int slotno;
|
||||
LWLockAcquire(ClogCtl->ControlLock, LW_EXCLUSIVE);
|
||||
|
||||
memcpy(&pageno, XLogRecGetData(record), sizeof(int));
|
||||
slotno = ZeroCLOGPage(pageno, false);
|
||||
SimpleLruWritePage(ClogCtl, slotno, NULL);
|
||||
/* Assert(ClogCtl->page_status[slotno] == SLRU_PAGE_CLEAN); */
|
||||
|
||||
LWLockAcquire(ClogCtl->ControlLock, LW_EXCLUSIVE);
|
||||
|
||||
slotno = ZeroCLOGPage(pageno, false);
|
||||
SimpleLruWritePage(ClogCtl, slotno, NULL);
|
||||
/* Assert(ClogCtl->page_status[slotno] == SLRU_PAGE_CLEAN); */
|
||||
|
||||
LWLockRelease(ClogCtl->ControlLock);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
clog_undo(XLogRecPtr lsn, XLogRecord *record)
|
||||
{
|
||||
}
|
||||
|
||||
void
|
||||
clog_desc(char *buf, uint8 xl_info, char *rec)
|
||||
{
|
||||
uint8 info = xl_info & ~XLR_INFO_MASK;
|
||||
|
||||
if (info == CLOG_ZEROPAGE)
|
||||
{
|
||||
int pageno;
|
||||
|
||||
memcpy(&pageno, rec, sizeof(int));
|
||||
sprintf(buf + strlen(buf), "zeropage: %d", pageno);
|
||||
}
|
||||
else
|
||||
strcat(buf, "UNKNOWN");
|
||||
LWLockRelease(ClogCtl->ControlLock);
|
||||
}
|
||||
|
||||
@@ -3,16 +3,16 @@
|
||||
*
|
||||
* Resource managers definition
|
||||
*
|
||||
* $PostgreSQL: pgsql/src/backend/access/transam/rmgr.c,v 1.12 2003/11/29 19:51:40 pgsql Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/access/transam/rmgr.c,v 1.13 2004/07/01 00:49:42 tgl Exp $
|
||||
*/
|
||||
#include "postgres.h"
|
||||
|
||||
#include "access/clog.h"
|
||||
#include "access/gist.h"
|
||||
#include "access/hash.h"
|
||||
#include "access/heapam.h"
|
||||
#include "access/nbtree.h"
|
||||
#include "access/rtree.h"
|
||||
#include "access/slru.h"
|
||||
#include "access/xact.h"
|
||||
#include "access/xlog.h"
|
||||
#include "storage/smgr.h"
|
||||
@@ -23,7 +23,7 @@ RmgrData RmgrTable[RM_MAX_ID + 1] = {
|
||||
{"XLOG", xlog_redo, xlog_undo, xlog_desc, NULL, NULL},
|
||||
{"Transaction", xact_redo, xact_undo, xact_desc, NULL, NULL},
|
||||
{"Storage", smgr_redo, smgr_undo, smgr_desc, NULL, NULL},
|
||||
{"CLOG", clog_redo, clog_undo, clog_desc, NULL, NULL},
|
||||
{"SLRU", slru_redo, slru_undo, slru_desc, NULL, NULL},
|
||||
{"Reserved 4", NULL, NULL, NULL, NULL, NULL},
|
||||
{"Reserved 5", NULL, NULL, NULL, NULL, NULL},
|
||||
{"Reserved 6", NULL, NULL, NULL, NULL, NULL},
|
||||
|
||||
@@ -6,7 +6,7 @@
|
||||
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $PostgreSQL: pgsql/src/backend/access/transam/slru.c,v 1.16 2004/05/31 03:47:54 tgl Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/access/transam/slru.c,v 1.17 2004/07/01 00:49:42 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -16,8 +16,9 @@
|
||||
#include <sys/stat.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include "access/clog.h"
|
||||
#include "access/slru.h"
|
||||
#include "access/clog.h" /* only for NUM_CLOG_BUFFERS */
|
||||
#include "access/subtrans.h"
|
||||
#include "postmaster/bgwriter.h"
|
||||
#include "storage/fd.h"
|
||||
#include "storage/lwlock.h"
|
||||
@@ -1025,3 +1026,55 @@ SlruScanDirectory(SlruCtl ctl, int cutoffPage, bool doDeletions)
|
||||
|
||||
return found;
|
||||
}
|
||||
|
||||
/*
|
||||
* SLRU resource manager's routines
|
||||
*/
|
||||
void
|
||||
slru_redo(XLogRecPtr lsn, XLogRecord *record)
|
||||
{
|
||||
uint8 info = record->xl_info & ~XLR_INFO_MASK;
|
||||
int pageno;
|
||||
|
||||
memcpy(&pageno, XLogRecGetData(record), sizeof(int));
|
||||
|
||||
switch (info)
|
||||
{
|
||||
case CLOG_ZEROPAGE:
|
||||
clog_zeropage_redo(pageno);
|
||||
break;
|
||||
case SUBTRANS_ZEROPAGE:
|
||||
subtrans_zeropage_redo(pageno);
|
||||
break;
|
||||
default:
|
||||
elog(PANIC, "slru_redo: unknown op code %u", info);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
slru_undo(XLogRecPtr lsn, XLogRecord *record)
|
||||
{
|
||||
}
|
||||
|
||||
void
|
||||
slru_desc(char *buf, uint8 xl_info, char *rec)
|
||||
{
|
||||
uint8 info = xl_info & ~XLR_INFO_MASK;
|
||||
|
||||
if (info == CLOG_ZEROPAGE)
|
||||
{
|
||||
int pageno;
|
||||
|
||||
memcpy(&pageno, rec, sizeof(int));
|
||||
sprintf(buf + strlen(buf), "clog zeropage: %d", pageno);
|
||||
}
|
||||
else if (info == SUBTRANS_ZEROPAGE)
|
||||
{
|
||||
int pageno;
|
||||
|
||||
memcpy(&pageno, rec, sizeof(int));
|
||||
sprintf(buf + strlen(buf), "subtrans zeropage: %d", pageno);
|
||||
}
|
||||
else
|
||||
strcat(buf, "UNKNOWN");
|
||||
}
|
||||
|
||||
388
src/backend/access/transam/subtrans.c
Normal file
388
src/backend/access/transam/subtrans.c
Normal file
@@ -0,0 +1,388 @@
|
||||
/*-------------------------------------------------------------------------
|
||||
*
|
||||
* subtrans.c
|
||||
* PostgreSQL subtrans-log manager
|
||||
*
|
||||
* The pg_subtrans manager is a pg_clog-like manager which stores the parent
|
||||
* transaction Id for each transaction. It is a fundamental part of the
|
||||
* nested transactions implementation. A main transaction has a parent
|
||||
* of InvalidTransactionId, and each subtransaction has its immediate parent.
|
||||
* The tree can easily be walked from child to parent, but not in the
|
||||
* opposite direction.
|
||||
*
|
||||
* This code is mostly derived from clog.c.
|
||||
*
|
||||
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $PostgreSQL: pgsql/src/backend/access/transam/subtrans.c,v 1.1 2004/07/01 00:49:42 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
#include "postgres.h"
|
||||
|
||||
#include <fcntl.h>
|
||||
#include <dirent.h>
|
||||
#include <sys/stat.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include "access/slru.h"
|
||||
#include "access/subtrans.h"
|
||||
#include "miscadmin.h"
|
||||
#include "storage/lwlock.h"
|
||||
|
||||
|
||||
/*
|
||||
* Defines for SubTrans page and segment sizes. A page is the same BLCKSZ
|
||||
* as is used everywhere else in Postgres.
|
||||
*
|
||||
* Note: because TransactionIds are 32 bits and wrap around at 0xFFFFFFFF,
|
||||
* SubTrans page numbering also wraps around at
|
||||
* 0xFFFFFFFF/SUBTRANS_XACTS_PER_PAGE, and segment numbering at
|
||||
* 0xFFFFFFFF/SUBTRANS_XACTS_PER_PAGE/SLRU_SEGMENTS_PER_PAGE. We need take no
|
||||
* explicit notice of that fact in this module, except when comparing segment
|
||||
* and page numbers in TruncateSubTrans (see SubTransPagePrecedes).
|
||||
*/
|
||||
|
||||
/* We need four bytes per xact */
|
||||
#define SUBTRANS_XACTS_PER_PAGE (BLCKSZ / sizeof(TransactionId))
|
||||
|
||||
#define TransactionIdToPage(xid) ((xid) / (TransactionId) SUBTRANS_XACTS_PER_PAGE)
|
||||
#define TransactionIdToEntry(xid) ((xid) % (TransactionId) SUBTRANS_XACTS_PER_PAGE)
|
||||
|
||||
|
||||
/*----------
|
||||
* Shared-memory data structures for SUBTRANS control
|
||||
*
|
||||
* XLOG interactions: this module generates an XLOG record whenever a new
|
||||
* SUBTRANS page is initialized to zeroes. Other writes of SUBTRANS come from
|
||||
* recording of transaction commit or abort in xact.c, which generates its
|
||||
* own XLOG records for these events and will re-perform the status update
|
||||
* on redo; so we need make no additional XLOG entry here. Also, the XLOG
|
||||
* is guaranteed flushed through the XLOG commit record before we are called
|
||||
* to log a commit, so the WAL rule "write xlog before data" is satisfied
|
||||
* automatically for commits, and we don't really care for aborts. Therefore,
|
||||
* we don't need to mark SUBTRANS pages with LSN information; we have enough
|
||||
* synchronization already.
|
||||
*----------
|
||||
*/
|
||||
|
||||
|
||||
static SlruCtlData SubTransCtlData;
|
||||
static SlruCtl SubTransCtl = &SubTransCtlData;
|
||||
|
||||
|
||||
static int ZeroSUBTRANSPage(int pageno, bool writeXlog);
|
||||
static bool SubTransPagePrecedes(int page1, int page2);
|
||||
static void WriteZeroPageXlogRec(int pageno);
|
||||
|
||||
|
||||
/*
|
||||
* Record the parent of a subtransaction in the subtrans log.
|
||||
*/
|
||||
void
|
||||
SubTransSetParent(TransactionId xid, TransactionId parent)
|
||||
{
|
||||
int pageno = TransactionIdToPage(xid);
|
||||
int entryno = TransactionIdToEntry(xid);
|
||||
TransactionId *ptr;
|
||||
|
||||
LWLockAcquire(SubTransCtl->ControlLock, LW_EXCLUSIVE);
|
||||
|
||||
ptr = (TransactionId *) SimpleLruReadPage(SubTransCtl, pageno, xid, true);
|
||||
ptr += entryno;
|
||||
|
||||
/* Current state should be 0 or target state */
|
||||
Assert(*ptr == InvalidTransactionId || *ptr == parent);
|
||||
|
||||
*ptr = parent;
|
||||
|
||||
/* ...->page_status[slotno] = SLRU_PAGE_DIRTY; already done */
|
||||
|
||||
LWLockRelease(SubTransCtl->ControlLock);
|
||||
}
|
||||
|
||||
/*
|
||||
* Interrogate the parent of a transaction in the subtrans log.
|
||||
*/
|
||||
TransactionId
|
||||
SubTransGetParent(TransactionId xid)
|
||||
{
|
||||
int pageno = TransactionIdToPage(xid);
|
||||
int entryno = TransactionIdToEntry(xid);
|
||||
TransactionId *ptr;
|
||||
TransactionId parent;
|
||||
|
||||
/* Bootstrap and frozen XIDs have no parent */
|
||||
if (!TransactionIdIsNormal(xid))
|
||||
return InvalidTransactionId;
|
||||
|
||||
LWLockAcquire(SubTransCtl->ControlLock, LW_EXCLUSIVE);
|
||||
|
||||
ptr = (TransactionId *) SimpleLruReadPage(SubTransCtl, pageno, xid, false);
|
||||
ptr += entryno;
|
||||
|
||||
parent = *ptr;
|
||||
|
||||
LWLockRelease(SubTransCtl->ControlLock);
|
||||
|
||||
return parent;
|
||||
}
|
||||
|
||||
/*
|
||||
* SubTransGetTopmostTransaction
|
||||
*
|
||||
* Returns the topmost transaction of the given transaction id.
|
||||
*/
|
||||
TransactionId
|
||||
SubTransGetTopmostTransaction(TransactionId xid)
|
||||
{
|
||||
TransactionId parentXid = xid,
|
||||
previousXid = xid;
|
||||
|
||||
while (TransactionIdIsValid(parentXid))
|
||||
{
|
||||
previousXid = parentXid;
|
||||
parentXid = SubTransGetParent(parentXid);
|
||||
}
|
||||
|
||||
Assert(TransactionIdIsValid(previousXid));
|
||||
|
||||
return previousXid;
|
||||
}
|
||||
|
||||
/*
|
||||
* SubTransXidsHaveCommonAncestor
|
||||
*
|
||||
* Returns true iff the Xids have a common ancestor
|
||||
*/
|
||||
bool
|
||||
SubTransXidsHaveCommonAncestor(TransactionId xid1, TransactionId xid2)
|
||||
{
|
||||
if (TransactionIdEquals(xid1, xid2))
|
||||
return true;
|
||||
|
||||
while (TransactionIdIsValid(xid1) && TransactionIdIsValid(xid2))
|
||||
{
|
||||
if (TransactionIdPrecedes(xid2, xid1))
|
||||
xid1 = SubTransGetParent(xid1);
|
||||
else
|
||||
xid2 = SubTransGetParent(xid2);
|
||||
|
||||
if (TransactionIdEquals(xid1, xid2))
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
* Initialization of shared memory for Subtrans
|
||||
*/
|
||||
|
||||
int
|
||||
SUBTRANSShmemSize(void)
|
||||
{
|
||||
return SimpleLruShmemSize();
|
||||
}
|
||||
|
||||
void
|
||||
SUBTRANSShmemInit(void)
|
||||
{
|
||||
SimpleLruInit(SubTransCtl, "SUBTRANS Ctl", "pg_subtrans");
|
||||
SubTransCtl->PagePrecedes = SubTransPagePrecedes;
|
||||
}
|
||||
|
||||
/*
|
||||
* This func must be called ONCE on system install. It creates
|
||||
* the initial SubTrans segment. (The SubTrans directory is assumed to
|
||||
* have been created by initdb, and SubTransShmemInit must have been called
|
||||
* already.)
|
||||
*/
|
||||
void
|
||||
BootStrapSUBTRANS(void)
|
||||
{
|
||||
int slotno;
|
||||
|
||||
LWLockAcquire(SubTransCtl->ControlLock, LW_EXCLUSIVE);
|
||||
|
||||
/* Create and zero the first page of the commit log */
|
||||
slotno = ZeroSUBTRANSPage(0, false);
|
||||
|
||||
/* Make sure it's written out */
|
||||
SimpleLruWritePage(SubTransCtl, slotno, NULL);
|
||||
/* Assert(SubTransCtl->page_status[slotno] == SLRU_PAGE_CLEAN); */
|
||||
|
||||
LWLockRelease(SubTransCtl->ControlLock);
|
||||
}
|
||||
|
||||
/*
|
||||
* Initialize (or reinitialize) a page of SubTrans to zeroes.
|
||||
* If writeXlog is TRUE, also emit an XLOG record saying we did this.
|
||||
*
|
||||
* The page is not actually written, just set up in shared memory.
|
||||
* The slot number of the new page is returned.
|
||||
*
|
||||
* Control lock must be held at entry, and will be held at exit.
|
||||
*/
|
||||
static int
|
||||
ZeroSUBTRANSPage(int pageno, bool writeXlog)
|
||||
{
|
||||
int slotno = SimpleLruZeroPage(SubTransCtl, pageno);
|
||||
|
||||
if (writeXlog)
|
||||
WriteZeroPageXlogRec(pageno);
|
||||
|
||||
return slotno;
|
||||
}
|
||||
|
||||
/*
|
||||
* This must be called ONCE during postmaster or standalone-backend startup,
|
||||
* after StartupXLOG has initialized ShmemVariableCache->nextXid.
|
||||
*/
|
||||
void
|
||||
StartupSUBTRANS(void)
|
||||
{
|
||||
/*
|
||||
* Initialize our idea of the latest page number.
|
||||
*/
|
||||
SimpleLruSetLatestPage(SubTransCtl,
|
||||
TransactionIdToPage(ShmemVariableCache->nextXid));
|
||||
}
|
||||
|
||||
/*
|
||||
* This must be called ONCE during postmaster or standalone-backend shutdown
|
||||
*/
|
||||
void
|
||||
ShutdownSUBTRANS(void)
|
||||
{
|
||||
SimpleLruFlush(SubTransCtl, false);
|
||||
}
|
||||
|
||||
/*
|
||||
* Perform a checkpoint --- either during shutdown, or on-the-fly
|
||||
*/
|
||||
void
|
||||
CheckPointSUBTRANS(void)
|
||||
{
|
||||
SimpleLruFlush(SubTransCtl, true);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Make sure that SubTrans has room for a newly-allocated XID.
|
||||
*
|
||||
* NB: this is called while holding XidGenLock. We want it to be very fast
|
||||
* most of the time; even when it's not so fast, no actual I/O need happen
|
||||
* unless we're forced to write out a dirty subtrans or xlog page to make room
|
||||
* in shared memory.
|
||||
*/
|
||||
void
|
||||
ExtendSUBTRANS(TransactionId newestXact)
|
||||
{
|
||||
int pageno;
|
||||
|
||||
/*
|
||||
* No work except at first XID of a page. But beware: just after
|
||||
* wraparound, the first XID of page zero is FirstNormalTransactionId.
|
||||
*/
|
||||
if (TransactionIdToEntry(newestXact) != 0 &&
|
||||
!TransactionIdEquals(newestXact, FirstNormalTransactionId))
|
||||
return;
|
||||
|
||||
pageno = TransactionIdToPage(newestXact);
|
||||
|
||||
LWLockAcquire(SubTransCtl->ControlLock, LW_EXCLUSIVE);
|
||||
|
||||
/* Zero the page and make an XLOG entry about it */
|
||||
ZeroSUBTRANSPage(pageno, true);
|
||||
|
||||
LWLockRelease(SubTransCtl->ControlLock);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Remove all SubTrans segments before the one holding the passed transaction ID
|
||||
*
|
||||
* When this is called, we know that the database logically contains no
|
||||
* reference to transaction IDs older than oldestXact. However, we must
|
||||
* not truncate the SubTrans until we have performed a checkpoint, to ensure
|
||||
* that no such references remain on disk either; else a crash just after
|
||||
* the truncation might leave us with a problem. Since SubTrans segments hold
|
||||
* a large number of transactions, the opportunity to actually remove a
|
||||
* segment is fairly rare, and so it seems best not to do the checkpoint
|
||||
* unless we have confirmed that there is a removable segment. Therefore
|
||||
* we issue the checkpoint command here, not in higher-level code as might
|
||||
* seem cleaner.
|
||||
*/
|
||||
void
|
||||
TruncateSUBTRANS(TransactionId oldestXact)
|
||||
{
|
||||
int cutoffPage;
|
||||
|
||||
/*
|
||||
* The cutoff point is the start of the segment containing oldestXact.
|
||||
* We pass the *page* containing oldestXact to SimpleLruTruncate.
|
||||
*/
|
||||
cutoffPage = TransactionIdToPage(oldestXact);
|
||||
SimpleLruTruncate(SubTransCtl, cutoffPage);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Decide which of two SubTrans page numbers is "older" for truncation purposes.
|
||||
*
|
||||
* We need to use comparison of TransactionIds here in order to do the right
|
||||
* thing with wraparound XID arithmetic. However, if we are asked about
|
||||
* page number zero, we don't want to hand InvalidTransactionId to
|
||||
* TransactionIdPrecedes: it'll get weird about permanent xact IDs. So,
|
||||
* offset both xids by FirstNormalTransactionId to avoid that.
|
||||
*/
|
||||
static bool
|
||||
SubTransPagePrecedes(int page1, int page2)
|
||||
{
|
||||
TransactionId xid1;
|
||||
TransactionId xid2;
|
||||
|
||||
xid1 = ((TransactionId) page1) * SUBTRANS_XACTS_PER_PAGE;
|
||||
xid1 += FirstNormalTransactionId;
|
||||
xid2 = ((TransactionId) page2) * SUBTRANS_XACTS_PER_PAGE;
|
||||
xid2 += FirstNormalTransactionId;
|
||||
|
||||
return TransactionIdPrecedes(xid1, xid2);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Write a ZEROPAGE xlog record
|
||||
*
|
||||
* Note: xlog record is marked as outside transaction control, since we
|
||||
* want it to be redone whether the invoking transaction commits or not.
|
||||
* (Besides which, this is normally done just before entering a transaction.)
|
||||
*/
|
||||
static void
|
||||
WriteZeroPageXlogRec(int pageno)
|
||||
{
|
||||
XLogRecData rdata;
|
||||
|
||||
rdata.buffer = InvalidBuffer;
|
||||
rdata.data = (char *) (&pageno);
|
||||
rdata.len = sizeof(int);
|
||||
rdata.next = NULL;
|
||||
(void) XLogInsert(RM_SLRU_ID, SUBTRANS_ZEROPAGE | XLOG_NO_TRAN, &rdata);
|
||||
}
|
||||
|
||||
/* Redo a ZEROPAGE action during WAL replay */
|
||||
void
|
||||
subtrans_zeropage_redo(int pageno)
|
||||
{
|
||||
int slotno;
|
||||
|
||||
LWLockAcquire(SubTransCtl->ControlLock, LW_EXCLUSIVE);
|
||||
|
||||
slotno = ZeroSUBTRANSPage(pageno, false);
|
||||
SimpleLruWritePage(SubTransCtl, slotno, NULL);
|
||||
/* Assert(SubTransCtl->page_status[slotno] == SLRU_PAGE_CLEAN); */
|
||||
|
||||
LWLockRelease(SubTransCtl->ControlLock);
|
||||
}
|
||||
@@ -8,7 +8,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/access/transam/transam.c,v 1.56 2003/11/29 19:51:40 pgsql Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/access/transam/transam.c,v 1.57 2004/07/01 00:49:42 tgl Exp $
|
||||
*
|
||||
* NOTES
|
||||
* This file contains the high level access-method interface to the
|
||||
@@ -20,6 +20,7 @@
|
||||
#include "postgres.h"
|
||||
|
||||
#include "access/clog.h"
|
||||
#include "access/subtrans.h"
|
||||
#include "access/transam.h"
|
||||
|
||||
|
||||
@@ -35,44 +36,40 @@
|
||||
bool AMI_OVERRIDE = false;
|
||||
|
||||
|
||||
static bool TransactionLogTest(TransactionId transactionId, XidStatus status);
|
||||
static XidStatus TransactionLogFetch(TransactionId transactionId);
|
||||
static void TransactionLogUpdate(TransactionId transactionId,
|
||||
XidStatus status);
|
||||
|
||||
/* ----------------
|
||||
* Single-item cache for results of TransactionLogTest.
|
||||
* Single-item cache for results of TransactionLogFetch.
|
||||
* ----------------
|
||||
*/
|
||||
static TransactionId cachedTestXid = InvalidTransactionId;
|
||||
static XidStatus cachedTestXidStatus;
|
||||
static TransactionId cachedFetchXid = InvalidTransactionId;
|
||||
static XidStatus cachedFetchXidStatus;
|
||||
|
||||
|
||||
/* ----------------------------------------------------------------
|
||||
* postgres log access method interface
|
||||
*
|
||||
* TransactionLogTest
|
||||
* TransactionLogFetch
|
||||
* TransactionLogUpdate
|
||||
* ----------------------------------------------------------------
|
||||
*/
|
||||
|
||||
/* --------------------------------
|
||||
* TransactionLogTest
|
||||
* --------------------------------
|
||||
/*
|
||||
* TransactionLogFetch --- fetch commit status of specified transaction id
|
||||
*/
|
||||
|
||||
static bool /* true/false: does transaction id have
|
||||
* specified status? */
|
||||
TransactionLogTest(TransactionId transactionId, /* transaction id to test */
|
||||
XidStatus status) /* transaction status */
|
||||
static XidStatus
|
||||
TransactionLogFetch(TransactionId transactionId)
|
||||
{
|
||||
XidStatus xidstatus; /* recorded status of xid */
|
||||
XidStatus xidstatus;
|
||||
|
||||
/*
|
||||
* Before going to the commit log manager, check our single item cache
|
||||
* to see if we didn't just check the transaction status a moment ago.
|
||||
*/
|
||||
if (TransactionIdEquals(transactionId, cachedTestXid))
|
||||
return (status == cachedTestXidStatus);
|
||||
if (TransactionIdEquals(transactionId, cachedFetchXid))
|
||||
return cachedFetchXidStatus;
|
||||
|
||||
/*
|
||||
* Also, check to see if the transaction ID is a permanent one.
|
||||
@@ -80,10 +77,10 @@ TransactionLogTest(TransactionId transactionId, /* transaction id to test */
|
||||
if (!TransactionIdIsNormal(transactionId))
|
||||
{
|
||||
if (TransactionIdEquals(transactionId, BootstrapTransactionId))
|
||||
return (status == TRANSACTION_STATUS_COMMITTED);
|
||||
return TRANSACTION_STATUS_COMMITTED;
|
||||
if (TransactionIdEquals(transactionId, FrozenTransactionId))
|
||||
return (status == TRANSACTION_STATUS_COMMITTED);
|
||||
return (status == TRANSACTION_STATUS_ABORTED);
|
||||
return TRANSACTION_STATUS_COMMITTED;
|
||||
return TRANSACTION_STATUS_ABORTED;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -92,15 +89,17 @@ TransactionLogTest(TransactionId transactionId, /* transaction id to test */
|
||||
xidstatus = TransactionIdGetStatus(transactionId);
|
||||
|
||||
/*
|
||||
* DO NOT cache status for unfinished transactions!
|
||||
* DO NOT cache status for unfinished or sub-committed transactions!
|
||||
* We only cache status that is guaranteed not to change.
|
||||
*/
|
||||
if (xidstatus != TRANSACTION_STATUS_IN_PROGRESS)
|
||||
if (xidstatus != TRANSACTION_STATUS_IN_PROGRESS &&
|
||||
xidstatus != TRANSACTION_STATUS_SUB_COMMITTED)
|
||||
{
|
||||
TransactionIdStore(transactionId, &cachedTestXid);
|
||||
cachedTestXidStatus = xidstatus;
|
||||
TransactionIdStore(transactionId, &cachedFetchXid);
|
||||
cachedFetchXidStatus = xidstatus;
|
||||
}
|
||||
|
||||
return (status == xidstatus);
|
||||
return xidstatus;
|
||||
}
|
||||
|
||||
/* --------------------------------
|
||||
@@ -115,12 +114,23 @@ TransactionLogUpdate(TransactionId transactionId, /* trans id to update */
|
||||
* update the commit log
|
||||
*/
|
||||
TransactionIdSetStatus(transactionId, status);
|
||||
}
|
||||
|
||||
/*
|
||||
* update (invalidate) our single item TransactionLogTest cache.
|
||||
*/
|
||||
TransactionIdStore(transactionId, &cachedTestXid);
|
||||
cachedTestXidStatus = status;
|
||||
/*
|
||||
* TransactionLogMultiUpdate
|
||||
*
|
||||
* Update multiple transaction identifiers to a given status.
|
||||
* Don't depend on this being atomic; it's not.
|
||||
*/
|
||||
static void
|
||||
TransactionLogMultiUpdate(int nxids, TransactionId *xids, XidStatus status)
|
||||
{
|
||||
int i;
|
||||
|
||||
Assert(nxids != 0);
|
||||
|
||||
for (i = 0; i < nxids; i++)
|
||||
TransactionIdSetStatus(xids[i], status);
|
||||
}
|
||||
|
||||
/* --------------------------------
|
||||
@@ -171,13 +181,38 @@ AmiTransactionOverride(bool flag)
|
||||
bool /* true if given transaction committed */
|
||||
TransactionIdDidCommit(TransactionId transactionId)
|
||||
{
|
||||
XidStatus xidstatus;
|
||||
|
||||
if (AMI_OVERRIDE)
|
||||
{
|
||||
Assert(transactionId == BootstrapTransactionId);
|
||||
return true;
|
||||
}
|
||||
|
||||
return TransactionLogTest(transactionId, TRANSACTION_STATUS_COMMITTED);
|
||||
xidstatus = TransactionLogFetch(transactionId);
|
||||
|
||||
/*
|
||||
* If it's marked committed, it's committed.
|
||||
*/
|
||||
if (xidstatus == TRANSACTION_STATUS_COMMITTED)
|
||||
return true;
|
||||
|
||||
/*
|
||||
* If it's marked subcommitted, we have to check the parent recursively.
|
||||
*/
|
||||
if (xidstatus == TRANSACTION_STATUS_SUB_COMMITTED)
|
||||
{
|
||||
TransactionId parentXid;
|
||||
|
||||
parentXid = SubTransGetParent(transactionId);
|
||||
Assert(TransactionIdIsValid(parentXid));
|
||||
return TransactionIdDidCommit(parentXid);
|
||||
}
|
||||
|
||||
/*
|
||||
* It's not committed.
|
||||
*/
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -190,35 +225,49 @@ TransactionIdDidCommit(TransactionId transactionId)
|
||||
bool /* true if given transaction aborted */
|
||||
TransactionIdDidAbort(TransactionId transactionId)
|
||||
{
|
||||
XidStatus xidstatus;
|
||||
|
||||
if (AMI_OVERRIDE)
|
||||
{
|
||||
Assert(transactionId == BootstrapTransactionId);
|
||||
return false;
|
||||
}
|
||||
|
||||
return TransactionLogTest(transactionId, TRANSACTION_STATUS_ABORTED);
|
||||
}
|
||||
xidstatus = TransactionLogFetch(transactionId);
|
||||
|
||||
/*
|
||||
* Now this func in shmem.c and gives quality answer by scanning
|
||||
* PGPROC structures of all running backend. - vadim 11/26/96
|
||||
*
|
||||
* Old comments:
|
||||
* true if given transaction has neither committed nor aborted
|
||||
*/
|
||||
#ifdef NOT_USED
|
||||
bool
|
||||
TransactionIdIsInProgress(TransactionId transactionId)
|
||||
{
|
||||
if (AMI_OVERRIDE)
|
||||
/*
|
||||
* If it's marked aborted, it's aborted.
|
||||
*/
|
||||
if (xidstatus == TRANSACTION_STATUS_ABORTED)
|
||||
return true;
|
||||
|
||||
/*
|
||||
* If it's marked subcommitted, we have to check the parent recursively.
|
||||
*
|
||||
* If we detect that the parent has aborted, update pg_clog to show the
|
||||
* subtransaction as aborted. This is only needed when the parent
|
||||
* crashed before either committing or aborting. We want to clean up
|
||||
* pg_clog so future visitors don't need to make this check again.
|
||||
*/
|
||||
if (xidstatus == TRANSACTION_STATUS_SUB_COMMITTED)
|
||||
{
|
||||
Assert(transactionId == BootstrapTransactionId);
|
||||
return false;
|
||||
TransactionId parentXid;
|
||||
bool parentAborted;
|
||||
|
||||
parentXid = SubTransGetParent(transactionId);
|
||||
parentAborted = TransactionIdDidAbort(parentXid);
|
||||
|
||||
if (parentAborted)
|
||||
TransactionIdAbort(transactionId);
|
||||
|
||||
return parentAborted;
|
||||
}
|
||||
|
||||
return TransactionLogTest(transactionId, TRANSACTION_STATUS_IN_PROGRESS);
|
||||
/*
|
||||
* It's not aborted.
|
||||
*/
|
||||
return false;
|
||||
}
|
||||
#endif /* NOT_USED */
|
||||
|
||||
/* --------------------------------
|
||||
* TransactionId Commit
|
||||
@@ -252,6 +301,46 @@ TransactionIdAbort(TransactionId transactionId)
|
||||
TransactionLogUpdate(transactionId, TRANSACTION_STATUS_ABORTED);
|
||||
}
|
||||
|
||||
/*
|
||||
* TransactionIdSubCommit
|
||||
* Marks the subtransaction associated with the identifier as
|
||||
* sub-committed.
|
||||
*/
|
||||
void
|
||||
TransactionIdSubCommit(TransactionId transactionId)
|
||||
{
|
||||
TransactionLogUpdate(transactionId, TRANSACTION_STATUS_SUB_COMMITTED);
|
||||
}
|
||||
|
||||
/*
|
||||
* TransactionIdCommitTree
|
||||
* Marks all the given transaction ids as committed.
|
||||
*
|
||||
* The caller has to be sure that this is used only to mark subcommitted
|
||||
* subtransactions as committed, and only *after* marking the toplevel
|
||||
* parent as committed. Otherwise there is a race condition against
|
||||
* TransactionIdDidCommit.
|
||||
*/
|
||||
void
|
||||
TransactionIdCommitTree(int nxids, TransactionId *xids)
|
||||
{
|
||||
if (nxids > 0)
|
||||
TransactionLogMultiUpdate(nxids, xids, TRANSACTION_STATUS_COMMITTED);
|
||||
}
|
||||
|
||||
/*
|
||||
* TransactionIdAbortTree
|
||||
* Marks all the given transaction ids as aborted.
|
||||
*
|
||||
* We don't need to worry about the non-atomic behavior, since any onlookers
|
||||
* will consider all the xacts as not-yet-committed anyway.
|
||||
*/
|
||||
void
|
||||
TransactionIdAbortTree(int nxids, TransactionId *xids)
|
||||
{
|
||||
if (nxids > 0)
|
||||
TransactionLogMultiUpdate(nxids, xids, TRANSACTION_STATUS_ABORTED);
|
||||
}
|
||||
|
||||
/*
|
||||
* TransactionIdPrecedes --- is id1 logically < id2?
|
||||
|
||||
@@ -6,7 +6,7 @@
|
||||
* Copyright (c) 2000-2003, PostgreSQL Global Development Group
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/access/transam/varsup.c,v 1.55 2004/01/26 19:15:59 tgl Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/access/transam/varsup.c,v 1.56 2004/07/01 00:49:42 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -14,6 +14,7 @@
|
||||
#include "postgres.h"
|
||||
|
||||
#include "access/clog.h"
|
||||
#include "access/subtrans.h"
|
||||
#include "access/transam.h"
|
||||
#include "storage/ipc.h"
|
||||
#include "storage/proc.h"
|
||||
@@ -30,7 +31,7 @@ VariableCache ShmemVariableCache = NULL;
|
||||
* Allocate the next XID for my new transaction.
|
||||
*/
|
||||
TransactionId
|
||||
GetNewTransactionId(void)
|
||||
GetNewTransactionId(bool isSubXact)
|
||||
{
|
||||
TransactionId xid;
|
||||
|
||||
@@ -52,8 +53,11 @@ GetNewTransactionId(void)
|
||||
* commit a later XID before we zero the page. Fortunately, a page of
|
||||
* the commit log holds 32K or more transactions, so we don't have to
|
||||
* do this very often.
|
||||
*
|
||||
* Extend pg_subtrans too.
|
||||
*/
|
||||
ExtendCLOG(xid);
|
||||
ExtendSUBTRANS(xid);
|
||||
|
||||
/*
|
||||
* Now advance the nextXid counter. This must not happen until after
|
||||
@@ -82,8 +86,11 @@ GetNewTransactionId(void)
|
||||
* its own spinlock used only for fetching/storing that PGPROC's xid.
|
||||
* (SInvalLock would then mean primarily that PGPROCs couldn't be added/
|
||||
* removed while holding the lock.)
|
||||
*
|
||||
* We don't want a subtransaction to update the stored Xid; we'll check
|
||||
* if a transaction Xid is a running subxact by checking pg_subtrans.
|
||||
*/
|
||||
if (MyProc != NULL)
|
||||
if (MyProc != NULL && !isSubXact)
|
||||
MyProc->xid = xid;
|
||||
|
||||
LWLockRelease(XidGenLock);
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -7,7 +7,7 @@
|
||||
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $PostgreSQL: pgsql/src/backend/access/transam/xlog.c,v 1.146 2004/06/03 02:08:00 tgl Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/access/transam/xlog.c,v 1.147 2004/07/01 00:49:50 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -22,6 +22,7 @@
|
||||
#include <sys/time.h>
|
||||
|
||||
#include "access/clog.h"
|
||||
#include "access/subtrans.h"
|
||||
#include "access/transam.h"
|
||||
#include "access/xact.h"
|
||||
#include "access/xlog.h"
|
||||
@@ -2755,6 +2756,7 @@ BootStrapXLOG(void)
|
||||
|
||||
/* Bootstrap the commit log, too */
|
||||
BootStrapCLOG();
|
||||
BootStrapSUBTRANS();
|
||||
}
|
||||
|
||||
static char *
|
||||
@@ -3154,6 +3156,7 @@ StartupXLOG(void)
|
||||
|
||||
/* Start up the commit log, too */
|
||||
StartupCLOG();
|
||||
StartupSUBTRANS();
|
||||
|
||||
ereport(LOG,
|
||||
(errmsg("database system is ready")));
|
||||
@@ -3292,6 +3295,7 @@ ShutdownXLOG(int code, Datum arg)
|
||||
CritSectionCount++;
|
||||
CreateCheckPoint(true, true);
|
||||
ShutdownCLOG();
|
||||
ShutdownSUBTRANS();
|
||||
CritSectionCount--;
|
||||
|
||||
ereport(LOG,
|
||||
@@ -3467,6 +3471,7 @@ CreateCheckPoint(bool shutdown, bool force)
|
||||
END_CRIT_SECTION();
|
||||
|
||||
CheckPointCLOG();
|
||||
CheckPointSUBTRANS();
|
||||
FlushBufferPool();
|
||||
|
||||
START_CRIT_SECTION();
|
||||
|
||||
Reference in New Issue
Block a user