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)
613 if (persistence == RELPERSISTENCE_UNLOGGED)
616 rel->
rd_rel->relkind == RELKIND_MATVIEW ||
617 rel->
rd_rel->relkind == RELKIND_TOASTVALUE);
657 rel->
rd_rel->relpersistence);
672 (rel->
rd_rel->relpersistence == RELPERSISTENCE_UNLOGGED &&
676 rel->
rd_rel->relpersistence);
693 double *tups_vacuumed,
694 double *tups_recently_dead)
700 bool is_system_catalog;
721 natts = newTupDesc->
natts;
723 isnull = (
bool *)
palloc(natts *
sizeof(
bool));
743 if (OldIndex != NULL && !use_sort)
745 const int ci_index[] = {
793 if (indexScan != NULL)
800 elog(
ERROR,
"CLUSTER does not support lossy index conditions");
851 *tups_recently_dead += 1;
867 if (!is_system_catalog &&
869 elog(
WARNING,
"concurrent insert in progress within table \"%s\"",
879 if (!is_system_catalog &&
881 elog(
WARNING,
"concurrent delete in progress within table \"%s\"",
884 *tups_recently_dead += 1;
888 elog(
ERROR,
"unexpected HeapTupleSatisfiesVacuum result");
903 *tups_recently_dead -= 1;
909 if (tuplesort != NULL)
922 const int ct_index[] = {
935 ct_val[0] = *num_tuples;
936 ct_val[1] = *num_tuples;
941 if (indexScan != NULL)
943 if (tableScan != NULL)
952 if (tuplesort != NULL)
1024 double *liverows,
double *deadrows,
1042 HeapTuple targtuple = &hslot->base.tupdata;
1043 bool sample_it =
false;
1141 elog(
ERROR,
"unexpected HeapTupleSatisfiesVacuum result");
1175 void *callback_state,
1179 bool is_system_catalog;
1180 bool checking_uniqueness;
1190 bool need_unregister_snapshot =
false;
1205 checking_uniqueness = (indexInfo->
ii_Unique ||
1212 Assert(!(anyvisible && checking_uniqueness));
1252 need_unregister_snapshot =
true;
1316 Assert(start_blockno == 0);
1336 if (blocks_done != previous_blkno)
1340 previous_blkno = blocks_done;
1415 tupleIsAlive =
false;
1420 tupleIsAlive =
true;
1449 tupleIsAlive =
false;
1460 tupleIsAlive =
true;
1476 if (!is_system_catalog)
1477 elog(
WARNING,
"concurrent insert in progress within table \"%s\"",
1486 if (checking_uniqueness)
1515 tupleIsAlive =
true;
1527 tupleIsAlive =
false;
1535 if (!is_system_catalog)
1536 elog(
WARNING,
"concurrent delete in progress within table \"%s\"",
1553 if (checking_uniqueness ||
1604 tupleIsAlive =
false;
1607 elog(
ERROR,
"unexpected HeapTupleSatisfiesVacuum result");
1608 indexIt = tupleIsAlive =
false;
1620 tupleIsAlive =
true;
1633 if (predicate != NULL)
1635 if (!
ExecQual(predicate, econtext))
1684 errmsg_internal(
"failed to find parent tuple for heap-only tuple at (%u,%u) in table \"%s\"",
1690 root_offsets[offnum - 1]);
1700 tupleIsAlive, callback_state);
1726 if (need_unregister_snapshot)
1764 bool tuplesort_empty =
false;
1846 memset(in_index, 0,
sizeof(in_index));
1852 rootTuple = *heapcursor;
1857 root_offnum = root_offsets[root_offnum - 1];
1861 errmsg_internal(
"failed to find parent tuple for heap-only tuple at (%u,%u) in table \"%s\"",
1872 while (!tuplesort_empty &&
1889 false, &ts_val, &ts_isnull,
1891 Assert(tuplesort_empty || !ts_isnull);
1892 if (!tuplesort_empty)
1895 indexcursor = &decoded;
1908 if ((tuplesort_empty ||
1910 !in_index[root_offnum - 1])
1921 if (predicate != NULL)
1923 if (!
ExecQual(predicate, econtext))
1966 state->tups_inserted += 1;
2007 blocks_done = hscan->
rs_cblock - startblock;
2013 blocks_done = nblocks - startblock +
2035 int32 data_length = 0;
2036 bool maxlength_unknown =
false;
2037 bool has_toastable_attrs =
false;
2042 for (
i = 0;
i < tupdesc->
natts;
i++)
2046 if (att->attisdropped)
2049 if (att->attlen > 0)
2052 data_length += att->attlen;
2060 maxlength_unknown =
true;
2062 data_length += maxlen;
2063 if (att->attstorage != TYPSTORAGE_PLAIN)
2064 has_toastable_attrs =
true;
2067 if (!has_toastable_attrs)
2069 if (maxlength_unknown)
2083 return rel->
rd_rel->relam;
2092 #define HEAP_OVERHEAD_BYTES_PER_TUPLE \
2093 (MAXALIGN(SizeofHeapTupleHeader) + sizeof(ItemIdData))
2094 #define HEAP_USABLE_BYTES_PER_PAGE \
2095 (BLCKSZ - SizeOfPageHeaderData)
2174 for (curslot = 0; curslot < tbmres->
ntuples; curslot++)
2182 &heapTuple, NULL,
true))
2474 for (
i = 0;
i < newTupDesc->
natts;
i++)
2512 while (start <= end)
2514 int mid = (start + end) / 2;
2517 if (tupoffset == curoffset)
2519 else if (tupoffset < curoffset)
2542 .
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, const Datum *values, const 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 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, 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)
#define IsolationIsSerializable()