Movatterモバイル変換

[0]ホーム
URL:

Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly

 Sign up
Appearance settings

Commit1b67fe1

Browse files
committed
heap' logging
1 parent80c6469 commit1b67fe1

File tree

7 files changed

+130
-130
lines changed

7 files changed

+130
-130
lines changed

‎src/backend/access/heap/heapam.c‎

Lines changed: 73 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@
88
*
99
*
1010
* IDENTIFICATION
11-
* $Header: /cvsroot/pgsql/src/backend/access/heap/heapam.c,v 1.74 2000/07/02 22:00:27 momjian Exp $
11+
* $Header: /cvsroot/pgsql/src/backend/access/heap/heapam.c,v 1.75 2000/07/03 02:54:15 vadim Exp $
1212
*
1313
*
1414
* INTERFACE ROUTINES
@@ -1271,10 +1271,9 @@ heap_get_latest_tid(Relation relation,
12711271
Oid
12721272
heap_insert(Relationrelation,HeapTupletup)
12731273
{
1274-
/* ----------------
1275-
*increment access statistics
1276-
* ----------------
1277-
*/
1274+
Bufferbuffer;
1275+
1276+
/* increment access statistics */
12781277
tup->tableOid=relation->rd_id;
12791278
IncrHeapAccessStat(local_insert);
12801279
IncrHeapAccessStat(global_insert);
@@ -1300,15 +1299,20 @@ heap_insert(Relation relation, HeapTuple tup)
13001299
tup->t_data->t_infomask &= ~(HEAP_XACT_MASK);
13011300
tup->t_data->t_infomask |=HEAP_XMAX_INVALID;
13021301

1303-
RelationPutHeapTupleAtEnd(relation,tup);
1302+
/* Find buffer for this tuple */
1303+
buffer=RelationGetBufferForTuple(relation,tup->t_len,InvalidBuffer);
1304+
1305+
/* NO ELOG(ERROR) from here till changes are logged */
1306+
RelationPutHeapTuple(relation,buffer,tup);
13041307

13051308
#ifdefXLOG
13061309
/* XLOG stuff */
13071310
{
13081311
xl_heap_insertxlrec;
13091312
xlrec.itid.dbId=relation->rd_lockInfo.lockRelId.dbId;
13101313
xlrec.itid.relId=relation->rd_lockInfo.lockRelId.relId;
1311-
XXXxlrec.itid.tid=tp.t_self;
1314+
xlrec.itid.cid=GetCurrentCommandId();
1315+
xlrec.itid.tid=tup->t_self;
13121316
xlrec.t_natts=tup->t_data->t_natts;
13131317
xlrec.t_oid=tup->t_data->t_oid;
13141318
xlrec.t_hoff=tup->t_data->t_hoff;
@@ -1319,10 +1323,14 @@ XXXxlrec.itid.tid = tp.t_self;
13191323
(char*)tup->t_data+ offsetof(HeapTupleHeaderData,tbits),
13201324
tup->t_len- offsetof(HeapTupleHeaderData,tbits));
13211325

1322-
dp->pd_lsn=recptr;
1326+
((PageHeader)BufferGetPage(buffer))->pd_lsn=recptr;
1327+
((PageHeader)BufferGetPage(buffer))->pd_sui=ThisStartUpID;
13231328
}
13241329
#endif
13251330

1331+
LockBuffer(buffer,BUFFER_LOCK_UNLOCK);
1332+
WriteBuffer(buffer);
1333+
13261334
if (IsSystemRelationName(RelationGetRelationName(relation)))
13271335
RelationMark4RollbackHeapTuple(relation,tup);
13281336

@@ -1417,11 +1425,13 @@ heap_delete(Relation relation, ItemPointer tid, ItemPointer ctid)
14171425
xl_heap_deletexlrec;
14181426
xlrec.dtid.dbId=relation->rd_lockInfo.lockRelId.dbId;
14191427
xlrec.dtid.relId=relation->rd_lockInfo.lockRelId.relId;
1428+
xlrec.dtid.cid=GetCurrentCommandId();
14201429
xlrec.dtid.tid=tp.t_self;
14211430
XLogRecPtrrecptr=XLogInsert(RM_HEAP_ID,XLOG_HEAP_DELETE,
14221431
(char*)xlrec,sizeof(xlrec),NULL,0);
14231432

14241433
dp->pd_lsn=recptr;
1434+
dp->pd_sui=ThisStartUpID;
14251435
}
14261436
#endif
14271437

