| 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 |
} |