Debian Codegraph @

src/backend/access/table/tableam.c

raw
1 /*----------------------------------------------------------------------
2 *
3 * tableam.c
4 * Table access method routines too big to be inline functions.
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/table/tableam.c
12 *
13 * NOTES
14 * Note that most function in here are documented in tableam.h, rather than
15 * here. That's because there's a lot of inline functions in tableam.h and
16 * it'd be harder to understand if one constantly had to switch between files.
17 *
18 *----------------------------------------------------------------------
19 */
20 #include "postgres.h"
21
22 #include <math.h>
23
24 #include "access/syncscan.h"
25 #include "access/tableam.h"
26 #include "access/xact.h"
27 #include "optimizer/optimizer.h"
28 #include "optimizer/plancat.h"
29 #include "port/pg_bitutils.h"
30 #include "storage/bufmgr.h"
31 #include "storage/shmem.h"
32 #include "storage/smgr.h"
33
34 /*
35 * Constants to control the behavior of block allocation to parallel workers
36 * during a parallel seqscan. Technically these values do not need to be
37 * powers of 2, but having them as powers of 2 makes the math more optimal
38 * and makes the ramp-down stepping more even.
39 */
40
41 /* The number of I/O chunks we try to break a parallel seqscan down into */
42 #define PARALLEL_SEQSCAN_NCHUNKS 2048
43 /* Ramp down size of allocations when we've only this number of chunks left */
44 #define PARALLEL_SEQSCAN_RAMPDOWN_CHUNKS 64
45 /* Cap the size of parallel I/O chunks to this number of blocks */
46 #define PARALLEL_SEQSCAN_MAX_CHUNK_SIZE 8192
47
48 /* GUC variables */
49 char *default_table_access_method = DEFAULT_TABLE_ACCESS_METHOD;
50 bool synchronize_seqscans = true;
51
52
53 /* ----------------------------------------------------------------------------
54 * Slot functions.
55 * ----------------------------------------------------------------------------
56 */
57
58 const TupleTableSlotOps *
59 table_slot_callbacks(Relation relation)
60 {
61 const TupleTableSlotOps *tts_cb;
62
63 if (relation->rd_tableam)
64 tts_cb = relation->rd_tableam->slot_callbacks(relation);
65 else if (relation->rd_rel->relkind == RELKIND_FOREIGN_TABLE)
66 {
67 /*
68 * Historically FDWs expect to store heap tuples in slots. Continue
69 * handing them one, to make it less painful to adapt FDWs to new
70 * versions. The cost of a heap slot over a virtual slot is pretty
71 * small.
72 */
73 tts_cb = &TTSOpsHeapTuple;
74 }
75 else
76 {
77 /*
78 * These need to be supported, as some parts of the code (like COPY)
79 * need to create slots for such relations too. It seems better to
80 * centralize the knowledge that a heap slot is the right thing in
81 * that case here.
82 */
83 Assert(relation->rd_rel->relkind == RELKIND_VIEW ||
84 relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
85 tts_cb = &TTSOpsVirtual;
86 }
87
88 return tts_cb;
89 }
90
91 TupleTableSlot *
92 table_slot_create(Relation relation, List **reglist)
93 {
94 const TupleTableSlotOps *tts_cb;
95 TupleTableSlot *slot;
96
97 tts_cb = table_slot_callbacks(relation);
98 slot = MakeSingleTupleTableSlot(RelationGetDescr(relation), tts_cb);
99
100 if (reglist)
101 *reglist = lappend(*reglist, slot);
102
103 return slot;
104 }
105
106
107 /* ----------------------------------------------------------------------------
108 * Table scan functions.
109 * ----------------------------------------------------------------------------
110 */
111
112 TableScanDesc
113 table_beginscan_catalog(Relation relation, int nkeys, struct ScanKeyData *key)
114 {
115 uint32 flags = SO_TYPE_SEQSCAN |
116 SO_ALLOW_STRAT | SO_ALLOW_SYNC | SO_ALLOW_PAGEMODE | SO_TEMP_SNAPSHOT;
117 Oid relid = RelationGetRelid(relation);
118 Snapshot snapshot = RegisterSnapshot(GetCatalogSnapshot(relid));
119
120 return relation->rd_tableam->scan_begin(relation, snapshot, nkeys, key,
121 NULL, flags);
122 }
123
124
125 /* ----------------------------------------------------------------------------
126 * Parallel table scan related functions.
127 * ----------------------------------------------------------------------------
128 */
129
130 Size
131 table_parallelscan_estimate(Relation rel, Snapshot snapshot)
132 {
133 Size sz = 0;
134
135 if (IsMVCCSnapshot(snapshot))
136 sz = add_size(sz, EstimateSnapshotSpace(snapshot));
137 else
138 Assert(snapshot == SnapshotAny);
139
140 sz = add_size(sz, rel->rd_tableam->parallelscan_estimate(rel));
141
142 return sz;
143 }
144
145 void
146 table_parallelscan_initialize(Relation rel, ParallelTableScanDesc pscan,
147 Snapshot snapshot)
148 {
149 Size snapshot_off = rel->rd_tableam->parallelscan_initialize(rel, pscan);
150
151 pscan->phs_snapshot_off = snapshot_off;
152
153 if (IsMVCCSnapshot(snapshot))
154 {
155 SerializeSnapshot(snapshot, (char *) pscan + pscan->phs_snapshot_off);
156 pscan->phs_snapshot_any = false;
157 }
158 else
159 {
160 Assert(snapshot == SnapshotAny);
161 pscan->phs_snapshot_any = true;
162 }
163 }
164
165 TableScanDesc
166 table_beginscan_parallel(Relation relation, ParallelTableScanDesc pscan)
167 {
168 Snapshot snapshot;
169 uint32 flags = SO_TYPE_SEQSCAN |
170 SO_ALLOW_STRAT | SO_ALLOW_SYNC | SO_ALLOW_PAGEMODE;
171
172 Assert(RelFileLocatorEquals(relation->rd_locator, pscan->phs_locator));
173
174 if (!pscan->phs_snapshot_any)
175 {
176 /* Snapshot was serialized -- restore it */
177 snapshot = RestoreSnapshot((char *) pscan + pscan->phs_snapshot_off);
178 RegisterSnapshot(snapshot);
179 flags |= SO_TEMP_SNAPSHOT;
180 }
181 else
182 {
183 /* SnapshotAny passed by caller (not serialized) */
184 snapshot = SnapshotAny;
185 }
186
187 return relation->rd_tableam->scan_begin(relation, snapshot, 0, NULL,
188 pscan, flags);
189 }
190
191
192 /* ----------------------------------------------------------------------------
193 * Index scan related functions.
194 * ----------------------------------------------------------------------------
195 */
196
197 /*
198 * To perform that check simply start an index scan, create the necessary
199 * slot, do the heap lookup, and shut everything down again. This could be
200 * optimized, but is unlikely to matter from a performance POV. If there
201 * frequently are live index pointers also matching a unique index key, the
202 * CPU overhead of this routine is unlikely to matter.
203 *
204 * Note that *tid may be modified when we return true if the AM supports
205 * storing multiple row versions reachable via a single index entry (like
206 * heap's HOT).
207 */
208 bool
209 table_index_fetch_tuple_check(Relation rel,
210 ItemPointer tid,
211 Snapshot snapshot,
212 bool *all_dead)
213 {
214 IndexFetchTableData *scan;
215 TupleTableSlot *slot;
216 bool call_again = false;
217 bool found;
218
219 slot = table_slot_create(rel, NULL);
220 scan = table_index_fetch_begin(rel);
221 found = table_index_fetch_tuple(scan, tid, snapshot, slot, &call_again,
222 all_dead);
223 table_index_fetch_end(scan);
224 ExecDropSingleTupleTableSlot(slot);
225
226 return found;
227 }
228
229
230 /* ------------------------------------------------------------------------
231 * Functions for non-modifying operations on individual tuples
232 * ------------------------------------------------------------------------
233 */
234
235 void
236 table_tuple_get_latest_tid(TableScanDesc scan, ItemPointer tid)
237 {
238 Relation rel = scan->rs_rd;
239 const TableAmRoutine *tableam = rel->rd_tableam;
240
241 /*
242 * We don't expect direct calls to table_tuple_get_latest_tid with valid
243 * CheckXidAlive for catalog or regular tables. See detailed comments in
244 * xact.c where these variables are declared.
245 */
246 if (unlikely(TransactionIdIsValid(CheckXidAlive) && !bsysscan))
247 elog(ERROR, "unexpected table_tuple_get_latest_tid call during logical decoding");
248
249 /*
250 * Since this can be called with user-supplied TID, don't trust the input
251 * too much.
252 */
253 if (!tableam->tuple_tid_valid(scan, tid))
254 ereport(ERROR,
255 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
256 errmsg("tid (%u, %u) is not valid for relation \"%s\"",
257 ItemPointerGetBlockNumberNoCheck(tid),
258 ItemPointerGetOffsetNumberNoCheck(tid),
259 RelationGetRelationName(rel))));
260
261 tableam->tuple_get_latest_tid(scan, tid);
262 }
263
264
265 /* ----------------------------------------------------------------------------
266 * Functions to make modifications a bit simpler.
267 * ----------------------------------------------------------------------------
268 */
269
270 /*
271 * simple_table_tuple_insert - insert a tuple
272 *
273 * Currently, this routine differs from table_tuple_insert only in supplying a
274 * default command ID and not allowing access to the speedup options.
275 */
276 void
277 simple_table_tuple_insert(Relation rel, TupleTableSlot *slot)
278 {
279 table_tuple_insert(rel, slot, GetCurrentCommandId(true), 0, NULL);
280 }
281
282 /*
283 * simple_table_tuple_delete - delete a tuple
284 *
285 * This routine may be used to delete a tuple when concurrent updates of
286 * the target tuple are not expected (for example, because we have a lock
287 * on the relation associated with the tuple). Any failure is reported
288 * via ereport().
289 */
290 void
291 simple_table_tuple_delete(Relation rel, ItemPointer tid, Snapshot snapshot)
292 {
293 TM_Result result;
294 TM_FailureData tmfd;
295
296 result = table_tuple_delete(rel, tid,
297 GetCurrentCommandId(true),
298 snapshot, InvalidSnapshot,
299 true /* wait for commit */ ,
300 &tmfd, false /* changingPart */ );
301
302 switch (result)
303 {
304 case TM_SelfModified:
305 /* Tuple was already updated in current command? */
306 elog(ERROR, "tuple already updated by self");
307 break;
308
309 case TM_Ok:
310 /* done successfully */
311 break;
312
313 case TM_Updated:
314 elog(ERROR, "tuple concurrently updated");
315 break;
316
317 case TM_Deleted:
318 elog(ERROR, "tuple concurrently deleted");
319 break;
320
321 default:
322 elog(ERROR, "unrecognized table_tuple_delete status: %u", result);
323 break;
324 }
325 }
326
327 /*
328 * simple_table_tuple_update - replace a tuple
329 *
330 * This routine may be used to update a tuple when concurrent updates of
331 * the target tuple are not expected (for example, because we have a lock
332 * on the relation associated with the tuple). Any failure is reported
333 * via ereport().
334 */
335 void
336 simple_table_tuple_update(Relation rel, ItemPointer otid,
337 TupleTableSlot *slot,
338 Snapshot snapshot,
339 TU_UpdateIndexes *update_indexes)
340 {
341 TM_Result result;
342 TM_FailureData tmfd;
343 LockTupleMode lockmode;
344
345 result = table_tuple_update(rel, otid, slot,
346 GetCurrentCommandId(true),
347 snapshot, InvalidSnapshot,
348 true /* wait for commit */ ,
349 &tmfd, &lockmode, update_indexes);
350
351 switch (result)
352 {
353 case TM_SelfModified:
354 /* Tuple was already updated in current command? */
355 elog(ERROR, "tuple already updated by self");
356 break;
357
358 case TM_Ok:
359 /* done successfully */
360 break;
361
362 case TM_Updated:
363 elog(ERROR, "tuple concurrently updated");
364 break;
365
366 case TM_Deleted:
367 elog(ERROR, "tuple concurrently deleted");
368 break;
369
370 default:
371 elog(ERROR, "unrecognized table_tuple_update status: %u", result);
372 break;
373 }
374 }
375
376
377 /* ----------------------------------------------------------------------------
378 * Helper functions to implement parallel scans for block oriented AMs.
379 * ----------------------------------------------------------------------------
380 */
381
382 Size
383 table_block_parallelscan_estimate(Relation rel)
384 {
385 return sizeof(ParallelBlockTableScanDescData);
386 }
387
388 Size
389 table_block_parallelscan_initialize(Relation rel, ParallelTableScanDesc pscan)
390 {
391 ParallelBlockTableScanDesc bpscan = (ParallelBlockTableScanDesc) pscan;
392
393 bpscan->base.phs_locator = rel->rd_locator;
394 bpscan->phs_nblocks = RelationGetNumberOfBlocks(rel);
395 /* compare phs_syncscan initialization to similar logic in initscan */
396 bpscan->base.phs_syncscan = synchronize_seqscans &&
397 !RelationUsesLocalBuffers(rel) &&
398 bpscan->phs_nblocks > NBuffers / 4;
399 SpinLockInit(&bpscan->phs_mutex);
400 bpscan->phs_startblock = InvalidBlockNumber;
401 pg_atomic_init_u64(&bpscan->phs_nallocated, 0);
402
403 return sizeof(ParallelBlockTableScanDescData);
404 }
405
406 void
407 table_block_parallelscan_reinitialize(Relation rel, ParallelTableScanDesc pscan)
408 {
409 ParallelBlockTableScanDesc bpscan = (ParallelBlockTableScanDesc) pscan;
410
411 pg_atomic_write_u64(&bpscan->phs_nallocated, 0);
412 }
413
414 /*
415 * find and set the scan's startblock
416 *
417 * Determine where the parallel seq scan should start. This function may be
418 * called many times, once by each parallel worker. We must be careful only
419 * to set the startblock once.
420 */
421 void
422 table_block_parallelscan_startblock_init(Relation rel,
423 ParallelBlockTableScanWorker pbscanwork,
424 ParallelBlockTableScanDesc pbscan)
425 {
426 BlockNumber sync_startpage = InvalidBlockNumber;
427
428 /* Reset the state we use for controlling allocation size. */
429 memset(pbscanwork, 0, sizeof(*pbscanwork));
430
431 StaticAssertStmt(MaxBlockNumber <= 0xFFFFFFFE,
432 "pg_nextpower2_32 may be too small for non-standard BlockNumber width");
433
434 /*
435 * We determine the chunk size based on the size of the relation. First we
436 * split the relation into PARALLEL_SEQSCAN_NCHUNKS chunks but we then
437 * take the next highest power of 2 number of the chunk size. This means
438 * we split the relation into somewhere between PARALLEL_SEQSCAN_NCHUNKS
439 * and PARALLEL_SEQSCAN_NCHUNKS / 2 chunks.
440 */
441 pbscanwork->phsw_chunk_size = pg_nextpower2_32(Max(pbscan->phs_nblocks /
442 PARALLEL_SEQSCAN_NCHUNKS, 1));
443
444 /*
445 * Ensure we don't go over the maximum chunk size with larger tables. This
446 * means we may get much more than PARALLEL_SEQSCAN_NCHUNKS for larger
447 * tables. Too large a chunk size has been shown to be detrimental to
448 * synchronous scan performance.
449 */
450 pbscanwork->phsw_chunk_size = Min(pbscanwork->phsw_chunk_size,
451 PARALLEL_SEQSCAN_MAX_CHUNK_SIZE);
452
453 retry:
454 /* Grab the spinlock. */
455 SpinLockAcquire(&pbscan->phs_mutex);
456
457 /*
458 * If the scan's startblock has not yet been initialized, we must do so
459 * now. If this is not a synchronized scan, we just start at block 0, but
460 * if it is a synchronized scan, we must get the starting position from
461 * the synchronized scan machinery. We can't hold the spinlock while
462 * doing that, though, so release the spinlock, get the information we
463 * need, and retry. If nobody else has initialized the scan in the
464 * meantime, we'll fill in the value we fetched on the second time
465 * through.
466 */
467 if (pbscan->phs_startblock == InvalidBlockNumber)
468 {
469 if (!pbscan->base.phs_syncscan)
470 pbscan->phs_startblock = 0;
471 else if (sync_startpage != InvalidBlockNumber)
472 pbscan->phs_startblock = sync_startpage;
473 else
474 {
475 SpinLockRelease(&pbscan->phs_mutex);
476 sync_startpage = ss_get_location(rel, pbscan->phs_nblocks);
477 goto retry;
478 }
479 }
480 SpinLockRelease(&pbscan->phs_mutex);
481 }
482
483 /*
484 * get the next page to scan
485 *
486 * Get the next page to scan. Even if there are no pages left to scan,
487 * another backend could have grabbed a page to scan and not yet finished
488 * looking at it, so it doesn't follow that the scan is done when the first
489 * backend gets an InvalidBlockNumber return.
490 */
491 BlockNumber
492 table_block_parallelscan_nextpage(Relation rel,
493 ParallelBlockTableScanWorker pbscanwork,
494 ParallelBlockTableScanDesc pbscan)
495 {
496 BlockNumber page;
497 uint64 nallocated;
498
499 /*
500 * The logic below allocates block numbers out to parallel workers in a
501 * way that each worker will receive a set of consecutive block numbers to
502 * scan. Earlier versions of this would allocate the next highest block
503 * number to the next worker to call this function. This would generally
504 * result in workers never receiving consecutive block numbers. Some
505 * operating systems would not detect the sequential I/O pattern due to
506 * each backend being a different process which could result in poor
507 * performance due to inefficient or no readahead. To work around this
508 * issue, we now allocate a range of block numbers for each worker and
509 * when they come back for another block, we give them the next one in
510 * that range until the range is complete. When the worker completes the
511 * range of blocks we then allocate another range for it and return the
512 * first block number from that range.
513 *
514 * Here we name these ranges of blocks "chunks". The initial size of
515 * these chunks is determined in table_block_parallelscan_startblock_init
516 * based on the size of the relation. Towards the end of the scan, we
517 * start making reductions in the size of the chunks in order to attempt
518 * to divide the remaining work over all the workers as evenly as
519 * possible.
520 *
521 * Here pbscanwork is local worker memory. phsw_chunk_remaining tracks
522 * the number of blocks remaining in the chunk. When that reaches 0 then
523 * we must allocate a new chunk for the worker.
524 *
525 * phs_nallocated tracks how many blocks have been allocated to workers
526 * already. When phs_nallocated >= rs_nblocks, all blocks have been
527 * allocated.
528 *
529 * Because we use an atomic fetch-and-add to fetch the current value, the
530 * phs_nallocated counter will exceed rs_nblocks, because workers will
531 * still increment the value, when they try to allocate the next block but
532 * all blocks have been allocated already. The counter must be 64 bits
533 * wide because of that, to avoid wrapping around when rs_nblocks is close
534 * to 2^32.
535 *
536 * The actual block to return is calculated by adding the counter to the
537 * starting block number, modulo nblocks.
538 */
539
540 /*
541 * First check if we have any remaining blocks in a previous chunk for
542 * this worker. We must consume all of the blocks from that before we
543 * allocate a new chunk to the worker.
544 */
545 if (pbscanwork->phsw_chunk_remaining > 0)
546 {
547 /*
548 * Give them the next block in the range and update the remaining
549 * number of blocks.
550 */
551 nallocated = ++pbscanwork->phsw_nallocated;
552 pbscanwork->phsw_chunk_remaining--;
553 }
554 else
555 {
556 /*
557 * When we've only got PARALLEL_SEQSCAN_RAMPDOWN_CHUNKS chunks
558 * remaining in the scan, we half the chunk size. Since we reduce the
559 * chunk size here, we'll hit this again after doing
560 * PARALLEL_SEQSCAN_RAMPDOWN_CHUNKS at the new size. After a few
561 * iterations of this, we'll end up doing the last few blocks with the
562 * chunk size set to 1.
563 */
564 if (pbscanwork->phsw_chunk_size > 1 &&
565 pbscanwork->phsw_nallocated > pbscan->phs_nblocks -
566 (pbscanwork->phsw_chunk_size * PARALLEL_SEQSCAN_RAMPDOWN_CHUNKS))
567 pbscanwork->phsw_chunk_size >>= 1;
568
569 nallocated = pbscanwork->phsw_nallocated =
570 pg_atomic_fetch_add_u64(&pbscan->phs_nallocated,
571 pbscanwork->phsw_chunk_size);
572
573 /*
574 * Set the remaining number of blocks in this chunk so that subsequent
575 * calls from this worker continue on with this chunk until it's done.
576 */
577 pbscanwork->phsw_chunk_remaining = pbscanwork->phsw_chunk_size - 1;
578 }
579
580 if (nallocated >= pbscan->phs_nblocks)
581 page = InvalidBlockNumber; /* all blocks have been allocated */
582 else
583 page = (nallocated + pbscan->phs_startblock) % pbscan->phs_nblocks;
584
585 /*
586 * Report scan location. Normally, we report the current page number.
587 * When we reach the end of the scan, though, we report the starting page,
588 * not the ending page, just so the starting positions for later scans
589 * doesn't slew backwards. We only report the position at the end of the
590 * scan once, though: subsequent callers will report nothing.
591 */
592 if (pbscan->base.phs_syncscan)
593 {
594 if (page != InvalidBlockNumber)
595 ss_report_location(rel, page);
596 else if (nallocated == pbscan->phs_nblocks)
597 ss_report_location(rel, pbscan->phs_startblock);
598 }
599
600 return page;
601 }
602
603 /* ----------------------------------------------------------------------------
604 * Helper functions to implement relation sizing for block oriented AMs.
605 * ----------------------------------------------------------------------------
606 */
607
608 /*
609 * table_block_relation_size
610 *
611 * If a table AM uses the various relation forks as the sole place where data
612 * is stored, and if it uses them in the expected manner (e.g. the actual data
613 * is in the main fork rather than some other), it can use this implementation
614 * of the relation_size callback rather than implementing its own.
615 */
616 uint64
617 table_block_relation_size(Relation rel, ForkNumber forkNumber)
618 {
619 uint64 nblocks = 0;
620
621 /* InvalidForkNumber indicates returning the size for all forks */
622 if (forkNumber == InvalidForkNumber)
623 {
624 for (int i = 0; i < MAX_FORKNUM; i++)
625 nblocks += smgrnblocks(RelationGetSmgr(rel), i);
626 }
627 else
628 nblocks = smgrnblocks(RelationGetSmgr(rel), forkNumber);
629
630 return nblocks * BLCKSZ;
631 }
632
633 /*
634 * table_block_relation_estimate_size
635 *
636 * This function can't be directly used as the implementation of the
637 * relation_estimate_size callback, because it has a few additional parameters.
638 * Instead, it is intended to be used as a helper function; the caller can
639 * pass through the arguments to its relation_estimate_size function plus the
640 * additional values required here.
641 *
642 * overhead_bytes_per_tuple should contain the approximate number of bytes
643 * of storage required to store a tuple above and beyond what is required for
644 * the tuple data proper. Typically, this would include things like the
645 * size of the tuple header and item pointer. This is only used for query
646 * planning, so a table AM where the value is not constant could choose to
647 * pass a "best guess".
648 *
649 * usable_bytes_per_page should contain the approximate number of bytes per
650 * page usable for tuple data, excluding the page header and any anticipated
651 * special space.
652 */
653 void
654 table_block_relation_estimate_size(Relation rel, int32 *attr_widths,
655 BlockNumber *pages, double *tuples,
656 double *allvisfrac,
657 Size overhead_bytes_per_tuple,
658 Size usable_bytes_per_page)
659 {
660 BlockNumber curpages;
661 BlockNumber relpages;
662 double reltuples;
663 BlockNumber relallvisible;
664 double density;
665
666 /* it should have storage, so we can call the smgr */
667 curpages = RelationGetNumberOfBlocks(rel);
668
669 /* coerce values in pg_class to more desirable types */
670 relpages = (BlockNumber) rel->rd_rel->relpages;
671 reltuples = (double) rel->rd_rel->reltuples;
672 relallvisible = (BlockNumber) rel->rd_rel->relallvisible;
673
674 /*
675 * HACK: if the relation has never yet been vacuumed, use a minimum size
676 * estimate of 10 pages. The idea here is to avoid assuming a
677 * newly-created table is really small, even if it currently is, because
678 * that may not be true once some data gets loaded into it. Once a vacuum
679 * or analyze cycle has been done on it, it's more reasonable to believe
680 * the size is somewhat stable.
681 *
682 * (Note that this is only an issue if the plan gets cached and used again
683 * after the table has been filled. What we're trying to avoid is using a
684 * nestloop-type plan on a table that has grown substantially since the
685 * plan was made. Normally, autovacuum/autoanalyze will occur once enough
686 * inserts have happened and cause cached-plan invalidation; but that
687 * doesn't happen instantaneously, and it won't happen at all for cases
688 * such as temporary tables.)
689 *
690 * We test "never vacuumed" by seeing whether reltuples < 0.
691 *
692 * If the table has inheritance children, we don't apply this heuristic.
693 * Totally empty parent tables are quite common, so we should be willing
694 * to believe that they are empty.
695 */
696 if (curpages < 10 &&
697 reltuples < 0 &&
698 !rel->rd_rel->relhassubclass)
699 curpages = 10;
700
701 /* report estimated # pages */
702 *pages = curpages;
703 /* quick exit if rel is clearly empty */
704 if (curpages == 0)
705 {
706 *tuples = 0;
707 *allvisfrac = 0;
708 return;
709 }
710
711 /* estimate number of tuples from previous tuple density */
712 if (reltuples >= 0 && relpages > 0)
713 density = reltuples / (double) relpages;
714 else
715 {
716 /*
717 * When we have no data because the relation was never yet vacuumed,
718 * estimate tuple width from attribute datatypes. We assume here that
719 * the pages are completely full, which is OK for tables but is
720 * probably an overestimate for indexes. Fortunately
721 * get_relation_info() can clamp the overestimate to the parent
722 * table's size.
723 *
724 * Note: this code intentionally disregards alignment considerations,
725 * because (a) that would be gilding the lily considering how crude
726 * the estimate is, (b) it creates platform dependencies in the
727 * default plans which are kind of a headache for regression testing,
728 * and (c) different table AMs might use different padding schemes.
729 */
730 int32 tuple_width;
731 int fillfactor;
732
733 /*
734 * Without reltuples/relpages, we also need to consider fillfactor.
735 * The other branch considers it implicitly by calculating density
736 * from actual relpages/reltuples statistics.
737 */
738 fillfactor = RelationGetFillFactor(rel, HEAP_DEFAULT_FILLFACTOR);
739
740 tuple_width = get_rel_data_width(rel, attr_widths);
741 tuple_width += overhead_bytes_per_tuple;
742 /* note: integer division is intentional here */
743 density = (usable_bytes_per_page * fillfactor / 100) / tuple_width;
744 /* There's at least one row on the page, even with low fillfactor. */
745 density = clamp_row_est(density);
746 }
747 *tuples = rint(density * (double) curpages);
748
749 /*
750 * We use relallvisible as-is, rather than scaling it up like we do for
751 * the pages and tuples counts, on the theory that any pages added since
752 * the last VACUUM are most likely not marked all-visible. But costsize.c
753 * wants it converted to a fraction.
754 */
755 if (relallvisible == 0 || curpages <= 0)
756 *allvisfrac = 0;
757 else if ((double) relallvisible >= curpages)
758 *allvisfrac = 1;
759 else
760 *allvisfrac = (double) relallvisible / curpages;
761 }