@@ -1451,7 +1461,7 @@ heap_update(Relation relation, ItemPointer otid, HeapTuple newtup,
14511461
ItemIdlp;
14521462
HeapTupleDataoldtup;
14531463
PageHeaderdp;
1454-
Bufferbuffer;
1464+
Bufferbuffer,newbuf;
14551465
intresult;
14561466

14571467
newtup->tableOid=relation->rd_id;
@@ -1531,43 +1541,65 @@ heap_update(Relation relation, ItemPointer otid, HeapTuple newtup,
15311541
newtup->t_data->t_infomask &= ~(HEAP_XACT_MASK);
15321542
newtup->t_data->t_infomask |= (HEAP_XMAX_INVALID |HEAP_UPDATED);
15331543

1534-
/* logically delete old item */
1544+
/* Find buffer for new tuple */
1545+
1546+
if ((unsigned)MAXALIGN(newtup->t_len) <=PageGetFreeSpace((Page)dp))
1547+
newbuf=buffer;
1548+
else
1549+
newbuf=RelationGetBufferForTuple(relation,newtup->t_len,buffer);
1550+
1551+
/* NO ELOG(ERROR) from here till changes are logged */
1552+
1553+
/* insert new tuple */
1554+
RelationPutHeapTuple(relation,newbuf,newtup);
1555+
1556+
/* logically delete old tuple */
15351557
TransactionIdStore(GetCurrentTransactionId(),&(oldtup.t_data->t_xmax));
15361558
oldtup.t_data->t_cmax=GetCurrentCommandId();
15371559
oldtup.t_data->t_infomask &= ~(HEAP_XMAX_COMMITTED |
15381560
HEAP_XMAX_INVALID |HEAP_MARKED_FOR_UPDATE);
15391561

1540-
/* insert new item */
1541-
if ((unsigned)MAXALIGN(newtup->t_len) <=PageGetFreeSpace((Page)dp))
1542-
RelationPutHeapTuple(relation,buffer,newtup);
1543-
else
1562+
/* record address of new tuple in t_ctid of old one */
1563+
oldtup.t_data->t_ctid=newtup->t_self;
1564+
1565+
#ifdefXLOG
1566+
/* XLOG stuff */
15441567
{
1568+
xl_heap_updatexlrec;
1569+
xlrec.dtid.dbId=relation->rd_lockInfo.lockRelId.dbId;
1570+
xlrec.dtid.relId=relation->rd_lockInfo.lockRelId.relId;
1571+
xlrec.dtid.cid=GetCurrentCommandId();
1572+
xlrec.itid.tid=newtup->t_self;
1573+
xlrec.t_natts=newtup->t_data->t_natts;
1574+
xlrec.t_hoff=newtup->t_data->t_hoff;
1575+
xlrec.mask=newtup->t_data->t_infomask;
1576+
1577+
XLogRecPtrrecptr=XLogInsert(RM_HEAP_ID,XLOG_HEAP_UPDATE,
1578+
(char*)xlrec,sizeof(xlrec),
1579+
(char*)newtup->t_data+ offsetof(HeapTupleHeaderData,tbits),
1580+
newtup->t_len- offsetof(HeapTupleHeaderData,tbits));
15451581

1546-
/*
1547-
* New item won't fit on same page as old item, have to look for a
1548-
* new place to put it. Note that we have to unlock current buffer
1549-
* context - not good but RelationPutHeapTupleAtEnd uses extend
1550-
* lock.
1551-
*/
1552-
LockBuffer(buffer,BUFFER_LOCK_UNLOCK);
1553-
RelationPutHeapTupleAtEnd(relation,newtup);
1554-
LockBuffer(buffer,BUFFER_LOCK_EXCLUSIVE);
1582+
if (newbuf!=buffer)
1583+
{
1584+
((PageHeader)BufferGetPage(newbuf))->pd_lsn=recptr;
1585+
((PageHeader)BufferGetPage(newbuf))->pd_sui=ThisStartUpID;
1586+
}
1587+
((PageHeader)BufferGetPage(buffer))->pd_lsn=recptr;
1588+
((PageHeader)BufferGetPage(buffer))->pd_sui=ThisStartUpID;
15551589
}
1556-
/* mark for rollback caches */
1557-
RelationMark4RollbackHeapTuple(relation,newtup);
1558-
1559-
/*
1560-
* New item in place, now record address of new tuple in t_ctid of old
1561-
* one.
1562-
*/
1563-
oldtup.t_data->t_ctid=newtup->t_self;
1590+
#endif
15641591

1592+
if (newbuf!=buffer)
1593+
{
1594+
LockBuffer(newbuf,BUFFER_LOCK_UNLOCK);
1595+
WriteBuffer(newbuf);
1596+
}
15651597
LockBuffer(buffer,BUFFER_LOCK_UNLOCK);
1598+
WriteBuffer(buffer);
15661599

15671600
/* invalidate caches */
15681601
RelationInvalidateHeapTuple(relation,&oldtup);
1569-
1570-
WriteBuffer(buffer);
1602+
RelationMark4RollbackHeapTuple(relation,newtup);
15711603

15721604
returnHeapTupleMayBeUpdated;
15731605
}
@@ -1648,6 +1680,14 @@ heap_mark4update(Relation relation, HeapTuple tuple, Buffer *buffer)
16481680
returnresult;
16491681
}
16501682

