116 elog(
ERROR,
"unrecognized result from subplan");
120 node->
tbmres = tbmres = NULL;
142 elog(
ERROR,
"unrecognized result from subplan");
174 node->
tbmres = tbmres = NULL;
299 node->
tbmres = tbmres = NULL;
310 node->
tbmres = tbmres = NULL;
375 else if (prefetch_iterator)
381 elog(
ERROR,
"prefetch and main iterators are out of sync");
409 if (prefetch_iterator)
473 if (prefetch_iterator)
518 if (prefetch_iterator)
523 bool do_prefetch =
false;
728 scanstate->
tbm = NULL;
790 scanstate->bitmapqualorig =
797 scanstate->prefetch_maximum =
800 scanstate->ss.ss_currentRelation = currentRelation;
830 state = pstate->
state;
void table_scan_update_snapshot(TableScanDesc scan, Snapshot snapshot)
static bool table_scan_bitmap_next_tuple(TableScanDesc scan, struct TBMIterateResult *tbmres, TupleTableSlot *slot)
void ExecReScanBitmapHeapScan(BitmapHeapScanState *node)
struct dsa_area * es_query_dsa
void tbm_end_iterate(TBMIterator *iterator)
static void BitmapPrefetch(BitmapHeapScanState *node, TableScanDesc scan)
#define IsA(nodeptr, _type_)
BitmapHeapScanState * ExecInitBitmapHeapScan(BitmapHeapScan *node, EState *estate, int eflags)
ExprState * bitmapqualorig
Snapshot RestoreSnapshot(char *start_address)
static void BitmapAdjustPrefetchTarget(BitmapHeapScanState *node)
#define InvalidDsaPointer
dsa_pointer tbm_prepare_shared_iterate(TIDBitmap *tbm)
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
TupleTableSlot * ExecStoreAllNullTuple(TupleTableSlot *slot)
#define RelationGetDescr(relation)
#define castNode(_type_, nodeptr)
void ExecEndNode(PlanState *node)
TupleTableSlot * ExecScan(ScanState *node, ExecScanAccessMtd accessMtd, ExecScanRecheckMtd recheckMtd)
ExprContext * ps_ExprContext
shm_toc_estimator estimator
#define SpinLockInit(lock)
const TupleTableSlotOps * table_slot_callbacks(Relation relation)
void ExecReScan(PlanState *node)
int get_tablespace_io_concurrency(Oid spcid)
struct TableScanDescData * ss_currentScanDesc
void ConditionVariableBroadcast(ConditionVariable *cv)
TupleTableSlot * ss_ScanTupleSlot
void ReleaseBuffer(Buffer buffer)
Relation ss_currentRelation
#define shm_toc_estimate_chunk(e, sz)
static void table_rescan(TableScanDesc scan, struct ScanKeyData *key)
void ExecFreeExprContext(PlanState *planstate)
ExprState * ExecInitQual(List *qual, PlanState *parent)
#define SpinLockAcquire(lock)
void ConditionVariableInit(ConditionVariable *cv)
TupleTableSlot * ps_ResultTupleSlot
void ConditionVariableCancelSleep(void)
static TupleTableSlot * ExecBitmapHeapScan(PlanState *pstate)
void ExecBitmapHeapInitializeDSM(BitmapHeapScanState *node, ParallelContext *pcxt)
static TupleTableSlot * BitmapHeapNext(BitmapHeapScanState *node)
void ExecAssignScanProjectionInfo(ScanState *node)
ParallelBitmapHeapState * pstate
void SerializeSnapshot(Snapshot snapshot, char *start_address)
Relation ExecOpenScanRelation(EState *estate, Index scanrelid, int eflags)
#define EXEC_FLAG_BACKWARD
#define outerPlanState(node)
void ExecInitScanTupleSlot(EState *estate, ScanState *scanstate, TupleDesc tupledesc, const TupleTableSlotOps *tts_ops)
void tbm_free(TIDBitmap *tbm)
void ExecInitResultTypeTL(PlanState *planstate)
static bool BitmapShouldInitializeSharedState(ParallelBitmapHeapState *pstate)
TBMIterateResult * tbmres
void ExecBitmapHeapReInitializeDSM(BitmapHeapScanState *node, ParallelContext *pcxt)
void tbm_free_shared_area(dsa_area *dsa, dsa_pointer dp)
bool(* ExecScanRecheckMtd)(ScanState *node, TupleTableSlot *slot)
#define SpinLockRelease(lock)
static bool ExecQualAndReset(ExprState *state, ExprContext *econtext)
Size EstimateSnapshotSpace(Snapshot snap)
ExecProcNodeMtd ExecProcNode
static bool BitmapHeapRecheck(BitmapHeapScanState *node, TupleTableSlot *slot)
Size add_size(Size s1, Size s2)
#define IsMVCCSnapshot(snapshot)
dsa_pointer prefetch_iterator
static void BitmapAdjustPrefetchIterator(BitmapHeapScanState *node, TBMIterateResult *tbmres)
TBMIterateResult * tbm_iterate(TBMIterator *iterator)
void ConditionVariableSleep(ConditionVariable *cv, uint32 wait_event_info)
#define Assert(condition)
#define InstrCountFiltered2(node, delta)
#define VM_ALL_VISIBLE(r, b, v)
void ExecAssignExprContext(EState *estate, PlanState *planstate)
TBMIterator * tbm_begin_iterate(TIDBitmap *tbm)
TBMIterateResult * tbm_shared_iterate(TBMSharedIterator *iterator)
#define shm_toc_estimate_keys(e, cnt)
TupleTableSlot * ecxt_scantuple
TBMSharedIterator * shared_tbmiterator
TBMIterator * tbmiterator
void * shm_toc_allocate(shm_toc *toc, Size nbytes)
char phs_snapshot_data[FLEXIBLE_ARRAY_MEMBER]
#define DsaPointerIsValid(x)
static void BitmapDoneInitializingSharedState(ParallelBitmapHeapState *pstate)
static void table_endscan(TableScanDesc scan)
void shm_toc_insert(shm_toc *toc, uint64 key, void *address)
Node * MultiExecProcNode(PlanState *node)
TBMIterator * prefetch_iterator
static bool table_scan_bitmap_next_block(TableScanDesc scan, struct TBMIterateResult *tbmres)
void ExecBitmapHeapEstimate(BitmapHeapScanState *node, ParallelContext *pcxt)
void ExecScanReScan(ScanState *node)
PrefetchBufferResult PrefetchBuffer(Relation reln, ForkNumber forkNum, BlockNumber blockNum)
static TableScanDesc table_beginscan_bm(Relation rel, Snapshot snapshot, int nkeys, struct ScanKeyData *key)
#define CHECK_FOR_INTERRUPTS()
void ExecEndBitmapHeapScan(BitmapHeapScanState *node)
TupleTableSlot *(* ExecScanAccessMtd)(ScanState *node)
void ExecBitmapHeapInitializeWorker(BitmapHeapScanState *node, ParallelWorkerContext *pwcxt)
PlanState * ExecInitNode(Plan *node, EState *estate, int eflags)
TBMSharedIterator * tbm_attach_shared_iterate(dsa_area *dsa, dsa_pointer dp)
void * shm_toc_lookup(shm_toc *toc, uint64 key, bool noError)
TBMSharedIterator * shared_prefetch_iterator
#define offsetof(type, field)
void tbm_end_shared_iterate(TBMSharedIterator *iterator)