Age Owner Branch data TLA Line data Source code
1 : : /*-------------------------------------------------------------------------
2 : : *
3 : : * ginfast.c
4 : : * Fast insert routines for the Postgres inverted index access method.
5 : : * Pending entries are stored in linear list of pages. Later on
6 : : * (typically during VACUUM), ginInsertCleanup() will be invoked to
7 : : * transfer pending entries into the regular index structure. This
8 : : * wins because bulk insertion is much more efficient than retail.
9 : : *
10 : : * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
11 : : * Portions Copyright (c) 1994, Regents of the University of California
12 : : *
13 : : * IDENTIFICATION
14 : : * src/backend/access/gin/ginfast.c
15 : : *
16 : : *-------------------------------------------------------------------------
17 : : */
18 : :
19 : : #include "postgres.h"
20 : :
21 : : #include "access/gin_private.h"
22 : : #include "access/ginxlog.h"
23 : : #include "access/xlog.h"
24 : : #include "access/xloginsert.h"
25 : : #include "catalog/pg_am.h"
26 : : #include "commands/vacuum.h"
27 : : #include "miscadmin.h"
28 : : #include "port/pg_bitutils.h"
29 : : #include "postmaster/autovacuum.h"
30 : : #include "storage/indexfsm.h"
31 : : #include "storage/lmgr.h"
32 : : #include "storage/predicate.h"
33 : : #include "utils/acl.h"
34 : : #include "utils/fmgrprotos.h"
35 : : #include "utils/memutils.h"
36 : : #include "utils/rel.h"
37 : :
38 : : /* GUC parameter */
39 : : int gin_pending_list_limit = 0;
40 : :
41 : : #define GIN_PAGE_FREESIZE \
42 : : ( (Size) BLCKSZ - MAXALIGN(SizeOfPageHeaderData) - MAXALIGN(sizeof(GinPageOpaqueData)) )
43 : :
44 : : typedef struct KeyArray
45 : : {
46 : : Datum *keys; /* expansible array */
47 : : GinNullCategory *categories; /* another expansible array */
48 : : int32 nvalues; /* current number of valid entries */
49 : : int32 maxvalues; /* allocated size of arrays */
50 : : } KeyArray;
51 : :
52 : :
53 : : /*
54 : : * Build a pending-list page from the given array of tuples, and write it out.
55 : : *
56 : : * Returns amount of free space left on the page.
57 : : */
58 : : static int32
6010 tgl@sss.pgh.pa.us 59 :CBC 1476 : writeListPage(Relation index, Buffer buffer,
60 : : IndexTuple *tuples, int32 ntuples, BlockNumber rightlink)
61 : : {
3426 kgrittn@postgresql.o 62 : 1476 : Page page = BufferGetPage(buffer);
63 : : int32 i,
64 : : freesize,
5931 bruce@momjian.us 65 : 1476 : size = 0;
66 : : OffsetNumber l,
67 : : off;
68 : : PGAlignedBlock workspace;
69 : : char *ptr;
70 : :
6010 tgl@sss.pgh.pa.us 71 : 1476 : START_CRIT_SECTION();
72 : :
73 : 1476 : GinInitBuffer(buffer, GIN_LIST);
74 : :
75 : 1476 : off = FirstOffsetNumber;
2562 76 : 1476 : ptr = workspace.data;
77 : :
5931 bruce@momjian.us 78 [ + + ]: 8610 : for (i = 0; i < ntuples; i++)
79 : : {
80 : 7134 : int this_size = IndexTupleSize(tuples[i]);
81 : :
6010 tgl@sss.pgh.pa.us 82 : 7134 : memcpy(ptr, tuples[i], this_size);
83 : 7134 : ptr += this_size;
84 : 7134 : size += this_size;
85 : :
5931 bruce@momjian.us 86 : 7134 : l = PageAddItem(page, (Item) tuples[i], this_size, off, false, false);
87 : :
6010 tgl@sss.pgh.pa.us 88 [ - + ]: 7134 : if (l == InvalidOffsetNumber)
6010 tgl@sss.pgh.pa.us 89 [ # # ]:UBC 0 : elog(ERROR, "failed to add item to index page in \"%s\"",
90 : : RelationGetRelationName(index));
91 : :
6010 tgl@sss.pgh.pa.us 92 :CBC 7134 : off++;
93 : : }
94 : :
95 [ - + ]: 1476 : Assert(size <= BLCKSZ); /* else we overran workspace */
96 : :
97 : 1476 : GinPageGetOpaque(page)->rightlink = rightlink;
98 : :
99 : : /*
100 : : * tail page may contain only whole row(s) or final part of row placed on
101 : : * previous pages (a "row" here meaning all the index tuples generated for
102 : : * one heap tuple)
103 : : */
5931 bruce@momjian.us 104 [ + - ]: 1476 : if (rightlink == InvalidBlockNumber)
105 : : {
6010 tgl@sss.pgh.pa.us 106 : 1476 : GinPageSetFullRow(page);
107 : 1476 : GinPageGetOpaque(page)->maxoff = 1;
108 : : }
109 : : else
110 : : {
6010 tgl@sss.pgh.pa.us 111 :UBC 0 : GinPageGetOpaque(page)->maxoff = 0;
112 : : }
113 : :
6010 tgl@sss.pgh.pa.us 114 :CBC 1476 : MarkBufferDirty(buffer);
115 : :
5381 rhaas@postgresql.org 116 [ + + + + : 1476 : if (RelationNeedsWAL(index))
+ - + - ]
117 : : {
118 : : ginxlogInsertListPage data;
119 : : XLogRecPtr recptr;
120 : :
5835 tgl@sss.pgh.pa.us 121 : 584 : data.rightlink = rightlink;
122 : 584 : data.ntuples = ntuples;
123 : :
3943 heikki.linnakangas@i 124 : 584 : XLogBeginInsert();
207 peter@eisentraut.org 125 : 584 : XLogRegisterData(&data, sizeof(ginxlogInsertListPage));
126 : :
3943 heikki.linnakangas@i 127 : 584 : XLogRegisterBuffer(0, buffer, REGBUF_WILL_INIT);
2562 tgl@sss.pgh.pa.us 128 : 584 : XLogRegisterBufData(0, workspace.data, size);
129 : :
3943 heikki.linnakangas@i 130 : 584 : recptr = XLogInsert(RM_GIN_ID, XLOG_GIN_INSERT_LISTPAGE);
6010 tgl@sss.pgh.pa.us 131 : 584 : PageSetLSN(page, recptr);
132 : : }
133 : :
134 : : /* get free space before releasing buffer */
5835 135 : 1476 : freesize = PageGetExactFreeSpace(page);
136 : :
6010 137 : 1476 : UnlockReleaseBuffer(buffer);
138 : :
139 [ - + ]: 1476 : END_CRIT_SECTION();
140 : :
141 : 1476 : return freesize;
142 : : }
143 : :
144 : : static void
145 : 1476 : makeSublist(Relation index, IndexTuple *tuples, int32 ntuples,
146 : : GinMetaPageData *res)
147 : : {
5931 bruce@momjian.us 148 : 1476 : Buffer curBuffer = InvalidBuffer;
149 : 1476 : Buffer prevBuffer = InvalidBuffer;
150 : : int i,
151 : 1476 : size = 0,
152 : : tupsize;
153 : 1476 : int startTuple = 0;
154 : :
6010 tgl@sss.pgh.pa.us 155 [ - + ]: 1476 : Assert(ntuples > 0);
156 : :
157 : : /*
158 : : * Split tuples into pages
159 : : */
5931 bruce@momjian.us 160 [ + + ]: 8610 : for (i = 0; i < ntuples; i++)
161 : : {
162 [ + + ]: 7134 : if (curBuffer == InvalidBuffer)
163 : : {
6010 tgl@sss.pgh.pa.us 164 : 1476 : curBuffer = GinNewBuffer(index);
165 : :
5931 bruce@momjian.us 166 [ - + ]: 1476 : if (prevBuffer != InvalidBuffer)
167 : : {
6010 tgl@sss.pgh.pa.us 168 :UBC 0 : res->nPendingPages++;
169 : 0 : writeListPage(index, prevBuffer,
5835 170 : 0 : tuples + startTuple,
171 : : i - startTuple,
172 : : BufferGetBlockNumber(curBuffer));
173 : : }
174 : : else
175 : : {
6010 tgl@sss.pgh.pa.us 176 :CBC 1476 : res->head = BufferGetBlockNumber(curBuffer);
177 : : }
178 : :
179 : 1476 : prevBuffer = curBuffer;
180 : 1476 : startTuple = i;
181 : 1476 : size = 0;
182 : : }
183 : :
184 : 7134 : tupsize = MAXALIGN(IndexTupleSize(tuples[i])) + sizeof(ItemIdData);
185 : :
5835 186 [ - + ]: 7134 : if (size + tupsize > GinListPageSize)
187 : : {
188 : : /* won't fit, force a new page and reprocess */
6010 tgl@sss.pgh.pa.us 189 :UBC 0 : i--;
190 : 0 : curBuffer = InvalidBuffer;
191 : : }
192 : : else
193 : : {
6010 tgl@sss.pgh.pa.us 194 :CBC 7134 : size += tupsize;
195 : : }
196 : : }
197 : :
198 : : /*
199 : : * Write last page
200 : : */
201 : 1476 : res->tail = BufferGetBlockNumber(curBuffer);
202 : 2952 : res->tailFreeSize = writeListPage(index, curBuffer,
5835 203 : 1476 : tuples + startTuple,
204 : : ntuples - startTuple,
205 : : InvalidBlockNumber);
6010 206 : 1476 : res->nPendingPages++;
207 : : /* that was only one heap tuple */
208 : 1476 : res->nPendingHeapTuples = 1;
209 : 1476 : }
210 : :
211 : : /*
212 : : * Write the index tuples contained in *collector into the index's
213 : : * pending list.
214 : : *
215 : : * Function guarantees that all these tuples will be inserted consecutively,
216 : : * preserving order
217 : : */
218 : : void
5356 219 : 132941 : ginHeapTupleFastInsert(GinState *ginstate, GinTupleCollector *collector)
220 : : {
221 : 132941 : Relation index = ginstate->index;
222 : : Buffer metabuffer;
223 : : Page metapage;
5931 bruce@momjian.us 224 : 132941 : GinMetaPageData *metadata = NULL;
225 : 132941 : Buffer buffer = InvalidBuffer;
226 : 132941 : Page page = NULL;
227 : : ginxlogUpdateMeta data;
228 : 132941 : bool separateList = false;
229 : 132941 : bool needCleanup = false;
230 : : int cleanupSize;
231 : : bool needWal;
232 : :
233 [ - + ]: 132941 : if (collector->ntuples == 0)
6010 tgl@sss.pgh.pa.us 234 :UBC 0 : return;
235 : :
3943 heikki.linnakangas@i 236 [ + + + + :CBC 132941 : needWal = RelationNeedsWAL(index);
+ - + - ]
237 : :
1158 rhaas@postgresql.org 238 : 132941 : data.locator = index->rd_locator;
6010 tgl@sss.pgh.pa.us 239 : 132941 : data.ntuples = 0;
240 : 132941 : data.newRightlink = data.prevTail = InvalidBlockNumber;
241 : :
242 : 132941 : metabuffer = ReadBuffer(index, GIN_METAPAGE_BLKNO);
3426 kgrittn@postgresql.o 243 : 132941 : metapage = BufferGetPage(metabuffer);
244 : :
245 : : /*
246 : : * An insertion to the pending list could logically belong anywhere in the
247 : : * tree, so it conflicts with all serializable scans. All scans acquire a
248 : : * predicate lock on the metabuffer to represent that. Therefore we'll
249 : : * check for conflicts in, but not until we have the page locked and are
250 : : * ready to modify the page.
251 : : */
252 : :
5835 tgl@sss.pgh.pa.us 253 [ - + ]: 132941 : if (collector->sumsize + collector->ntuples * sizeof(ItemIdData) > GinListPageSize)
254 : : {
255 : : /*
256 : : * Total size is greater than one page => make sublist
257 : : */
6010 tgl@sss.pgh.pa.us 258 :UBC 0 : separateList = true;
259 : : }
260 : : else
261 : : {
6010 tgl@sss.pgh.pa.us 262 :CBC 132941 : LockBuffer(metabuffer, GIN_EXCLUSIVE);
263 : 132941 : metadata = GinPageGetMeta(metapage);
264 : :
5931 bruce@momjian.us 265 [ + + ]: 132941 : if (metadata->head == InvalidBlockNumber ||
266 [ + + ]: 132879 : collector->sumsize + collector->ntuples * sizeof(ItemIdData) > metadata->tailFreeSize)
267 : : {
268 : : /*
269 : : * Pending list is empty or total size is greater than freespace
270 : : * on tail page => make sublist
271 : : *
272 : : * We unlock metabuffer to keep high concurrency
273 : : */
6010 tgl@sss.pgh.pa.us 274 : 1476 : separateList = true;
275 : 1476 : LockBuffer(metabuffer, GIN_UNLOCK);
276 : : }
277 : : }
278 : :
5931 bruce@momjian.us 279 [ + + ]: 132941 : if (separateList)
280 : : {
281 : : /*
282 : : * We should make sublist separately and append it to the tail
283 : : */
284 : : GinMetaPageData sublist;
285 : :
5835 tgl@sss.pgh.pa.us 286 : 1476 : memset(&sublist, 0, sizeof(GinMetaPageData));
6010 287 : 1476 : makeSublist(index, collector->tuples, collector->ntuples, &sublist);
288 : :
289 : : /*
290 : : * metapage was unlocked, see above
291 : : */
292 : 1476 : LockBuffer(metabuffer, GIN_EXCLUSIVE);
293 : 1476 : metadata = GinPageGetMeta(metapage);
294 : :
796 tmunro@postgresql.or 295 : 1476 : CheckForSerializableConflictIn(index, NULL, GIN_METAPAGE_BLKNO);
296 : :
5931 bruce@momjian.us 297 [ + + ]: 1473 : if (metadata->head == InvalidBlockNumber)
298 : : {
299 : : /*
300 : : * Main list is empty, so just insert sublist as main list
301 : : */
6010 tgl@sss.pgh.pa.us 302 : 57 : START_CRIT_SECTION();
303 : :
5356 304 : 57 : metadata->head = sublist.head;
305 : 57 : metadata->tail = sublist.tail;
306 : 57 : metadata->tailFreeSize = sublist.tailFreeSize;
307 : :
308 : 57 : metadata->nPendingPages = sublist.nPendingPages;
309 : 57 : metadata->nPendingHeapTuples = sublist.nPendingHeapTuples;
310 : :
1059 michael@paquier.xyz 311 [ + + ]: 57 : if (needWal)
312 : 47 : XLogBeginInsert();
313 : : }
314 : : else
315 : : {
316 : : /*
317 : : * Merge lists
318 : : */
6010 tgl@sss.pgh.pa.us 319 : 1416 : data.prevTail = metadata->tail;
5835 320 : 1416 : data.newRightlink = sublist.head;
321 : :
6010 322 : 1416 : buffer = ReadBuffer(index, metadata->tail);
323 : 1416 : LockBuffer(buffer, GIN_EXCLUSIVE);
3426 kgrittn@postgresql.o 324 : 1416 : page = BufferGetPage(buffer);
325 : :
6010 tgl@sss.pgh.pa.us 326 [ - + ]: 1416 : Assert(GinPageGetOpaque(page)->rightlink == InvalidBlockNumber);
327 : :
328 : 1416 : START_CRIT_SECTION();
329 : :
330 : 1416 : GinPageGetOpaque(page)->rightlink = sublist.head;
331 : :
5835 332 : 1416 : MarkBufferDirty(buffer);
333 : :
6010 334 : 1416 : metadata->tail = sublist.tail;
335 : 1416 : metadata->tailFreeSize = sublist.tailFreeSize;
336 : :
337 : 1416 : metadata->nPendingPages += sublist.nPendingPages;
338 : 1416 : metadata->nPendingHeapTuples += sublist.nPendingHeapTuples;
339 : :
3943 heikki.linnakangas@i 340 [ + + ]: 1416 : if (needWal)
341 : : {
1059 michael@paquier.xyz 342 : 534 : XLogBeginInsert();
3943 heikki.linnakangas@i 343 : 534 : XLogRegisterBuffer(1, buffer, REGBUF_STANDARD);
344 : : }
345 : : }
346 : : }
347 : : else
348 : : {
349 : : /*
350 : : * Insert into tail page. Metapage is already locked
351 : : */
352 : : OffsetNumber l,
353 : : off;
354 : : int i,
355 : : tupsize;
356 : : char *ptr;
357 : : char *collectordata;
358 : :
796 tmunro@postgresql.or 359 : 131465 : CheckForSerializableConflictIn(index, NULL, GIN_METAPAGE_BLKNO);
360 : :
6010 tgl@sss.pgh.pa.us 361 : 131465 : buffer = ReadBuffer(index, metadata->tail);
362 : 131465 : LockBuffer(buffer, GIN_EXCLUSIVE);
3426 kgrittn@postgresql.o 363 : 131465 : page = BufferGetPage(buffer);
364 : :
6010 tgl@sss.pgh.pa.us 365 [ + - ]: 131465 : off = (PageIsEmpty(page)) ? FirstOffsetNumber :
5931 bruce@momjian.us 366 : 131465 : OffsetNumberNext(PageGetMaxOffsetNumber(page));
367 : :
3943 heikki.linnakangas@i 368 : 131465 : collectordata = ptr = (char *) palloc(collector->sumsize);
369 : :
6010 tgl@sss.pgh.pa.us 370 : 131465 : data.ntuples = collector->ntuples;
371 : :
1059 michael@paquier.xyz 372 : 131465 : START_CRIT_SECTION();
373 : :
3943 heikki.linnakangas@i 374 [ + + ]: 131465 : if (needWal)
375 : 72310 : XLogBeginInsert();
376 : :
377 : : /*
378 : : * Increase counter of heap tuples
379 : : */
5931 bruce@momjian.us 380 [ - + ]: 131465 : Assert(GinPageGetOpaque(page)->maxoff <= metadata->nPendingHeapTuples);
6010 tgl@sss.pgh.pa.us 381 : 131465 : GinPageGetOpaque(page)->maxoff++;
382 : 131465 : metadata->nPendingHeapTuples++;
383 : :
5931 bruce@momjian.us 384 [ + + ]: 705204 : for (i = 0; i < collector->ntuples; i++)
385 : : {
6010 tgl@sss.pgh.pa.us 386 : 573739 : tupsize = IndexTupleSize(collector->tuples[i]);
5931 bruce@momjian.us 387 : 573739 : l = PageAddItem(page, (Item) collector->tuples[i], tupsize, off, false, false);
388 : :
6010 tgl@sss.pgh.pa.us 389 [ - + ]: 573739 : if (l == InvalidOffsetNumber)
6010 tgl@sss.pgh.pa.us 390 [ # # ]:UBC 0 : elog(ERROR, "failed to add item to index page in \"%s\"",
391 : : RelationGetRelationName(index));
392 : :
6010 tgl@sss.pgh.pa.us 393 :CBC 573739 : memcpy(ptr, collector->tuples[i], tupsize);
5931 bruce@momjian.us 394 : 573739 : ptr += tupsize;
395 : :
6010 tgl@sss.pgh.pa.us 396 : 573739 : off++;
397 : : }
398 : :
3943 heikki.linnakangas@i 399 [ - + ]: 131465 : Assert((ptr - collectordata) <= collector->sumsize);
400 : :
684 jdavis@postgresql.or 401 : 131465 : MarkBufferDirty(buffer);
402 : :
3943 heikki.linnakangas@i 403 [ + + ]: 131465 : if (needWal)
404 : : {
405 : 72310 : XLogRegisterBuffer(1, buffer, REGBUF_STANDARD);
406 : 72310 : XLogRegisterBufData(1, collectordata, collector->sumsize);
407 : : }
408 : :
5835 tgl@sss.pgh.pa.us 409 : 131465 : metadata->tailFreeSize = PageGetExactFreeSpace(page);
410 : : }
411 : :
412 : : /*
413 : : * Set pd_lower just past the end of the metadata. This is essential,
414 : : * because without doing so, metadata will be lost if xlog.c compresses
415 : : * the page. (We must do this here because pre-v11 versions of PG did not
416 : : * set the metapage's pd_lower correctly, so a pg_upgraded index might
417 : : * contain the wrong value.)
418 : : */
2865 419 : 132938 : ((PageHeader) metapage)->pd_lower =
420 : 132938 : ((char *) metadata + sizeof(GinMetaPageData)) - (char *) metapage;
421 : :
422 : : /*
423 : : * Write metabuffer, make xlog entry
424 : : */
6010 425 : 132938 : MarkBufferDirty(metabuffer);
426 : :
3943 heikki.linnakangas@i 427 [ + + ]: 132938 : if (needWal)
428 : : {
429 : : XLogRecPtr recptr;
430 : :
5835 tgl@sss.pgh.pa.us 431 : 72891 : memcpy(&data.metadata, metadata, sizeof(GinMetaPageData));
432 : :
2865 433 : 72891 : XLogRegisterBuffer(0, metabuffer, REGBUF_WILL_INIT | REGBUF_STANDARD);
207 peter@eisentraut.org 434 : 72891 : XLogRegisterData(&data, sizeof(ginxlogUpdateMeta));
435 : :
3943 heikki.linnakangas@i 436 : 72891 : recptr = XLogInsert(RM_GIN_ID, XLOG_GIN_UPDATE_META_PAGE);
6010 tgl@sss.pgh.pa.us 437 : 72891 : PageSetLSN(metapage, recptr);
438 : :
5931 bruce@momjian.us 439 [ + + ]: 72891 : if (buffer != InvalidBuffer)
440 : : {
6010 tgl@sss.pgh.pa.us 441 : 72844 : PageSetLSN(page, recptr);
442 : : }
443 : : }
444 : :
445 [ + + ]: 132938 : if (buffer != InvalidBuffer)
446 : 132881 : UnlockReleaseBuffer(buffer);
447 : :
448 : : /*
449 : : * Force pending list cleanup when it becomes too long. And,
450 : : * ginInsertCleanup could take significant amount of time, so we prefer to
451 : : * call it when it can do all the work in a single collection cycle. In
452 : : * non-vacuum mode, it shouldn't require maintenance_work_mem, so fire it
453 : : * while pending list is still small enough to fit into
454 : : * gin_pending_list_limit.
455 : : *
456 : : * ginInsertCleanup() should not be called inside our CRIT_SECTION.
457 : : */
3952 fujii@postgresql.org 458 [ + - - + : 132938 : cleanupSize = GinGetPendingListCleanupSize(index);
+ + + - ]
218 tgl@sss.pgh.pa.us 459 [ - + ]: 132938 : if (metadata->nPendingPages * GIN_PAGE_FREESIZE > cleanupSize * (Size) 1024)
6010 tgl@sss.pgh.pa.us 460 :UBC 0 : needCleanup = true;
461 : :
6010 tgl@sss.pgh.pa.us 462 :CBC 132938 : UnlockReleaseBuffer(metabuffer);
463 : :
464 [ - + ]: 132938 : END_CRIT_SECTION();
465 : :
466 : : /*
467 : : * Since it could contend with concurrent cleanup process we cleanup
468 : : * pending list not forcibly.
469 : : */
5931 bruce@momjian.us 470 [ - + ]: 132938 : if (needCleanup)
2851 rhaas@postgresql.org 471 :UBC 0 : ginInsertCleanup(ginstate, false, true, false, NULL);
472 : : }
473 : :
474 : : /*
475 : : * Create temporary index tuples for a single indexable item (one index column
476 : : * for the heap tuple specified by ht_ctid), and append them to the array
477 : : * in *collector. They will subsequently be written out using
478 : : * ginHeapTupleFastInsert. Note that to guarantee consistent state, all
479 : : * temp tuples for a given heap tuple must be written in one call to
480 : : * ginHeapTupleFastInsert.
481 : : */
482 : : void
5356 tgl@sss.pgh.pa.us 483 :CBC 192980 : ginHeapTupleFastCollect(GinState *ginstate,
484 : : GinTupleCollector *collector,
485 : : OffsetNumber attnum, Datum value, bool isNull,
486 : : ItemPointer ht_ctid)
487 : : {
488 : : Datum *entries;
489 : : GinNullCategory *categories;
490 : : int32 i,
491 : : nentries;
492 : :
493 : : /*
494 : : * Extract the key values that need to be inserted in the index
495 : : */
496 : 192980 : entries = ginExtractEntries(ginstate, attnum, value, isNull,
497 : : &nentries, &categories);
498 : :
499 : : /*
500 : : * Protect against integer overflow in allocation calculations
501 : : */
2453 502 [ + - ]: 192980 : if (nentries < 0 ||
503 [ - + ]: 192980 : collector->ntuples + nentries > MaxAllocSize / sizeof(IndexTuple))
2453 tgl@sss.pgh.pa.us 504 [ # # ]:UBC 0 : elog(ERROR, "too many entries for GIN index");
505 : :
506 : : /*
507 : : * Allocate/reallocate memory for storing collected tuples
508 : : */
5931 bruce@momjian.us 509 [ + + ]:CBC 192980 : if (collector->tuples == NULL)
510 : : {
511 : : /*
512 : : * Determine the number of elements to allocate in the tuples array
513 : : * initially. Make it a power of 2 to avoid wasting memory when
514 : : * resizing (since palloc likes powers of 2).
515 : : */
1977 drowley@postgresql.o 516 : 132941 : collector->lentuples = pg_nextpower2_32(Max(16, nentries));
1090 peter@eisentraut.org 517 : 132941 : collector->tuples = palloc_array(IndexTuple, collector->lentuples);
518 : : }
2453 tgl@sss.pgh.pa.us 519 [ - + ]: 60039 : else if (collector->lentuples < collector->ntuples + nentries)
520 : : {
521 : : /*
522 : : * Advance lentuples to the next suitable power of 2. This won't
523 : : * overflow, though we could get to a value that exceeds
524 : : * MaxAllocSize/sizeof(IndexTuple), causing an error in repalloc.
525 : : */
1977 drowley@postgresql.o 526 :UBC 0 : collector->lentuples = pg_nextpower2_32(collector->ntuples + nentries);
1090 peter@eisentraut.org 527 : 0 : collector->tuples = repalloc_array(collector->tuples,
528 : : IndexTuple, collector->lentuples);
529 : : }
530 : :
531 : : /*
532 : : * Build an index tuple for each key value, and add to array. In pending
533 : : * tuples we just stick the heap TID into t_tid.
534 : : */
6010 tgl@sss.pgh.pa.us 535 [ + + ]:CBC 773853 : for (i = 0; i < nentries; i++)
536 : : {
537 : : IndexTuple itup;
538 : :
5356 539 : 580873 : itup = GinFormTuple(ginstate, attnum, entries[i], categories[i],
540 : : NULL, 0, 0, true);
541 : 580873 : itup->t_tid = *ht_ctid;
542 : 580873 : collector->tuples[collector->ntuples++] = itup;
543 : 580873 : collector->sumsize += IndexTupleSize(itup);
544 : : }
6010 545 : 192980 : }
546 : :
547 : : /*
548 : : * Deletes pending list pages up to (not including) newHead page.
549 : : * If newHead == InvalidBlockNumber then function drops the whole list.
550 : : *
551 : : * metapage is pinned and exclusive-locked throughout this function.
552 : : */
553 : : static void
554 : 29 : shiftList(Relation index, Buffer metabuffer, BlockNumber newHead,
555 : : bool fill_fsm, IndexBulkDeleteResult *stats)
556 : : {
557 : : Page metapage;
558 : : GinMetaPageData *metadata;
559 : : BlockNumber blknoToDelete;
560 : :
3426 kgrittn@postgresql.o 561 : 29 : metapage = BufferGetPage(metabuffer);
6010 tgl@sss.pgh.pa.us 562 : 29 : metadata = GinPageGetMeta(metapage);
563 : 29 : blknoToDelete = metadata->head;
564 : :
565 : : do
566 : : {
567 : : Page page;
568 : : int i;
5931 bruce@momjian.us 569 : 110 : int64 nDeletedHeapTuples = 0;
570 : : ginxlogDeleteListPages data;
571 : : Buffer buffers[GIN_NDELETE_AT_ONCE];
572 : : BlockNumber freespace[GIN_NDELETE_AT_ONCE];
573 : :
6010 tgl@sss.pgh.pa.us 574 : 110 : data.ndeleted = 0;
575 [ + + + + ]: 1554 : while (data.ndeleted < GIN_NDELETE_AT_ONCE && blknoToDelete != newHead)
576 : : {
3652 teodor@sigaev.ru 577 : 1444 : freespace[data.ndeleted] = blknoToDelete;
5931 bruce@momjian.us 578 : 1444 : buffers[data.ndeleted] = ReadBuffer(index, blknoToDelete);
579 : 1444 : LockBuffer(buffers[data.ndeleted], GIN_EXCLUSIVE);
3426 kgrittn@postgresql.o 580 : 1444 : page = BufferGetPage(buffers[data.ndeleted]);
581 : :
6010 tgl@sss.pgh.pa.us 582 : 1444 : data.ndeleted++;
583 : :
3418 teodor@sigaev.ru 584 [ - + ]: 1444 : Assert(!GinPageIsDeleted(page));
585 : :
6010 tgl@sss.pgh.pa.us 586 : 1444 : nDeletedHeapTuples += GinPageGetOpaque(page)->maxoff;
5931 bruce@momjian.us 587 : 1444 : blknoToDelete = GinPageGetOpaque(page)->rightlink;
588 : : }
589 : :
6010 tgl@sss.pgh.pa.us 590 [ + + ]: 110 : if (stats)
591 : 109 : stats->pages_deleted += data.ndeleted;
592 : :
593 : : /*
594 : : * This operation touches an unusually large number of pages, so
595 : : * prepare the XLogInsert machinery for that before entering the
596 : : * critical section.
597 : : */
3942 heikki.linnakangas@i 598 [ + + + + : 110 : if (RelationNeedsWAL(index))
+ - + - ]
599 : 53 : XLogEnsureRecordSpace(data.ndeleted, 0);
600 : :
6010 tgl@sss.pgh.pa.us 601 : 110 : START_CRIT_SECTION();
602 : :
603 : 110 : metadata->head = blknoToDelete;
604 : :
5931 bruce@momjian.us 605 [ - + ]: 110 : Assert(metadata->nPendingPages >= data.ndeleted);
6010 tgl@sss.pgh.pa.us 606 : 110 : metadata->nPendingPages -= data.ndeleted;
5931 bruce@momjian.us 607 [ - + ]: 110 : Assert(metadata->nPendingHeapTuples >= nDeletedHeapTuples);
6010 tgl@sss.pgh.pa.us 608 : 110 : metadata->nPendingHeapTuples -= nDeletedHeapTuples;
609 : :
5931 bruce@momjian.us 610 [ + + ]: 110 : if (blknoToDelete == InvalidBlockNumber)
611 : : {
6010 tgl@sss.pgh.pa.us 612 : 29 : metadata->tail = InvalidBlockNumber;
613 : 29 : metadata->tailFreeSize = 0;
614 : 29 : metadata->nPendingPages = 0;
615 : 29 : metadata->nPendingHeapTuples = 0;
616 : : }
617 : :
618 : : /*
619 : : * Set pd_lower just past the end of the metadata. This is essential,
620 : : * because without doing so, metadata will be lost if xlog.c
621 : : * compresses the page. (We must do this here because pre-v11
622 : : * versions of PG did not set the metapage's pd_lower correctly, so a
623 : : * pg_upgraded index might contain the wrong value.)
624 : : */
2865 625 : 110 : ((PageHeader) metapage)->pd_lower =
626 : 110 : ((char *) metadata + sizeof(GinMetaPageData)) - (char *) metapage;
627 : :
5931 bruce@momjian.us 628 : 110 : MarkBufferDirty(metabuffer);
629 : :
630 [ + + ]: 1554 : for (i = 0; i < data.ndeleted; i++)
631 : : {
3426 kgrittn@postgresql.o 632 : 1444 : page = BufferGetPage(buffers[i]);
5931 bruce@momjian.us 633 : 1444 : GinPageGetOpaque(page)->flags = GIN_DELETED;
634 : 1444 : MarkBufferDirty(buffers[i]);
635 : : }
636 : :
5381 rhaas@postgresql.org 637 [ + + + + : 110 : if (RelationNeedsWAL(index))
+ - + - ]
638 : : {
639 : : XLogRecPtr recptr;
640 : :
3943 heikki.linnakangas@i 641 : 53 : XLogBeginInsert();
2865 tgl@sss.pgh.pa.us 642 : 53 : XLogRegisterBuffer(0, metabuffer,
643 : : REGBUF_WILL_INIT | REGBUF_STANDARD);
3943 heikki.linnakangas@i 644 [ + + ]: 612 : for (i = 0; i < data.ndeleted; i++)
645 : 559 : XLogRegisterBuffer(i + 1, buffers[i], REGBUF_WILL_INIT);
646 : :
5835 tgl@sss.pgh.pa.us 647 : 53 : memcpy(&data.metadata, metadata, sizeof(GinMetaPageData));
648 : :
207 peter@eisentraut.org 649 : 53 : XLogRegisterData(&data,
650 : : sizeof(ginxlogDeleteListPages));
651 : :
3943 heikki.linnakangas@i 652 : 53 : recptr = XLogInsert(RM_GIN_ID, XLOG_GIN_DELETE_LISTPAGE);
6010 tgl@sss.pgh.pa.us 653 : 53 : PageSetLSN(metapage, recptr);
654 : :
5931 bruce@momjian.us 655 [ + + ]: 612 : for (i = 0; i < data.ndeleted; i++)
656 : : {
3426 kgrittn@postgresql.o 657 : 559 : page = BufferGetPage(buffers[i]);
6010 tgl@sss.pgh.pa.us 658 : 559 : PageSetLSN(page, recptr);
659 : : }
660 : : }
661 : :
5931 bruce@momjian.us 662 [ + + ]: 1554 : for (i = 0; i < data.ndeleted; i++)
663 : 1444 : UnlockReleaseBuffer(buffers[i]);
664 : :
6010 tgl@sss.pgh.pa.us 665 [ - + ]: 110 : END_CRIT_SECTION();
666 : :
3636 teodor@sigaev.ru 667 [ + + + + ]: 1465 : for (i = 0; fill_fsm && i < data.ndeleted; i++)
3652 668 : 1355 : RecordFreeIndexPage(index, freespace[i]);
669 : :
5931 bruce@momjian.us 670 [ + + ]: 110 : } while (blknoToDelete != newHead);
6010 tgl@sss.pgh.pa.us 671 : 29 : }
672 : :
673 : : /* Initialize empty KeyArray */
674 : : static void
5356 675 : 29 : initKeyArray(KeyArray *keys, int32 maxvalues)
676 : : {
1090 peter@eisentraut.org 677 : 29 : keys->keys = palloc_array(Datum, maxvalues);
678 : 29 : keys->categories = palloc_array(GinNullCategory, maxvalues);
5356 tgl@sss.pgh.pa.us 679 : 29 : keys->nvalues = 0;
680 : 29 : keys->maxvalues = maxvalues;
681 : 29 : }
682 : :
683 : : /* Add datum to KeyArray, resizing if needed */
684 : : static void
685 : 578838 : addDatum(KeyArray *keys, Datum datum, GinNullCategory category)
686 : : {
687 [ - + ]: 578838 : if (keys->nvalues >= keys->maxvalues)
688 : : {
5356 tgl@sss.pgh.pa.us 689 :UBC 0 : keys->maxvalues *= 2;
1090 peter@eisentraut.org 690 : 0 : keys->keys = repalloc_array(keys->keys, Datum, keys->maxvalues);
691 : 0 : keys->categories = repalloc_array(keys->categories, GinNullCategory, keys->maxvalues);
692 : : }
693 : :
5356 tgl@sss.pgh.pa.us 694 :CBC 578838 : keys->keys[keys->nvalues] = datum;
695 : 578838 : keys->categories[keys->nvalues] = category;
696 : 578838 : keys->nvalues++;
6010 697 : 578838 : }
698 : :
699 : : /*
700 : : * Collect data from a pending-list page in preparation for insertion into
701 : : * the main index.
702 : : *
703 : : * Go through all tuples >= startoff on page and collect values in accum
704 : : *
705 : : * Note that ka is just workspace --- it does not carry any state across
706 : : * calls.
707 : : */
708 : : static void
5356 709 : 1444 : processPendingPage(BuildAccumulator *accum, KeyArray *ka,
710 : : Page page, OffsetNumber startoff)
711 : : {
712 : : ItemPointerData heapptr;
713 : : OffsetNumber i,
714 : : maxoff;
715 : : OffsetNumber attrnum;
716 : :
717 : : /* reset *ka to empty */
718 : 1444 : ka->nvalues = 0;
719 : :
6010 720 : 1444 : maxoff = PageGetMaxOffsetNumber(page);
5931 bruce@momjian.us 721 [ - + ]: 1444 : Assert(maxoff >= FirstOffsetNumber);
6010 tgl@sss.pgh.pa.us 722 : 1444 : ItemPointerSetInvalid(&heapptr);
723 : 1444 : attrnum = 0;
724 : :
725 [ + + ]: 580282 : for (i = startoff; i <= maxoff; i = OffsetNumberNext(i))
726 : : {
5931 bruce@momjian.us 727 : 578838 : IndexTuple itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, i));
728 : : OffsetNumber curattnum;
729 : : Datum curkey;
730 : : GinNullCategory curcategory;
731 : :
732 : : /* Check for change of heap TID or attnum */
6010 tgl@sss.pgh.pa.us 733 : 578838 : curattnum = gintuple_get_attrnum(accum->ginstate, itup);
734 : :
5931 bruce@momjian.us 735 [ + + ]: 578838 : if (!ItemPointerIsValid(&heapptr))
736 : : {
6010 tgl@sss.pgh.pa.us 737 : 1444 : heapptr = itup->t_tid;
738 : 1444 : attrnum = curattnum;
739 : : }
5931 bruce@momjian.us 740 [ + + + + ]: 577394 : else if (!(ItemPointerEquals(&heapptr, &itup->t_tid) &&
741 : : curattnum == attrnum))
742 : : {
743 : : /*
744 : : * ginInsertBAEntries can insert several datums per call, but only
745 : : * for one heap tuple and one column. So call it at a boundary,
746 : : * and reset ka.
747 : : */
5356 tgl@sss.pgh.pa.us 748 : 191066 : ginInsertBAEntries(accum, &heapptr, attrnum,
749 : : ka->keys, ka->categories, ka->nvalues);
750 : 191066 : ka->nvalues = 0;
6010 751 : 191066 : heapptr = itup->t_tid;
752 : 191066 : attrnum = curattnum;
753 : : }
754 : :
755 : : /* Add key to KeyArray */
5356 756 : 578838 : curkey = gintuple_get_key(accum->ginstate, itup, &curcategory);
757 : 578838 : addDatum(ka, curkey, curcategory);
758 : : }
759 : :
760 : : /* Dump out all remaining keys */
761 : 1444 : ginInsertBAEntries(accum, &heapptr, attrnum,
762 : : ka->keys, ka->categories, ka->nvalues);
6010 763 : 1444 : }
764 : :
765 : : /*
766 : : * Move tuples from pending pages into regular GIN structure.
767 : : *
768 : : * On first glance it looks completely not crash-safe. But if we crash
769 : : * after posting entries to the main index and before removing them from the
770 : : * pending list, it's okay because when we redo the posting later on, nothing
771 : : * bad will happen.
772 : : *
773 : : * fill_fsm indicates that ginInsertCleanup should add deleted pages
774 : : * to FSM otherwise caller is responsible to put deleted pages into
775 : : * FSM.
776 : : *
777 : : * If stats isn't null, we count deleted pending pages into the counts.
778 : : */
779 : : void
3418 teodor@sigaev.ru 780 : 70 : ginInsertCleanup(GinState *ginstate, bool full_clean,
781 : : bool fill_fsm, bool forceCleanup,
782 : : IndexBulkDeleteResult *stats)
783 : : {
5356 tgl@sss.pgh.pa.us 784 : 70 : Relation index = ginstate->index;
785 : : Buffer metabuffer,
786 : : buffer;
787 : : Page metapage,
788 : : page;
789 : : GinMetaPageData *metadata;
790 : : MemoryContext opCtx,
791 : : oldCtx;
792 : : BuildAccumulator accum;
793 : : KeyArray datums;
794 : : BlockNumber blkno,
795 : : blknoFinish;
3418 teodor@sigaev.ru 796 : 70 : bool cleanupFinish = false;
3652 797 : 70 : bool fsm_vac = false;
798 : : int workMemory;
799 : :
800 : : /*
801 : : * We would like to prevent concurrent cleanup process. For that we will
802 : : * lock metapage in exclusive mode using LockPage() call. Nobody other
803 : : * will use that lock for metapage, so we keep possibility of concurrent
804 : : * insertion into pending list
805 : : */
806 : :
2851 rhaas@postgresql.org 807 [ + - ]: 70 : if (forceCleanup)
808 : : {
809 : : /*
810 : : * We are called from [auto]vacuum/analyze or gin_clean_pending_list()
811 : : * and we would like to wait concurrent cleanup to finish.
812 : : */
3418 teodor@sigaev.ru 813 : 70 : LockPage(index, GIN_METAPAGE_BLKNO, ExclusiveLock);
814 : 70 : workMemory =
551 heikki.linnakangas@i 815 [ - + ]: 7 : (AmAutoVacuumWorkerProcess() && autovacuum_work_mem != -1) ?
3376 rhaas@postgresql.org 816 [ + + ]: 77 : autovacuum_work_mem : maintenance_work_mem;
817 : : }
818 : : else
819 : : {
820 : : /*
821 : : * We are called from regular insert and if we see concurrent cleanup
822 : : * just exit in hope that concurrent process will clean up pending
823 : : * list.
824 : : */
3418 teodor@sigaev.ru 825 [ # # ]:UBC 0 : if (!ConditionalLockPage(index, GIN_METAPAGE_BLKNO, ExclusiveLock))
3418 teodor@sigaev.ru 826 :CBC 41 : return;
3418 teodor@sigaev.ru 827 :UBC 0 : workMemory = work_mem;
828 : : }
829 : :
6010 tgl@sss.pgh.pa.us 830 :CBC 70 : metabuffer = ReadBuffer(index, GIN_METAPAGE_BLKNO);
831 : 70 : LockBuffer(metabuffer, GIN_SHARE);
3426 kgrittn@postgresql.o 832 : 70 : metapage = BufferGetPage(metabuffer);
6010 tgl@sss.pgh.pa.us 833 : 70 : metadata = GinPageGetMeta(metapage);
834 : :
5931 bruce@momjian.us 835 [ + + ]: 70 : if (metadata->head == InvalidBlockNumber)
836 : : {
837 : : /* Nothing to do */
6010 tgl@sss.pgh.pa.us 838 : 41 : UnlockReleaseBuffer(metabuffer);
3418 teodor@sigaev.ru 839 : 41 : UnlockPage(index, GIN_METAPAGE_BLKNO, ExclusiveLock);
6010 tgl@sss.pgh.pa.us 840 : 41 : return;
841 : : }
842 : :
843 : : /*
844 : : * Remember a tail page to prevent infinite cleanup if other backends add
845 : : * new tuples faster than we can cleanup.
846 : : */
3418 teodor@sigaev.ru 847 : 29 : blknoFinish = metadata->tail;
848 : :
849 : : /*
850 : : * Read and lock head of pending list
851 : : */
6010 tgl@sss.pgh.pa.us 852 : 29 : blkno = metadata->head;
853 : 29 : buffer = ReadBuffer(index, blkno);
854 : 29 : LockBuffer(buffer, GIN_SHARE);
3426 kgrittn@postgresql.o 855 : 29 : page = BufferGetPage(buffer);
856 : :
6010 tgl@sss.pgh.pa.us 857 : 29 : LockBuffer(metabuffer, GIN_UNLOCK);
858 : :
859 : : /*
860 : : * Initialize. All temporary space will be in opCtx
861 : : */
862 : 29 : opCtx = AllocSetContextCreate(CurrentMemoryContext,
863 : : "GIN insert cleanup temporary context",
864 : : ALLOCSET_DEFAULT_SIZES);
865 : :
866 : 29 : oldCtx = MemoryContextSwitchTo(opCtx);
867 : :
5356 868 : 29 : initKeyArray(&datums, 128);
6010 869 : 29 : ginInitBA(&accum);
870 : 29 : accum.ginstate = ginstate;
871 : :
872 : : /*
873 : : * At the top of this loop, we have pin and lock on the current page of
874 : : * the pending list. However, we'll release that before exiting the loop.
875 : : * Note we also have pin but not lock on the metapage.
876 : : */
877 : : for (;;)
878 : : {
3418 teodor@sigaev.ru 879 [ - + ]: 1444 : Assert(!GinPageIsDeleted(page));
880 : :
881 : : /*
882 : : * Are we walk through the page which as we remember was a tail when
883 : : * we start our cleanup? But if caller asks us to clean up whole
884 : : * pending list then ignore old tail, we will work until list becomes
885 : : * empty.
886 : : */
887 [ + + + + ]: 1444 : if (blkno == blknoFinish && full_clean == false)
888 : 1 : cleanupFinish = true;
889 : :
890 : : /*
891 : : * read page's datums into accum
892 : : */
6010 tgl@sss.pgh.pa.us 893 : 1444 : processPendingPage(&accum, &datums, page, FirstOffsetNumber);
894 : :
207 nathan@postgresql.or 895 : 1444 : vacuum_delay_point(false);
896 : :
897 : : /*
898 : : * Is it time to flush memory to disk? Flush if we are at the end of
899 : : * the pending list, or if we have a full row and memory is getting
900 : : * full.
901 : : */
6010 tgl@sss.pgh.pa.us 902 [ + + ]: 1444 : if (GinPageGetOpaque(page)->rightlink == InvalidBlockNumber ||
903 [ + - ]: 1415 : (GinPageHasFullRow(page) &&
218 904 [ - + ]: 1415 : accum.allocatedMemory >= workMemory * (Size) 1024))
6010 tgl@sss.pgh.pa.us 905 :UBC 0 : {
906 : : ItemPointerData *list;
907 : : uint32 nlist;
908 : : Datum key;
909 : : GinNullCategory category;
910 : : OffsetNumber maxoff,
911 : : attnum;
912 : :
913 : : /*
914 : : * Unlock current page to increase performance. Changes of page
915 : : * will be checked later by comparing maxoff after completion of
916 : : * memory flush.
917 : : */
6010 tgl@sss.pgh.pa.us 918 :CBC 29 : maxoff = PageGetMaxOffsetNumber(page);
919 : 29 : LockBuffer(buffer, GIN_UNLOCK);
920 : :
921 : : /*
922 : : * Moving collected data into regular structure can take
923 : : * significant amount of time - so, run it without locking pending
924 : : * list.
925 : : */
5515 926 : 29 : ginBeginBAScan(&accum);
5356 927 : 183135 : while ((list = ginGetBAEntry(&accum,
2999 928 [ + + ]: 183135 : &attnum, &key, &category, &nlist)) != NULL)
929 : : {
5356 930 : 183106 : ginEntryInsert(ginstate, attnum, key, category,
931 : : list, nlist, NULL);
207 nathan@postgresql.or 932 : 183106 : vacuum_delay_point(false);
933 : : }
934 : :
935 : : /*
936 : : * Lock the whole list to remove pages
937 : : */
6010 tgl@sss.pgh.pa.us 938 : 29 : LockBuffer(metabuffer, GIN_EXCLUSIVE);
939 : 29 : LockBuffer(buffer, GIN_SHARE);
940 : :
3418 teodor@sigaev.ru 941 [ - + ]: 29 : Assert(!GinPageIsDeleted(page));
942 : :
943 : : /*
944 : : * While we left the page unlocked, more stuff might have gotten
945 : : * added to it. If so, process those entries immediately. There
946 : : * shouldn't be very many, so we don't worry about the fact that
947 : : * we're doing this with exclusive lock. Insertion algorithm
948 : : * guarantees that inserted row(s) will not continue on next page.
949 : : * NOTE: intentionally no vacuum_delay_point in this loop.
950 : : */
5931 bruce@momjian.us 951 [ - + ]: 29 : if (PageGetMaxOffsetNumber(page) != maxoff)
952 : : {
6010 tgl@sss.pgh.pa.us 953 :LBC (4) : ginInitBA(&accum);
5931 bruce@momjian.us 954 : (4) : processPendingPage(&accum, &datums, page, maxoff + 1);
955 : :
5515 tgl@sss.pgh.pa.us 956 : (4) : ginBeginBAScan(&accum);
5356 957 : (27) : while ((list = ginGetBAEntry(&accum,
2999 958 [ # # ]: (27) : &attnum, &key, &category, &nlist)) != NULL)
5356 959 : (23) : ginEntryInsert(ginstate, attnum, key, category,
960 : : list, nlist, NULL);
961 : : }
962 : :
963 : : /*
964 : : * Remember next page - it will become the new list head
965 : : */
6010 tgl@sss.pgh.pa.us 966 :CBC 29 : blkno = GinPageGetOpaque(page)->rightlink;
2999 967 : 29 : UnlockReleaseBuffer(buffer); /* shiftList will do exclusive
968 : : * locking */
969 : :
970 : : /*
971 : : * remove read pages from pending list, at this point all content
972 : : * of read pages is in regular structure
973 : : */
3418 teodor@sigaev.ru 974 : 29 : shiftList(index, metabuffer, blkno, fill_fsm, stats);
975 : :
976 : : /* At this point, some pending pages have been freed up */
3652 977 : 29 : fsm_vac = true;
978 : :
5931 bruce@momjian.us 979 [ - + ]: 29 : Assert(blkno == metadata->head);
6010 tgl@sss.pgh.pa.us 980 : 29 : LockBuffer(metabuffer, GIN_UNLOCK);
981 : :
982 : : /*
983 : : * if we removed the whole pending list or we cleanup tail (which
984 : : * we remembered on start our cleanup process) then just exit
985 : : */
3418 teodor@sigaev.ru 986 [ - + - - ]: 29 : if (blkno == InvalidBlockNumber || cleanupFinish)
987 : : break;
988 : :
989 : : /*
990 : : * release memory used so far and reinit state
991 : : */
6010 tgl@sss.pgh.pa.us 992 :UBC 0 : MemoryContextReset(opCtx);
5356 993 : 0 : initKeyArray(&datums, datums.maxvalues);
6010 994 : 0 : ginInitBA(&accum);
995 : : }
996 : : else
997 : : {
6010 tgl@sss.pgh.pa.us 998 :CBC 1415 : blkno = GinPageGetOpaque(page)->rightlink;
999 : 1415 : UnlockReleaseBuffer(buffer);
1000 : : }
1001 : :
1002 : : /*
1003 : : * Read next page in pending list
1004 : : */
207 nathan@postgresql.or 1005 : 1415 : vacuum_delay_point(false);
6010 tgl@sss.pgh.pa.us 1006 : 1415 : buffer = ReadBuffer(index, blkno);
1007 : 1415 : LockBuffer(buffer, GIN_SHARE);
3426 kgrittn@postgresql.o 1008 : 1415 : page = BufferGetPage(buffer);
1009 : : }
1010 : :
3418 teodor@sigaev.ru 1011 : 29 : UnlockPage(index, GIN_METAPAGE_BLKNO, ExclusiveLock);
6010 tgl@sss.pgh.pa.us 1012 : 29 : ReleaseBuffer(metabuffer);
1013 : :
1014 : : /*
1015 : : * As pending list pages can have a high churn rate, it is desirable to
1016 : : * recycle them immediately to the FreeSpaceMap when ordinary backends
1017 : : * clean the list.
1018 : : */
3636 teodor@sigaev.ru 1019 [ + - + + ]: 29 : if (fsm_vac && fill_fsm)
3652 1020 : 11 : IndexFreeSpaceMapVacuum(index);
1021 : :
1022 : : /* Clean up temporary space */
6010 tgl@sss.pgh.pa.us 1023 : 29 : MemoryContextSwitchTo(oldCtx);
1024 : 29 : MemoryContextDelete(opCtx);
1025 : : }
1026 : :
1027 : : /*
1028 : : * SQL-callable function to clean the insert pending list
1029 : : */
1030 : : Datum
3509 fujii@postgresql.org 1031 : 13 : gin_clean_pending_list(PG_FUNCTION_ARGS)
1032 : : {
1033 : 13 : Oid indexoid = PG_GETARG_OID(0);
2347 tgl@sss.pgh.pa.us 1034 : 13 : Relation indexRel = index_open(indexoid, RowExclusiveLock);
1035 : : IndexBulkDeleteResult stats;
1036 : :
3509 fujii@postgresql.org 1037 [ - + ]: 13 : if (RecoveryInProgress())
3507 peter_e@gmx.net 1038 [ # # ]:UBC 0 : ereport(ERROR,
1039 : : (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
1040 : : errmsg("recovery is in progress"),
1041 : : errhint("GIN pending list cannot be cleaned up during recovery.")));
1042 : :
1043 : : /* Must be a GIN index */
3509 fujii@postgresql.org 1044 [ + - ]:CBC 13 : if (indexRel->rd_rel->relkind != RELKIND_INDEX ||
1045 [ - + ]: 13 : indexRel->rd_rel->relam != GIN_AM_OID)
3509 fujii@postgresql.org 1046 [ # # ]:UBC 0 : ereport(ERROR,
1047 : : (errcode(ERRCODE_WRONG_OBJECT_TYPE),
1048 : : errmsg("\"%s\" is not a GIN index",
1049 : : RelationGetRelationName(indexRel))));
1050 : :
1051 : : /*
1052 : : * Reject attempts to read non-local temporary relations; we would be
1053 : : * likely to get wrong data since we have no visibility into the owning
1054 : : * session's local buffers.
1055 : : */
3509 fujii@postgresql.org 1056 [ + + - + ]:CBC 13 : if (RELATION_IS_OTHER_TEMP(indexRel))
3509 fujii@postgresql.org 1057 [ # # ]:UBC 0 : ereport(ERROR,
1058 : : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1059 : : errmsg("cannot access temporary indexes of other sessions")));
1060 : :
1061 : : /* User must own the index (comparable to privileges needed for VACUUM) */
1028 peter@eisentraut.org 1062 [ - + ]:CBC 13 : if (!object_ownercheck(RelationRelationId, indexoid, GetUserId()))
2835 peter_e@gmx.net 1063 :UBC 0 : aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_INDEX,
3509 fujii@postgresql.org 1064 : 0 : RelationGetRelationName(indexRel));
1065 : :
3509 fujii@postgresql.org 1066 :CBC 13 : memset(&stats, 0, sizeof(stats));
1067 : :
1068 : : /*
1069 : : * Can't assume anything about the content of an !indisready index. Make
1070 : : * those a no-op, not an error, so users can just run this function on all
1071 : : * indexes of the access method. Since an indisready&&!indisvalid index
1072 : : * is merely awaiting missed aminsert calls, we're capable of processing
1073 : : * it. Decline to do so, out of an abundance of caution.
1074 : : */
677 noah@leadboat.com 1075 [ + - ]: 13 : if (indexRel->rd_index->indisvalid)
1076 : : {
1077 : : GinState ginstate;
1078 : :
1079 : 13 : initGinState(&ginstate, indexRel);
1080 : 13 : ginInsertCleanup(&ginstate, true, true, true, &stats);
1081 : : }
1082 : : else
677 noah@leadboat.com 1083 [ # # ]:UBC 0 : ereport(DEBUG1,
1084 : : (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
1085 : : errmsg("index \"%s\" is not valid",
1086 : : RelationGetRelationName(indexRel))));
1087 : :
2347 tgl@sss.pgh.pa.us 1088 :CBC 13 : index_close(indexRel, RowExclusiveLock);
1089 : :
3509 fujii@postgresql.org 1090 : 13 : PG_RETURN_INT64((int64) stats.pages_deleted);
1091 : : }
|
