116 bool *call_again,
bool *all_dead)
137 if (prev_buf != hscan->
xs_cbuf)
147 &bslot->base.tupdata,
150 bslot->base.tupdata.t_self = *tid;
170 return got_heap_tuple;
190 bslot->base.tupdata.t_self = *tid;
191 if (
heap_fetch(relation, snapshot, &bslot->base.tupdata, &buffer,
false))
244 bool shouldFree =
true;
264 bool shouldFree =
true;
284 uint32 specToken,
bool succeeded)
286 bool shouldFree =
true;
309 return heap_delete(relation, tid, cid, crosscheck, wait, tmfd, changingPart);
319 bool shouldFree =
true;
327 result =
heap_update(relation, otid, tuple, cid, crosscheck, wait,
328 tmfd, lockmode, update_indexes);
378 follow_updates, &buffer, tmfd);
396 priorXmax = tmfd->
xmax;
412 errmsg(
"tuple to be locked was already moved to another partition due to concurrent update")));
415 if (
heap_fetch(relation, &SnapshotDirty, tuple, &buffer,
true))
438 errmsg_internal(
"t_xmin %u is uncommitted in tuple (%u,%u) to be updated in table \"%s\"",
466 (
errcode(ERRCODE_LOCK_NOT_AVAILABLE),
467 errmsg(
"could not obtain lock on row in relation \"%s\"",
489 tmfd->
xmax = priorXmax;
504 goto tuple_lock_retry;
512 if (tuple->
t_data == NULL)
616 if (persistence == RELPERSISTENCE_UNLOGGED)
619 rel->
rd_rel->relkind == RELKIND_MATVIEW ||
620 rel->
rd_rel->relkind == RELKIND_TOASTVALUE);
661 rel->
rd_rel->relpersistence);
676 (rel->
rd_rel->relpersistence == RELPERSISTENCE_UNLOGGED &&
680 rel->
rd_rel->relpersistence);
697 double *tups_vacuumed,
698 double *tups_recently_dead)
704 bool is_system_catalog;
725 natts = newTupDesc->
natts;
727 isnull = (
bool *)
palloc(natts *
sizeof(
bool));
752 if (OldIndex != NULL && !use_sort)
754 const int ci_index[] = {
802 if (indexScan != NULL)
809 elog(
ERROR,
"CLUSTER does not support lossy index conditions");
860 *tups_recently_dead += 1;
876 if (!is_system_catalog &&
878 elog(
WARNING,
"concurrent insert in progress within table \"%s\"",
888 if (!is_system_catalog &&
890 elog(
WARNING,
"concurrent delete in progress within table \"%s\"",
893 *tups_recently_dead += 1;
897 elog(
ERROR,
"unexpected HeapTupleSatisfiesVacuum result");
912 *tups_recently_dead -= 1;
918 if (tuplesort != NULL)
931 const int ct_index[] = {
944 ct_val[0] = *num_tuples;
945 ct_val[1] = *num_tuples;
950 if (indexScan != NULL)
952 if (tableScan != NULL)
961 if (tuplesort != NULL)
1033 double *liverows,
double *deadrows,
1051 HeapTuple targtuple = &hslot->base.tupdata;
1052 bool sample_it =
false;
1150 elog(
ERROR,
"unexpected HeapTupleSatisfiesVacuum result");
1184 void *callback_state,
1188 bool is_system_catalog;
1189 bool checking_uniqueness;
1199 bool need_unregister_snapshot =
false;
1214 checking_uniqueness = (indexInfo->
ii_Unique ||
1221 Assert(!(anyvisible && checking_uniqueness));
1261 need_unregister_snapshot =
true;
1325 Assert(start_blockno == 0);
1345 if (blocks_done != previous_blkno)
1349 previous_blkno = blocks_done;
1424 tupleIsAlive =
false;
1429 tupleIsAlive =
true;
1458 tupleIsAlive =
false;
1469 tupleIsAlive =
true;
1485 if (!is_system_catalog)
1486 elog(
WARNING,
"concurrent insert in progress within table \"%s\"",
1495 if (checking_uniqueness)
1524 tupleIsAlive =
true;
1536 tupleIsAlive =
false;
1544 if (!is_system_catalog)
1545 elog(
WARNING,
"concurrent delete in progress within table \"%s\"",
1562 if (checking_uniqueness ||
1613 tupleIsAlive =
false;
1616 elog(
ERROR,
"unexpected HeapTupleSatisfiesVacuum result");
1617 indexIt = tupleIsAlive =
false;
1629 tupleIsAlive =
true;
1642 if (predicate != NULL)
1644 if (!
ExecQual(predicate, econtext))
1693 errmsg_internal(
"failed to find parent tuple for heap-only tuple at (%u,%u) in table \"%s\"",
1699 root_offsets[offnum - 1]);
1709 tupleIsAlive, callback_state);
1735 if (need_unregister_snapshot)
1773 bool tuplesort_empty =
false;
1855 memset(in_index, 0,
sizeof(in_index));
1861 rootTuple = *heapcursor;
1866 root_offnum = root_offsets[root_offnum - 1];
1870 errmsg_internal(
"failed to find parent tuple for heap-only tuple at (%u,%u) in table \"%s\"",
1881 while (!tuplesort_empty &&
1898 false, &ts_val, &ts_isnull,
1900 Assert(tuplesort_empty || !ts_isnull);
1901 if (!tuplesort_empty)
1904 indexcursor = &decoded;
1917 if ((tuplesort_empty ||
1919 !in_index[root_offnum - 1])
1930 if (predicate != NULL)
1932 if (!
ExecQual(predicate, econtext))
1975 state->tups_inserted += 1;
2016 blocks_done = hscan->
rs_cblock - startblock;
2022 blocks_done = nblocks - startblock +
2044 int32 data_length = 0;
2045 bool maxlength_unknown =
false;
2046 bool has_toastable_attrs =
false;
2051 for (
i = 0;
i < tupdesc->
natts;
i++)
2055 if (att->attisdropped)
2058 if (att->attlen > 0)
2061 data_length += att->attlen;
2069 maxlength_unknown =
true;
2071 data_length += maxlen;
2072 if (att->attstorage != TYPSTORAGE_PLAIN)
2073 has_toastable_attrs =
true;
2076 if (!has_toastable_attrs)
2078 if (maxlength_unknown)
2092 return rel->
rd_rel->relam;
2101 #define HEAP_OVERHEAD_BYTES_PER_TUPLE \
2102 (MAXALIGN(SizeofHeapTupleHeader) + sizeof(ItemIdData))
2103 #define HEAP_USABLE_BYTES_PER_PAGE \
2104 (BLCKSZ - SizeOfPageHeaderData)
2181 for (curslot = 0; curslot < tbmres->
ntuples; curslot++)
2189 &heapTuple, NULL,
true))
2481 for (
i = 0;
i < newTupDesc->
natts;
i++)
2519 while (start <= end)
2521 int mid = (start + end) / 2;
2524 if (tupoffset == curoffset)
2526 else if (tupoffset < curoffset)
2549 .
type = T_TableAmRoutine,
void pgstat_progress_update_param(int index, int64 val)
void pgstat_progress_update_multi_param(int nparam, const int *index, const int64 *val)
#define InvalidBlockNumber
static bool BlockNumberIsValid(BlockNumber blockNumber)
static Datum values[MAXATTR]
Buffer ReleaseAndReadBuffer(Buffer buffer, Relation relation, BlockNumber blockNum)
void ReleaseBuffer(Buffer buffer)
void UnlockReleaseBuffer(Buffer buffer)
void LockBuffer(Buffer buffer, int mode)
void FlushRelationBuffers(Relation rel)
Buffer ReadBufferExtended(Relation reln, ForkNumber forkNum, BlockNumber blockNum, ReadBufferMode mode, BufferAccessStrategy strategy)
#define BUFFER_LOCK_UNLOCK
#define BUFFER_LOCK_SHARE
static Page BufferGetPage(Buffer buffer)
static bool BufferIsValid(Buffer bufnum)
static Item PageGetItem(Page page, ItemId itemId)
static ItemId PageGetItemId(Page page, OffsetNumber offsetNumber)
static bool PageIsAllVisible(Page page)
static OffsetNumber PageGetMaxOffsetNumber(Page page)
TransactionId MultiXactId
#define OidIsValid(objectId)
bool IsSystemRelation(Relation relation)
CommandId HeapTupleHeaderGetCmin(HeapTupleHeader tup)
static void PGresult * res
elog(ERROR, "%s: %s", p2, msg)
int errmsg_internal(const char *fmt,...)
int errcode(int sqlerrcode)
int errmsg(const char *fmt,...)
#define ereport(elevel,...)
ExprState * ExecPrepareQual(List *qual, EState *estate)
void ExecDropSingleTupleTableSlot(TupleTableSlot *slot)
TupleTableSlot * ExecStoreBufferHeapTuple(HeapTuple tuple, TupleTableSlot *slot, Buffer buffer)
const TupleTableSlotOps TTSOpsBufferHeapTuple
HeapTuple ExecFetchSlotHeapTuple(TupleTableSlot *slot, bool materialize, bool *shouldFree)
TupleTableSlot * ExecStoreHeapTuple(HeapTuple tuple, TupleTableSlot *slot, bool shouldFree)
const TupleTableSlotOps TTSOpsHeapTuple
TupleTableSlot * ExecStorePinnedBufferHeapTuple(HeapTuple tuple, TupleTableSlot *slot, Buffer buffer)
TupleTableSlot * MakeSingleTupleTableSlot(TupleDesc tupdesc, const TupleTableSlotOps *tts_ops)
EState * CreateExecutorState(void)
void FreeExecutorState(EState *estate)
#define GetPerTupleExprContext(estate)
static bool ExecQual(ExprState *state, ExprContext *econtext)
#define PG_RETURN_POINTER(x)
void heap_finish_speculative(Relation relation, ItemPointer tid)
void heap_insert(Relation relation, HeapTuple tup, CommandId cid, int options, BulkInsertState bistate)
bool heap_fetch(Relation relation, Snapshot snapshot, HeapTuple tuple, Buffer *userbuf, bool keep_buf)
TM_Result heap_delete(Relation relation, ItemPointer tid, CommandId cid, Snapshot crosscheck, bool wait, TM_FailureData *tmfd, bool changingPart)
bool heap_getnextslot(TableScanDesc sscan, ScanDirection direction, TupleTableSlot *slot)
void heap_endscan(TableScanDesc sscan)
void heap_rescan(TableScanDesc sscan, ScanKey key, bool set_params, bool allow_strat, bool allow_sync, bool allow_pagemode)
TM_Result heap_update(Relation relation, ItemPointer otid, HeapTuple newtup, CommandId cid, Snapshot crosscheck, bool wait, TM_FailureData *tmfd, LockTupleMode *lockmode, TU_UpdateIndexes *update_indexes)
HeapTuple heap_getnext(TableScanDesc sscan, ScanDirection direction)
bool heap_hot_search_buffer(ItemPointer tid, Relation relation, Buffer buffer, Snapshot snapshot, HeapTuple heapTuple, bool *all_dead, bool first_call)
bool heap_getnextslot_tidrange(TableScanDesc sscan, ScanDirection direction, TupleTableSlot *slot)
void heap_set_tidrange(TableScanDesc sscan, ItemPointer mintid, ItemPointer maxtid)
void heap_abort_speculative(Relation relation, ItemPointer tid)
TableScanDesc heap_beginscan(Relation relation, Snapshot snapshot, int nkeys, ScanKey key, ParallelTableScanDesc parallel_scan, uint32 flags)
TransactionId heap_index_delete_tuples(Relation rel, TM_IndexDeleteOp *delstate)
void heap_multi_insert(Relation relation, TupleTableSlot **slots, int ntuples, CommandId cid, int options, BulkInsertState bistate)
TM_Result heap_lock_tuple(Relation relation, HeapTuple tuple, CommandId cid, LockTupleMode mode, LockWaitPolicy wait_policy, bool follow_updates, Buffer *buffer, TM_FailureData *tmfd)
void heap_get_latest_tid(TableScanDesc sscan, ItemPointer tid)
void heap_setscanlimits(TableScanDesc sscan, BlockNumber startBlk, BlockNumber numBlks)
void HeapCheckForSerializableConflictOut(bool visible, Relation relation, HeapTuple tuple, Buffer buffer, Snapshot snapshot)
void heapgetpage(TableScanDesc sscan, BlockNumber block)
#define HEAP_INSERT_SPECULATIVE
struct HeapScanDescData * HeapScanDesc
@ HEAPTUPLE_RECENTLY_DEAD
@ HEAPTUPLE_INSERT_IN_PROGRESS
@ HEAPTUPLE_DELETE_IN_PROGRESS
static bool heapam_scan_analyze_next_block(TableScanDesc scan, BlockNumber blockno, BufferAccessStrategy bstrategy)
static double heapam_index_build_range_scan(Relation heapRelation, Relation indexRelation, IndexInfo *indexInfo, bool allow_sync, bool anyvisible, bool progress, BlockNumber start_blockno, BlockNumber numblocks, IndexBuildCallback callback, void *callback_state, TableScanDesc scan)
#define HEAP_OVERHEAD_BYTES_PER_TUPLE
static void heapam_estimate_rel_size(Relation rel, int32 *attr_widths, BlockNumber *pages, double *tuples, double *allvisfrac)
static IndexFetchTableData * heapam_index_fetch_begin(Relation rel)
static const TableAmRoutine heapam_methods
static void heapam_index_validate_scan(Relation heapRelation, Relation indexRelation, IndexInfo *indexInfo, Snapshot snapshot, ValidateIndexState *state)
static bool heapam_index_fetch_tuple(struct IndexFetchTableData *scan, ItemPointer tid, Snapshot snapshot, TupleTableSlot *slot, bool *call_again, bool *all_dead)
static void heapam_relation_copy_for_cluster(Relation OldHeap, Relation NewHeap, Relation OldIndex, bool use_sort, TransactionId OldestXmin, TransactionId *xid_cutoff, MultiXactId *multi_cutoff, double *num_tuples, double *tups_vacuumed, double *tups_recently_dead)
static void heapam_tuple_insert_speculative(Relation relation, TupleTableSlot *slot, CommandId cid, int options, BulkInsertState bistate, uint32 specToken)
static bool heapam_scan_sample_next_block(TableScanDesc scan, SampleScanState *scanstate)
static void heapam_tuple_insert(Relation relation, TupleTableSlot *slot, CommandId cid, int options, BulkInsertState bistate)
static TM_Result heapam_tuple_delete(Relation relation, ItemPointer tid, CommandId cid, Snapshot snapshot, Snapshot crosscheck, bool wait, TM_FailureData *tmfd, bool changingPart)
static void heapam_index_fetch_reset(IndexFetchTableData *scan)
static Oid heapam_relation_toast_am(Relation rel)
static TM_Result heapam_tuple_update(Relation relation, ItemPointer otid, TupleTableSlot *slot, CommandId cid, Snapshot snapshot, Snapshot crosscheck, bool wait, TM_FailureData *tmfd, LockTupleMode *lockmode, TU_UpdateIndexes *update_indexes)
static bool heapam_relation_needs_toast_table(Relation rel)
static BlockNumber heapam_scan_get_blocks_done(HeapScanDesc hscan)
static bool heapam_scan_bitmap_next_block(TableScanDesc scan, TBMIterateResult *tbmres)
const TableAmRoutine * GetHeapamTableAmRoutine(void)
static bool heapam_scan_analyze_next_tuple(TableScanDesc scan, TransactionId OldestXmin, double *liverows, double *deadrows, TupleTableSlot *slot)
static bool SampleHeapTupleVisible(TableScanDesc scan, Buffer buffer, HeapTuple tuple, OffsetNumber tupoffset)
static bool heapam_scan_sample_next_tuple(TableScanDesc scan, SampleScanState *scanstate, TupleTableSlot *slot)
static const TupleTableSlotOps * heapam_slot_callbacks(Relation relation)
static bool heapam_tuple_tid_valid(TableScanDesc scan, ItemPointer tid)
#define HEAP_USABLE_BYTES_PER_PAGE
static TM_Result heapam_tuple_lock(Relation relation, ItemPointer tid, Snapshot snapshot, TupleTableSlot *slot, CommandId cid, LockTupleMode mode, LockWaitPolicy wait_policy, uint8 flags, TM_FailureData *tmfd)
static void heapam_relation_copy_data(Relation rel, const RelFileLocator *newrlocator)
static void heapam_index_fetch_end(IndexFetchTableData *scan)
static void heapam_tuple_complete_speculative(Relation relation, TupleTableSlot *slot, uint32 specToken, bool succeeded)
static void reform_and_rewrite_tuple(HeapTuple tuple, Relation OldHeap, Relation NewHeap, Datum *values, bool *isnull, RewriteState rwstate)
static void heapam_relation_set_new_filelocator(Relation rel, const RelFileLocator *newrlocator, char persistence, TransactionId *freezeXid, MultiXactId *minmulti)
static bool heapam_fetch_row_version(Relation relation, ItemPointer tid, Snapshot snapshot, TupleTableSlot *slot)
static bool heapam_scan_bitmap_next_tuple(TableScanDesc scan, TBMIterateResult *tbmres, TupleTableSlot *slot)
static void heapam_relation_nontransactional_truncate(Relation rel)
static bool heapam_tuple_satisfies_snapshot(Relation rel, TupleTableSlot *slot, Snapshot snapshot)
Datum heap_tableam_handler(PG_FUNCTION_ARGS)
bool HeapTupleSatisfiesVisibility(HeapTuple htup, Snapshot snapshot, Buffer buffer)
HTSV_Result HeapTupleSatisfiesVacuum(HeapTuple htup, TransactionId OldestXmin, Buffer buffer)
void heap_fetch_toast_slice(Relation toastrel, Oid valueid, int32 attrsize, int32 sliceoffset, int32 slicelength, struct varlena *result)
#define TOAST_TUPLE_THRESHOLD
HeapTuple heap_form_tuple(TupleDesc tupleDescriptor, Datum *values, bool *isnull)
void heap_deform_tuple(HeapTuple tuple, TupleDesc tupleDesc, Datum *values, bool *isnull)
void heap_freetuple(HeapTuple htup)
HeapTupleHeaderData * HeapTupleHeader
#define HeapTupleHeaderSetSpeculativeToken(tup, token)
#define SizeofHeapTupleHeader
#define HeapTupleHeaderGetXmin(tup)
#define HeapTupleIsHeapOnly(tuple)
#define HeapTupleIsHotUpdated(tuple)
#define MaxHeapTuplesPerPage
#define HeapTupleHeaderGetUpdateXid(tup)
#define HeapTupleHeaderIsSpeculative(tup)
void FormIndexDatum(IndexInfo *indexInfo, TupleTableSlot *slot, EState *estate, Datum *values, bool *isnull)
static void itemptr_decode(ItemPointer itemptr, int64 encoded)
bool index_getnext_slot(IndexScanDesc scan, ScanDirection direction, TupleTableSlot *slot)
bool index_insert(Relation indexRelation, Datum *values, bool *isnull, ItemPointer heap_t_ctid, Relation heapRelation, IndexUniqueCheck checkUnique, bool indexUnchanged, IndexInfo *indexInfo)
IndexScanDesc index_beginscan(Relation heapRelation, Relation indexRelation, Snapshot snapshot, int nkeys, int norderbys)
void index_endscan(IndexScanDesc scan)
void index_rescan(IndexScanDesc scan, ScanKey keys, int nkeys, ScanKey orderbys, int norderbys)
#define ItemIdGetLength(itemId)
#define ItemIdIsNormal(itemId)
#define ItemIdIsDead(itemId)
int32 ItemPointerCompare(ItemPointer arg1, ItemPointer arg2)
bool ItemPointerEquals(ItemPointer pointer1, ItemPointer pointer2)
static void ItemPointerSet(ItemPointerData *pointer, BlockNumber blockNumber, OffsetNumber offNum)
static void ItemPointerSetOffsetNumber(ItemPointerData *pointer, OffsetNumber offsetNumber)
static OffsetNumber ItemPointerGetOffsetNumber(const ItemPointerData *pointer)
static bool ItemPointerIndicatesMovedPartitions(const ItemPointerData *pointer)
static BlockNumber ItemPointerGetBlockNumber(const ItemPointerData *pointer)
static void ItemPointerCopy(const ItemPointerData *fromPointer, ItemPointerData *toPointer)
static bool ItemPointerIsValid(const ItemPointerData *pointer)
Assert(fmt[strlen(fmt) - 1] !='\n')
void XactLockTableWait(TransactionId xid, Relation rel, ItemPointer ctid, XLTW_Oper oper)
bool ConditionalXactLockTableWait(TransactionId xid)
void MemoryContextReset(MemoryContext context)
void pfree(void *pointer)
void * palloc0(Size size)
#define IsBootstrapProcessingMode()
#define CHECK_FOR_INTERRUPTS()
MultiXactId GetOldestMultiXactId(void)
#define InvalidOffsetNumber
#define OffsetNumberIsValid(offsetNumber)
#define OffsetNumberNext(offsetNumber)
#define FirstOffsetNumber
FormData_pg_attribute * Form_pg_attribute
#define ERRCODE_DATA_CORRUPTED
static PgChecksumMode mode
#define ERRCODE_T_R_SERIALIZATION_FAILURE
#define pgstat_count_heap_fetch(rel)
#define pgstat_count_heap_getnext(rel)
static int64 DatumGetInt64(Datum X)
void PredicateLockTID(Relation relation, ItemPointer tid, Snapshot snapshot, TransactionId tuple_xid)
TransactionId GetOldestNonRemovableTransactionId(Relation rel)
#define PROGRESS_CLUSTER_INDEX_RELID
#define PROGRESS_CLUSTER_HEAP_BLKS_SCANNED
#define PROGRESS_CLUSTER_PHASE_SORT_TUPLES
#define PROGRESS_CLUSTER_PHASE_SEQ_SCAN_HEAP
#define PROGRESS_SCAN_BLOCKS_DONE
#define PROGRESS_CLUSTER_PHASE
#define PROGRESS_CLUSTER_HEAP_TUPLES_SCANNED
#define PROGRESS_CLUSTER_TOTAL_HEAP_BLKS
#define PROGRESS_CLUSTER_HEAP_TUPLES_WRITTEN
#define PROGRESS_CLUSTER_PHASE_INDEX_SCAN_HEAP
#define PROGRESS_SCAN_BLOCKS_TOTAL
#define PROGRESS_CLUSTER_PHASE_WRITE_NEW_HEAP
void heap_get_root_tuples(Page page, OffsetNumber *root_offsets)
void heap_page_prune_opt(Relation relation, Buffer buffer)
#define RelationGetRelid(relation)
static SMgrRelation RelationGetSmgr(Relation rel)
#define RelationGetDescr(relation)
#define RelationGetRelationName(relation)
#define RelationGetTargetBlock(relation)
#define RelationIsPermanent(relation)
struct ParallelBlockTableScanDescData * ParallelBlockTableScanDesc
void end_heap_rewrite(RewriteState state)
bool rewrite_heap_dead_tuple(RewriteState state, HeapTuple old_tuple)
RewriteState begin_heap_rewrite(Relation old_heap, Relation new_heap, TransactionId oldest_xmin, TransactionId freeze_xid, MultiXactId cutoff_multi)
void rewrite_heap_tuple(RewriteState state, HeapTuple old_tuple, HeapTuple new_tuple)
void smgrimmedsync(SMgrRelation reln, ForkNumber forknum)
void smgrcreate(SMgrRelation reln, ForkNumber forknum, bool isRedo)
void smgrclose(SMgrRelation reln)
SMgrRelation smgropen(RelFileLocator rlocator, BackendId backend)
bool smgrexists(SMgrRelation reln, ForkNumber forknum)
Snapshot GetTransactionSnapshot(void)
void UnregisterSnapshot(Snapshot snapshot)
Snapshot RegisterSnapshot(Snapshot snapshot)
#define InitDirtySnapshot(snapshotdata)
#define IsMVCCSnapshot(snapshot)
void RelationCopyStorage(SMgrRelation src, SMgrRelation dst, ForkNumber forkNum, char relpersistence)
SMgrRelation RelationCreateStorage(RelFileLocator rlocator, char relpersistence, bool register_delete)
void log_smgrcreate(const RelFileLocator *rlocator, ForkNumber forkNum)
void RelationDropStorage(Relation rel)
void RelationTruncate(Relation rel, BlockNumber nblocks)
MemoryContext ecxt_per_tuple_memory
TupleTableSlot * ecxt_scantuple
BlockNumber rs_startblock
OffsetNumber rs_vistuples[MaxHeapTuplesPerPage]
TableScanDescData rs_base
IndexFetchTableData xs_base
ExprState * ii_PredicateState
List * ii_ExpressionsState
BlockNumber phs_startblock
struct TsmRoutine * tsmroutine
OffsetNumber offsets[FLEXIBLE_ARRAY_MEMBER]
struct SnapshotData * rs_snapshot
struct ParallelTableScanDescData * rs_parallel
NextSampleTuple_function NextSampleTuple
NextSampleBlock_function NextSampleBlock
void ss_report_location(Relation rel, BlockNumber location)
Size table_block_parallelscan_initialize(Relation rel, ParallelTableScanDesc pscan)
void table_block_parallelscan_reinitialize(Relation rel, ParallelTableScanDesc pscan)
uint64 table_block_relation_size(Relation rel, ForkNumber forkNumber)
TupleTableSlot * table_slot_create(Relation relation, List **reglist)
Size table_block_parallelscan_estimate(Relation rel)
void table_block_relation_estimate_size(Relation rel, int32 *attr_widths, BlockNumber *pages, double *tuples, double *allvisfrac, Size overhead_bytes_per_tuple, Size usable_bytes_per_page)
static TableScanDesc table_beginscan(Relation rel, Snapshot snapshot, int nkeys, struct ScanKeyData *key)
static void table_endscan(TableScanDesc scan)
static TableScanDesc table_beginscan_strat(Relation rel, Snapshot snapshot, int nkeys, struct ScanKeyData *key, bool allow_strat, bool allow_sync)
#define TUPLE_LOCK_FLAG_FIND_LAST_VERSION
void(* IndexBuildCallback)(Relation index, ItemPointer tid, Datum *values, bool *isnull, bool tupleIsAlive, void *state)
static bool table_scan_getnextslot(TableScanDesc sscan, ScanDirection direction, TupleTableSlot *slot)
#define TUPLE_LOCK_FLAG_LOCK_UPDATE_IN_PROGRESS
static void callback(struct sockaddr *addr, struct sockaddr *mask, void *unused)
#define InvalidTransactionId
#define TransactionIdEquals(id1, id2)
#define TransactionIdIsValid(xid)
#define TupleDescAttr(tupdesc, i)
void tuplesort_performsort(Tuplesortstate *state)
void tuplesort_end(Tuplesortstate *state)
HeapTuple tuplesort_getheaptuple(Tuplesortstate *state, bool forward)
Tuplesortstate * tuplesort_begin_cluster(TupleDesc tupDesc, Relation indexRel, Relation heaprel, int workMem, SortCoordinate coordinate, int sortopt)
void tuplesort_putheaptuple(Tuplesortstate *state, HeapTuple tup)
bool tuplesort_getdatum(Tuplesortstate *state, bool forward, bool copy, Datum *val, bool *isNull, Datum *abbrev)
#define att_align_nominal(cur_offset, attalign)
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
#define TTS_IS_BUFFERTUPLE(slot)
void heap_vacuum_rel(Relation rel, VacuumParams *params, BufferAccessStrategy bstrategy)
bool TransactionIdIsCurrentTransactionId(TransactionId xid)