Age Owner Branch data TLA Line data Source code
1 : : /*-------------------------------------------------------------------------
2 : : *
3 : : * nbtinsert.c
4 : : * Item insertion in Lehman and Yao btrees for Postgres.
5 : : *
6 : : * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
7 : : * Portions Copyright (c) 1994, Regents of the University of California
8 : : *
9 : : *
10 : : * IDENTIFICATION
11 : : * src/backend/access/nbtree/nbtinsert.c
12 : : *
13 : : *-------------------------------------------------------------------------
14 : : */
15 : :
16 : : #include "postgres.h"
17 : :
18 : : #include "access/nbtree.h"
19 : : #include "access/nbtxlog.h"
20 : : #include "access/tableam.h"
21 : : #include "access/transam.h"
22 : : #include "access/xloginsert.h"
23 : : #include "common/int.h"
24 : : #include "common/pg_prng.h"
25 : : #include "lib/qunique.h"
26 : : #include "miscadmin.h"
27 : : #include "storage/lmgr.h"
28 : : #include "storage/predicate.h"
29 : :
30 : : /* Minimum tree height for application of fastpath optimization */
31 : : #define BTREE_FASTPATH_MIN_LEVEL 2
32 : :
33 : :
34 : : static BTStack _bt_search_insert(Relation rel, Relation heaprel,
35 : : BTInsertState insertstate);
36 : : static TransactionId _bt_check_unique(Relation rel, BTInsertState insertstate,
37 : : Relation heapRel,
38 : : IndexUniqueCheck checkUnique, bool *is_unique,
39 : : uint32 *speculativeToken);
40 : : static OffsetNumber _bt_findinsertloc(Relation rel,
41 : : BTInsertState insertstate,
42 : : bool checkingunique,
43 : : bool indexUnchanged,
44 : : BTStack stack,
45 : : Relation heapRel);
46 : : static void _bt_stepright(Relation rel, Relation heaprel,
47 : : BTInsertState insertstate, BTStack stack);
48 : : static void _bt_insertonpg(Relation rel, Relation heaprel, BTScanInsert itup_key,
49 : : Buffer buf,
50 : : Buffer cbuf,
51 : : BTStack stack,
52 : : IndexTuple itup,
53 : : Size itemsz,
54 : : OffsetNumber newitemoff,
55 : : int postingoff,
56 : : bool split_only_page);
57 : : static Buffer _bt_split(Relation rel, Relation heaprel, BTScanInsert itup_key,
58 : : Buffer buf, Buffer cbuf, OffsetNumber newitemoff,
59 : : Size newitemsz, IndexTuple newitem, IndexTuple orignewitem,
60 : : IndexTuple nposting, uint16 postingoff);
61 : : static void _bt_insert_parent(Relation rel, Relation heaprel, Buffer buf,
62 : : Buffer rbuf, BTStack stack, bool isroot, bool isonly);
63 : : static Buffer _bt_newlevel(Relation rel, Relation heaprel, Buffer lbuf, Buffer rbuf);
64 : : static inline bool _bt_pgaddtup(Page page, Size itemsize, const IndexTupleData *itup,
65 : : OffsetNumber itup_off, bool newfirstdataitem);
66 : : static void _bt_delete_or_dedup_one_page(Relation rel, Relation heapRel,
67 : : BTInsertState insertstate,
68 : : bool simpleonly, bool checkingunique,
69 : : bool uniquedup, bool indexUnchanged);
70 : : static void _bt_simpledel_pass(Relation rel, Buffer buffer, Relation heapRel,
71 : : OffsetNumber *deletable, int ndeletable,
72 : : IndexTuple newitem, OffsetNumber minoff,
73 : : OffsetNumber maxoff);
74 : : static BlockNumber *_bt_deadblocks(Page page, OffsetNumber *deletable,
75 : : int ndeletable, IndexTuple newitem,
76 : : int *nblocks);
77 : : static inline int _bt_blk_cmp(const void *arg1, const void *arg2);
78 : :
79 : : /*
80 : : * _bt_doinsert() -- Handle insertion of a single index tuple in the tree.
81 : : *
82 : : * This routine is called by the public interface routine, btinsert.
83 : : * By here, itup is filled in, including the TID.
84 : : *
85 : : * If checkUnique is UNIQUE_CHECK_NO or UNIQUE_CHECK_PARTIAL, this
86 : : * will allow duplicates. Otherwise (UNIQUE_CHECK_YES or
87 : : * UNIQUE_CHECK_EXISTING) it will throw error for a duplicate.
88 : : * For UNIQUE_CHECK_EXISTING we merely run the duplicate check, and
89 : : * don't actually insert.
90 : : *
91 : : * indexUnchanged executor hint indicates if itup is from an
92 : : * UPDATE that didn't logically change the indexed value, but
93 : : * must nevertheless have a new entry to point to a successor
94 : : * version.
95 : : *
96 : : * The result value is only significant for UNIQUE_CHECK_PARTIAL:
97 : : * it must be true if the entry is known unique, else false.
98 : : * (In the current implementation we'll also return true after a
99 : : * successful UNIQUE_CHECK_YES or UNIQUE_CHECK_EXISTING call, but
100 : : * that's just a coding artifact.)
101 : : */
102 : : bool
7216 tgl@sss.pgh.pa.us 103 :CBC 3668181 : _bt_doinsert(Relation rel, IndexTuple itup,
104 : : IndexUniqueCheck checkUnique, bool indexUnchanged,
105 : : Relation heapRel)
106 : : {
5935 107 : 3668181 : bool is_unique = false;
108 : : BTInsertStateData insertstate;
109 : : BTScanInsert itup_key;
110 : : BTStack stack;
2414 pg@bowt.ie 111 : 3668181 : bool checkingunique = (checkUnique != UNIQUE_CHECK_NO);
112 : :
113 : : /* we need an insertion scan key to do our search, so build one */
871 114 : 3668181 : itup_key = _bt_mkscankey(rel, itup);
115 : :
2380 116 [ + + ]: 3668181 : if (checkingunique)
117 : : {
118 [ + + ]: 2658043 : if (!itup_key->anynullkeys)
119 : : {
120 : : /* No (heapkeyspace) scantid until uniqueness established */
121 : 2647956 : itup_key->scantid = NULL;
122 : : }
123 : : else
124 : : {
125 : : /*
126 : : * Scan key for new tuple contains NULL key values. Bypass
127 : : * checkingunique steps. They are unnecessary because core code
128 : : * considers NULL unequal to every value, including NULL.
129 : : *
130 : : * This optimization avoids O(N^2) behavior within the
131 : : * _bt_findinsertloc() heapkeyspace path when a unique index has a
132 : : * large number of "duplicates" with NULL key values.
133 : : */
134 : 10087 : checkingunique = false;
135 : : /* Tuple is unique in the sense that core code cares about */
136 [ - + ]: 10087 : Assert(checkUnique != UNIQUE_CHECK_EXISTING);
137 : 10087 : is_unique = true;
138 : : }
139 : : }
140 : :
141 : : /*
142 : : * Fill in the BTInsertState working area, to track the current page and
143 : : * position within the page to insert on.
144 : : *
145 : : * Note that itemsz is passed down to lower level code that deals with
146 : : * inserting the item. It must be MAXALIGN()'d. This ensures that space
147 : : * accounting code consistently considers the alignment overhead that we
148 : : * expect PageAddItem() will add later. (Actually, index_form_tuple() is
149 : : * already conservative about alignment, but we don't rely on that from
150 : : * this distance. Besides, preserving the "true" tuple size in index
151 : : * tuple headers for the benefit of nbtsplitloc.c might happen someday.
152 : : * Note that heapam does not MAXALIGN() each heap tuple's lp_len field.)
153 : : */
2414 154 : 3668181 : insertstate.itup = itup;
155 : 3668181 : insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
156 : 3668181 : insertstate.itup_key = itup_key;
157 : 3668181 : insertstate.bounds_valid = false;
158 : 3668181 : insertstate.buf = InvalidBuffer;
2071 159 : 3668181 : insertstate.postingoff = 0;
160 : :
2050 161 : 3668193 : search:
162 : :
163 : : /*
164 : : * Find and lock the leaf page that the tuple should be added to by
165 : : * searching from the root page. insertstate.buf will hold a buffer that
166 : : * is locked in exclusive mode afterwards.
167 : : */
941 andres@anarazel.de 168 : 3668193 : stack = _bt_search_insert(rel, heapRel, &insertstate);
169 : :
170 : : /*
171 : : * checkingunique inserts are not allowed to go ahead when two tuples with
172 : : * equal key attribute values would be visible to new MVCC snapshots once
173 : : * the xact commits. Check for conflicts in the locked page/buffer (if
174 : : * needed) here.
175 : : *
176 : : * It might be necessary to check a page to the right in _bt_check_unique,
177 : : * though that should be very rare. In practice the first page the value
178 : : * could be on (with scantid omitted) is almost always also the only page
179 : : * that a matching tuple might be found on. This is due to the behavior
180 : : * of _bt_findsplitloc with duplicate tuples -- a group of duplicates can
181 : : * only be allowed to cross a page boundary when there is no candidate
182 : : * leaf page split point that avoids it. Also, _bt_check_unique can use
183 : : * the leaf page high key to determine that there will be no duplicates on
184 : : * the right sibling without actually visiting it (it uses the high key in
185 : : * cases where the new item happens to belong at the far right of the leaf
186 : : * page).
187 : : *
188 : : * NOTE: obviously, _bt_check_unique can only detect keys that are already
189 : : * in the index; so it cannot defend against concurrent insertions of the
190 : : * same key. We protect against that by means of holding a write lock on
191 : : * the first page the value could be on, with omitted/-inf value for the
192 : : * implicit heap TID tiebreaker attribute. Any other would-be inserter of
193 : : * the same key must acquire a write lock on the same page, so only one
194 : : * would-be inserter can be making the check at one time. Furthermore,
195 : : * once we are past the check we hold write locks continuously until we
196 : : * have performed our insertion, so no later inserter can fail to see our
197 : : * insertion. (This requires some care in _bt_findinsertloc.)
198 : : *
199 : : * If we must wait for another xact, we release the lock while waiting,
200 : : * and then must perform a new search.
201 : : *
202 : : * For a partial uniqueness check, we don't wait for the other xact. Just
203 : : * let the tuple in and return false for possibly non-unique, or true for
204 : : * definitely unique.
205 : : */
2414 pg@bowt.ie 206 [ + + ]: 3668193 : if (checkingunique)
207 : : {
208 : : TransactionId xwait;
209 : : uint32 speculativeToken;
210 : :
211 : 2647968 : xwait = _bt_check_unique(rel, &insertstate, heapRel, checkUnique,
212 : : &is_unique, &speculativeToken);
213 : :
2050 214 [ + + ]: 2647717 : if (unlikely(TransactionIdIsValid(xwait)))
215 : : {
216 : : /* Have to wait for the other guy ... */
2414 217 : 12 : _bt_relbuf(rel, insertstate.buf);
218 : 12 : insertstate.buf = InvalidBuffer;
219 : :
220 : : /*
221 : : * If it's a speculative insertion, wait for it to finish (ie. to
222 : : * go ahead with the insertion, or kill the tuple). Otherwise
223 : : * wait for the transaction to finish as usual.
224 : : */
3826 andres@anarazel.de 225 [ - + ]: 12 : if (speculativeToken)
3826 andres@anarazel.de 226 :UBC 0 : SpeculativeInsertionWait(xwait, speculativeToken);
227 : : else
3826 andres@anarazel.de 228 :CBC 12 : XactLockTableWait(xwait, rel, &itup->t_tid, XLTW_InsertIndex);
229 : :
230 : : /* start over... */
2773 andrew@dunslane.net 231 [ - + ]: 12 : if (stack)
2773 andrew@dunslane.net 232 :UBC 0 : _bt_freestack(stack);
2050 pg@bowt.ie 233 :CBC 12 : goto search;
234 : : }
235 : :
236 : : /* Uniqueness is established -- restore heap tid as scantid */
2414 237 [ + - ]: 2647705 : if (itup_key->heapkeyspace)
238 : 2647705 : itup_key->scantid = &itup->t_tid;
239 : : }
240 : :
5935 tgl@sss.pgh.pa.us 241 [ + + ]: 3667930 : if (checkUnique != UNIQUE_CHECK_EXISTING)
242 : : {
243 : : OffsetNumber newitemoff;
244 : :
245 : : /*
246 : : * The only conflict predicate locking cares about for indexes is when
247 : : * an index tuple insert conflicts with an existing lock. We don't
248 : : * know the actual page we're going to insert on for sure just yet in
249 : : * checkingunique and !heapkeyspace cases, but it's okay to use the
250 : : * first page the value could be on (with scantid omitted) instead.
251 : : */
2100 tmunro@postgresql.or 252 : 3667903 : CheckForSerializableConflictIn(rel, NULL, BufferGetBlockNumber(insertstate.buf));
253 : :
254 : : /*
255 : : * Do the insertion. Note that insertstate contains cached binary
256 : : * search bounds established within _bt_check_unique when insertion is
257 : : * checkingunique.
258 : : */
2414 pg@bowt.ie 259 : 3667900 : newitemoff = _bt_findinsertloc(rel, &insertstate, checkingunique,
260 : : indexUnchanged, stack, heapRel);
941 andres@anarazel.de 261 : 3667900 : _bt_insertonpg(rel, heapRel, itup_key, insertstate.buf, InvalidBuffer,
262 : : stack, itup, insertstate.itemsz, newitemoff,
263 : : insertstate.postingoff, false);
264 : : }
265 : : else
266 : : {
267 : : /* just release the buffer */
2414 pg@bowt.ie 268 : 27 : _bt_relbuf(rel, insertstate.buf);
269 : : }
270 : :
271 : : /* be tidy */
2773 andrew@dunslane.net 272 [ + + ]: 3667927 : if (stack)
273 : 3187141 : _bt_freestack(stack);
2414 pg@bowt.ie 274 : 3667927 : pfree(itup_key);
275 : :
5935 tgl@sss.pgh.pa.us 276 : 3667927 : return is_unique;
277 : : }
278 : :
279 : : /*
280 : : * _bt_search_insert() -- _bt_search() wrapper for inserts
281 : : *
282 : : * Search the tree for a particular scankey, or more precisely for the first
283 : : * leaf page it could be on. Try to make use of the fastpath optimization's
284 : : * rightmost leaf page cache before actually searching the tree from the root
285 : : * page, though.
286 : : *
287 : : * Return value is a stack of parent-page pointers (though see notes about
288 : : * fastpath optimization and page splits below). insertstate->buf is set to
289 : : * the address of the leaf-page buffer, which is write-locked and pinned in
290 : : * all cases (if necessary by creating a new empty root page for caller).
291 : : *
292 : : * The fastpath optimization avoids most of the work of searching the tree
293 : : * repeatedly when a single backend inserts successive new tuples on the
294 : : * rightmost leaf page of an index. A backend cache of the rightmost leaf
295 : : * page is maintained within _bt_insertonpg(), and used here. The cache is
296 : : * invalidated here when an insert of a non-pivot tuple must take place on a
297 : : * non-rightmost leaf page.
298 : : *
299 : : * The optimization helps with indexes on an auto-incremented field. It also
300 : : * helps with indexes on datetime columns, as well as indexes with lots of
301 : : * NULL values. (NULLs usually get inserted in the rightmost page for single
302 : : * column indexes, since they usually get treated as coming after everything
303 : : * else in the key space. Individual NULL tuples will generally be placed on
304 : : * the rightmost leaf page due to the influence of the heap TID column.)
305 : : *
306 : : * Note that we avoid applying the optimization when there is insufficient
307 : : * space on the rightmost page to fit caller's new item. This is necessary
308 : : * because we'll need to return a real descent stack when a page split is
309 : : * expected (actually, caller can cope with a leaf page split that uses a NULL
310 : : * stack, but that's very slow and so must be avoided). Note also that the
311 : : * fastpath optimization acquires the lock on the page conditionally as a way
312 : : * of reducing extra contention when there are concurrent insertions into the
313 : : * rightmost page (we give up if we'd have to wait for the lock). We assume
314 : : * that it isn't useful to apply the optimization when there is contention,
315 : : * since each per-backend cache won't stay valid for long.
316 : : */
317 : : static BTStack
941 andres@anarazel.de 318 : 3668193 : _bt_search_insert(Relation rel, Relation heaprel, BTInsertState insertstate)
319 : : {
2050 pg@bowt.ie 320 [ - + ]: 3668193 : Assert(insertstate->buf == InvalidBuffer);
321 [ - + ]: 3668193 : Assert(!insertstate->bounds_valid);
322 [ - + ]: 3668193 : Assert(insertstate->postingoff == 0);
323 : :
324 [ + - + + ]: 3668193 : if (RelationGetTargetBlock(rel) != InvalidBlockNumber)
325 : : {
326 : : /* Simulate a _bt_getbuf() call with conditional locking */
327 [ + - ]: 36888 : insertstate->buf = ReadBuffer(rel, RelationGetTargetBlock(rel));
1925 328 [ + + ]: 36888 : if (_bt_conditionallockbuf(rel, insertstate->buf))
329 : : {
330 : : Page page;
331 : : BTPageOpaque opaque;
332 : :
2050 333 : 35948 : _bt_checkpage(rel, insertstate->buf);
334 : 35948 : page = BufferGetPage(insertstate->buf);
1306 michael@paquier.xyz 335 : 35948 : opaque = BTPageGetOpaque(page);
336 : :
337 : : /*
338 : : * Check if the page is still the rightmost leaf page and has
339 : : * enough free space to accommodate the new tuple. Also check
340 : : * that the insertion scan key is strictly greater than the first
341 : : * non-pivot tuple on the page. (Note that we expect itup_key's
342 : : * scantid to be unset when our caller is a checkingunique
343 : : * inserter.)
344 : : */
1806 pg@bowt.ie 345 [ + + ]: 35948 : if (P_RIGHTMOST(opaque) &&
346 [ + - ]: 35914 : P_ISLEAF(opaque) &&
347 [ + - ]: 35914 : !P_IGNORE(opaque) &&
2050 348 [ + + + - ]: 71621 : PageGetFreeSpace(page) > insertstate->itemsz &&
349 [ + + ]: 71414 : PageGetMaxOffsetNumber(page) >= P_HIKEY &&
350 : 35707 : _bt_compare(rel, insertstate->itup_key, page, P_HIKEY) > 0)
351 : : {
352 : : /*
353 : : * Caller can use the fastpath optimization because cached
354 : : * block is still rightmost leaf page, which can fit caller's
355 : : * new tuple without splitting. Keep block in local cache for
356 : : * next insert, and have caller use NULL stack.
357 : : *
358 : : * Note that _bt_insert_parent() has an assertion that catches
359 : : * leaf page splits that somehow follow from a fastpath insert
360 : : * (it should only be passed a NULL stack when it must deal
361 : : * with a concurrent root page split, and never because a NULL
362 : : * stack was returned here).
363 : : */
364 : 35693 : return NULL;
365 : : }
366 : :
367 : : /* Page unsuitable for caller, drop lock and pin */
368 : 255 : _bt_relbuf(rel, insertstate->buf);
369 : : }
370 : : else
371 : : {
372 : : /* Lock unavailable, drop pin */
373 : 940 : ReleaseBuffer(insertstate->buf);
374 : : }
375 : :
376 : : /* Forget block, since cache doesn't appear to be useful */
377 : 1195 : RelationSetTargetBlock(rel, InvalidBlockNumber);
378 : : }
379 : :
380 : : /* Cannot use optimization -- descend tree, return proper descent stack */
941 andres@anarazel.de 381 : 3632500 : return _bt_search(rel, heaprel, insertstate->itup_key, &insertstate->buf,
382 : : BT_WRITE);
383 : : }
384 : :
385 : : /*
386 : : * _bt_check_unique() -- Check for violation of unique index constraint
387 : : *
388 : : * Returns InvalidTransactionId if there is no conflict, else an xact ID
389 : : * we must wait for to see if it commits a conflicting tuple. If an actual
390 : : * conflict is detected, no return --- just ereport(). If an xact ID is
391 : : * returned, and the conflicting tuple still has a speculative insertion in
392 : : * progress, *speculativeToken is set to non-zero, and the caller can wait for
393 : : * the verdict on the insertion using SpeculativeInsertionWait().
394 : : *
395 : : * However, if checkUnique == UNIQUE_CHECK_PARTIAL, we always return
396 : : * InvalidTransactionId because we don't want to wait. In this case we
397 : : * set *is_unique to false if there is a potential conflict, and the
398 : : * core code must redo the uniqueness check later.
399 : : *
400 : : * As a side-effect, sets state in insertstate that can later be used by
401 : : * _bt_findinsertloc() to reuse most of the binary search work we do
402 : : * here.
403 : : *
404 : : * This code treats NULLs as equal, unlike the default semantics for unique
405 : : * indexes. So do not call here when there are NULL values in scan key and
406 : : * the index uses the default NULLS DISTINCT mode.
407 : : */
408 : : static TransactionId
2414 pg@bowt.ie 409 : 2647968 : _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
410 : : IndexUniqueCheck checkUnique, bool *is_unique,
411 : : uint32 *speculativeToken)
412 : : {
413 : 2647968 : IndexTuple itup = insertstate->itup;
1963 414 : 2647968 : IndexTuple curitup = NULL;
1664 415 : 2647968 : ItemId curitemid = NULL;
2414 416 : 2647968 : BTScanInsert itup_key = insertstate->itup_key;
417 : : SnapshotData SnapshotDirty;
418 : : OffsetNumber offset;
419 : : OffsetNumber maxoff;
420 : : Page page;
421 : : BTPageOpaque opaque;
9230 tgl@sss.pgh.pa.us 422 : 2647968 : Buffer nbuf = InvalidBuffer;
5935 423 : 2647968 : bool found = false;
2071 pg@bowt.ie 424 : 2647968 : bool inposting = false;
425 : 2647968 : bool prevalldead = true;
426 : 2647968 : int curposti = 0;
427 : :
428 : : /* Assume unique until we find a duplicate */
5935 tgl@sss.pgh.pa.us 429 : 2647968 : *is_unique = true;
430 : :
6792 431 : 2647968 : InitDirtySnapshot(SnapshotDirty);
432 : :
2414 pg@bowt.ie 433 : 2647968 : page = BufferGetPage(insertstate->buf);
1306 michael@paquier.xyz 434 : 2647968 : opaque = BTPageGetOpaque(page);
9230 tgl@sss.pgh.pa.us 435 : 2647968 : maxoff = PageGetMaxOffsetNumber(page);
436 : :
437 : : /*
438 : : * Find the first tuple with the same key.
439 : : *
440 : : * This also saves the binary search bounds in insertstate. We use them
441 : : * in the fastpath below, but also in the _bt_findinsertloc() call later.
442 : : */
2399 pg@bowt.ie 443 [ - + ]: 2647968 : Assert(!insertstate->bounds_valid);
2414 444 : 2647968 : offset = _bt_binsrch_insert(rel, insertstate);
445 : :
446 : : /*
447 : : * Scan over all equal tuples, looking for live conflicts.
448 : : */
449 [ + + - + ]: 2647968 : Assert(!insertstate->bounds_valid || insertstate->low == offset);
2380 450 [ - + ]: 2647968 : Assert(!itup_key->anynullkeys);
2414 451 [ + - ]: 2647968 : Assert(itup_key->scantid == NULL);
452 : : for (;;)
453 : : {
454 : : /*
455 : : * Each iteration of the loop processes one heap TID, not one index
456 : : * tuple. Current offset number for page isn't usually advanced on
457 : : * iterations that process heap TIDs from posting list tuples.
458 : : *
459 : : * "inposting" state is set when _inside_ a posting list --- not when
460 : : * we're at the start (or end) of a posting list. We advance curposti
461 : : * at the end of the iteration when inside a posting list tuple. In
462 : : * general, every loop iteration either advances the page offset or
463 : : * advances curposti --- an iteration that handles the rightmost/max
464 : : * heap TID in a posting list finally advances the page offset (and
465 : : * unsets "inposting").
466 : : *
467 : : * Make sure the offset points to an actual index tuple before trying
468 : : * to examine it...
469 : : */
9230 tgl@sss.pgh.pa.us 470 [ + + ]: 8646343 : if (offset <= maxoff)
471 : : {
472 : : /*
473 : : * Fastpath: In most cases, we can use cached search bounds to
474 : : * limit our consideration to items that are definitely
475 : : * duplicates. This fastpath doesn't apply when the original page
476 : : * is empty, or when initial offset is past the end of the
477 : : * original page, which may indicate that we need to examine a
478 : : * second or subsequent page.
479 : : *
480 : : * Note that this optimization allows us to avoid calling
481 : : * _bt_compare() directly when there are no duplicates, as long as
482 : : * the offset where the key will go is not at the end of the page.
483 : : */
2414 pg@bowt.ie 484 [ + + + + ]: 7163673 : if (nbuf == InvalidBuffer && offset == insertstate->stricthigh)
485 : : {
486 [ - + ]: 1050193 : Assert(insertstate->bounds_valid);
487 [ + + - + ]: 1050193 : Assert(insertstate->low >= P_FIRSTDATAKEY(opaque));
488 [ - + ]: 1050193 : Assert(insertstate->low <= insertstate->stricthigh);
2380 489 [ - + ]: 1050193 : Assert(_bt_compare(rel, itup_key, page, offset) < 0);
2414 490 : 1050193 : break;
491 : : }
492 : :
493 : : /*
494 : : * We can skip items that are already marked killed.
495 : : *
496 : : * In the presence of heavy update activity an index may contain
497 : : * many killed items with the same key; running _bt_compare() on
498 : : * each killed item gets expensive. Just advance over killed
499 : : * items as quickly as we can. We only apply _bt_compare() when
500 : : * we get to a non-killed item. We could reuse the bounds to
501 : : * avoid _bt_compare() calls for known equal tuples, but it
502 : : * doesn't seem worth it.
503 : : */
2071 504 [ + + ]: 6113480 : if (!inposting)
505 : 3855941 : curitemid = PageGetItemId(page, offset);
506 [ + + + + ]: 6113480 : if (inposting || !ItemIdIsDead(curitemid))
507 : : {
508 : : ItemPointerData htid;
509 : 5824721 : bool all_dead = false;
510 : :
511 [ + + ]: 5824721 : if (!inposting)
512 : : {
513 : : /* Plain tuple, or first TID in posting list tuple */
514 [ + + ]: 3567182 : if (_bt_compare(rel, itup_key, page, offset) != 0)
515 : 102318 : break; /* we're past all the equal tuples */
516 : :
517 : : /* Advanced curitup */
518 : 3464864 : curitup = (IndexTuple) PageGetItem(page, curitemid);
519 [ - + ]: 3464864 : Assert(!BTreeTupleIsPivot(curitup));
520 : : }
521 : :
522 : : /* okay, we gotta fetch the heap tuple using htid ... */
523 [ + + ]: 5722403 : if (!BTreeTupleIsPosting(curitup))
524 : : {
525 : : /* ... htid is from simple non-pivot tuple */
526 [ - + ]: 3441540 : Assert(!inposting);
527 : 3441540 : htid = curitup->t_tid;
528 : : }
529 [ + + ]: 2280863 : else if (!inposting)
530 : : {
531 : : /* ... htid is first TID in new posting list */
532 : 23324 : inposting = true;
533 : 23324 : prevalldead = true;
534 : 23324 : curposti = 0;
535 : 23324 : htid = *BTreeTupleGetPostingN(curitup, 0);
536 : : }
537 : : else
538 : : {
539 : : /* ... htid is second or subsequent TID in posting list */
540 [ - + ]: 2257539 : Assert(curposti > 0);
541 : 2257539 : htid = *BTreeTupleGetPostingN(curitup, curposti);
542 : : }
543 : :
544 : : /*
545 : : * If we are doing a recheck, we expect to find the tuple we
546 : : * are rechecking. It's not a duplicate, but we have to keep
547 : : * scanning.
548 : : */
5935 tgl@sss.pgh.pa.us 549 [ + + + + ]: 5722513 : if (checkUnique == UNIQUE_CHECK_EXISTING &&
550 : 110 : ItemPointerCompare(&htid, &itup->t_tid) == 0)
551 : : {
552 : 27 : found = true;
553 : : }
554 : :
555 : : /*
556 : : * Check if there's any table tuples for this index entry
557 : : * satisfying SnapshotDirty. This is necessary because for AMs
558 : : * with optimizations like heap's HOT, we have just a single
559 : : * index entry for the entire chain.
560 : : */
2409 andres@anarazel.de 561 [ + + ]: 5722376 : else if (table_index_fetch_tuple_check(heapRel, &htid,
562 : : &SnapshotDirty,
563 : : &all_dead))
564 : : {
565 : : TransactionId xwait;
566 : :
567 : : /*
568 : : * It is a duplicate. If we are only doing a partial
569 : : * check, then don't bother checking if the tuple is being
570 : : * updated in another transaction. Just return the fact
571 : : * that it is a potential conflict and leave the full
572 : : * check till later. Don't invalidate binary search
573 : : * bounds.
574 : : */
5935 tgl@sss.pgh.pa.us 575 [ + + ]: 366 : if (checkUnique == UNIQUE_CHECK_PARTIAL)
576 : : {
577 [ - + ]: 103 : if (nbuf != InvalidBuffer)
5935 tgl@sss.pgh.pa.us 578 :UBC 0 : _bt_relbuf(rel, nbuf);
5935 tgl@sss.pgh.pa.us 579 :CBC 103 : *is_unique = false;
580 : 115 : return InvalidTransactionId;
581 : : }
582 : :
583 : : /*
584 : : * If this tuple is being updated by other transaction
585 : : * then we have to wait for its commit/abort.
586 : : */
587 : 526 : xwait = (TransactionIdIsValid(SnapshotDirty.xmin)) ?
588 [ + + ]: 263 : SnapshotDirty.xmin : SnapshotDirty.xmax;
589 : :
8558 590 [ + + ]: 263 : if (TransactionIdIsValid(xwait))
591 : : {
592 [ - + ]: 12 : if (nbuf != InvalidBuffer)
8558 tgl@sss.pgh.pa.us 593 :UBC 0 : _bt_relbuf(rel, nbuf);
594 : : /* Tell _bt_doinsert to wait... */
3826 andres@anarazel.de 595 :CBC 12 : *speculativeToken = SnapshotDirty.speculativeToken;
596 : : /* Caller releases lock on buf immediately */
2399 pg@bowt.ie 597 : 12 : insertstate->bounds_valid = false;
8558 tgl@sss.pgh.pa.us 598 : 12 : return xwait;
599 : : }
600 : :
601 : : /*
602 : : * Otherwise we have a definite conflict. But before
603 : : * complaining, look to see if the tuple we want to insert
604 : : * is itself now committed dead --- if so, don't complain.
605 : : * This is a waste of time in normal scenarios but we must
606 : : * do it to support CREATE INDEX CONCURRENTLY.
607 : : *
608 : : * We must follow HOT-chains here because during
609 : : * concurrent index build, we insert the root TID though
610 : : * the actual tuple may be somewhere in the HOT-chain.
611 : : * While following the chain we might not stop at the
612 : : * exact tuple which triggered the insert, but that's OK
613 : : * because if we find a live tuple anywhere in this chain,
614 : : * we have a unique key conflict. The other live tuple is
615 : : * not part of this chain because it had a different index
616 : : * entry.
617 : : */
1951 pg@bowt.ie 618 : 251 : htid = itup->t_tid;
619 [ - + ]: 251 : if (table_index_fetch_tuple_check(heapRel, &htid,
620 : : SnapshotSelf, NULL))
621 : : {
622 : : /* Normal case --- it's still live */
623 : : }
624 : : else
625 : : {
626 : : /*
627 : : * It's been deleted, so no error, and no need to
628 : : * continue searching
629 : : */
7004 tgl@sss.pgh.pa.us 630 :UBC 0 : break;
631 : : }
632 : :
633 : : /*
634 : : * Check for a conflict-in as we would if we were going to
635 : : * write to this page. We aren't actually going to write,
636 : : * but we want a chance to report SSI conflicts that would
637 : : * otherwise be masked by this unique constraint
638 : : * violation.
639 : : */
2100 tmunro@postgresql.or 640 :CBC 251 : CheckForSerializableConflictIn(rel, NULL, BufferGetBlockNumber(insertstate->buf));
641 : :
642 : : /*
643 : : * This is a definite conflict. Break the tuple down into
644 : : * datums and report the error. But first, make sure we
645 : : * release the buffer locks we're holding ---
646 : : * BuildIndexValueDescription could make catalog accesses,
647 : : * which in the worst case might touch this same index and
648 : : * cause deadlocks.
649 : : */
5932 tgl@sss.pgh.pa.us 650 [ - + ]: 247 : if (nbuf != InvalidBuffer)
5932 tgl@sss.pgh.pa.us 651 :UBC 0 : _bt_relbuf(rel, nbuf);
2414 pg@bowt.ie 652 :CBC 247 : _bt_relbuf(rel, insertstate->buf);
653 : 247 : insertstate->buf = InvalidBuffer;
2399 654 : 247 : insertstate->bounds_valid = false;
655 : :
656 : : {
657 : : Datum values[INDEX_MAX_KEYS];
658 : : bool isnull[INDEX_MAX_KEYS];
659 : : char *key_desc;
660 : :
5932 tgl@sss.pgh.pa.us 661 : 247 : index_deform_tuple(itup, RelationGetDescr(rel),
662 : : values, isnull);
663 : :
3942 sfrost@snowman.net 664 : 247 : key_desc = BuildIndexValueDescription(rel, values,
665 : : isnull);
666 : :
5932 tgl@sss.pgh.pa.us 667 [ + - + + ]: 247 : ereport(ERROR,
668 : : (errcode(ERRCODE_UNIQUE_VIOLATION),
669 : : errmsg("duplicate key value violates unique constraint \"%s\"",
670 : : RelationGetRelationName(rel)),
671 : : key_desc ? errdetail("Key %s already exists.",
672 : : key_desc) : 0,
673 : : errtableconstraint(heapRel,
674 : : RelationGetRelationName(rel))));
675 : : }
676 : : }
2071 pg@bowt.ie 677 [ + + + + : 5722010 : else if (all_dead && (!inposting ||
+ + ]
678 : 18792 : (prevalldead &&
679 [ + + ]: 18792 : curposti == BTreeTupleGetNPosting(curitup) - 1)))
680 : : {
681 : : /*
682 : : * The conflicting tuple (or all HOT chains pointed to by
683 : : * all posting list TIDs) is dead to everyone, so mark the
684 : : * index entry killed.
685 : : */
6613 tgl@sss.pgh.pa.us 686 : 53082 : ItemIdMarkDead(curitemid);
687 : 53082 : opaque->btpo_flags |= BTP_HAS_GARBAGE;
688 : :
689 : : /*
690 : : * Mark buffer with a dirty hint, since state is not
691 : : * crucial. Be sure to mark the proper buffer dirty.
692 : : */
693 [ + + ]: 53082 : if (nbuf != InvalidBuffer)
4516 jdavis@postgresql.or 694 : 3 : MarkBufferDirtyHint(nbuf, true);
695 : : else
2414 pg@bowt.ie 696 : 53079 : MarkBufferDirtyHint(insertstate->buf, true);
697 : : }
698 : :
699 : : /*
700 : : * Remember if posting list tuple has even a single HOT chain
701 : : * whose members are not all dead
702 : : */
2071 703 [ + + + + ]: 5722037 : if (!all_dead && inposting)
704 : 2261978 : prevalldead = false;
705 : : }
706 : : }
707 : :
708 [ + + + + ]: 7493466 : if (inposting && curposti < BTreeTupleGetNPosting(curitup) - 1)
709 : : {
710 : : /* Advance to next TID in same posting list */
711 : 2257539 : curposti++;
712 : 2257539 : continue;
713 : : }
714 [ + + ]: 5235927 : else if (offset < maxoff)
715 : : {
716 : : /* Advance to next tuple */
717 : 3735814 : curposti = 0;
718 : 3735814 : inposting = false;
9230 tgl@sss.pgh.pa.us 719 : 3735814 : offset = OffsetNumberNext(offset);
720 : : }
721 : : else
722 : : {
723 : : int highkeycmp;
724 : :
725 : : /* If scankey == hikey we gotta check the next page too */
726 [ + + ]: 1500113 : if (P_RIGHTMOST(opaque))
727 : 1428633 : break;
2414 pg@bowt.ie 728 : 71480 : highkeycmp = _bt_compare(rel, itup_key, page, P_HIKEY);
729 [ - + ]: 71480 : Assert(highkeycmp <= 0);
730 [ + + ]: 71480 : if (highkeycmp != 0)
9230 tgl@sss.pgh.pa.us 731 : 66458 : break;
732 : : /* Advance to next non-dead page --- there must be one */
733 : : for (;;)
8284 tgl@sss.pgh.pa.us 734 :UBC 0 : {
2071 pg@bowt.ie 735 :CBC 5022 : BlockNumber nblkno = opaque->btpo_next;
736 : :
7860 tgl@sss.pgh.pa.us 737 : 5022 : nbuf = _bt_relandgetbuf(rel, nbuf, nblkno, BT_READ);
3478 kgrittn@postgresql.o 738 : 5022 : page = BufferGetPage(nbuf);
1306 michael@paquier.xyz 739 : 5022 : opaque = BTPageGetOpaque(page);
8284 tgl@sss.pgh.pa.us 740 [ + - ]: 5022 : if (!P_IGNORE(opaque))
741 : 5022 : break;
8284 tgl@sss.pgh.pa.us 742 [ # # ]:UBC 0 : if (P_RIGHTMOST(opaque))
6511 743 [ # # ]: 0 : elog(ERROR, "fell off the end of index \"%s\"",
744 : : RelationGetRelationName(rel));
745 : : }
746 : : /* Will also advance to next tuple */
2071 pg@bowt.ie 747 :CBC 5022 : curposti = 0;
748 : 5022 : inposting = false;
9230 tgl@sss.pgh.pa.us 749 : 5022 : maxoff = PageGetMaxOffsetNumber(page);
750 [ + + ]: 5022 : offset = P_FIRSTDATAKEY(opaque);
751 : : /* Don't invalidate binary search bounds */
752 : : }
753 : : }
754 : :
755 : : /*
756 : : * If we are doing a recheck then we should have found the tuple we are
757 : : * checking. Otherwise there's something very wrong --- probably, the
758 : : * index is on a non-immutable expression.
759 : : */
5935 760 [ + + - + ]: 2647602 : if (checkUnique == UNIQUE_CHECK_EXISTING && !found)
5935 tgl@sss.pgh.pa.us 761 [ # # ]:UBC 0 : ereport(ERROR,
762 : : (errcode(ERRCODE_INTERNAL_ERROR),
763 : : errmsg("failed to re-find tuple within index \"%s\"",
764 : : RelationGetRelationName(rel)),
765 : : errhint("This may be because of a non-immutable index expression."),
766 : : errtableconstraint(heapRel,
767 : : RelationGetRelationName(rel))));
768 : :
9230 tgl@sss.pgh.pa.us 769 [ + + ]:CBC 2647602 : if (nbuf != InvalidBuffer)
8871 770 : 2880 : _bt_relbuf(rel, nbuf);
771 : :
8832 772 : 2647602 : return InvalidTransactionId;
773 : : }
774 : :
775 : :
776 : : /*
777 : : * _bt_findinsertloc() -- Finds an insert location for a tuple
778 : : *
779 : : * On entry, insertstate buffer contains the page the new tuple belongs
780 : : * on. It is exclusive-locked and pinned by the caller.
781 : : *
782 : : * If 'checkingunique' is true, the buffer on entry is the first page
783 : : * that contains duplicates of the new key. If there are duplicates on
784 : : * multiple pages, the correct insertion position might be some page to
785 : : * the right, rather than the first page. In that case, this function
786 : : * moves right to the correct target page.
787 : : *
788 : : * (In a !heapkeyspace index, there can be multiple pages with the same
789 : : * high key, where the new tuple could legitimately be placed on. In
790 : : * that case, the caller passes the first page containing duplicates,
791 : : * just like when checkingunique=true. If that page doesn't have enough
792 : : * room for the new tuple, this function moves right, trying to find a
793 : : * legal page that does.)
794 : : *
795 : : * If 'indexUnchanged' is true, this is for an UPDATE that didn't
796 : : * logically change the indexed value, but must nevertheless have a new
797 : : * entry to point to a successor version. This hint from the executor
798 : : * will influence our behavior when the page might have to be split and
799 : : * we must consider our options. Bottom-up index deletion can avoid
800 : : * pathological version-driven page splits, but we only want to go to the
801 : : * trouble of trying it when we already have moderate confidence that
802 : : * it's appropriate. The hint should not significantly affect our
803 : : * behavior over time unless practically all inserts on to the leaf page
804 : : * get the hint.
805 : : *
806 : : * On exit, insertstate buffer contains the chosen insertion page, and
807 : : * the offset within that page is returned. If _bt_findinsertloc needed
808 : : * to move right, the lock and pin on the original page are released, and
809 : : * the new buffer is exclusively locked and pinned instead.
810 : : *
811 : : * If insertstate contains cached binary search bounds, we will take
812 : : * advantage of them. This avoids repeating comparisons that we made in
813 : : * _bt_check_unique() already.
814 : : */
815 : : static OffsetNumber
6814 bruce@momjian.us 816 : 3667900 : _bt_findinsertloc(Relation rel,
817 : : BTInsertState insertstate,
818 : : bool checkingunique,
819 : : bool indexUnchanged,
820 : : BTStack stack,
821 : : Relation heapRel)
822 : : {
2414 pg@bowt.ie 823 : 3667900 : BTScanInsert itup_key = insertstate->itup_key;
824 : 3667900 : Page page = BufferGetPage(insertstate->buf);
825 : : BTPageOpaque opaque;
826 : : OffsetNumber newitemoff;
827 : :
1306 michael@paquier.xyz 828 : 3667900 : opaque = BTPageGetOpaque(page);
829 : :
830 : : /* Check 1/3 of a page restriction */
231 pg@bowt.ie 831 [ - + ]: 3667900 : if (unlikely(insertstate->itemsz > BTMaxItemSize))
2414 pg@bowt.ie 832 :UBC 0 : _bt_check_third_page(rel, heapRel, itup_key->heapkeyspace, page,
833 : : insertstate->itup);
834 : :
1806 pg@bowt.ie 835 [ + - - + ]:CBC 3667900 : Assert(P_ISLEAF(opaque) && !P_INCOMPLETE_SPLIT(opaque));
2414 836 [ + + - + ]: 3667900 : Assert(!insertstate->bounds_valid || checkingunique);
837 [ + - - + ]: 3667900 : Assert(!itup_key->heapkeyspace || itup_key->scantid != NULL);
838 [ - + - - ]: 3667900 : Assert(itup_key->heapkeyspace || itup_key->scantid == NULL);
2071 839 [ + + - + ]: 3667900 : Assert(!itup_key->allequalimage || itup_key->heapkeyspace);
840 : :
2414 841 [ + - ]: 3667900 : if (itup_key->heapkeyspace)
842 : : {
843 : : /* Keep track of whether checkingunique duplicate seen */
1749 844 : 3667900 : bool uniquedup = indexUnchanged;
845 : :
846 : : /*
847 : : * If we're inserting into a unique index, we may have to walk right
848 : : * through leaf pages to find the one leaf page that we must insert on
849 : : * to.
850 : : *
851 : : * This is needed for checkingunique callers because a scantid was not
852 : : * used when we called _bt_search(). scantid can only be set after
853 : : * _bt_check_unique() has checked for duplicates. The buffer
854 : : * initially stored in insertstate->buf has the page where the first
855 : : * duplicate key might be found, which isn't always the page that new
856 : : * tuple belongs on. The heap TID attribute for new tuple (scantid)
857 : : * could force us to insert on a sibling page, though that should be
858 : : * very rare in practice.
859 : : */
2414 860 [ + + ]: 3667900 : if (checkingunique)
861 : : {
2071 862 [ + + ]: 2647675 : if (insertstate->low < insertstate->stricthigh)
863 : : {
864 : : /* Encountered a duplicate in _bt_check_unique() */
865 [ - + ]: 221183 : Assert(insertstate->bounds_valid);
866 : 221183 : uniquedup = true;
867 : : }
868 : :
869 : : for (;;)
870 : : {
871 : : /*
872 : : * Does the new tuple belong on this page?
873 : : *
874 : : * The earlier _bt_check_unique() call may well have
875 : : * established a strict upper bound on the offset for the new
876 : : * item. If it's not the last item of the page (i.e. if there
877 : : * is at least one tuple on the page that goes after the tuple
878 : : * we're inserting) then we know that the tuple belongs on
879 : : * this page. We can skip the high key check.
880 : : */
2414 881 [ + + ]: 2652697 : if (insertstate->bounds_valid &&
882 [ + - + + ]: 5284566 : insertstate->low <= insertstate->stricthigh &&
883 : 2642283 : insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
884 : 1139235 : break;
885 : :
886 : : /* Test '<=', not '!=', since scantid is set now */
1806 887 [ + + + + ]: 1592614 : if (P_RIGHTMOST(opaque) ||
2414 888 : 79152 : _bt_compare(rel, itup_key, page, P_HIKEY) <= 0)
889 : : break;
890 : :
941 andres@anarazel.de 891 : 5022 : _bt_stepright(rel, heapRel, insertstate, stack);
892 : : /* Update local state after stepping right */
2414 pg@bowt.ie 893 : 5022 : page = BufferGetPage(insertstate->buf);
1306 michael@paquier.xyz 894 : 5022 : opaque = BTPageGetOpaque(page);
895 : : /* Assume duplicates (if checkingunique) */
2071 pg@bowt.ie 896 : 5022 : uniquedup = true;
897 : : }
898 : : }
899 : :
900 : : /*
901 : : * If the target page cannot fit newitem, try to avoid splitting the
902 : : * page on insert by performing deletion or deduplication now
903 : : */
904 [ + + ]: 3667900 : if (PageGetFreeSpace(page) < insertstate->itemsz)
1806 905 : 25244 : _bt_delete_or_dedup_one_page(rel, heapRel, insertstate, false,
906 : : checkingunique, uniquedup,
907 : : indexUnchanged);
908 : : }
909 : : else
910 : : {
911 : : /*----------
912 : : * This is a !heapkeyspace (version 2 or 3) index. The current page
913 : : * is the first page that we could insert the new tuple to, but there
914 : : * may be other pages to the right that we could opt to use instead.
915 : : *
916 : : * If the new key is equal to one or more existing keys, we can
917 : : * legitimately place it anywhere in the series of equal keys. In
918 : : * fact, if the new key is equal to the page's "high key" we can place
919 : : * it on the next page. If it is equal to the high key, and there's
920 : : * not room to insert the new tuple on the current page without
921 : : * splitting, then we move right hoping to find more free space and
922 : : * avoid a split.
923 : : *
924 : : * Keep scanning right until we
925 : : * (a) find a page with enough free space,
926 : : * (b) reach the last page where the tuple can legally go, or
927 : : * (c) get tired of searching.
928 : : * (c) is not flippant; it is important because if there are many
929 : : * pages' worth of equal keys, it's better to split one of the early
930 : : * pages than to scan all the way to the end of the run of equal keys
931 : : * on every insert. We implement "get tired" as a random choice,
932 : : * since stopping after scanning a fixed number of pages wouldn't work
933 : : * well (we'd never reach the right-hand side of previously split
934 : : * pages). The probability of moving right is set at 0.99, which may
935 : : * seem too high to change the behavior much, but it does an excellent
936 : : * job of preventing O(N^2) behavior with many equal keys.
937 : : *----------
938 : : */
2414 pg@bowt.ie 939 [ # # ]:UBC 0 : while (PageGetFreeSpace(page) < insertstate->itemsz)
940 : : {
941 : : /*
942 : : * Before considering moving right, see if we can obtain enough
943 : : * space by erasing LP_DEAD items
944 : : */
1806 945 [ # # ]: 0 : if (P_HAS_GARBAGE(opaque))
946 : : {
947 : : /* Perform simple deletion */
948 : 0 : _bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
949 : : false, false, false);
950 : :
2414 951 [ # # ]: 0 : if (PageGetFreeSpace(page) >= insertstate->itemsz)
952 : 0 : break; /* OK, now we have enough space */
953 : : }
954 : :
955 : : /*
956 : : * Nope, so check conditions (b) and (c) enumerated above
957 : : *
958 : : * The earlier _bt_check_unique() call may well have established a
959 : : * strict upper bound on the offset for the new item. If it's not
960 : : * the last item of the page (i.e. if there is at least one tuple
961 : : * on the page that's greater than the tuple we're inserting to)
962 : : * then we know that the tuple belongs on this page. We can skip
963 : : * the high key check.
964 : : */
965 [ # # ]: 0 : if (insertstate->bounds_valid &&
966 [ # # # # ]: 0 : insertstate->low <= insertstate->stricthigh &&
967 : 0 : insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
968 : 0 : break;
969 : :
1806 970 [ # # # # ]: 0 : if (P_RIGHTMOST(opaque) ||
2414 971 [ # # ]: 0 : _bt_compare(rel, itup_key, page, P_HIKEY) != 0 ||
1430 tgl@sss.pgh.pa.us 972 : 0 : pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 100))
973 : : break;
974 : :
941 andres@anarazel.de 975 : 0 : _bt_stepright(rel, heapRel, insertstate, stack);
976 : : /* Update local state after stepping right */
2414 pg@bowt.ie 977 : 0 : page = BufferGetPage(insertstate->buf);
1306 michael@paquier.xyz 978 : 0 : opaque = BTPageGetOpaque(page);
979 : : }
980 : : }
981 : :
982 : : /*
983 : : * We should now be on the correct page. Find the offset within the page
984 : : * for the new tuple. (Possibly reusing earlier search bounds.)
985 : : */
1806 pg@bowt.ie 986 [ + + - + ]:CBC 3667900 : Assert(P_RIGHTMOST(opaque) ||
987 : : _bt_compare(rel, itup_key, page, P_HIKEY) <= 0);
988 : :
2071 989 : 3667900 : newitemoff = _bt_binsrch_insert(rel, insertstate);
990 : :
991 [ + + ]: 3667900 : if (insertstate->postingoff == -1)
992 : : {
993 : : /*
994 : : * There is an overlapping posting list tuple with its LP_DEAD bit
995 : : * set. We don't want to unnecessarily unset its LP_DEAD bit while
996 : : * performing a posting list split, so perform simple index tuple
997 : : * deletion early.
998 : : */
1806 999 : 3 : _bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
1000 : : false, false, false);
1001 : :
1002 : : /*
1003 : : * Do new binary search. New insert location cannot overlap with any
1004 : : * posting list now.
1005 : : */
1006 [ - + ]: 3 : Assert(!insertstate->bounds_valid);
2071 1007 : 3 : insertstate->postingoff = 0;
1008 : 3 : newitemoff = _bt_binsrch_insert(rel, insertstate);
1009 [ - + ]: 3 : Assert(insertstate->postingoff == 0);
1010 : : }
1011 : :
1012 : 3667900 : return newitemoff;
1013 : : }
1014 : :
1015 : : /*
1016 : : * Step right to next non-dead page, during insertion.
1017 : : *
1018 : : * This is a bit more complicated than moving right in a search. We must
1019 : : * write-lock the target page before releasing write lock on current page;
1020 : : * else someone else's _bt_check_unique scan could fail to see our insertion.
1021 : : * Write locks on intermediate dead pages won't do because we don't know when
1022 : : * they will get de-linked from the tree.
1023 : : *
1024 : : * This is more aggressive than it needs to be for non-unique !heapkeyspace
1025 : : * indexes.
1026 : : */
1027 : : static void
871 1028 : 5022 : _bt_stepright(Relation rel, Relation heaprel, BTInsertState insertstate,
1029 : : BTStack stack)
1030 : : {
1031 : : Page page;
1032 : : BTPageOpaque opaque;
1033 : : Buffer rbuf;
1034 : : BlockNumber rblkno;
1035 : :
1036 [ - + ]: 5022 : Assert(heaprel != NULL);
2414 1037 : 5022 : page = BufferGetPage(insertstate->buf);
1306 michael@paquier.xyz 1038 : 5022 : opaque = BTPageGetOpaque(page);
1039 : :
2414 pg@bowt.ie 1040 : 5022 : rbuf = InvalidBuffer;
1806 1041 : 5022 : rblkno = opaque->btpo_next;
1042 : : for (;;)
1043 : : {
2414 1044 : 5022 : rbuf = _bt_relandgetbuf(rel, rbuf, rblkno, BT_WRITE);
1045 : 5022 : page = BufferGetPage(rbuf);
1306 michael@paquier.xyz 1046 : 5022 : opaque = BTPageGetOpaque(page);
1047 : :
1048 : : /*
1049 : : * If this page was incompletely split, finish the split now. We do
1050 : : * this while holding a lock on the left sibling, which is not good
1051 : : * because finishing the split could be a fairly lengthy operation.
1052 : : * But this should happen very seldom.
1053 : : */
1806 pg@bowt.ie 1054 [ - + ]: 5022 : if (P_INCOMPLETE_SPLIT(opaque))
1055 : : {
941 andres@anarazel.de 1056 :UBC 0 : _bt_finish_split(rel, heaprel, rbuf, stack);
2414 pg@bowt.ie 1057 : 0 : rbuf = InvalidBuffer;
1058 : 0 : continue;
1059 : : }
1060 : :
1806 pg@bowt.ie 1061 [ + - ]:CBC 5022 : if (!P_IGNORE(opaque))
2414 1062 : 5022 : break;
1806 pg@bowt.ie 1063 [ # # ]:UBC 0 : if (P_RIGHTMOST(opaque))
2414 1064 [ # # ]: 0 : elog(ERROR, "fell off the end of index \"%s\"",
1065 : : RelationGetRelationName(rel));
1066 : :
1806 1067 : 0 : rblkno = opaque->btpo_next;
1068 : : }
1069 : : /* rbuf locked; unlock buf, update state for caller */
2414 pg@bowt.ie 1070 :CBC 5022 : _bt_relbuf(rel, insertstate->buf);
1071 : 5022 : insertstate->buf = rbuf;
1072 : 5022 : insertstate->bounds_valid = false;
6814 bruce@momjian.us 1073 : 5022 : }
1074 : :
1075 : : /*----------
1076 : : * _bt_insertonpg() -- Insert a tuple on a particular page in the index.
1077 : : *
1078 : : * This recursive procedure does the following things:
1079 : : *
1080 : : * + if postingoff != 0, splits existing posting list tuple
1081 : : * (since it overlaps with new 'itup' tuple).
1082 : : * + if necessary, splits the target page, using 'itup_key' for
1083 : : * suffix truncation on leaf pages (caller passes NULL for
1084 : : * non-leaf pages).
1085 : : * + inserts the new tuple (might be split from posting list).
1086 : : * + if the page was split, pops the parent stack, and finds the
1087 : : * right place to insert the new child pointer (by walking
1088 : : * right using information stored in the parent stack).
1089 : : * + invokes itself with the appropriate tuple for the right
1090 : : * child page on the parent.
1091 : : * + updates the metapage if a true root or fast root is split.
1092 : : *
1093 : : * On entry, we must have the correct buffer in which to do the
1094 : : * insertion, and the buffer must be pinned and write-locked. On return,
1095 : : * we will have dropped both the pin and the lock on the buffer.
1096 : : *
1097 : : * This routine only performs retail tuple insertions. 'itup' should
1098 : : * always be either a non-highkey leaf item, or a downlink (new high
1099 : : * key items are created indirectly, when a page is split). When
1100 : : * inserting to a non-leaf page, 'cbuf' is the left-sibling of the page
1101 : : * we're inserting the downlink for. This function will clear the
1102 : : * INCOMPLETE_SPLIT flag on it, and release the buffer.
1103 : : *----------
1104 : : */
1105 : : static void
1106 : 3678696 : _bt_insertonpg(Relation rel,
1107 : : Relation heaprel,
1108 : : BTScanInsert itup_key,
1109 : : Buffer buf,
1110 : : Buffer cbuf,
1111 : : BTStack stack,
1112 : : IndexTuple itup,
1113 : : Size itemsz,
1114 : : OffsetNumber newitemoff,
1115 : : int postingoff,
1116 : : bool split_only_page)
1117 : : {
1118 : : Page page;
1119 : : BTPageOpaque opaque;
1120 : : bool isleaf,
1121 : : isroot,
1122 : : isrightmost,
1123 : : isonly;
2071 pg@bowt.ie 1124 : 3678696 : IndexTuple oposting = NULL;
1125 : 3678696 : IndexTuple origitup = NULL;
1126 : 3678696 : IndexTuple nposting = NULL;
1127 : :
3478 kgrittn@postgresql.o 1128 : 3678696 : page = BufferGetPage(buf);
1306 michael@paquier.xyz 1129 : 3678696 : opaque = BTPageGetOpaque(page);
1806 pg@bowt.ie 1130 : 3678696 : isleaf = P_ISLEAF(opaque);
1131 : 3678696 : isroot = P_ISROOT(opaque);
1132 : 3678696 : isrightmost = P_RIGHTMOST(opaque);
1133 [ + + + + ]: 3678696 : isonly = P_LEFTMOST(opaque) && P_RIGHTMOST(opaque);
1134 : :
1135 : : /* child buffer must be given iff inserting on an internal page */
1136 [ - + ]: 3678696 : Assert(isleaf == !BufferIsValid(cbuf));
1137 : : /* tuple must have appropriate number of attributes */
1138 [ + + - + : 3678696 : Assert(!isleaf ||
- - ]
1139 : : BTreeTupleGetNAtts(itup, rel) ==
1140 : : IndexRelationGetNumberOfAttributes(rel));
1141 [ + + + - : 3678696 : Assert(isleaf ||
- + ]
1142 : : BTreeTupleGetNAtts(itup, rel) <=
1143 : : IndexRelationGetNumberOfKeyAttributes(rel));
2071 1144 [ - + ]: 3678696 : Assert(!BTreeTupleIsPosting(itup));
2052 1145 [ - + ]: 3678696 : Assert(MAXALIGN(IndexTupleSize(itup)) == itemsz);
1146 : : /* Caller must always finish incomplete split for us */
1806 1147 [ - + ]: 3678696 : Assert(!P_INCOMPLETE_SPLIT(opaque));
1148 : :
1149 : : /*
1150 : : * Every internal page should have exactly one negative infinity item at
1151 : : * all times. Only _bt_split() and _bt_newlevel() should add items that
1152 : : * become negative infinity items through truncation, since they're the
1153 : : * only routines that allocate new internal pages.
1154 : : */
1155 [ + + + + : 3678696 : Assert(isleaf || newitemoff > P_FIRSTDATAKEY(opaque));
- + ]
1156 : :
1157 : : /*
1158 : : * Do we need to split an existing posting list item?
1159 : : */
2071 1160 [ + + ]: 3678696 : if (postingoff != 0)
1161 : : {
1162 : 14065 : ItemId itemid = PageGetItemId(page, newitemoff);
1163 : :
1164 : : /*
1165 : : * The new tuple is a duplicate with a heap TID that falls inside the
1166 : : * range of an existing posting list tuple on a leaf page. Prepare to
1167 : : * split an existing posting list. Overwriting the posting list with
1168 : : * its post-split version is treated as an extra step in either the
1169 : : * insert or page split critical section.
1170 : : */
1462 1171 [ + - + - : 14065 : Assert(isleaf && itup_key->heapkeyspace && itup_key->allequalimage);
- + ]
2071 1172 : 14065 : oposting = (IndexTuple) PageGetItem(page, itemid);
1173 : :
1174 : : /*
1175 : : * postingoff value comes from earlier call to _bt_binsrch_posting().
1176 : : * Its binary search might think that a plain tuple must be a posting
1177 : : * list tuple that needs to be split. This can happen with corruption
1178 : : * involving an existing plain tuple that is a duplicate of the new
1179 : : * item, up to and including its table TID. Check for that here in
1180 : : * passing.
1181 : : *
1182 : : * Also verify that our caller has made sure that the existing posting
1183 : : * list tuple does not have its LP_DEAD bit set.
1184 : : */
1462 1185 [ + - - + ]: 14065 : if (!BTreeTupleIsPosting(oposting) || ItemIdIsDead(itemid))
1462 pg@bowt.ie 1186 [ # # ]:UBC 0 : ereport(ERROR,
1187 : : (errcode(ERRCODE_INDEX_CORRUPTED),
1188 : : errmsg_internal("table tid from new index tuple (%u,%u) overlaps with invalid duplicate tuple at offset %u of block %u in index \"%s\"",
1189 : : ItemPointerGetBlockNumber(&itup->t_tid),
1190 : : ItemPointerGetOffsetNumber(&itup->t_tid),
1191 : : newitemoff, BufferGetBlockNumber(buf),
1192 : : RelationGetRelationName(rel))));
1193 : :
1194 : : /* use a mutable copy of itup as our itup from here on */
2071 pg@bowt.ie 1195 :CBC 14065 : origitup = itup;
1196 : 14065 : itup = CopyIndexTuple(origitup);
1197 : 14065 : nposting = _bt_swap_posting(itup, oposting, postingoff);
1198 : : /* itup now contains rightmost/max TID from oposting */
1199 : :
1200 : : /* Alter offset so that newitem goes after posting list */
1201 : 14065 : newitemoff = OffsetNumberNext(newitemoff);
1202 : : }
1203 : :
1204 : : /*
1205 : : * Do we need to split the page to fit the item on it?
1206 : : *
1207 : : * Note: PageGetFreeSpace() subtracts sizeof(ItemIdData) from its result,
1208 : : * so this comparison is correct even though we appear to be accounting
1209 : : * only for the item and not for its line pointer.
1210 : : */
9230 tgl@sss.pgh.pa.us 1211 [ + + ]: 3678696 : if (PageGetFreeSpace(page) < itemsz)
1212 : : {
1213 : : Buffer rbuf;
1214 : :
2024 pg@bowt.ie 1215 [ - + ]: 11471 : Assert(!split_only_page);
1216 : :
1217 : : /* split the buffer into left and right halves */
941 andres@anarazel.de 1218 : 11471 : rbuf = _bt_split(rel, heaprel, itup_key, buf, cbuf, newitemoff, itemsz,
1219 : : itup, origitup, nposting, postingoff);
5377 heikki.linnakangas@i 1220 : 11471 : PredicateLockPageSplit(rel,
1221 : : BufferGetBlockNumber(buf),
1222 : : BufferGetBlockNumber(rbuf));
1223 : :
1224 : : /*----------
1225 : : * By here,
1226 : : *
1227 : : * + our target page has been split;
1228 : : * + the original tuple has been inserted;
1229 : : * + we have write locks on both the old (left half)
1230 : : * and new (right half) buffers, after the split; and
1231 : : * + we know the key we want to insert into the parent
1232 : : * (it's the "high key" on the left child page).
1233 : : *
1234 : : * We're ready to do the parent insertion. We need to hold onto the
1235 : : * locks for the child pages until we locate the parent, but we can
1236 : : * at least release the lock on the right child before doing the
1237 : : * actual insertion. The lock on the left child will be released
1238 : : * last of all by parent insertion, where it is the 'cbuf' of parent
1239 : : * page.
1240 : : *----------
1241 : : */
941 andres@anarazel.de 1242 : 11471 : _bt_insert_parent(rel, heaprel, buf, rbuf, stack, isroot, isonly);
1243 : : }
1244 : : else
1245 : : {
8285 tgl@sss.pgh.pa.us 1246 : 3667225 : Buffer metabuf = InvalidBuffer;
1247 : 3667225 : Page metapg = NULL;
1248 : 3667225 : BTMetaPageData *metad = NULL;
1249 : : BlockNumber blockcache;
1250 : :
1251 : : /*
1252 : : * If we are doing this insert because we split a page that was the
1253 : : * only one on its tree level, but was not the root, it may have been
1254 : : * the "fast root". We need to ensure that the fast root link points
1255 : : * at or above the current page. We can safely acquire a lock on the
1256 : : * metapage here --- see comments for _bt_newlevel().
1257 : : */
1806 pg@bowt.ie 1258 [ + + ]: 3667225 : if (unlikely(split_only_page))
1259 : : {
2050 1260 [ - + ]: 12 : Assert(!isleaf);
1261 [ - + ]: 12 : Assert(BufferIsValid(cbuf));
1262 : :
871 1263 : 12 : metabuf = _bt_getbuf(rel, BTREE_METAPAGE, BT_WRITE);
3478 kgrittn@postgresql.o 1264 : 12 : metapg = BufferGetPage(metabuf);
8285 tgl@sss.pgh.pa.us 1265 : 12 : metad = BTPageGetMeta(metapg);
1266 : :
1707 pg@bowt.ie 1267 [ - + ]: 12 : if (metad->btm_fastlevel >= opaque->btpo_level)
1268 : : {
1269 : : /* no update wanted */
8285 tgl@sss.pgh.pa.us 1270 :UBC 0 : _bt_relbuf(rel, metabuf);
1271 : 0 : metabuf = InvalidBuffer;
1272 : : }
1273 : : }
1274 : :
1275 : : /* Do the update. No ereport(ERROR) until changes are logged */
8285 tgl@sss.pgh.pa.us 1276 :CBC 3667225 : START_CRIT_SECTION();
1277 : :
2071 pg@bowt.ie 1278 [ + + ]: 3667225 : if (postingoff != 0)
1279 : 14039 : memcpy(oposting, nposting, MAXALIGN(IndexTupleSize(nposting)));
1280 : :
1 peter@eisentraut.org 1281 [ - + ]:GNC 3667225 : if (PageAddItem(page, itup, itemsz, newitemoff, false, false) == InvalidOffsetNumber)
5539 tgl@sss.pgh.pa.us 1282 [ # # ]:UBC 0 : elog(PANIC, "failed to add new item to block %u in index \"%s\"",
1283 : : BufferGetBlockNumber(buf), RelationGetRelationName(rel));
1284 : :
7151 tgl@sss.pgh.pa.us 1285 :CBC 3667225 : MarkBufferDirty(buf);
1286 : :
8285 1287 [ + + ]: 3667225 : if (BufferIsValid(metabuf))
1288 : : {
1289 : : /* upgrade meta-page if needed */
2414 pg@bowt.ie 1290 [ - + ]: 12 : if (metad->btm_version < BTREE_NOVAC_VERSION)
2764 teodor@sigaev.ru 1291 :UBC 0 : _bt_upgrademetapage(metapg);
2051 pg@bowt.ie 1292 :CBC 12 : metad->btm_fastroot = BufferGetBlockNumber(buf);
1707 1293 : 12 : metad->btm_fastlevel = opaque->btpo_level;
7151 tgl@sss.pgh.pa.us 1294 : 12 : MarkBufferDirty(metabuf);
1295 : : }
1296 : :
1297 : : /*
1298 : : * Clear INCOMPLETE_SPLIT flag on child if inserting the new item
1299 : : * finishes a split
1300 : : */
2024 pg@bowt.ie 1301 [ + + ]: 3667225 : if (!isleaf)
1302 : : {
3478 kgrittn@postgresql.o 1303 : 10667 : Page cpage = BufferGetPage(cbuf);
1306 michael@paquier.xyz 1304 : 10667 : BTPageOpaque cpageop = BTPageGetOpaque(cpage);
1305 : :
4242 heikki.linnakangas@i 1306 [ - + ]: 10667 : Assert(P_INCOMPLETE_SPLIT(cpageop));
1307 : 10667 : cpageop->btpo_flags &= ~BTP_INCOMPLETE_SPLIT;
1308 : 10667 : MarkBufferDirty(cbuf);
1309 : : }
1310 : :
1311 : : /* XLOG stuff */
5433 rhaas@postgresql.org 1312 [ + + + + : 3667225 : if (RelationNeedsWAL(rel))
+ + + + ]
1313 : : {
1314 : : xl_btree_insert xlrec;
1315 : : xl_btree_metadata xlmeta;
1316 : : uint8 xlinfo;
1317 : : XLogRecPtr recptr;
1318 : : uint16 upostingoff;
1319 : :
2051 pg@bowt.ie 1320 : 3314211 : xlrec.offnum = newitemoff;
1321 : :
3995 heikki.linnakangas@i 1322 : 3314211 : XLogBeginInsert();
259 peter@eisentraut.org 1323 : 3314211 : XLogRegisterData(&xlrec, SizeOfBtreeInsert);
1324 : :
2050 pg@bowt.ie 1325 [ + + + + ]: 3314211 : if (isleaf && postingoff == 0)
1326 : : {
1327 : : /* Simple leaf insert */
7138 tgl@sss.pgh.pa.us 1328 : 3290404 : xlinfo = XLOG_BTREE_INSERT_LEAF;
1329 : : }
2071 pg@bowt.ie 1330 [ + + ]: 23807 : else if (postingoff != 0)
1331 : : {
1332 : : /*
1333 : : * Leaf insert with posting list split. Must include
1334 : : * postingoff field before newitem/orignewitem.
1335 : : */
2023 1336 [ - + ]: 14039 : Assert(isleaf);
2071 1337 : 14039 : xlinfo = XLOG_BTREE_INSERT_POST;
1338 : : }
1339 : : else
1340 : : {
1341 : : /* Internal page insert, which finishes a split on cbuf */
7138 tgl@sss.pgh.pa.us 1342 : 9768 : xlinfo = XLOG_BTREE_INSERT_UPPER;
2024 pg@bowt.ie 1343 : 9768 : XLogRegisterBuffer(1, cbuf, REGBUF_STANDARD);
1344 : :
2023 1345 [ + + ]: 9768 : if (BufferIsValid(metabuf))
1346 : : {
1347 : : /* Actually, it's an internal page insert + meta update */
1348 : 12 : xlinfo = XLOG_BTREE_INSERT_META;
1349 : :
1350 [ - + ]: 12 : Assert(metad->btm_version >= BTREE_NOVAC_VERSION);
1351 : 12 : xlmeta.version = metad->btm_version;
1352 : 12 : xlmeta.root = metad->btm_root;
1353 : 12 : xlmeta.level = metad->btm_level;
1354 : 12 : xlmeta.fastroot = metad->btm_fastroot;
1355 : 12 : xlmeta.fastlevel = metad->btm_fastlevel;
1707 1356 : 12 : xlmeta.last_cleanup_num_delpages = metad->btm_last_cleanup_num_delpages;
2023 1357 : 12 : xlmeta.allequalimage = metad->btm_allequalimage;
1358 : :
1359 : 12 : XLogRegisterBuffer(2, metabuf,
1360 : : REGBUF_WILL_INIT | REGBUF_STANDARD);
259 peter@eisentraut.org 1361 : 12 : XLogRegisterBufData(2, &xlmeta,
1362 : : sizeof(xl_btree_metadata));
1363 : : }
1364 : : }
1365 : :
3995 heikki.linnakangas@i 1366 : 3314211 : XLogRegisterBuffer(0, buf, REGBUF_STANDARD);
2071 pg@bowt.ie 1367 [ + + ]: 3314211 : if (postingoff == 0)
1368 : : {
1369 : : /* Just log itup from caller */
259 peter@eisentraut.org 1370 : 3300172 : XLogRegisterBufData(0, itup, IndexTupleSize(itup));
1371 : : }
1372 : : else
1373 : : {
1374 : : /*
1375 : : * Insert with posting list split (XLOG_BTREE_INSERT_POST
1376 : : * record) case.
1377 : : *
1378 : : * Log postingoff. Also log origitup, not itup. REDO routine
1379 : : * must reconstruct final itup (as well as nposting) using
1380 : : * _bt_swap_posting().
1381 : : */
2007 pg@bowt.ie 1382 : 14039 : upostingoff = postingoff;
1383 : :
259 peter@eisentraut.org 1384 : 14039 : XLogRegisterBufData(0, &upostingoff, sizeof(uint16));
1385 : 14039 : XLogRegisterBufData(0, origitup,
2071 pg@bowt.ie 1386 : 14039 : IndexTupleSize(origitup));
1387 : : }
1388 : :
3995 heikki.linnakangas@i 1389 : 3314211 : recptr = XLogInsert(RM_BTREE_ID, xlinfo);
1390 : :
8285 tgl@sss.pgh.pa.us 1391 [ + + ]: 3314211 : if (BufferIsValid(metabuf))
1392 : 12 : PageSetLSN(metapg, recptr);
2024 pg@bowt.ie 1393 [ + + ]: 3314211 : if (!isleaf)
3478 kgrittn@postgresql.o 1394 : 9768 : PageSetLSN(BufferGetPage(cbuf), recptr);
1395 : :
8285 tgl@sss.pgh.pa.us 1396 : 3314211 : PageSetLSN(page, recptr);
1397 : : }
1398 : :
1399 [ - + ]: 3667225 : END_CRIT_SECTION();
1400 : :
1401 : : /* Release subsidiary buffers */
1402 [ + + ]: 3667225 : if (BufferIsValid(metabuf))
7151 1403 : 12 : _bt_relbuf(rel, metabuf);
2024 pg@bowt.ie 1404 [ + + ]: 3667225 : if (!isleaf)
4242 heikki.linnakangas@i 1405 : 10667 : _bt_relbuf(rel, cbuf);
1406 : :
1407 : : /*
1408 : : * Cache the block number if this is the rightmost leaf page. Cache
1409 : : * may be used by a future inserter within _bt_search_insert().
1410 : : */
2050 pg@bowt.ie 1411 : 3667225 : blockcache = InvalidBlockNumber;
1806 1412 [ + + + + : 3667225 : if (isrightmost && isleaf && !isroot)
+ + ]
2050 1413 : 2041810 : blockcache = BufferGetBlockNumber(buf);
1414 : :
1415 : : /* Release buffer for insertion target block */
7151 tgl@sss.pgh.pa.us 1416 : 3667225 : _bt_relbuf(rel, buf);
1417 : :
1418 : : /*
1419 : : * If we decided to cache the insertion target block before releasing
1420 : : * its buffer lock, then cache it now. Check the height of the tree
1421 : : * first, though. We don't go for the optimization with small
1422 : : * indexes. Defer final check to this point to ensure that we don't
1423 : : * call _bt_getrootheight while holding a buffer lock.
1424 : : */
2050 pg@bowt.ie 1425 [ + + + + ]: 5709035 : if (BlockNumberIsValid(blockcache) &&
871 1426 : 2041810 : _bt_getrootheight(rel) >= BTREE_FASTPATH_MIN_LEVEL)
2050 1427 : 36904 : RelationSetTargetBlock(rel, blockcache);
1428 : : }
1429 : :
1430 : : /* be tidy */
2071 1431 [ + + ]: 3678696 : if (postingoff != 0)
1432 : : {
1433 : : /* itup is actually a modified copy of caller's original */
1434 : 14065 : pfree(nposting);
1435 : 14065 : pfree(itup);
1436 : : }
10703 scrappy@hub.org 1437 : 3678696 : }
1438 : :
1439 : : /*
1440 : : * _bt_split() -- split a page in the btree.
1441 : : *
1442 : : * On entry, buf is the page to split, and is pinned and write-locked.
1443 : : * newitemoff etc. tell us about the new item that must be inserted
1444 : : * along with the data from the original page.
1445 : : *
1446 : : * itup_key is used for suffix truncation on leaf pages (internal
1447 : : * page callers pass NULL). When splitting a non-leaf page, 'cbuf'
1448 : : * is the left-sibling of the page we're inserting the downlink for.
1449 : : * This function will clear the INCOMPLETE_SPLIT flag on it, and
1450 : : * release the buffer.
1451 : : *
1452 : : * orignewitem, nposting, and postingoff are needed when an insert of
1453 : : * orignewitem results in both a posting list split and a page split.
1454 : : * These extra posting list split details are used here in the same
1455 : : * way as they are used in the more common case where a posting list
1456 : : * split does not coincide with a page split. We need to deal with
1457 : : * posting list splits directly in order to ensure that everything
1458 : : * that follows from the insert of orignewitem is handled as a single
1459 : : * atomic operation (though caller's insert of a new pivot/downlink
1460 : : * into parent page will still be a separate operation). See
1461 : : * nbtree/README for details on the design of posting list splits.
1462 : : *
1463 : : * Returns the new right sibling of buf, pinned and write-locked.
1464 : : * The pin and lock on buf are maintained.
1465 : : */
1466 : : static Buffer
941 andres@anarazel.de 1467 : 11471 : _bt_split(Relation rel, Relation heaprel, BTScanInsert itup_key, Buffer buf,
1468 : : Buffer cbuf, OffsetNumber newitemoff, Size newitemsz, IndexTuple newitem,
1469 : : IndexTuple orignewitem, IndexTuple nposting, uint16 postingoff)
1470 : : {
1471 : : Buffer rbuf;
1472 : : Page origpage;
1473 : : Page leftpage,
1474 : : rightpage;
1475 : : PGAlignedBlock leftpage_buf,
1476 : : rightpage_buf;
1477 : : BlockNumber origpagenumber,
1478 : : rightpagenumber;
1479 : : BTPageOpaque ropaque,
1480 : : lopaque,
1481 : : oopaque;
8284 tgl@sss.pgh.pa.us 1482 : 11471 : Buffer sbuf = InvalidBuffer;
1483 : 11471 : Page spage = NULL;
1484 : 11471 : BTPageOpaque sopaque = NULL;
1485 : : Size itemsz;
1486 : : ItemId itemid;
1487 : : IndexTuple firstright,
1488 : : lefthighkey;
1489 : : OffsetNumber firstrightoff;
1490 : : OffsetNumber afterleftoff,
1491 : : afterrightoff,
1492 : : minusinfoff;
1493 : : OffsetNumber origpagepostingoff;
1494 : : OffsetNumber maxoff;
1495 : : OffsetNumber i;
1496 : : bool newitemonleft,
1497 : : isleaf,
1498 : : isrightmost;
1499 : :
1500 : : /*
1501 : : * origpage is the original page to be split. leftpage is a temporary
1502 : : * buffer that receives the left-sibling data, which will be copied back
1503 : : * into origpage on success. rightpage is the new page that will receive
1504 : : * the right-sibling data.
1505 : : *
1506 : : * leftpage is allocated after choosing a split point. rightpage's new
1507 : : * buffer isn't acquired until after leftpage is initialized and has new
1508 : : * high key, the last point where splitting the page may fail (barring
1509 : : * corruption). Failing before acquiring new buffer won't have lasting
1510 : : * consequences, since origpage won't have been modified and leftpage is
1511 : : * only workspace.
1512 : : */
3478 kgrittn@postgresql.o 1513 : 11471 : origpage = BufferGetPage(buf);
1306 michael@paquier.xyz 1514 : 11471 : oopaque = BTPageGetOpaque(origpage);
2024 pg@bowt.ie 1515 : 11471 : isleaf = P_ISLEAF(oopaque);
1516 : 11471 : isrightmost = P_RIGHTMOST(oopaque);
1517 : 11471 : maxoff = PageGetMaxOffsetNumber(origpage);
5539 tgl@sss.pgh.pa.us 1518 : 11471 : origpagenumber = BufferGetBlockNumber(buf);
1519 : :
1520 : : /*
1521 : : * Choose a point to split origpage at.
1522 : : *
1523 : : * A split point can be thought of as a point _between_ two existing data
1524 : : * items on origpage (the lastleft and firstright tuples), provided you
1525 : : * pretend that the new item that didn't fit is already on origpage.
1526 : : *
1527 : : * Since origpage does not actually contain newitem, the representation of
1528 : : * split points needs to work with two boundary cases: splits where
1529 : : * newitem is lastleft, and splits where newitem is firstright.
1530 : : * newitemonleft resolves the ambiguity that would otherwise exist when
1531 : : * newitemoff == firstrightoff. In all other cases it's clear which side
1532 : : * of the split every tuple goes on from context. newitemonleft is
1533 : : * usually (but not always) redundant information.
1534 : : *
1535 : : * firstrightoff is supposed to be an origpage offset number, but it's
1536 : : * possible that its value will be maxoff+1, which is "past the end" of
1537 : : * origpage. This happens in the rare case where newitem goes after all
1538 : : * existing items (i.e. newitemoff is maxoff+1) and we end up splitting
1539 : : * origpage at the point that leaves newitem alone on new right page. Any
1540 : : * "!newitemonleft && newitemoff == firstrightoff" split point makes
1541 : : * newitem the firstright tuple, though, so this case isn't a special
1542 : : * case.
1543 : : */
2024 pg@bowt.ie 1544 : 11471 : firstrightoff = _bt_findsplitloc(rel, origpage, newitemoff, newitemsz,
1545 : : newitem, &newitemonleft);
1546 : :
1547 : : /* Use temporary buffer for leftpage */
32 michael@paquier.xyz 1548 :GNC 11471 : leftpage = leftpage_buf.data;
2360 pg@bowt.ie 1549 :CBC 11471 : _bt_pageinit(leftpage, BufferGetPageSize(buf));
1306 michael@paquier.xyz 1550 : 11471 : lopaque = BTPageGetOpaque(leftpage);
1551 : :
1552 : : /*
1553 : : * leftpage won't be the root when we're done. Also, clear the SPLIT_END
1554 : : * and HAS_GARBAGE flags.
1555 : : */
9155 vadim4o@yahoo.com 1556 : 11471 : lopaque->btpo_flags = oopaque->btpo_flags;
7035 tgl@sss.pgh.pa.us 1557 : 11471 : lopaque->btpo_flags &= ~(BTP_ROOT | BTP_SPLIT_END | BTP_HAS_GARBAGE);
1558 : : /* set flag in leftpage indicating that rightpage has no downlink yet */
4242 heikki.linnakangas@i 1559 : 11471 : lopaque->btpo_flags |= BTP_INCOMPLETE_SPLIT;
10278 bruce@momjian.us 1560 : 11471 : lopaque->btpo_prev = oopaque->btpo_prev;
1561 : : /* handle btpo_next after rightpage buffer acquired */
1707 pg@bowt.ie 1562 : 11471 : lopaque->btpo_level = oopaque->btpo_level;
1563 : : /* handle btpo_cycleid after rightpage buffer acquired */
1564 : :
1565 : : /*
1566 : : * Copy the original page's LSN into leftpage, which will become the
1567 : : * updated version of the page. We need this because XLogInsert will
1568 : : * examine the LSN and possibly dump it in a page image.
1569 : : */
2360 1570 : 11471 : PageSetLSN(leftpage, PageGetLSN(origpage));
1571 : :
1572 : : /*
1573 : : * Determine page offset number of existing overlapped-with-orignewitem
1574 : : * posting list when it is necessary to perform a posting list split in
1575 : : * passing. Note that newitem was already changed by caller (newitem no
1576 : : * longer has the orignewitem TID).
1577 : : *
1578 : : * This page offset number (origpagepostingoff) will be used to pretend
1579 : : * that the posting split has already taken place, even though the
1580 : : * required modifications to origpage won't occur until we reach the
1581 : : * critical section. The lastleft and firstright tuples of our page split
1582 : : * point should, in effect, come from an imaginary version of origpage
1583 : : * that has the nposting tuple instead of the original posting list tuple.
1584 : : *
1585 : : * Note: _bt_findsplitloc() should have compensated for coinciding posting
1586 : : * list splits in just the same way, at least in theory. It doesn't
1587 : : * bother with that, though. In practice it won't affect its choice of
1588 : : * split point.
1589 : : */
2071 1590 : 11471 : origpagepostingoff = InvalidOffsetNumber;
1591 [ + + ]: 11471 : if (postingoff != 0)
1592 : : {
1593 [ - + ]: 26 : Assert(isleaf);
1594 [ - + ]: 26 : Assert(ItemPointerCompare(&orignewitem->t_tid,
1595 : : &newitem->t_tid) < 0);
1596 [ - + ]: 26 : Assert(BTreeTupleIsPosting(nposting));
1597 : 26 : origpagepostingoff = OffsetNumberPrev(newitemoff);
1598 : : }
1599 : :
1600 : : /*
1601 : : * The high key for the new left page is a possibly-truncated copy of
1602 : : * firstright on the leaf level (it's "firstright itself" on internal
1603 : : * pages; see !isleaf comments below). This may seem to be contrary to
1604 : : * Lehman & Yao's approach of using a copy of lastleft as the new high key
1605 : : * when splitting on the leaf level. It isn't, though.
1606 : : *
1607 : : * Suffix truncation will leave the left page's high key fully equal to
1608 : : * lastleft when lastleft and firstright are equal prior to heap TID (that
1609 : : * is, the tiebreaker TID value comes from lastleft). It isn't actually
1610 : : * necessary for a new leaf high key to be a copy of lastleft for the L&Y
1611 : : * "subtree" invariant to hold. It's sufficient to make sure that the new
1612 : : * leaf high key is strictly less than firstright, and greater than or
1613 : : * equal to (not necessarily equal to) lastleft. In other words, when
1614 : : * suffix truncation isn't possible during a leaf page split, we take
1615 : : * L&Y's exact approach to generating a new high key for the left page.
1616 : : * (Actually, that is slightly inaccurate. We don't just use a copy of
1617 : : * lastleft. A tuple with all the keys from firstright but the max heap
1618 : : * TID from lastleft is used, to avoid introducing a special case.)
1619 : : */
2024 1620 [ + + + + ]: 11471 : if (!newitemonleft && newitemoff == firstrightoff)
1621 : : {
1622 : : /* incoming tuple becomes firstright */
9230 tgl@sss.pgh.pa.us 1623 : 17 : itemsz = newitemsz;
2024 pg@bowt.ie 1624 : 17 : firstright = newitem;
1625 : : }
1626 : : else
1627 : : {
1628 : : /* existing item at firstrightoff becomes firstright */
1629 : 11454 : itemid = PageGetItemId(origpage, firstrightoff);
9230 tgl@sss.pgh.pa.us 1630 : 11454 : itemsz = ItemIdGetLength(itemid);
2024 pg@bowt.ie 1631 : 11454 : firstright = (IndexTuple) PageGetItem(origpage, itemid);
1632 [ - + ]: 11454 : if (firstrightoff == origpagepostingoff)
2024 pg@bowt.ie 1633 :LBC (2) : firstright = nposting;
1634 : : }
1635 : :
2024 pg@bowt.ie 1636 [ + + ]:CBC 11471 : if (isleaf)
1637 : : {
1638 : : IndexTuple lastleft;
1639 : :
1640 : : /* Attempt suffix truncation for leaf page splits */
1641 [ + + + + ]: 11342 : if (newitemonleft && newitemoff == firstrightoff)
1642 : : {
1643 : : /* incoming tuple becomes lastleft */
2414 1644 : 237 : lastleft = newitem;
1645 : : }
1646 : : else
1647 : : {
1648 : : OffsetNumber lastleftoff;
1649 : :
1650 : : /* existing item before firstrightoff becomes lastleft */
2024 1651 : 11105 : lastleftoff = OffsetNumberPrev(firstrightoff);
2414 1652 [ + + - + ]: 11105 : Assert(lastleftoff >= P_FIRSTDATAKEY(oopaque));
1653 : 11105 : itemid = PageGetItemId(origpage, lastleftoff);
1654 : 11105 : lastleft = (IndexTuple) PageGetItem(origpage, itemid);
2071 1655 [ + + ]: 11105 : if (lastleftoff == origpagepostingoff)
1656 : 2 : lastleft = nposting;
1657 : : }
1658 : :
2024 1659 : 11342 : lefthighkey = _bt_truncate(rel, lastleft, firstright, itup_key);
1660 : 11342 : itemsz = IndexTupleSize(lefthighkey);
1661 : : }
1662 : : else
1663 : : {
1664 : : /*
1665 : : * Don't perform suffix truncation on a copy of firstright to make
1666 : : * left page high key for internal page splits. Must use firstright
1667 : : * as new high key directly.
1668 : : *
1669 : : * Each distinct separator key value originates as a leaf level high
1670 : : * key; all other separator keys/pivot tuples are copied from one
1671 : : * level down. A separator key in a grandparent page must be
1672 : : * identical to high key in rightmost parent page of the subtree to
1673 : : * its left, which must itself be identical to high key in rightmost
1674 : : * child page of that same subtree (this even applies to separator
1675 : : * from grandparent's high key). There must always be an unbroken
1676 : : * "seam" of identical separator keys that guide index scans at every
1677 : : * level, starting from the grandparent. That's why suffix truncation
1678 : : * is unsafe here.
1679 : : *
1680 : : * Internal page splits will truncate firstright into a "negative
1681 : : * infinity" data item when it gets inserted on the new right page
1682 : : * below, though. This happens during the call to _bt_pgaddtup() for
1683 : : * the new first data item for right page. Do not confuse this
1684 : : * mechanism with suffix truncation. It is just a convenient way of
1685 : : * implementing page splits that split the internal page "inside"
1686 : : * firstright. The lefthighkey separator key cannot appear a second
1687 : : * time in the right page (only firstright's downlink goes in right
1688 : : * page).
1689 : : */
1690 : 129 : lefthighkey = firstright;
1691 : : }
1692 : :
1693 : : /*
1694 : : * Add new high key to leftpage
1695 : : */
1696 : 11471 : afterleftoff = P_HIKEY;
1697 : :
1698 [ + - - + ]: 11471 : Assert(BTreeTupleGetNAtts(lefthighkey, rel) > 0);
1699 [ + - - + ]: 11471 : Assert(BTreeTupleGetNAtts(lefthighkey, rel) <=
1700 : : IndexRelationGetNumberOfKeyAttributes(rel));
1701 [ - + ]: 11471 : Assert(itemsz == MAXALIGN(IndexTupleSize(lefthighkey)));
1 peter@eisentraut.org 1702 [ - + ]:GNC 11471 : if (PageAddItem(leftpage, lefthighkey, itemsz, afterleftoff, false, false) == InvalidOffsetNumber)
2024 pg@bowt.ie 1703 [ # # ]:UBC 0 : elog(ERROR, "failed to add high key to the left sibling"
1704 : : " while splitting block %u of index \"%s\"",
1705 : : origpagenumber, RelationGetRelationName(rel));
2024 pg@bowt.ie 1706 :CBC 11471 : afterleftoff = OffsetNumberNext(afterleftoff);
1707 : :
1708 : : /*
1709 : : * Acquire a new right page to split into, now that left page has a new
1710 : : * high key.
1711 : : *
1712 : : * To not confuse future VACUUM operations, we zero the right page and
1713 : : * work on an in-memory copy of it before writing WAL, then copy its
1714 : : * contents back to the actual page once we start the critical section
1715 : : * work. This simplifies the split work, so as there is no need to zero
1716 : : * the right page before throwing an error.
1717 : : */
871 1718 : 11471 : rbuf = _bt_allocbuf(rel, heaprel);
32 michael@paquier.xyz 1719 :GNC 11471 : rightpage = rightpage_buf.data;
1720 : :
1721 : : /*
1722 : : * Copy the contents of the right page into its temporary location, and
1723 : : * zero the original space.
1724 : : */
1725 : 11471 : memcpy(rightpage, BufferGetPage(rbuf), BLCKSZ);
1726 : 11471 : memset(BufferGetPage(rbuf), 0, BLCKSZ);
2360 pg@bowt.ie 1727 :CBC 11471 : rightpagenumber = BufferGetBlockNumber(rbuf);
1728 : : /* rightpage was initialized by _bt_allocbuf */
1306 michael@paquier.xyz 1729 : 11471 : ropaque = BTPageGetOpaque(rightpage);
1730 : :
1731 : : /*
1732 : : * Finish off remaining leftpage special area fields. They cannot be set
1733 : : * before both origpage (leftpage) and rightpage buffers are acquired and
1734 : : * locked.
1735 : : *
1736 : : * btpo_cycleid is only used with leaf pages, though we set it here in all
1737 : : * cases just to be consistent.
1738 : : */
2360 pg@bowt.ie 1739 : 11471 : lopaque->btpo_next = rightpagenumber;
1740 : 11471 : lopaque->btpo_cycleid = _bt_vacuum_cycleid(rel);
1741 : :
1742 : : /*
1743 : : * rightpage won't be the root when we're done. Also, clear the SPLIT_END
1744 : : * and HAS_GARBAGE flags.
1745 : : */
1746 : 11471 : ropaque->btpo_flags = oopaque->btpo_flags;
1747 : 11471 : ropaque->btpo_flags &= ~(BTP_ROOT | BTP_SPLIT_END | BTP_HAS_GARBAGE);
1748 : 11471 : ropaque->btpo_prev = origpagenumber;
1749 : 11471 : ropaque->btpo_next = oopaque->btpo_next;
1707 1750 : 11471 : ropaque->btpo_level = oopaque->btpo_level;
2360 1751 : 11471 : ropaque->btpo_cycleid = lopaque->btpo_cycleid;
1752 : :
1753 : : /*
1754 : : * Add new high key to rightpage where necessary.
1755 : : *
1756 : : * If the page we're splitting is not the rightmost page at its level in
1757 : : * the tree, then the first entry on the page is the high key from
1758 : : * origpage.
1759 : : */
2024 1760 : 11471 : afterrightoff = P_HIKEY;
1761 : :
1762 [ + + ]: 11471 : if (!isrightmost)
1763 : : {
1764 : : IndexTuple righthighkey;
1765 : :
2360 1766 : 5047 : itemid = PageGetItemId(origpage, P_HIKEY);
1767 : 5047 : itemsz = ItemIdGetLength(itemid);
2024 1768 : 5047 : righthighkey = (IndexTuple) PageGetItem(origpage, itemid);
1769 [ + - - + ]: 5047 : Assert(BTreeTupleGetNAtts(righthighkey, rel) > 0);
1770 [ + - - + ]: 5047 : Assert(BTreeTupleGetNAtts(righthighkey, rel) <=
1771 : : IndexRelationGetNumberOfKeyAttributes(rel));
1 peter@eisentraut.org 1772 [ - + ]:GNC 5047 : if (PageAddItem(rightpage, righthighkey, itemsz, afterrightoff, false, false) == InvalidOffsetNumber)
1773 : : {
2024 pg@bowt.ie 1774 [ # # ]:UBC 0 : elog(ERROR, "failed to add high key to the right sibling"
1775 : : " while splitting block %u of index \"%s\"",
1776 : : origpagenumber, RelationGetRelationName(rel));
1777 : : }
2024 pg@bowt.ie 1778 :CBC 5047 : afterrightoff = OffsetNumberNext(afterrightoff);
1779 : : }
1780 : :
1781 : : /*
1782 : : * Internal page splits truncate first data item on right page -- it
1783 : : * becomes "minus infinity" item for the page. Set this up here.
1784 : : */
1785 : 11471 : minusinfoff = InvalidOffsetNumber;
1786 [ + + ]: 11471 : if (!isleaf)
1787 : 129 : minusinfoff = afterrightoff;
1788 : :
1789 : : /*
1790 : : * Now transfer all the data items (non-pivot tuples in isleaf case, or
1791 : : * additional pivot tuples in !isleaf case) to the appropriate page.
1792 : : *
1793 : : * Note: we *must* insert at least the right page's items in item-number
1794 : : * order, for the benefit of _bt_restore_page().
1795 : : */
9230 tgl@sss.pgh.pa.us 1796 [ + + + + ]: 3490255 : for (i = P_FIRSTDATAKEY(oopaque); i <= maxoff; i = OffsetNumberNext(i))
1797 : : {
1798 : : IndexTuple dataitem;
1799 : :
10278 bruce@momjian.us 1800 : 3478784 : itemid = PageGetItemId(origpage, i);
1801 : 3478784 : itemsz = ItemIdGetLength(itemid);
2024 pg@bowt.ie 1802 : 3478784 : dataitem = (IndexTuple) PageGetItem(origpage, itemid);
1803 : :
1804 : : /* replace original item with nposting due to posting split? */
2071 1805 [ + + ]: 3478784 : if (i == origpagepostingoff)
1806 : : {
2024 1807 [ - + ]: 26 : Assert(BTreeTupleIsPosting(dataitem));
2071 1808 [ - + ]: 26 : Assert(itemsz == MAXALIGN(IndexTupleSize(nposting)));
2024 1809 : 26 : dataitem = nposting;
1810 : : }
1811 : :
1812 : : /* does new item belong before this one? */
2071 1813 [ + + ]: 3478758 : else if (i == newitemoff)
1814 : : {
9230 tgl@sss.pgh.pa.us 1815 [ + + ]: 6552 : if (newitemonleft)
1816 : : {
2024 pg@bowt.ie 1817 [ - + ]: 1874 : Assert(newitemoff <= firstrightoff);
1818 [ - + ]: 1874 : if (!_bt_pgaddtup(leftpage, newitemsz, newitem, afterleftoff,
1819 : : false))
1820 : : {
5539 tgl@sss.pgh.pa.us 1821 [ # # ]:UBC 0 : elog(ERROR, "failed to add new item to the left sibling"
1822 : : " while splitting block %u of index \"%s\"",
1823 : : origpagenumber, RelationGetRelationName(rel));
1824 : : }
2024 pg@bowt.ie 1825 :CBC 1874 : afterleftoff = OffsetNumberNext(afterleftoff);
1826 : : }
1827 : : else
1828 : : {
1829 [ - + ]: 4678 : Assert(newitemoff >= firstrightoff);
1830 [ - + ]: 4678 : if (!_bt_pgaddtup(rightpage, newitemsz, newitem, afterrightoff,
1831 : : afterrightoff == minusinfoff))
1832 : : {
5539 tgl@sss.pgh.pa.us 1833 [ # # ]:UBC 0 : elog(ERROR, "failed to add new item to the right sibling"
1834 : : " while splitting block %u of index \"%s\"",
1835 : : origpagenumber, RelationGetRelationName(rel));
1836 : : }
2024 pg@bowt.ie 1837 :CBC 4678 : afterrightoff = OffsetNumberNext(afterrightoff);
1838 : : }
1839 : : }
1840 : :
1841 : : /* decide which page to put it on */
1842 [ + + ]: 3478784 : if (i < firstrightoff)
1843 : : {
1844 [ - + ]: 2638110 : if (!_bt_pgaddtup(leftpage, itemsz, dataitem, afterleftoff, false))
1845 : : {
5539 tgl@sss.pgh.pa.us 1846 [ # # ]:UBC 0 : elog(ERROR, "failed to add old item to the left sibling"
1847 : : " while splitting block %u of index \"%s\"",
1848 : : origpagenumber, RelationGetRelationName(rel));
1849 : : }
2024 pg@bowt.ie 1850 :CBC 2638110 : afterleftoff = OffsetNumberNext(afterleftoff);
1851 : : }
1852 : : else
1853 : : {
1854 [ - + ]: 840674 : if (!_bt_pgaddtup(rightpage, itemsz, dataitem, afterrightoff,
1855 : : afterrightoff == minusinfoff))
1856 : : {
5539 tgl@sss.pgh.pa.us 1857 [ # # ]:UBC 0 : elog(ERROR, "failed to add old item to the right sibling"
1858 : : " while splitting block %u of index \"%s\"",
1859 : : origpagenumber, RelationGetRelationName(rel));
1860 : : }
2024 pg@bowt.ie 1861 :CBC 840674 : afterrightoff = OffsetNumberNext(afterrightoff);
1862 : : }
1863 : : }
1864 : :
1865 : : /* Handle case where newitem goes at the end of rightpage */
9230 tgl@sss.pgh.pa.us 1866 [ + + ]: 11471 : if (i <= newitemoff)
1867 : : {
1868 : : /*
1869 : : * Can't have newitemonleft here; that would imply we were told to put
1870 : : * *everything* on the left page, which cannot fit (if it could, we'd
1871 : : * not be splitting the page).
1872 : : */
2024 pg@bowt.ie 1873 [ + - - + ]: 4919 : Assert(!newitemonleft && newitemoff == maxoff + 1);
1874 [ - + ]: 4919 : if (!_bt_pgaddtup(rightpage, newitemsz, newitem, afterrightoff,
1875 : : afterrightoff == minusinfoff))
1876 : : {
5539 tgl@sss.pgh.pa.us 1877 [ # # ]:UBC 0 : elog(ERROR, "failed to add new item to the right sibling"
1878 : : " while splitting block %u of index \"%s\"",
1879 : : origpagenumber, RelationGetRelationName(rel));
1880 : : }
2024 pg@bowt.ie 1881 :CBC 4919 : afterrightoff = OffsetNumberNext(afterrightoff);
1882 : : }
1883 : :
1884 : : /*
1885 : : * We have to grab the original right sibling (if any) and update its prev
1886 : : * link. We are guaranteed that this is deadlock-free, since we couple
1887 : : * the locks in the standard order: left to right.
1888 : : */
1889 [ + + ]: 11471 : if (!isrightmost)
1890 : : {
871 1891 : 5047 : sbuf = _bt_getbuf(rel, oopaque->btpo_next, BT_WRITE);
3478 kgrittn@postgresql.o 1892 : 5047 : spage = BufferGetPage(sbuf);
1306 michael@paquier.xyz 1893 : 5047 : sopaque = BTPageGetOpaque(spage);
5539 tgl@sss.pgh.pa.us 1894 [ - + ]: 5047 : if (sopaque->btpo_prev != origpagenumber)
1895 : : {
2280 peter@eisentraut.org 1896 [ # # ]:UBC 0 : ereport(ERROR,
1897 : : (errcode(ERRCODE_INDEX_CORRUPTED),
1898 : : errmsg_internal("right sibling's left-link doesn't match: "
1899 : : "block %u links to %u instead of expected %u in index \"%s\"",
1900 : : oopaque->btpo_next, sopaque->btpo_prev, origpagenumber,
1901 : : RelationGetRelationName(rel))));
1902 : : }
1903 : :
1904 : : /*
1905 : : * Check to see if we can set the SPLIT_END flag in the right-hand
1906 : : * split page; this can save some I/O for vacuum since it need not
1907 : : * proceed to the right sibling. We can set the flag if the right
1908 : : * sibling has a different cycleid: that means it could not be part of
1909 : : * a group of pages that were all split off from the same ancestor
1910 : : * page. If you're confused, imagine that page A splits to A B and
1911 : : * then again, yielding A C B, while vacuum is in progress. Tuples
1912 : : * originally in A could now be in either B or C, hence vacuum must
1913 : : * examine both pages. But if D, our right sibling, has a different
1914 : : * cycleid then it could not contain any tuples that were in A when
1915 : : * the vacuum started.
1916 : : */
7113 tgl@sss.pgh.pa.us 1917 [ - + ]:CBC 5047 : if (sopaque->btpo_cycleid != ropaque->btpo_cycleid)
7113 tgl@sss.pgh.pa.us 1918 :LBC (1) : ropaque->btpo_flags |= BTP_SPLIT_END;
1919 : : }
1920 : :
1921 : : /*
1922 : : * Right sibling is locked, new siblings are prepared, but original page
1923 : : * is not updated yet.
1924 : : *
1925 : : * NO EREPORT(ERROR) till right sibling is updated. We can get away with
1926 : : * not starting the critical section till here because we haven't been
1927 : : * scribbling on the original page yet; see comments above.
1928 : : */
9055 tgl@sss.pgh.pa.us 1929 :CBC 11471 : START_CRIT_SECTION();
1930 : :
1931 : : /*
1932 : : * By here, the original data page has been split into two new halves, and
1933 : : * these are correct. The algorithm requires that the left page never
1934 : : * move during a split, so we copy the new left page back on top of the
1935 : : * original. We need to do this before writing the WAL record, so that
1936 : : * XLogInsert can WAL log an image of the page if necessary.
1937 : : */
32 michael@paquier.xyz 1938 :GNC 11471 : memcpy(origpage, leftpage, BLCKSZ);
1939 : : /* leftpage, lopaque must not be used below here */
1940 : :
1941 : : /*
1942 : : * Move the contents of the right page from its temporary location to the
1943 : : * destination buffer, before writing the WAL record. Unlike the left
1944 : : * page, the right page and its opaque area are still needed to complete
1945 : : * the update of the page, so reinitialize them.
1946 : : */
1947 : 11471 : rightpage = BufferGetPage(rbuf);
1948 : 11471 : memcpy(rightpage, rightpage_buf.data, BLCKSZ);
1949 : 11471 : ropaque = BTPageGetOpaque(rightpage);
1950 : :
6775 tgl@sss.pgh.pa.us 1951 :CBC 11471 : MarkBufferDirty(buf);
1952 : 11471 : MarkBufferDirty(rbuf);
1953 : :
2024 pg@bowt.ie 1954 [ + + ]: 11471 : if (!isrightmost)
1955 : : {
5539 tgl@sss.pgh.pa.us 1956 : 5047 : sopaque->btpo_prev = rightpagenumber;
6775 1957 : 5047 : MarkBufferDirty(sbuf);
1958 : : }
1959 : :
1960 : : /*
1961 : : * Clear INCOMPLETE_SPLIT flag on child if inserting the new item finishes
1962 : : * a split
1963 : : */
4242 heikki.linnakangas@i 1964 [ + + ]: 11471 : if (!isleaf)
1965 : : {
3478 kgrittn@postgresql.o 1966 : 129 : Page cpage = BufferGetPage(cbuf);
1306 michael@paquier.xyz 1967 : 129 : BTPageOpaque cpageop = BTPageGetOpaque(cpage);
1968 : :
4242 heikki.linnakangas@i 1969 : 129 : cpageop->btpo_flags &= ~BTP_INCOMPLETE_SPLIT;
1970 : 129 : MarkBufferDirty(cbuf);
1971 : : }
1972 : :
1973 : : /* XLOG stuff */
5433 rhaas@postgresql.org 1974 [ + + + + : 11471 : if (RelationNeedsWAL(rel))
+ + + - ]
1975 : : {
1976 : : xl_btree_split xlrec;
1977 : : uint8 xlinfo;
1978 : : XLogRecPtr recptr;
1979 : :
1707 pg@bowt.ie 1980 : 10553 : xlrec.level = ropaque->btpo_level;
1981 : : /* See comments below on newitem, orignewitem, and posting lists */
2024 1982 : 10553 : xlrec.firstrightoff = firstrightoff;
3995 heikki.linnakangas@i 1983 : 10553 : xlrec.newitemoff = newitemoff;
2071 pg@bowt.ie 1984 : 10553 : xlrec.postingoff = 0;
2024 1985 [ + + + + ]: 10553 : if (postingoff != 0 && origpagepostingoff < firstrightoff)
2071 1986 : 11 : xlrec.postingoff = postingoff;
1987 : :
3995 heikki.linnakangas@i 1988 : 10553 : XLogBeginInsert();
259 peter@eisentraut.org 1989 : 10553 : XLogRegisterData(&xlrec, SizeOfBtreeSplit);
1990 : :
3995 heikki.linnakangas@i 1991 : 10553 : XLogRegisterBuffer(0, buf, REGBUF_STANDARD);
1992 : 10553 : XLogRegisterBuffer(1, rbuf, REGBUF_WILL_INIT);
1993 : : /* Log original right sibling, since we've changed its prev-pointer */
2024 pg@bowt.ie 1994 [ + + ]: 10553 : if (!isrightmost)
3995 heikki.linnakangas@i 1995 : 5041 : XLogRegisterBuffer(2, sbuf, REGBUF_STANDARD);
2024 pg@bowt.ie 1996 [ + + ]: 10553 : if (!isleaf)
3995 heikki.linnakangas@i 1997 : 129 : XLogRegisterBuffer(3, cbuf, REGBUF_STANDARD);
1998 : :
1999 : : /*
2000 : : * Log the new item, if it was inserted on the left page. (If it was
2001 : : * put on the right page, we don't need to explicitly WAL log it
2002 : : * because it's included with all the other items on the right page.)
2003 : : * Show the new item as belonging to the left page buffer, so that it
2004 : : * is not stored if XLogInsert decides it needs a full-page image of
2005 : : * the left page. We always store newitemoff in the record, though.
2006 : : *
2007 : : * The details are sometimes slightly different for page splits that
2008 : : * coincide with a posting list split. If both the replacement
2009 : : * posting list and newitem go on the right page, then we don't need
2010 : : * to log anything extra, just like the simple !newitemonleft
2011 : : * no-posting-split case (postingoff is set to zero in the WAL record,
2012 : : * so recovery doesn't need to process a posting list split at all).
2013 : : * Otherwise, we set postingoff and log orignewitem instead of
2014 : : * newitem, despite having actually inserted newitem. REDO routine
2015 : : * must reconstruct nposting and newitem using _bt_swap_posting().
2016 : : *
2017 : : * Note: It's possible that our page split point is the point that
2018 : : * makes the posting list lastleft and newitem firstright. This is
2019 : : * the only case where we log orignewitem/newitem despite newitem
2020 : : * going on the right page. If XLogInsert decides that it can omit
2021 : : * orignewitem due to logging a full-page image of the left page,
2022 : : * everything still works out, since recovery only needs to log
2023 : : * orignewitem for items on the left page (just like the regular
2024 : : * newitem-logged case).
2025 : : */
2071 pg@bowt.ie 2026 [ + + + + ]: 10553 : if (newitemonleft && xlrec.postingoff == 0)
259 peter@eisentraut.org 2027 : 1862 : XLogRegisterBufData(0, newitem, newitemsz);
2071 pg@bowt.ie 2028 [ + + ]: 8691 : else if (xlrec.postingoff != 0)
2029 : : {
2024 2030 [ - + ]: 11 : Assert(isleaf);
2031 [ + + - + ]: 11 : Assert(newitemonleft || firstrightoff == newitemoff);
2032 [ - + ]: 11 : Assert(newitemsz == IndexTupleSize(orignewitem));
259 peter@eisentraut.org 2033 : 11 : XLogRegisterBufData(0, orignewitem, newitemsz);
2034 : : }
2035 : :
2036 : : /* Log the left page's new high key */
2024 pg@bowt.ie 2037 [ + + ]: 10553 : if (!isleaf)
2038 : : {
2039 : : /* lefthighkey isn't local copy, get current pointer */
2040 : 129 : itemid = PageGetItemId(origpage, P_HIKEY);
2041 : 129 : lefthighkey = (IndexTuple) PageGetItem(origpage, itemid);
2042 : : }
259 peter@eisentraut.org 2043 : 10553 : XLogRegisterBufData(0, lefthighkey,
2024 pg@bowt.ie 2044 : 10553 : MAXALIGN(IndexTupleSize(lefthighkey)));
2045 : :
2046 : : /*
2047 : : * Log the contents of the right page in the format understood by
2048 : : * _bt_restore_page(). The whole right page will be recreated.
2049 : : *
2050 : : * Direct access to page is not good but faster - we should implement
2051 : : * some new func in page API. Note we only store the tuples
2052 : : * themselves, knowing that they were inserted in item-number order
2053 : : * and so the line pointers can be reconstructed. See comments for
2054 : : * _bt_restore_page().
2055 : : */
3995 heikki.linnakangas@i 2056 : 10553 : XLogRegisterBufData(1,
3051 tgl@sss.pgh.pa.us 2057 : 10553 : (char *) rightpage + ((PageHeader) rightpage)->pd_upper,
3995 heikki.linnakangas@i 2058 : 10553 : ((PageHeader) rightpage)->pd_special - ((PageHeader) rightpage)->pd_upper);
2059 : :
2414 pg@bowt.ie 2060 [ + + ]: 10553 : xlinfo = newitemonleft ? XLOG_BTREE_SPLIT_L : XLOG_BTREE_SPLIT_R;
3995 heikki.linnakangas@i 2061 : 10553 : recptr = XLogInsert(RM_BTREE_ID, xlinfo);
2062 : :
6837 alvherre@alvh.no-ip. 2063 : 10553 : PageSetLSN(origpage, recptr);
9155 vadim4o@yahoo.com 2064 : 10553 : PageSetLSN(rightpage, recptr);
2024 pg@bowt.ie 2065 [ + + ]: 10553 : if (!isrightmost)
9155 vadim4o@yahoo.com 2066 : 5041 : PageSetLSN(spage, recptr);
4228 heikki.linnakangas@i 2067 [ + + ]: 10553 : if (!isleaf)
3478 kgrittn@postgresql.o 2068 : 129 : PageSetLSN(BufferGetPage(cbuf), recptr);
2069 : : }
2070 : :
9044 tgl@sss.pgh.pa.us 2071 [ - + ]: 11471 : END_CRIT_SECTION();
2072 : :
2073 : : /* release the old right sibling */
2024 pg@bowt.ie 2074 [ + + ]: 11471 : if (!isrightmost)
7151 tgl@sss.pgh.pa.us 2075 : 5047 : _bt_relbuf(rel, sbuf);
2076 : :
2077 : : /* release the child */
4242 heikki.linnakangas@i 2078 [ + + ]: 11471 : if (!isleaf)
2079 : 129 : _bt_relbuf(rel, cbuf);
2080 : :
2081 : : /* be tidy */
2024 pg@bowt.ie 2082 [ + + ]: 11471 : if (isleaf)
2083 : 11342 : pfree(lefthighkey);
2084 : :
2085 : : /* split's done */
9919 bruce@momjian.us 2086 : 11471 : return rbuf;
2087 : : }
2088 : :
2089 : : /*
2090 : : * _bt_insert_parent() -- Insert downlink into parent, completing split.
2091 : : *
2092 : : * On entry, buf and rbuf are the left and right split pages, which we
2093 : : * still hold write locks on. Both locks will be released here. We
2094 : : * release the rbuf lock once we have a write lock on the page that we
2095 : : * intend to insert a downlink to rbuf on (i.e. buf's current parent page).
2096 : : * The lock on buf is released at the same point as the lock on the parent
2097 : : * page, since buf's INCOMPLETE_SPLIT flag must be cleared by the same
2098 : : * atomic operation that completes the split by inserting a new downlink.
2099 : : *
2100 : : * stack - stack showing how we got here. Will be NULL when splitting true
2101 : : * root, or during concurrent root split, where we can be inefficient
2102 : : * isroot - we split the true root
2103 : : * isonly - we split a page alone on its level (might have been fast root)
2104 : : */
2105 : : static void
8285 tgl@sss.pgh.pa.us 2106 : 11471 : _bt_insert_parent(Relation rel,
2107 : : Relation heaprel,
2108 : : Buffer buf,
2109 : : Buffer rbuf,
2110 : : BTStack stack,
2111 : : bool isroot,
2112 : : bool isonly)
2113 : : {
871 pg@bowt.ie 2114 [ - + ]: 11471 : Assert(heaprel != NULL);
2115 : :
2116 : : /*
2117 : : * Here we have to do something Lehman and Yao don't talk about: deal with
2118 : : * a root split and construction of a new root. If our stack is empty
2119 : : * then we have just split a node on what had been the root level when we
2120 : : * descended the tree. If it was still the root then we perform a
2121 : : * new-root construction. If it *wasn't* the root anymore, search to find
2122 : : * the next higher level that someone constructed meanwhile, and find the
2123 : : * right place to insert as for the normal case.
2124 : : *
2125 : : * If we have to search for the parent level, we do so by re-descending
2126 : : * from the root. This is not super-efficient, but it's rare enough not
2127 : : * to matter.
2128 : : */
1806 2129 [ + + ]: 11471 : if (isroot)
2130 : : {
2131 : : Buffer rootbuf;
2132 : :
7965 neilc@samurai.com 2133 [ - + ]: 675 : Assert(stack == NULL);
1806 pg@bowt.ie 2134 [ - + ]: 675 : Assert(isonly);
2135 : : /* create a new root node one level up and update the metapage */
871 2136 : 675 : rootbuf = _bt_newlevel(rel, heaprel, buf, rbuf);
2137 : : /* release the split buffers */
7151 tgl@sss.pgh.pa.us 2138 : 675 : _bt_relbuf(rel, rootbuf);
2139 : 675 : _bt_relbuf(rel, rbuf);
2140 : 675 : _bt_relbuf(rel, buf);
2141 : : }
2142 : : else
2143 : : {
8285 2144 : 10796 : BlockNumber bknum = BufferGetBlockNumber(buf);
2145 : 10796 : BlockNumber rbknum = BufferGetBlockNumber(rbuf);
3478 kgrittn@postgresql.o 2146 : 10796 : Page page = BufferGetPage(buf);
2147 : : IndexTuple new_item;
2148 : : BTStackData fakestack;
2149 : : IndexTuple ritem;
2150 : : Buffer pbuf;
2151 : :
7965 neilc@samurai.com 2152 [ + + ]: 10796 : if (stack == NULL)
2153 : : {
2154 : : BTPageOpaque opaque;
2155 : :
4065 heikki.linnakangas@i 2156 [ - + ]: 12 : elog(DEBUG2, "concurrent ROOT page split");
1306 michael@paquier.xyz 2157 : 12 : opaque = BTPageGetOpaque(page);
2158 : :
2159 : : /*
2160 : : * We should never reach here when a leaf page split takes place
2161 : : * despite the insert of newitem being able to apply the fastpath
2162 : : * optimization. Make sure of that with an assertion.
2163 : : *
2164 : : * This is more of a performance issue than a correctness issue.
2165 : : * The fastpath won't have a descent stack. Using a phony stack
2166 : : * here works, but never rely on that. The fastpath should be
2167 : : * rejected within _bt_search_insert() when the rightmost leaf
2168 : : * page will split, since it's faster to go through _bt_search()
2169 : : * and get a stack in the usual way.
2170 : : */
1806 pg@bowt.ie 2171 [ + - + - : 12 : Assert(!(P_ISLEAF(opaque) &&
- + ]
2172 : : BlockNumberIsValid(RelationGetTargetBlock(rel))));
2173 : :
2174 : : /* Find the leftmost page at the next level up */
781 tmunro@postgresql.or 2175 : 12 : pbuf = _bt_get_endpoint(rel, opaque->btpo_level + 1, false);
2176 : : /* Set up a phony stack entry pointing there */
8285 tgl@sss.pgh.pa.us 2177 : 12 : stack = &fakestack;
2178 : 12 : stack->bts_blkno = BufferGetBlockNumber(pbuf);
2179 : 12 : stack->bts_offset = InvalidOffsetNumber;
2180 : 12 : stack->bts_parent = NULL;
2181 : 12 : _bt_relbuf(rel, pbuf);
2182 : : }
2183 : :
2184 : : /* get high key from left, a strict lower bound for new right page */
7216 2185 : 10796 : ritem = (IndexTuple) PageGetItem(page,
2186 : 10796 : PageGetItemId(page, P_HIKEY));
2187 : :
2188 : : /* form an index tuple that points at the new right page */
2189 : 10796 : new_item = CopyIndexTuple(ritem);
2143 pg@bowt.ie 2190 : 10796 : BTreeTupleSetDownLink(new_item, rbknum);
2191 : :
2192 : : /*
2193 : : * Re-find and write lock the parent of buf.
2194 : : *
2195 : : * It's possible that the location of buf's downlink has changed since
2196 : : * our initial _bt_search() descent. _bt_getstackbuf() will detect
2197 : : * and recover from this, updating the stack, which ensures that the
2198 : : * new downlink will be inserted at the correct offset. Even buf's
2199 : : * parent may have changed.
2200 : : */
941 andres@anarazel.de 2201 : 10796 : pbuf = _bt_getstackbuf(rel, heaprel, stack, bknum);
2202 : :
2203 : : /*
2204 : : * Unlock the right child. The left child will be unlocked in
2205 : : * _bt_insertonpg().
2206 : : *
2207 : : * Unlocking the right child must be delayed until here to ensure that
2208 : : * no concurrent VACUUM operation can become confused. Page deletion
2209 : : * cannot be allowed to fail to re-find a downlink for the rbuf page.
2210 : : * (Actually, this is just a vestige of how things used to work. The
2211 : : * page deletion code is expected to check for the INCOMPLETE_SPLIT
2212 : : * flag on the left child. It won't attempt deletion of the right
2213 : : * child until the split is complete. Despite all this, we opt to
2214 : : * conservatively delay unlocking the right child until here.)
2215 : : */
7151 tgl@sss.pgh.pa.us 2216 : 10796 : _bt_relbuf(rel, rbuf);
2217 : :
8285 2218 [ - + ]: 10796 : if (pbuf == InvalidBuffer)
2280 peter@eisentraut.org 2219 [ # # ]:UBC 0 : ereport(ERROR,
2220 : : (errcode(ERRCODE_INDEX_CORRUPTED),
2221 : : errmsg_internal("failed to re-find parent key in index \"%s\" for split pages %u/%u",
2222 : : RelationGetRelationName(rel), bknum, rbknum)));
2223 : :
2224 : : /* Recursively insert into the parent */
941 andres@anarazel.de 2225 :CBC 21592 : _bt_insertonpg(rel, heaprel, NULL, pbuf, buf, stack->bts_parent,
2052 pg@bowt.ie 2226 : 10796 : new_item, MAXALIGN(IndexTupleSize(new_item)),
1806 2227 : 10796 : stack->bts_offset + 1, 0, isonly);
2228 : :
2229 : : /* be tidy */
8285 tgl@sss.pgh.pa.us 2230 : 10796 : pfree(new_item);
2231 : : }
2232 : 11471 : }
2233 : :
2234 : : /*
2235 : : * _bt_finish_split() -- Finish an incomplete split
2236 : : *
2237 : : * A crash or other failure can leave a split incomplete. The insertion
2238 : : * routines won't allow to insert on a page that is incompletely split.
2239 : : * Before inserting on such a page, call _bt_finish_split().
2240 : : *
2241 : : * On entry, 'lbuf' must be locked in write-mode. On exit, it is unlocked
2242 : : * and unpinned.
2243 : : *
2244 : : * Caller must provide a valid heaprel, since finishing a page split requires
2245 : : * allocating a new page if and when the parent page splits in turn.
2246 : : */
2247 : : void
941 andres@anarazel.de 2248 :UBC 0 : _bt_finish_split(Relation rel, Relation heaprel, Buffer lbuf, BTStack stack)
2249 : : {
3478 kgrittn@postgresql.o 2250 : 0 : Page lpage = BufferGetPage(lbuf);
1306 michael@paquier.xyz 2251 : 0 : BTPageOpaque lpageop = BTPageGetOpaque(lpage);
2252 : : Buffer rbuf;
2253 : : Page rpage;
2254 : : BTPageOpaque rpageop;
2255 : : bool wasroot;
2256 : : bool wasonly;
2257 : :
4242 heikki.linnakangas@i 2258 [ # # ]: 0 : Assert(P_INCOMPLETE_SPLIT(lpageop));
871 pg@bowt.ie 2259 [ # # ]: 0 : Assert(heaprel != NULL);
2260 : :
2261 : : /* Lock right sibling, the one missing the downlink */
2262 : 0 : rbuf = _bt_getbuf(rel, lpageop->btpo_next, BT_WRITE);
3478 kgrittn@postgresql.o 2263 : 0 : rpage = BufferGetPage(rbuf);
1306 michael@paquier.xyz 2264 : 0 : rpageop = BTPageGetOpaque(rpage);
2265 : :
2266 : : /* Could this be a root split? */
4242 heikki.linnakangas@i 2267 [ # # ]: 0 : if (!stack)
2268 : : {
2269 : : Buffer metabuf;
2270 : : Page metapg;
2271 : : BTMetaPageData *metad;
2272 : :
2273 : : /* acquire lock on the metapage */
871 pg@bowt.ie 2274 : 0 : metabuf = _bt_getbuf(rel, BTREE_METAPAGE, BT_WRITE);
3478 kgrittn@postgresql.o 2275 : 0 : metapg = BufferGetPage(metabuf);
4242 heikki.linnakangas@i 2276 : 0 : metad = BTPageGetMeta(metapg);
2277 : :
1806 pg@bowt.ie 2278 : 0 : wasroot = (metad->btm_root == BufferGetBlockNumber(lbuf));
2279 : :
4242 heikki.linnakangas@i 2280 : 0 : _bt_relbuf(rel, metabuf);
2281 : : }
2282 : : else
1806 pg@bowt.ie 2283 : 0 : wasroot = false;
2284 : :
2285 : : /* Was this the only page on the level before split? */
2286 [ # # # # ]: 0 : wasonly = (P_LEFTMOST(lpageop) && P_RIGHTMOST(rpageop));
2287 : :
4242 heikki.linnakangas@i 2288 [ # # ]: 0 : elog(DEBUG1, "finishing incomplete split of %u/%u",
2289 : : BufferGetBlockNumber(lbuf), BufferGetBlockNumber(rbuf));
2290 : :
941 andres@anarazel.de 2291 : 0 : _bt_insert_parent(rel, heaprel, lbuf, rbuf, stack, wasroot, wasonly);
4242 heikki.linnakangas@i 2292 : 0 : }
2293 : :
2294 : : /*
2295 : : * _bt_getstackbuf() -- Walk back up the tree one step, and find the pivot
2296 : : * tuple whose downlink points to child page.
2297 : : *
2298 : : * Caller passes child's block number, which is used to identify
2299 : : * associated pivot tuple in parent page using a linear search that
2300 : : * matches on pivot's downlink/block number. The expected location of
2301 : : * the pivot tuple is taken from the stack one level above the child
2302 : : * page. This is used as a starting point. Insertions into the
2303 : : * parent level could cause the pivot tuple to move right; deletions
2304 : : * could cause it to move left, but not left of the page we previously
2305 : : * found it on.
2306 : : *
2307 : : * Caller can use its stack to relocate the pivot tuple/downlink for
2308 : : * any same-level page to the right of the page found by its initial
2309 : : * descent. This is necessary because of the possibility that caller
2310 : : * moved right to recover from a concurrent page split. It's also
2311 : : * convenient for certain callers to be able to step right when there
2312 : : * wasn't a concurrent page split, while still using their original
2313 : : * stack. For example, the checkingunique _bt_doinsert() case may
2314 : : * have to step right when there are many physical duplicates, and its
2315 : : * scantid forces an insertion to the right of the "first page the
2316 : : * value could be on". (This is also relied on by all of our callers
2317 : : * when dealing with !heapkeyspace indexes.)
2318 : : *
2319 : : * Returns write-locked parent page buffer, or InvalidBuffer if pivot
2320 : : * tuple not found (should not happen). Adjusts bts_blkno &
2321 : : * bts_offset if changed. Page split caller should insert its new
2322 : : * pivot tuple for its new right sibling page on parent page, at the
2323 : : * offset number bts_offset + 1.
2324 : : */
2325 : : Buffer
941 andres@anarazel.de 2326 :CBC 13896 : _bt_getstackbuf(Relation rel, Relation heaprel, BTStack stack, BlockNumber child)
2327 : : {
2328 : : BlockNumber blkno;
2329 : : OffsetNumber start;
2330 : :
9230 tgl@sss.pgh.pa.us 2331 : 13896 : blkno = stack->bts_blkno;
2332 : 13896 : start = stack->bts_offset;
2333 : :
2334 : : for (;;)
2335 : 9 : {
2336 : : Buffer buf;
2337 : : Page page;
2338 : : BTPageOpaque opaque;
2339 : :
871 pg@bowt.ie 2340 : 13905 : buf = _bt_getbuf(rel, blkno, BT_WRITE);
3478 kgrittn@postgresql.o 2341 : 13905 : page = BufferGetPage(buf);
1306 michael@paquier.xyz 2342 : 13905 : opaque = BTPageGetOpaque(page);
2343 : :
871 pg@bowt.ie 2344 [ - + ]: 13905 : Assert(heaprel != NULL);
2437 2345 [ - + ]: 13905 : if (P_INCOMPLETE_SPLIT(opaque))
2346 : : {
941 andres@anarazel.de 2347 :UBC 0 : _bt_finish_split(rel, heaprel, buf, stack->bts_parent);
4242 heikki.linnakangas@i 2348 : 0 : continue;
2349 : : }
2350 : :
8284 tgl@sss.pgh.pa.us 2351 [ + + ]:CBC 13905 : if (!P_IGNORE(opaque))
2352 : : {
2353 : : OffsetNumber offnum,
2354 : : minoff,
2355 : : maxoff;
2356 : : ItemId itemid;
2357 : : IndexTuple item;
2358 : :
2359 [ + + ]: 13896 : minoff = P_FIRSTDATAKEY(opaque);
2360 : 13896 : maxoff = PageGetMaxOffsetNumber(page);
2361 : :
2362 : : /*
2363 : : * start = InvalidOffsetNumber means "search the whole page". We
2364 : : * need this test anyway due to possibility that page has a high
2365 : : * key now when it didn't before.
2366 : : */
2367 [ + + ]: 13896 : if (start < minoff)
2368 : 21 : start = minoff;
2369 : :
2370 : : /*
2371 : : * Need this check too, to guard against possibility that page
2372 : : * split since we visited it originally.
2373 : : */
7742 2374 [ - + ]: 13896 : if (start > maxoff)
7742 tgl@sss.pgh.pa.us 2375 :LBC (1) : start = OffsetNumberNext(maxoff);
2376 : :
2377 : : /*
2378 : : * These loops will check every item on the page --- but in an
2379 : : * order that's attuned to the probability of where it actually
2380 : : * is. Scan to the right first, then to the left.
2381 : : */
8284 tgl@sss.pgh.pa.us 2382 :CBC 13896 : for (offnum = start;
2383 [ + - ]: 13944 : offnum <= maxoff;
2384 : 48 : offnum = OffsetNumberNext(offnum))
2385 : : {
2386 : 13944 : itemid = PageGetItemId(page, offnum);
7216 2387 : 13944 : item = (IndexTuple) PageGetItem(page, itemid);
2388 : :
2143 pg@bowt.ie 2389 [ + + ]: 13944 : if (BTreeTupleGetDownLink(item) == child)
2390 : : {
2391 : : /* Return accurate pointer to where link is now */
8284 tgl@sss.pgh.pa.us 2392 : 13896 : stack->bts_blkno = blkno;
2393 : 13896 : stack->bts_offset = offnum;
2394 : 13896 : return buf;
2395 : : }
2396 : : }
2397 : :
8284 tgl@sss.pgh.pa.us 2398 :LBC (1) : for (offnum = OffsetNumberPrev(start);
2399 [ # # ]: (221) : offnum >= minoff;
2400 : (220) : offnum = OffsetNumberPrev(offnum))
2401 : : {
2402 : (220) : itemid = PageGetItemId(page, offnum);
7216 2403 : (220) : item = (IndexTuple) PageGetItem(page, itemid);
2404 : :
2143 pg@bowt.ie 2405 [ # # ]: (220) : if (BTreeTupleGetDownLink(item) == child)
2406 : : {
2407 : : /* Return accurate pointer to where link is now */
8284 tgl@sss.pgh.pa.us 2408 :UBC 0 : stack->bts_blkno = blkno;
2409 : 0 : stack->bts_offset = offnum;
2410 : 0 : return buf;
2411 : : }
2412 : : }
2413 : : }
2414 : :
2415 : : /*
2416 : : * The item we're looking for moved right at least one page.
2417 : : *
2418 : : * Lehman and Yao couple/chain locks when moving right here, which we
2419 : : * can avoid. See nbtree/README.
2420 : : */
9230 tgl@sss.pgh.pa.us 2421 [ - + ]:CBC 9 : if (P_RIGHTMOST(opaque))
2422 : : {
8871 tgl@sss.pgh.pa.us 2423 :UBC 0 : _bt_relbuf(rel, buf);
7860 2424 : 0 : return InvalidBuffer;
2425 : : }
9230 tgl@sss.pgh.pa.us 2426 :CBC 9 : blkno = opaque->btpo_next;
8285 2427 : 9 : start = InvalidOffsetNumber;
8871 2428 : 9 : _bt_relbuf(rel, buf);
2429 : : }
2430 : : }
2431 : :
2432 : : /*
2433 : : * _bt_newlevel() -- Create a new level above root page.
2434 : : *
2435 : : * We've just split the old root page and need to create a new one.
2436 : : * In order to do this, we add a new root page to the file, then lock
2437 : : * the metadata page and update it. This is guaranteed to be deadlock-
2438 : : * free, because all readers release their locks on the metadata page
2439 : : * before trying to lock the root, and all writers lock the root before
2440 : : * trying to lock the metadata page. We have a write lock on the old
2441 : : * root page, so we have not introduced any cycles into the waits-for
2442 : : * graph.
2443 : : *
2444 : : * On entry, lbuf (the old root) and rbuf (its new peer) are write-
2445 : : * locked. On exit, a new root page exists with entries for the
2446 : : * two new children, metapage is updated and unlocked/unpinned.
2447 : : * The new root buffer is returned to caller which has to unlock/unpin
2448 : : * lbuf, rbuf & rootbuf.
2449 : : */
2450 : : static Buffer
871 pg@bowt.ie 2451 : 675 : _bt_newlevel(Relation rel, Relation heaprel, Buffer lbuf, Buffer rbuf)
2452 : : {
2453 : : Buffer rootbuf;
2454 : : Page lpage,
2455 : : rootpage;
2456 : : BlockNumber lbkno,
2457 : : rbkno;
2458 : : BlockNumber rootblknum;
2459 : : BTPageOpaque rootopaque;
2460 : : BTPageOpaque lopaque;
2461 : : ItemId itemid;
2462 : : IndexTuple item;
2463 : : IndexTuple left_item;
2464 : : Size left_item_sz;
2465 : : IndexTuple right_item;
2466 : : Size right_item_sz;
2467 : : Buffer metabuf;
2468 : : Page metapg;
2469 : : BTMetaPageData *metad;
2470 : :
8285 tgl@sss.pgh.pa.us 2471 : 675 : lbkno = BufferGetBlockNumber(lbuf);
2472 : 675 : rbkno = BufferGetBlockNumber(rbuf);
3478 kgrittn@postgresql.o 2473 : 675 : lpage = BufferGetPage(lbuf);
1306 michael@paquier.xyz 2474 : 675 : lopaque = BTPageGetOpaque(lpage);
2475 : :
2476 : : /* get a new root page */
871 pg@bowt.ie 2477 : 675 : rootbuf = _bt_allocbuf(rel, heaprel);
3478 kgrittn@postgresql.o 2478 : 675 : rootpage = BufferGetPage(rootbuf);
9155 vadim4o@yahoo.com 2479 : 675 : rootblknum = BufferGetBlockNumber(rootbuf);
2480 : :
2481 : : /* acquire lock on the metapage */
871 pg@bowt.ie 2482 : 675 : metabuf = _bt_getbuf(rel, BTREE_METAPAGE, BT_WRITE);
3478 kgrittn@postgresql.o 2483 : 675 : metapg = BufferGetPage(metabuf);
9070 vadim4o@yahoo.com 2484 : 675 : metad = BTPageGetMeta(metapg);
2485 : :
2486 : : /*
2487 : : * Create downlink item for left page (old root). The key value used is
2488 : : * "minus infinity", a sentinel value that's reliably less than any real
2489 : : * key value that could appear in the left page.
2490 : : */
4225 heikki.linnakangas@i 2491 : 675 : left_item_sz = sizeof(IndexTupleData);
2492 : 675 : left_item = (IndexTuple) palloc(left_item_sz);
2493 : 675 : left_item->t_info = left_item_sz;
2143 pg@bowt.ie 2494 : 675 : BTreeTupleSetDownLink(left_item, lbkno);
2030 2495 : 675 : BTreeTupleSetNAtts(left_item, 0, false);
2496 : :
2497 : : /*
2498 : : * Create downlink item for right page. The key for it is obtained from
2499 : : * the "high key" position in the left page.
2500 : : */
4225 heikki.linnakangas@i 2501 : 675 : itemid = PageGetItemId(lpage, P_HIKEY);
2502 : 675 : right_item_sz = ItemIdGetLength(itemid);
2503 : 675 : item = (IndexTuple) PageGetItem(lpage, itemid);
2504 : 675 : right_item = CopyIndexTuple(item);
2143 pg@bowt.ie 2505 : 675 : BTreeTupleSetDownLink(right_item, rbkno);
2506 : :
2507 : : /* NO EREPORT(ERROR) from here till newroot op is logged */
9055 tgl@sss.pgh.pa.us 2508 : 675 : START_CRIT_SECTION();
2509 : :
2510 : : /* upgrade metapage if needed */
2414 pg@bowt.ie 2511 [ - + ]: 675 : if (metad->btm_version < BTREE_NOVAC_VERSION)
2708 teodor@sigaev.ru 2512 :UBC 0 : _bt_upgrademetapage(metapg);
2513 : :
2514 : : /* set btree special data */
1306 michael@paquier.xyz 2515 :CBC 675 : rootopaque = BTPageGetOpaque(rootpage);
10278 bruce@momjian.us 2516 : 675 : rootopaque->btpo_prev = rootopaque->btpo_next = P_NONE;
8285 tgl@sss.pgh.pa.us 2517 : 675 : rootopaque->btpo_flags = BTP_ROOT;
1707 pg@bowt.ie 2518 : 675 : rootopaque->btpo_level =
1306 michael@paquier.xyz 2519 : 675 : (BTPageGetOpaque(lpage))->btpo_level + 1;
7113 tgl@sss.pgh.pa.us 2520 : 675 : rootopaque->btpo_cycleid = 0;
2521 : :
2522 : : /* update metapage data */
8285 2523 : 675 : metad->btm_root = rootblknum;
1707 pg@bowt.ie 2524 : 675 : metad->btm_level = rootopaque->btpo_level;
8285 tgl@sss.pgh.pa.us 2525 : 675 : metad->btm_fastroot = rootblknum;
1707 pg@bowt.ie 2526 : 675 : metad->btm_fastlevel = rootopaque->btpo_level;
2527 : :
2528 : : /*
2529 : : * Insert the left page pointer into the new root page. The root page is
2530 : : * the rightmost page on its level so there is no "high key" in it; the
2531 : : * two items will go into positions P_HIKEY and P_FIRSTKEY.
2532 : : *
2533 : : * Note: we *must* insert the two items in item-number order, for the
2534 : : * benefit of _bt_restore_page().
2535 : : */
2749 teodor@sigaev.ru 2536 [ + - - + ]: 675 : Assert(BTreeTupleGetNAtts(left_item, rel) == 0);
1 peter@eisentraut.org 2537 [ - + ]:GNC 675 : if (PageAddItem(rootpage, left_item, left_item_sz, P_HIKEY, false, false) == InvalidOffsetNumber)
6511 tgl@sss.pgh.pa.us 2538 [ # # ]:UBC 0 : elog(PANIC, "failed to add leftkey to new root page"
2539 : : " while splitting block %u of index \"%s\"",
2540 : : BufferGetBlockNumber(lbuf), RelationGetRelationName(rel));
2541 : :
2542 : : /*
2543 : : * insert the right page pointer into the new root page.
2544 : : */
2414 pg@bowt.ie 2545 [ + - - + ]:CBC 675 : Assert(BTreeTupleGetNAtts(right_item, rel) > 0);
2546 [ + - - + ]: 675 : Assert(BTreeTupleGetNAtts(right_item, rel) <=
2547 : : IndexRelationGetNumberOfKeyAttributes(rel));
1 peter@eisentraut.org 2548 [ - + ]:GNC 675 : if (PageAddItem(rootpage, right_item, right_item_sz, P_FIRSTKEY, false, false) == InvalidOffsetNumber)
6511 tgl@sss.pgh.pa.us 2549 [ # # ]:UBC 0 : elog(PANIC, "failed to add rightkey to new root page"
2550 : : " while splitting block %u of index \"%s\"",
2551 : : BufferGetBlockNumber(lbuf), RelationGetRelationName(rel));
2552 : :
2553 : : /* Clear the incomplete-split flag in the left child */
4242 heikki.linnakangas@i 2554 [ - + ]:CBC 675 : Assert(P_INCOMPLETE_SPLIT(lopaque));
2555 : 675 : lopaque->btpo_flags &= ~BTP_INCOMPLETE_SPLIT;
2556 : 675 : MarkBufferDirty(lbuf);
2557 : :
7151 tgl@sss.pgh.pa.us 2558 : 675 : MarkBufferDirty(rootbuf);
2559 : 675 : MarkBufferDirty(metabuf);
2560 : :
2561 : : /* XLOG stuff */
5433 rhaas@postgresql.org 2562 [ + + + + : 675 : if (RelationNeedsWAL(rel))
+ + + - ]
2563 : : {
2564 : : xl_btree_newroot xlrec;
2565 : : XLogRecPtr recptr;
2566 : : xl_btree_metadata md;
2567 : :
8285 tgl@sss.pgh.pa.us 2568 : 656 : xlrec.rootblk = rootblknum;
9070 vadim4o@yahoo.com 2569 : 656 : xlrec.level = metad->btm_level;
2570 : :
3995 heikki.linnakangas@i 2571 : 656 : XLogBeginInsert();
259 peter@eisentraut.org 2572 : 656 : XLogRegisterData(&xlrec, SizeOfBtreeNewroot);
2573 : :
3995 heikki.linnakangas@i 2574 : 656 : XLogRegisterBuffer(0, rootbuf, REGBUF_WILL_INIT);
2575 : 656 : XLogRegisterBuffer(1, lbuf, REGBUF_STANDARD);
2916 tgl@sss.pgh.pa.us 2576 : 656 : XLogRegisterBuffer(2, metabuf, REGBUF_WILL_INIT | REGBUF_STANDARD);
2577 : :
2414 pg@bowt.ie 2578 [ - + ]: 656 : Assert(metad->btm_version >= BTREE_NOVAC_VERSION);
2579 : 656 : md.version = metad->btm_version;
3995 heikki.linnakangas@i 2580 : 656 : md.root = rootblknum;
2581 : 656 : md.level = metad->btm_level;
2582 : 656 : md.fastroot = rootblknum;
2583 : 656 : md.fastlevel = metad->btm_level;
1707 pg@bowt.ie 2584 : 656 : md.last_cleanup_num_delpages = metad->btm_last_cleanup_num_delpages;
2071 2585 : 656 : md.allequalimage = metad->btm_allequalimage;
2586 : :
259 peter@eisentraut.org 2587 : 656 : XLogRegisterBufData(2, &md, sizeof(xl_btree_metadata));
2588 : :
2589 : : /*
2590 : : * Direct access to page is not good but faster - we should implement
2591 : : * some new func in page API.
2592 : : */
3995 heikki.linnakangas@i 2593 : 656 : XLogRegisterBufData(0,
3051 tgl@sss.pgh.pa.us 2594 : 656 : (char *) rootpage + ((PageHeader) rootpage)->pd_upper,
3995 heikki.linnakangas@i 2595 : 656 : ((PageHeader) rootpage)->pd_special -
2596 : 656 : ((PageHeader) rootpage)->pd_upper);
2597 : :
2598 : 656 : recptr = XLogInsert(RM_BTREE_ID, XLOG_BTREE_NEWROOT);
2599 : :
4207 2600 : 656 : PageSetLSN(lpage, recptr);
9155 vadim4o@yahoo.com 2601 : 656 : PageSetLSN(rootpage, recptr);
9146 2602 : 656 : PageSetLSN(metapg, recptr);
2603 : : }
2604 : :
9055 tgl@sss.pgh.pa.us 2605 [ - + ]: 675 : END_CRIT_SECTION();
2606 : :
2607 : : /* done with metapage */
7151 2608 : 675 : _bt_relbuf(rel, metabuf);
2609 : :
4225 heikki.linnakangas@i 2610 : 675 : pfree(left_item);
2611 : 675 : pfree(right_item);
2612 : :
7230 neilc@samurai.com 2613 : 675 : return rootbuf;
2614 : : }
2615 : :
2616 : : /*
2617 : : * _bt_pgaddtup() -- add a data item to a particular page during split.
2618 : : *
2619 : : * The difference between this routine and a bare PageAddItem call is
2620 : : * that this code can deal with the first data item on an internal btree
2621 : : * page in passing. This data item (which is called "firstright" within
2622 : : * _bt_split()) has a key that must be treated as minus infinity after
2623 : : * the split. Therefore, we truncate away all attributes when caller
2624 : : * specifies it's the first data item on page (downlink is not changed,
2625 : : * though). This extra step is only needed for the right page of an
2626 : : * internal page split. There is no need to do this for the first data
2627 : : * item on the existing/left page, since that will already have been
2628 : : * truncated during an earlier page split.
2629 : : *
2630 : : * See _bt_split() for a high level explanation of why we truncate here.
2631 : : * Note that this routine has nothing to do with suffix truncation,
2632 : : * despite using some of the same infrastructure.
2633 : : */
2634 : : static inline bool
5539 tgl@sss.pgh.pa.us 2635 : 3490255 : _bt_pgaddtup(Page page,
2636 : : Size itemsize,
2637 : : const IndexTupleData *itup,
2638 : : OffsetNumber itup_off,
2639 : : bool newfirstdataitem)
2640 : : {
2641 : : IndexTupleData trunctuple;
2642 : :
2024 pg@bowt.ie 2643 [ + + ]: 3490255 : if (newfirstdataitem)
2644 : : {
7216 tgl@sss.pgh.pa.us 2645 : 129 : trunctuple = *itup;
2646 : 129 : trunctuple.t_info = sizeof(IndexTupleData);
2030 pg@bowt.ie 2647 : 129 : BTreeTupleSetNAtts(&trunctuple, 0, false);
7216 tgl@sss.pgh.pa.us 2648 : 129 : itup = &trunctuple;
2649 : 129 : itemsize = sizeof(IndexTupleData);
2650 : : }
2651 : :
1 peter@eisentraut.org 2652 [ - + ]:GNC 3490255 : if (unlikely(PageAddItem(page, itup, itemsize, itup_off, false, false) == InvalidOffsetNumber))
5539 tgl@sss.pgh.pa.us 2653 :UBC 0 : return false;
2654 : :
5539 tgl@sss.pgh.pa.us 2655 :CBC 3490255 : return true;
2656 : : }
2657 : :
2658 : : /*
2659 : : * _bt_delete_or_dedup_one_page - Try to avoid a leaf page split.
2660 : : *
2661 : : * There are three operations performed here: simple index deletion, bottom-up
2662 : : * index deletion, and deduplication. If all three operations fail to free
2663 : : * enough space for the incoming item then caller will go on to split the
2664 : : * page. We always consider simple deletion first. If that doesn't work out
2665 : : * we consider alternatives. Callers that only want us to consider simple
2666 : : * deletion (without any fallback) ask for that using the 'simpleonly'
2667 : : * argument.
2668 : : *
2669 : : * We usually pick only one alternative "complex" operation when simple
2670 : : * deletion alone won't prevent a page split. The 'checkingunique',
2671 : : * 'uniquedup', and 'indexUnchanged' arguments are used for that.
2672 : : *
2673 : : * Note: We used to only delete LP_DEAD items when the BTP_HAS_GARBAGE page
2674 : : * level flag was found set. The flag was useful back when there wasn't
2675 : : * necessarily one single page for a duplicate tuple to go on (before heap TID
2676 : : * became a part of the key space in version 4 indexes). But we don't
2677 : : * actually look at the flag anymore (it's not a gating condition for our
2678 : : * caller). That would cause us to miss tuples that are safe to delete,
2679 : : * without getting any benefit in return. We know that the alternative is to
2680 : : * split the page; scanning the line pointer array in passing won't have
2681 : : * noticeable overhead. (We still maintain the BTP_HAS_GARBAGE flag despite
2682 : : * all this because !heapkeyspace indexes must still do a "getting tired"
2683 : : * linear search, and so are likely to get some benefit from using it as a
2684 : : * gating condition.)
2685 : : */
2686 : : static void
1806 pg@bowt.ie 2687 : 25247 : _bt_delete_or_dedup_one_page(Relation rel, Relation heapRel,
2688 : : BTInsertState insertstate,
2689 : : bool simpleonly, bool checkingunique,
2690 : : bool uniquedup, bool indexUnchanged)
2691 : : {
2692 : : OffsetNumber deletable[MaxIndexTuplesPerPage];
6964 bruce@momjian.us 2693 : 25247 : int ndeletable = 0;
2694 : : OffsetNumber offnum,
2695 : : minoff,
2696 : : maxoff;
1806 pg@bowt.ie 2697 : 25247 : Buffer buffer = insertstate->buf;
2698 : 25247 : BTScanInsert itup_key = insertstate->itup_key;
3478 kgrittn@postgresql.o 2699 : 25247 : Page page = BufferGetPage(buffer);
1306 michael@paquier.xyz 2700 : 25247 : BTPageOpaque opaque = BTPageGetOpaque(page);
2701 : :
2414 pg@bowt.ie 2702 [ - + ]: 25247 : Assert(P_ISLEAF(opaque));
1749 2703 [ + + - + ]: 25247 : Assert(simpleonly || itup_key->heapkeyspace);
2704 [ + + + - : 25247 : Assert(!simpleonly || (!checkingunique && !uniquedup && !indexUnchanged));
+ - - + ]
2705 : :
2706 : : /*
2707 : : * Scan over all items to see which ones need to be deleted according to
2708 : : * LP_DEAD flags. We'll usually manage to delete a few extra items that
2709 : : * are not marked LP_DEAD in passing. Often the extra items that actually
2710 : : * end up getting deleted are items that would have had their LP_DEAD bit
2711 : : * set before long anyway (if we opted not to include them as extras).
2712 : : */
2713 [ + + ]: 25247 : minoff = P_FIRSTDATAKEY(opaque);
7035 tgl@sss.pgh.pa.us 2714 : 25247 : maxoff = PageGetMaxOffsetNumber(page);
1749 pg@bowt.ie 2715 : 25247 : for (offnum = minoff;
7035 tgl@sss.pgh.pa.us 2716 [ + + ]: 6806452 : offnum <= maxoff;
2717 : 6781205 : offnum = OffsetNumberNext(offnum))
2718 : : {
6964 bruce@momjian.us 2719 : 6781205 : ItemId itemId = PageGetItemId(page, offnum);
2720 : :
6621 tgl@sss.pgh.pa.us 2721 [ + + ]: 6781205 : if (ItemIdIsDead(itemId))
7035 2722 : 129262 : deletable[ndeletable++] = offnum;
2723 : : }
2724 : :
2725 [ + + ]: 25247 : if (ndeletable > 0)
2726 : : {
1749 pg@bowt.ie 2727 : 3671 : _bt_simpledel_pass(rel, buffer, heapRel, deletable, ndeletable,
2728 : : insertstate->itup, minoff, maxoff);
1806 2729 : 3671 : insertstate->bounds_valid = false;
2730 : :
2731 : : /* Return when a page split has already been avoided */
2732 [ + + ]: 3671 : if (PageGetFreeSpace(page) >= insertstate->itemsz)
2733 : 11849 : return;
2734 : :
2735 : : /* Might as well assume duplicates (if checkingunique) */
2736 : 49 : uniquedup = true;
2737 : : }
2738 : :
2739 : : /*
2740 : : * We're done with simple deletion. Return early with callers that only
2741 : : * call here so that simple deletion can be considered. This includes
2742 : : * callers that explicitly ask for this and checkingunique callers that
2743 : : * probably don't have any version churn duplicates on the page.
2744 : : *
2745 : : * Note: The page's BTP_HAS_GARBAGE hint flag may still be set when we
2746 : : * return at this point (or when we go on the try either or both of our
2747 : : * other strategies and they also fail). We do not bother expending a
2748 : : * separate write to clear it, however. Caller will definitely clear it
2749 : : * when it goes on to split the page (note also that the deduplication
2750 : : * process will clear the flag in passing, just to keep things tidy).
2751 : : */
1749 2752 [ + - + + : 21625 : if (simpleonly || (checkingunique && !uniquedup))
+ + ]
2753 : : {
2754 [ - + ]: 8033 : Assert(!indexUnchanged);
1806 2755 : 8033 : return;
2756 : : }
2757 : :
2758 : : /* Assume bounds about to be invalidated (this is almost certain now) */
2759 : 13592 : insertstate->bounds_valid = false;
2760 : :
2761 : : /*
2762 : : * Perform bottom-up index deletion pass when executor hint indicated that
2763 : : * incoming item is logically unchanged, or for a unique index that is
2764 : : * known to have physical duplicates for some other reason. (There is a
2765 : : * large overlap between these two cases for a unique index. It's worth
2766 : : * having both triggering conditions in order to apply the optimization in
2767 : : * the event of successive related INSERT and DELETE statements.)
2768 : : *
2769 : : * We'll go on to do a deduplication pass when a bottom-up pass fails to
2770 : : * delete an acceptable amount of free space (a significant fraction of
2771 : : * the page, or space for the new item, whichever is greater).
2772 : : *
2773 : : * Note: Bottom-up index deletion uses the same equality/equivalence
2774 : : * routines as deduplication internally. However, it does not merge
2775 : : * together index tuples, so the same correctness considerations do not
2776 : : * apply. We deliberately omit an index-is-allequalimage test here.
2777 : : */
1749 2778 [ + + + + : 15512 : if ((indexUnchanged || uniquedup) &&
+ + ]
2779 : 1920 : _bt_bottomupdel_pass(rel, buffer, heapRel, insertstate->itemsz))
2780 : 194 : return;
2781 : :
2782 : : /* Perform deduplication pass (when enabled and index-is-allequalimage) */
1806 2783 [ + - - + : 13398 : if (BTGetDeduplicateItems(rel) && itup_key->allequalimage)
+ + + + +
+ + - ]
924 2784 : 13389 : _bt_dedup_pass(rel, buffer, insertstate->itup, insertstate->itemsz,
2785 [ + + + + ]: 13389 : (indexUnchanged || uniquedup));
2786 : : }
2787 : :
2788 : : /*
2789 : : * _bt_simpledel_pass - Simple index tuple deletion pass.
2790 : : *
2791 : : * We delete all LP_DEAD-set index tuples on a leaf page. The offset numbers
2792 : : * of all such tuples are determined by caller (caller passes these to us as
2793 : : * its 'deletable' argument).
2794 : : *
2795 : : * We might also delete extra index tuples that turn out to be safe to delete
2796 : : * in passing (though they must be cheap to check in passing to begin with).
2797 : : * There is no certainty that any extra tuples will be deleted, though. The
2798 : : * high level goal of the approach we take is to get the most out of each call
2799 : : * here (without noticeably increasing the per-call overhead compared to what
2800 : : * we need to do just to be able to delete the page's LP_DEAD-marked index
2801 : : * tuples).
2802 : : *
2803 : : * The number of extra index tuples that turn out to be deletable might
2804 : : * greatly exceed the number of LP_DEAD-marked index tuples due to various
2805 : : * locality related effects. For example, it's possible that the total number
2806 : : * of table blocks (pointed to by all TIDs on the leaf page) is naturally
2807 : : * quite low, in which case we might end up checking if it's possible to
2808 : : * delete _most_ index tuples on the page (without the tableam needing to
2809 : : * access additional table blocks). The tableam will sometimes stumble upon
2810 : : * _many_ extra deletable index tuples in indexes where this pattern is
2811 : : * common.
2812 : : *
2813 : : * See nbtree/README for further details on simple index tuple deletion.
2814 : : */
2815 : : static void
1749 2816 : 3671 : _bt_simpledel_pass(Relation rel, Buffer buffer, Relation heapRel,
2817 : : OffsetNumber *deletable, int ndeletable, IndexTuple newitem,
2818 : : OffsetNumber minoff, OffsetNumber maxoff)
2819 : : {
2820 : 3671 : Page page = BufferGetPage(buffer);
2821 : : BlockNumber *deadblocks;
2822 : : int ndeadblocks;
2823 : : TM_IndexDeleteOp delstate;
2824 : : OffsetNumber offnum;
2825 : :
2826 : : /* Get array of table blocks pointed to by LP_DEAD-set tuples */
2827 : 3671 : deadblocks = _bt_deadblocks(page, deletable, ndeletable, newitem,
2828 : : &ndeadblocks);
2829 : :
2830 : : /* Initialize tableam state that describes index deletion operation */
1454 2831 : 3671 : delstate.irel = rel;
2832 : 3671 : delstate.iblknum = BufferGetBlockNumber(buffer);
1749 2833 : 3671 : delstate.bottomup = false;
2834 : 3671 : delstate.bottomupfreespace = 0;
2835 : 3671 : delstate.ndeltids = 0;
2836 : 3671 : delstate.deltids = palloc(MaxTIDsPerBTreePage * sizeof(TM_IndexDelete));
2837 : 3671 : delstate.status = palloc(MaxTIDsPerBTreePage * sizeof(TM_IndexStatus));
2838 : :
2839 : 3671 : for (offnum = minoff;
2840 [ + + ]: 1044110 : offnum <= maxoff;
2841 : 1040439 : offnum = OffsetNumberNext(offnum))
2842 : : {
2843 : 1040439 : ItemId itemid = PageGetItemId(page, offnum);
2844 : 1040439 : IndexTuple itup = (IndexTuple) PageGetItem(page, itemid);
2845 : 1040439 : TM_IndexDelete *odeltid = &delstate.deltids[delstate.ndeltids];
2846 : 1040439 : TM_IndexStatus *ostatus = &delstate.status[delstate.ndeltids];
2847 : : BlockNumber tidblock;
2848 : : void *match;
2849 : :
2850 [ + + ]: 1040439 : if (!BTreeTupleIsPosting(itup))
2851 : : {
2852 : 993570 : tidblock = ItemPointerGetBlockNumber(&itup->t_tid);
2853 : 993570 : match = bsearch(&tidblock, deadblocks, ndeadblocks,
2854 : : sizeof(BlockNumber), _bt_blk_cmp);
2855 : :
2856 [ + + ]: 993570 : if (!match)
2857 : : {
2858 [ - + ]: 619464 : Assert(!ItemIdIsDead(itemid));
2859 : 619464 : continue;
2860 : : }
2861 : :
2862 : : /*
2863 : : * TID's table block is among those pointed to by the TIDs from
2864 : : * LP_DEAD-bit set tuples on page -- add TID to deltids
2865 : : */
2866 : 374106 : odeltid->tid = itup->t_tid;
2867 : 374106 : odeltid->id = delstate.ndeltids;
2868 : 374106 : ostatus->idxoffnum = offnum;
2869 : 374106 : ostatus->knowndeletable = ItemIdIsDead(itemid);
2870 : 374106 : ostatus->promising = false; /* unused */
2871 : 374106 : ostatus->freespace = 0; /* unused */
2872 : :
2873 : 374106 : delstate.ndeltids++;
2874 : : }
2875 : : else
2876 : : {
2877 : 46869 : int nitem = BTreeTupleGetNPosting(itup);
2878 : :
2879 [ + + ]: 231267 : for (int p = 0; p < nitem; p++)
2880 : : {
2881 : 184398 : ItemPointer tid = BTreeTupleGetPostingN(itup, p);
2882 : :
2883 : 184398 : tidblock = ItemPointerGetBlockNumber(tid);
2884 : 184398 : match = bsearch(&tidblock, deadblocks, ndeadblocks,
2885 : : sizeof(BlockNumber), _bt_blk_cmp);
2886 : :
2887 [ + + ]: 184398 : if (!match)
2888 : : {
2889 [ - + ]: 161996 : Assert(!ItemIdIsDead(itemid));
2890 : 161996 : continue;
2891 : : }
2892 : :
2893 : : /*
2894 : : * TID's table block is among those pointed to by the TIDs
2895 : : * from LP_DEAD-bit set tuples on page -- add TID to deltids
2896 : : */
2897 : 22402 : odeltid->tid = *tid;
2898 : 22402 : odeltid->id = delstate.ndeltids;
2899 : 22402 : ostatus->idxoffnum = offnum;
2900 : 22402 : ostatus->knowndeletable = ItemIdIsDead(itemid);
2901 : 22402 : ostatus->promising = false; /* unused */
2902 : 22402 : ostatus->freespace = 0; /* unused */
2903 : :
2904 : 22402 : odeltid++;
2905 : 22402 : ostatus++;
2906 : 22402 : delstate.ndeltids++;
2907 : : }
2908 : : }
2909 : : }
2910 : :
2911 : 3671 : pfree(deadblocks);
2912 : :
2913 [ - + ]: 3671 : Assert(delstate.ndeltids >= ndeletable);
2914 : :
2915 : : /* Physically delete LP_DEAD tuples (plus any delete-safe extra TIDs) */
2916 : 3671 : _bt_delitems_delete_check(rel, buffer, heapRel, &delstate);
2917 : :
2918 : 3671 : pfree(delstate.deltids);
2919 : 3671 : pfree(delstate.status);
2920 : 3671 : }
2921 : :
2922 : : /*
2923 : : * _bt_deadblocks() -- Get LP_DEAD related table blocks.
2924 : : *
2925 : : * Builds sorted and unique-ified array of table block numbers from index
2926 : : * tuple TIDs whose line pointers are marked LP_DEAD. Also adds the table
2927 : : * block from incoming newitem just in case it isn't among the LP_DEAD-related
2928 : : * table blocks.
2929 : : *
2930 : : * Always counting the newitem's table block as an LP_DEAD related block makes
2931 : : * sense because the cost is consistently low; it is practically certain that
2932 : : * the table block will not incur a buffer miss in tableam. On the other hand
2933 : : * the benefit is often quite high. There is a decent chance that there will
2934 : : * be some deletable items from this block, since in general most garbage
2935 : : * tuples became garbage in the recent past (in many cases this won't be the
2936 : : * first logical row that core code added to/modified in table block
2937 : : * recently).
2938 : : *
2939 : : * Returns final array, and sets *nblocks to its final size for caller.
2940 : : */
2941 : : static BlockNumber *
2942 : 3671 : _bt_deadblocks(Page page, OffsetNumber *deletable, int ndeletable,
2943 : : IndexTuple newitem, int *nblocks)
2944 : : {
2945 : : int spacentids,
2946 : : ntids;
2947 : : BlockNumber *tidblocks;
2948 : :
2949 : : /*
2950 : : * Accumulate each TID's block in array whose initial size has space for
2951 : : * one table block per LP_DEAD-set tuple (plus space for the newitem table
2952 : : * block). Array will only need to grow when there are LP_DEAD-marked
2953 : : * posting list tuples (which is not that common).
2954 : : */
2955 : 3671 : spacentids = ndeletable + 1;
2956 : 3671 : ntids = 0;
2957 : 3671 : tidblocks = (BlockNumber *) palloc(sizeof(BlockNumber) * spacentids);
2958 : :
2959 : : /*
2960 : : * First add the table block for the incoming newitem. This is the one
2961 : : * case where simple deletion can visit a table block that doesn't have
2962 : : * any known deletable items.
2963 : : */
2964 [ + - - + ]: 3671 : Assert(!BTreeTupleIsPosting(newitem) && !BTreeTupleIsPivot(newitem));
2965 : 3671 : tidblocks[ntids++] = ItemPointerGetBlockNumber(&newitem->t_tid);
2966 : :
2967 [ + + ]: 132933 : for (int i = 0; i < ndeletable; i++)
2968 : : {
2969 : 129262 : ItemId itemid = PageGetItemId(page, deletable[i]);
2970 : 129262 : IndexTuple itup = (IndexTuple) PageGetItem(page, itemid);
2971 : :
2972 [ - + ]: 129262 : Assert(ItemIdIsDead(itemid));
2973 : :
2974 [ + + ]: 129262 : if (!BTreeTupleIsPosting(itup))
2975 : : {
2976 [ + + ]: 124967 : if (ntids + 1 > spacentids)
2977 : : {
2978 : 107 : spacentids *= 2;
2979 : : tidblocks = (BlockNumber *)
2980 : 107 : repalloc(tidblocks, sizeof(BlockNumber) * spacentids);
2981 : : }
2982 : :
2983 : 124967 : tidblocks[ntids++] = ItemPointerGetBlockNumber(&itup->t_tid);
2984 : : }
2985 : : else
2986 : : {
2987 : 4295 : int nposting = BTreeTupleGetNPosting(itup);
2988 : :
2989 [ + + ]: 4295 : if (ntids + nposting > spacentids)
2990 : : {
2991 : 98 : spacentids = Max(spacentids * 2, ntids + nposting);
2992 : : tidblocks = (BlockNumber *)
2993 : 98 : repalloc(tidblocks, sizeof(BlockNumber) * spacentids);
2994 : : }
2995 : :
2996 [ + + ]: 14281 : for (int j = 0; j < nposting; j++)
2997 : : {
2998 : 9986 : ItemPointer tid = BTreeTupleGetPostingN(itup, j);
2999 : :
3000 : 9986 : tidblocks[ntids++] = ItemPointerGetBlockNumber(tid);
3001 : : }
3002 : : }
3003 : : }
3004 : :
3005 : 3671 : qsort(tidblocks, ntids, sizeof(BlockNumber), _bt_blk_cmp);
3006 : 3671 : *nblocks = qunique(tidblocks, ntids, sizeof(BlockNumber), _bt_blk_cmp);
3007 : :
3008 : 3671 : return tidblocks;
3009 : : }
3010 : :
3011 : : /*
3012 : : * _bt_blk_cmp() -- qsort comparison function for _bt_simpledel_pass
3013 : : */
3014 : : static inline int
3015 : 2654729 : _bt_blk_cmp(const void *arg1, const void *arg2)
3016 : : {
3017 : 2654729 : BlockNumber b1 = *((BlockNumber *) arg1);
3018 : 2654729 : BlockNumber b2 = *((BlockNumber *) arg2);
3019 : :
620 nathan@postgresql.or 3020 : 2654729 : return pg_cmp_u32(b1, b2);
3021 : : }
|
