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
Appearance settings

Commit 6f38d4d

Browse filesBrowse files
macdicemacdice
committed
Remove dependency on HeapTuple from predicate locking functions.
The following changes make the predicate locking functions more generic and suitable for use by future access methods: - PredicateLockTuple() is renamed to PredicateLockTID(). It takes ItemPointer and inserting transaction ID instead of HeapTuple. - CheckForSerializableConflictIn() takes blocknum instead of buffer. - CheckForSerializableConflictOut() no longer takes HeapTuple or buffer. Author: Ashwin Agrawal Reviewed-by: Andres Freund, Kuntal Ghosh, Thomas Munro Discussion: https://postgr.es/m/CALfoeiv0k3hkEb3Oqk%3DziWqtyk2Jys1UOK5hwRBNeANT_yX%2Bng%40mail.gmail.com
1 parent 4589c6a commit 6f38d4d
Copy full SHA for 6f38d4d

File tree

Expand file treeCollapse file tree

12 files changed

+176
-130
lines changed
Filter options
Expand file treeCollapse file tree

12 files changed

+176
-130
lines changed

‎src/backend/access/gin/ginbtree.c

Copy file name to clipboardExpand all lines: src/backend/access/gin/ginbtree.c
+1-1Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -89,7 +89,7 @@ ginFindLeafPage(GinBtree btree, bool searchMode,
8989
stack->predictNumber = 1;
9090

9191
if (rootConflictCheck)
92-
CheckForSerializableConflictIn(btree->index, NULL, stack->buffer);
92+
CheckForSerializableConflictIn(btree->index, NULL, btree->rootBlkno);
9393

9494
for (;;)
9595
{

‎src/backend/access/gin/ginfast.c

Copy file name to clipboardExpand all lines: src/backend/access/gin/ginfast.c
+1-1Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -246,7 +246,7 @@ ginHeapTupleFastInsert(GinState *ginstate, GinTupleCollector *collector)
246246
* tree, so it conflicts with all serializable scans. All scans acquire a
247247
* predicate lock on the metabuffer to represent that.
248248
*/
249-
CheckForSerializableConflictIn(index, NULL, metabuffer);
249+
CheckForSerializableConflictIn(index, NULL, GIN_METAPAGE_BLKNO);
250250

251251
if (collector->sumsize + collector->ntuples * sizeof(ItemIdData) > GinListPageSize)
252252
{

‎src/backend/access/gin/gininsert.c

Copy file name to clipboardExpand all lines: src/backend/access/gin/gininsert.c
+4-2Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -216,7 +216,8 @@ ginEntryInsert(GinState *ginstate,
216216
return;
217217
}
218218

219-
CheckForSerializableConflictIn(ginstate->index, NULL, stack->buffer);
219+
CheckForSerializableConflictIn(ginstate->index, NULL,
220+
BufferGetBlockNumber(stack->buffer));
220221
/* modify an existing leaf entry */
221222
itup = addItemPointersToLeafTuple(ginstate, itup,
222223
items, nitem, buildStats, stack->buffer);
@@ -225,7 +226,8 @@ ginEntryInsert(GinState *ginstate,
225226
}
226227
else
227228
{
228-
CheckForSerializableConflictIn(ginstate->index, NULL, stack->buffer);
229+
CheckForSerializableConflictIn(ginstate->index, NULL,
230+
BufferGetBlockNumber(stack->buffer));
229231
/* no match, so construct a new leaf entry */
230232
itup = buildFreshLeafTuple(ginstate, attnum, key, category,
231233
items, nitem, buildStats, stack->buffer);

‎src/backend/access/gist/gist.c

Copy file name to clipboardExpand all lines: src/backend/access/gist/gist.c
+1-1Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1264,7 +1264,7 @@ gistinserttuples(GISTInsertState *state, GISTInsertStack *stack,
12641264
* Check for any rw conflicts (in serializable isolation level) just
12651265
* before we intend to modify the page
12661266
*/
1267-
CheckForSerializableConflictIn(state->r, NULL, stack->buffer);
1267+
CheckForSerializableConflictIn(state->r, NULL, BufferGetBlockNumber(stack->buffer));
12681268

12691269
/* Insert the tuple(s) to the page, splitting the page if necessary */
12701270
is_split = gistplacetopage(state->r, state->freespace, giststate,

‎src/backend/access/hash/hashinsert.c

Copy file name to clipboardExpand all lines: src/backend/access/hash/hashinsert.c
+1-1Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -88,7 +88,7 @@ _hash_doinsert(Relation rel, IndexTuple itup, Relation heapRel)
8888
&usedmetap);
8989
Assert(usedmetap != NULL);
9090

91-
CheckForSerializableConflictIn(rel, NULL, buf);
91+
CheckForSerializableConflictIn(rel, NULL, BufferGetBlockNumber(buf));
9292

9393
/* remember the primary bucket buffer to release the pin on it at end. */
9494
bucket_buf = buf;

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

Copy file name to clipboardExpand all lines: src/backend/access/heap/heapam.c
+109-16Lines changed: 109 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -41,6 +41,7 @@
4141
#include "access/multixact.h"
4242
#include "access/parallel.h"
4343
#include "access/relscan.h"
44+
#include "access/subtrans.h"
4445
#include "access/sysattr.h"
4546
#include "access/tableam.h"
4647
#include "access/transam.h"
@@ -446,8 +447,8 @@ heapgetpage(TableScanDesc sscan, BlockNumber page)
446447
else
447448
valid = HeapTupleSatisfiesVisibility(&loctup, snapshot, buffer);
448449

449-
CheckForSerializableConflictOut(valid, scan->rs_base.rs_rd,
450-
&loctup, buffer, snapshot);
450+
HeapCheckForSerializableConflictOut(valid, scan->rs_base.rs_rd,
451+
&loctup, buffer, snapshot);
451452

452453
if (valid)
453454
scan->rs_vistuples[ntup++] = lineoff;
@@ -668,9 +669,9 @@ heapgettup(HeapScanDesc scan,
668669
snapshot,
669670
scan->rs_cbuf);
670671

671-
CheckForSerializableConflictOut(valid, scan->rs_base.rs_rd,
672-
tuple, scan->rs_cbuf,
673-
snapshot);
672+
HeapCheckForSerializableConflictOut(valid, scan->rs_base.rs_rd,
673+
tuple, scan->rs_cbuf,
674+
snapshot);
674675

675676
if (valid && key != NULL)
676677
HeapKeyTest(tuple, RelationGetDescr(scan->rs_base.rs_rd),
@@ -1477,9 +1478,10 @@ heap_fetch(Relation relation,
14771478
valid = HeapTupleSatisfiesVisibility(tuple, snapshot, buffer);
14781479

14791480
if (valid)
1480-
PredicateLockTuple(relation, tuple, snapshot);
1481+
PredicateLockTID(relation, &(tuple->t_self), snapshot,
1482+
HeapTupleHeaderGetXmin(tuple->t_data));
14811483

1482-
CheckForSerializableConflictOut(valid, relation, tuple, buffer, snapshot);
1484+
HeapCheckForSerializableConflictOut(valid, relation, tuple, buffer, snapshot);
14831485

14841486
LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
14851487

@@ -1610,13 +1612,14 @@ heap_hot_search_buffer(ItemPointer tid, Relation relation, Buffer buffer,
16101612
{
16111613
/* If it's visible per the snapshot, we must return it */
16121614
valid = HeapTupleSatisfiesVisibility(heapTuple, snapshot, buffer);
1613-
CheckForSerializableConflictOut(valid, relation, heapTuple,
1614-
buffer, snapshot);
1615+
HeapCheckForSerializableConflictOut(valid, relation, heapTuple,
1616+
buffer, snapshot);
16151617

16161618
if (valid)
16171619
{
16181620
ItemPointerSetOffsetNumber(tid, offnum);
1619-
PredicateLockTuple(relation, heapTuple, snapshot);
1621+
PredicateLockTID(relation, &heapTuple->t_self, snapshot,
1622+
HeapTupleHeaderGetXmin(heapTuple->t_data));
16201623
if (all_dead)
16211624
*all_dead = false;
16221625
return true;
@@ -1750,7 +1753,7 @@ heap_get_latest_tid(TableScanDesc sscan,
17501753
* candidate.
17511754
*/
17521755
valid = HeapTupleSatisfiesVisibility(&tp, snapshot, buffer);
1753-
CheckForSerializableConflictOut(valid, relation, &tp, buffer, snapshot);
1756+
HeapCheckForSerializableConflictOut(valid, relation, &tp, buffer, snapshot);
17541757
if (valid)
17551758
*tid = ctid;
17561759

@@ -1905,7 +1908,7 @@ heap_insert(Relation relation, HeapTuple tup, CommandId cid,
19051908
* lock "gaps" as index page locks do. So we don't need to specify a
19061909
* buffer when making the call, which makes for a faster check.
19071910
*/
1908-
CheckForSerializableConflictIn(relation, NULL, InvalidBuffer);
1911+
CheckForSerializableConflictIn(relation, NULL, InvalidBlockNumber);
19091912

19101913
/* NO EREPORT(ERROR) from here till changes are logged */
19111914
START_CRIT_SECTION();
@@ -2159,7 +2162,7 @@ heap_multi_insert(Relation relation, TupleTableSlot **slots, int ntuples,
21592162
* lock "gaps" as index page locks do. So we don't need to specify a
21602163
* buffer when making the call, which makes for a faster check.
21612164
*/
2162-
CheckForSerializableConflictIn(relation, NULL, InvalidBuffer);
2165+
CheckForSerializableConflictIn(relation, NULL, InvalidBlockNumber);
21632166

21642167
ndone = 0;
21652168
while (ndone < ntuples)
@@ -2350,7 +2353,7 @@ heap_multi_insert(Relation relation, TupleTableSlot **slots, int ntuples,
23502353
* lock "gaps" as index page locks do. So we don't need to specify a
23512354
* buffer when making the call.
23522355
*/
2353-
CheckForSerializableConflictIn(relation, NULL, InvalidBuffer);
2356+
CheckForSerializableConflictIn(relation, NULL, InvalidBlockNumber);
23542357

23552358
/*
23562359
* If tuples are cachable, mark them for invalidation from the caches in
@@ -2664,7 +2667,7 @@ heap_delete(Relation relation, ItemPointer tid,
26642667
* being visible to the scan (i.e., an exclusive buffer content lock is
26652668
* continuously held from this point until the tuple delete is visible).
26662669
*/
2667-
CheckForSerializableConflictIn(relation, &tp, buffer);
2670+
CheckForSerializableConflictIn(relation, tid, BufferGetBlockNumber(buffer));
26682671

26692672
/* replace cid with a combo cid if necessary */
26702673
HeapTupleHeaderAdjustCmax(tp.t_data, &cid, &iscombo);
@@ -3580,7 +3583,7 @@ heap_update(Relation relation, ItemPointer otid, HeapTuple newtup,
35803583
* will include checking the relation level, there is no benefit to a
35813584
* separate check for the new tuple.
35823585
*/
3583-
CheckForSerializableConflictIn(relation, &oldtup, buffer);
3586+
CheckForSerializableConflictIn(relation, otid, BufferGetBlockNumber(buffer));
35843587

35853588
/*
35863589
* At this point newbuf and buffer are both pinned and locked, and newbuf
@@ -9043,3 +9046,93 @@ heap_mask(char *pagedata, BlockNumber blkno)
90439046
}
90449047
}
90459048
}
9049+
9050+
/*
9051+
* HeapCheckForSerializableConflictOut
9052+
* We are reading a tuple which has been modified. If it is visible to
9053+
* us but has been deleted, that indicates a rw-conflict out. If it's
9054+
* not visible and was created by a concurrent (overlapping)
9055+
* serializable transaction, that is also a rw-conflict out,
9056+
*
9057+
* We will determine the top level xid of the writing transaction with which
9058+
* we may be in conflict, and check for overlap with our own transaction.
9059+
* If the transactions overlap (i.e., they cannot see each other's writes),
9060+
* then we have a conflict out.
9061+
*
9062+
* This function should be called just about anywhere in heapam.c where a
9063+
* tuple has been read. The caller must hold at least a shared lock on the
9064+
* buffer, because this function might set hint bits on the tuple. There is
9065+
* currently no known reason to call this function from an index AM.
9066+
*/
9067+
void
9068+
HeapCheckForSerializableConflictOut(bool visible, Relation relation,
9069+
HeapTuple tuple, Buffer buffer,
9070+
Snapshot snapshot)
9071+
{
9072+
TransactionId xid;
9073+
HTSV_Result htsvResult;
9074+
9075+
if (!CheckForSerializableConflictOutNeeded(relation, snapshot))
9076+
return;
9077+
9078+
/*
9079+
* Check to see whether the tuple has been written to by a concurrent
9080+
* transaction, either to create it not visible to us, or to delete it
9081+
* while it is visible to us. The "visible" bool indicates whether the
9082+
* tuple is visible to us, while HeapTupleSatisfiesVacuum checks what else
9083+
* is going on with it.
9084+
*/
9085+
htsvResult = HeapTupleSatisfiesVacuum(tuple, TransactionXmin, buffer);
9086+
switch (htsvResult)
9087+
{
9088+
case HEAPTUPLE_LIVE:
9089+
if (visible)
9090+
return;
9091+
xid = HeapTupleHeaderGetXmin(tuple->t_data);
9092+
break;
9093+
case HEAPTUPLE_RECENTLY_DEAD:
9094+
if (!visible)
9095+
return;
9096+
xid = HeapTupleHeaderGetUpdateXid(tuple->t_data);
9097+
break;
9098+
case HEAPTUPLE_DELETE_IN_PROGRESS:
9099+
xid = HeapTupleHeaderGetUpdateXid(tuple->t_data);
9100+
break;
9101+
case HEAPTUPLE_INSERT_IN_PROGRESS:
9102+
xid = HeapTupleHeaderGetXmin(tuple->t_data);
9103+
break;
9104+
case HEAPTUPLE_DEAD:
9105+
return;
9106+
default:
9107+
9108+
/*
9109+
* The only way to get to this default clause is if a new value is
9110+
* added to the enum type without adding it to this switch
9111+
* statement. That's a bug, so elog.
9112+
*/
9113+
elog(ERROR, "unrecognized return value from HeapTupleSatisfiesVacuum: %u", htsvResult);
9114+
9115+
/*
9116+
* In spite of having all enum values covered and calling elog on
9117+
* this default, some compilers think this is a code path which
9118+
* allows xid to be used below without initialization. Silence
9119+
* that warning.
9120+
*/
9121+
xid = InvalidTransactionId;
9122+
}
9123+
9124+
Assert(TransactionIdIsValid(xid));
9125+
Assert(TransactionIdFollowsOrEquals(xid, TransactionXmin));
9126+
9127+
/*
9128+
* Find top level xid. Bail out if xid is too early to be a conflict, or
9129+
* if it's our own xid.
9130+
*/
9131+
if (TransactionIdEquals(xid, GetTopTransactionIdIfAny()))
9132+
return;
9133+
xid = SubTransGetTopmostTransaction(xid);
9134+
if (TransactionIdPrecedes(xid, TransactionXmin))
9135+
return;
9136+
9137+
return CheckForSerializableConflictOut(relation, xid, snapshot);
9138+
}

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

Copy file name to clipboardExpand all lines: src/backend/access/heap/heapam_handler.c
+6-5Lines changed: 6 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -2171,10 +2171,11 @@ heapam_scan_bitmap_next_block(TableScanDesc scan,
21712171
if (valid)
21722172
{
21732173
hscan->rs_vistuples[ntup++] = offnum;
2174-
PredicateLockTuple(scan->rs_rd, &loctup, snapshot);
2174+
PredicateLockTID(scan->rs_rd, &loctup.t_self, snapshot,
2175+
HeapTupleHeaderGetXmin(loctup.t_data));
21752176
}
2176-
CheckForSerializableConflictOut(valid, scan->rs_rd, &loctup,
2177-
buffer, snapshot);
2177+
HeapCheckForSerializableConflictOut(valid, scan->rs_rd, &loctup,
2178+
buffer, snapshot);
21782179
}
21792180
}
21802181

@@ -2361,8 +2362,8 @@ heapam_scan_sample_next_tuple(TableScanDesc scan, SampleScanState *scanstate,
23612362

23622363
/* in pagemode, heapgetpage did this for us */
23632364
if (!pagemode)
2364-
CheckForSerializableConflictOut(visible, scan->rs_rd, tuple,
2365-
hscan->rs_cbuf, scan->rs_snapshot);
2365+
HeapCheckForSerializableConflictOut(visible, scan->rs_rd, tuple,
2366+
hscan->rs_cbuf, scan->rs_snapshot);
23662367

23672368
/* Try next tuple from same page. */
23682369
if (!visible)

‎src/backend/access/index/indexam.c

Copy file name to clipboardExpand all lines: src/backend/access/index/indexam.c
+2-2Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -180,8 +180,8 @@ index_insert(Relation indexRelation,
180180

181181
if (!(indexRelation->rd_indam->ampredlocks))
182182
CheckForSerializableConflictIn(indexRelation,
183-
(HeapTuple) NULL,
184-
InvalidBuffer);
183+
(ItemPointer) NULL,
184+
InvalidBlockNumber);
185185

186186
return indexRelation->rd_indam->aminsert(indexRelation, values, isnull,
187187
heap_t_ctid, heapRelation,

‎src/backend/access/nbtree/nbtinsert.c

Copy file name to clipboardExpand all lines: src/backend/access/nbtree/nbtinsert.c
+2-2Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -285,7 +285,7 @@ _bt_doinsert(Relation rel, IndexTuple itup,
285285
* checkingunique and !heapkeyspace cases, but it's okay to use the
286286
* first page the value could be on (with scantid omitted) instead.
287287
*/
288-
CheckForSerializableConflictIn(rel, NULL, insertstate.buf);
288+
CheckForSerializableConflictIn(rel, NULL, BufferGetBlockNumber(insertstate.buf));
289289

290290
/*
291291
* Do the insertion. Note that insertstate contains cached binary
@@ -528,7 +528,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
528528
* otherwise be masked by this unique constraint
529529
* violation.
530530
*/
531-
CheckForSerializableConflictIn(rel, NULL, insertstate->buf);
531+
CheckForSerializableConflictIn(rel, NULL, BufferGetBlockNumber(insertstate->buf));
532532

533533
/*
534534
* This is a definite conflict. Break the tuple down into

0 commit comments

Comments
0 (0)
Morty Proxy This is a proxified and sanitized view of the page, visit original site.