1683+
#ifdefXLOG
1684+
/*
1685+
* XLOG stuff: no logging is required as long as we have no
1686+
* savepoints. For savepoints private log could be used...
1687+
*/
1688+
((PageHeader)BufferGetPage(*buffer))->pd_sui=ThisStartUpID;
1689+
#endif
1690+
16511691
/* store transaction information of xact marking the tuple */
16521692
TransactionIdStore(GetCurrentTransactionId(),&(tuple->t_data->t_xmax));
16531693
tuple->t_data->t_cmax=GetCurrentCommandId();

‎src/backend/access/heap/hio.c‎

Lines changed: 32 additions & 71 deletions
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@
88
*
99
*
1010
* IDENTIFICATION
11-
* $Id: hio.c,v 1.31 2000/04/12 17:14:45 momjian Exp $
11+
* $Id: hio.c,v 1.32 2000/07/03 02:54:15 vadim Exp $
1212
*
1313
*-------------------------------------------------------------------------
1414
*/
@@ -19,17 +19,11 @@
1919
#include"access/hio.h"
2020

2121
/*
22-
* amputunique- place tuple at tid
23-
* Currently on errors, calls elog. Perhaps should return -1?
24-
* Possible errors include the addition of a tuple to the page
25-
* between the time the linep is chosen and the page is L_UP'd.
22+
* RelationPutHeapTuple- place tuple at specified page
2623
*
27-
* This should be coordinated with the B-tree code.
28-
* Probably needs to have an amdelunique to allow for
29-
* internal index records to be deleted and reordered as needed.
30-
* For the heap AM, this should never be needed.
24+
* !!! ELOG(ERROR) IS DISALLOWED HERE !!!
3125
*
32-
* Note - we assume that caller hold BUFFER_LOCK_EXCLUSIVE on the buffer.
26+
* Note - we assume that caller hold BUFFER_LOCK_EXCLUSIVE on the buffer.
3327
*
3428
*/
3529
void
@@ -57,62 +51,41 @@ RelationPutHeapTuple(Relation relation,
5751
offnum=PageAddItem((Page)pageHeader, (Item)tuple->t_data,
5852
tuple->t_len,InvalidOffsetNumber,LP_USED);
5953

54+
if (offnum==InvalidOffsetNumber)
55+
elog(STOP,"RelationPutHeapTuple: failed to add tuple");
56+
6057
itemId=PageGetItemId((Page)pageHeader,offnum);
6158
item=PageGetItem((Page)pageHeader,itemId);
6259

6360
ItemPointerSet(&((HeapTupleHeader)item)->t_ctid,
6461
BufferGetBlockNumber(buffer),offnum);
6562

66-
/*
67-
* Let the caller do this!
68-
*
69-
* WriteBuffer(buffer);
70-
*/
71-
7263
/* return an accurate tuple */
7364
ItemPointerSet(&tuple->t_self,BufferGetBlockNumber(buffer),offnum);
7465
}
7566

7667
/*
77-
* This routine is another in the series of attempts to reduce the number
78-
* of I/O's and system calls executed in the various benchmarks. In
79-
* particular, this routine is used to append data to the end of a relation
80-
* file without excessive lseeks. This code should do no more than 2 semops
81-
* in the ideal case.
68+
* RelationGetBufferForTuple
8269
*
83-
*Eventually, we should cache the number of blocks in a relation somewhere.
84-
*Until that time, this code will have todo an lseek to determine the number
85-
*of blocks in a relation.
70+
*Returns (locked) buffer to add tuple with given len.
71+
*If Ubuf is valid then no attempt tolock it should be made -
72+
*this is for heap_update...
8673
*
87-
* This code should ideally do at most 4 semops, 1 lseek, and possibly 1 write
88-
* to do an append; it's possible to eliminate 2 of the semops if we do direct
89-
* buffer stuff (!); the lseek and the write can go if we get
90-
* RelationGetNumberOfBlocks to be useful.
74+
* ELOG(ERROR) is allowed here, so this routine *must* be called
75+
* before any (unlogged) changes are made in buffer pool.
9176
*
92-
* NOTE: This code presumes that we have a write lock on the relation.
93-
* Not now - we use extend locking...
94-
*
95-
* Also note that this routine probably shouldn't have to exist, and does
96-
* screw up the call graph rather badly, but we are wasting so much time and
97-
* system resources being massively general that we are losing badly in our
98-
* performance benchmarks.
9977
*/
100-
void
101-
RelationPutHeapTupleAtEnd(Relationrelation,HeapTupletuple)
78+
Buffer
79+
RelationGetBufferForTuple(Relationrelation,Sizelen,BufferUbuf)
10280
{
10381
Bufferbuffer;
10482
PagepageHeader;
10583
BlockNumberlastblock;
106-
OffsetNumberoffnum;
107-
Sizelen;
108-
ItemIditemId;
109-
Itemitem;
11084

111-
len=MAXALIGN(tuple->t_len);/* be conservative */
85+
len=MAXALIGN(len);/* be conservative */
11286

11387
/*
114-
* If we're gonna fail for oversize tuple, do it right away... this
115-
* code should go away eventually.
88+
* If we're gonna fail for oversize tuple, do it right away
11689
*/
11790
if (len>MaxTupleSize)
11891
elog(ERROR,"Tuple is too big: size %u, max size %ld",
@@ -152,52 +125,40 @@ RelationPutHeapTupleAtEnd(Relation relation, HeapTuple tuple)
152125
else
153126
buffer=ReadBuffer(relation,lastblock-1);
154127

155-
LockBuffer(buffer,BUFFER_LOCK_EXCLUSIVE);
128+
if (buffer!=Ubuf)
129+
LockBuffer(buffer,BUFFER_LOCK_EXCLUSIVE);
156130
pageHeader= (Page)BufferGetPage(buffer);
157131

158132
/*
159133
* Is there room on the last existing page?
160134
*/
161135
if (len>PageGetFreeSpace(pageHeader))
162136
{
163-
LockBuffer(buffer,BUFFER_LOCK_UNLOCK);
137+
if (buffer!=Ubuf)
138+
LockBuffer(buffer,BUFFER_LOCK_UNLOCK);
164139
buffer=ReleaseAndReadBuffer(buffer,relation,P_NEW);
165140
LockBuffer(buffer,BUFFER_LOCK_EXCLUSIVE);
166141
pageHeader= (Page)BufferGetPage(buffer);
167142
PageInit(pageHeader,BufferGetPageSize(buffer),0);
168143

169144
if (len>PageGetFreeSpace(pageHeader))
170145
{
171-
172-
/*
173-
* BUG: by elog'ing here, we leave the new buffer locked and
174-
* not marked dirty, which may result in an invalid page
175-
* header being left on disk. But we should not get here
176-
* given the test at the top of the routine, and the whole
177-
* deal should go away when we implement tuple splitting
178-
* anyway...
179-
*/
180-
elog(ERROR,"Tuple is too big: size %u",len);
146+
/* We should not get here given the test at the top */
147+
elog(STOP,"Tuple is too big: size %u",len);
181148
}
182149
}
150+
/*
151+
* Caller should check space in Ubuf but...
152+
*/
153+
elseif (buffer==Ubuf)
154+
{
155+
ReleaseBuffer(buffer);
156+
buffer=Ubuf;
157+
}
183158

184159
if (!relation->rd_myxactonly)
185160
UnlockPage(relation,0,ExclusiveLock);
186161

187-
offnum=PageAddItem((Page)pageHeader, (Item)tuple->t_data,
188-
tuple->t_len,InvalidOffsetNumber,LP_USED);
189-
190-
itemId=PageGetItemId((Page)pageHeader,offnum);
191-
item=PageGetItem((Page)pageHeader,itemId);
192-
193-
lastblock=BufferGetBlockNumber(buffer);
194-
195-
ItemPointerSet(&((HeapTupleHeader)item)->t_ctid,lastblock,offnum);
196-
197-
/* return an accurate tuple self-pointer */
198-
ItemPointerSet(&tuple->t_self,lastblock,offnum);
199-
200-
LockBuffer(buffer,BUFFER_LOCK_UNLOCK);
201-
WriteBuffer(buffer);
162+
return(buffer);
202163

203164
}

0 commit comments

Comments
 (0)
[8]ページ先頭
©2009-2025 Movatter.jp