PostgreSQL Source Code  git master
nodeBitmapHeapscan.h File Reference
#include "nodes/execnodes.h"
#include "access/parallel.h"
Include dependency graph for nodeBitmapHeapscan.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions

BitmapHeapScanStateExecInitBitmapHeapScan (BitmapHeapScan *node, EState *estate, int eflags)
 
void ExecEndBitmapHeapScan (BitmapHeapScanState *node)
 
void ExecReScanBitmapHeapScan (BitmapHeapScanState *node)
 
void ExecBitmapHeapEstimate (BitmapHeapScanState *node, ParallelContext *pcxt)
 
void ExecBitmapHeapInitializeDSM (BitmapHeapScanState *node, ParallelContext *pcxt)
 
void ExecBitmapHeapReInitializeDSM (BitmapHeapScanState *node, ParallelContext *pcxt)
 
void ExecBitmapHeapInitializeWorker (BitmapHeapScanState *node, ParallelWorkerContext *pwcxt)
 

Function Documentation

◆ ExecBitmapHeapEstimate()

void ExecBitmapHeapEstimate ( BitmapHeapScanState node,
ParallelContext pcxt 
)

Definition at line 869 of file nodeBitmapHeapscan.c.

References add_size(), EState::es_snapshot, EstimateSnapshotSpace(), ParallelContext::estimator, offsetof, ScanState::ps, BitmapHeapScanState::pscan_len, shm_toc_estimate_chunk, shm_toc_estimate_keys, BitmapHeapScanState::ss, and PlanState::state.

Referenced by ExecParallelEstimate().

871 {
872  EState *estate = node->ss.ps.state;
873 
875  phs_snapshot_data),
877 
879  shm_toc_estimate_keys(&pcxt->estimator, 1);
880 }
shm_toc_estimator estimator
Definition: parallel.h:41
Snapshot es_snapshot
Definition: execnodes.h:503
EState * state
Definition: execnodes.h:942
#define shm_toc_estimate_chunk(e, sz)
Definition: shm_toc.h:51
PlanState ps
Definition: execnodes.h:1331
Size EstimateSnapshotSpace(Snapshot snap)
Definition: snapmgr.c:2078
Size add_size(Size s1, Size s2)
Definition: shmem.c:475
#define shm_toc_estimate_keys(e, cnt)
Definition: shm_toc.h:53
#define offsetof(type, field)
Definition: c.h:655

◆ ExecBitmapHeapInitializeDSM()

void ExecBitmapHeapInitializeDSM ( BitmapHeapScanState node,
ParallelContext pcxt 
)

Definition at line 889 of file nodeBitmapHeapscan.c.

References BM_INITIAL, ConditionVariableInit(), ParallelBitmapHeapState::cv, EState::es_query_dsa, EState::es_snapshot, ParallelBitmapHeapState::mutex, ParallelBitmapHeapState::phs_snapshot_data, PlanState::plan, Plan::plan_node_id, ParallelBitmapHeapState::prefetch_iterator, ParallelBitmapHeapState::prefetch_pages, ParallelBitmapHeapState::prefetch_target, ScanState::ps, BitmapHeapScanState::pscan_len, BitmapHeapScanState::pstate, SerializeSnapshot(), shm_toc_allocate(), shm_toc_insert(), SpinLockInit, BitmapHeapScanState::ss, PlanState::state, ParallelBitmapHeapState::state, ParallelBitmapHeapState::tbmiterator, and ParallelContext::toc.

Referenced by ExecParallelInitializeDSM().

891 {
892  ParallelBitmapHeapState *pstate;
893  EState *estate = node->ss.ps.state;
894  dsa_area *dsa = node->ss.ps.state->es_query_dsa;
895 
896  /* If there's no DSA, there are no workers; initialize nothing. */
897  if (dsa == NULL)
898  return;
899 
900  pstate = shm_toc_allocate(pcxt->toc, node->pscan_len);
901 
902  pstate->tbmiterator = 0;
903  pstate->prefetch_iterator = 0;
904 
905  /* Initialize the mutex */
906  SpinLockInit(&pstate->mutex);
907  pstate->prefetch_pages = 0;
908  pstate->prefetch_target = 0;
909  pstate->state = BM_INITIAL;
910 
911  ConditionVariableInit(&pstate->cv);
913 
914  shm_toc_insert(pcxt->toc, node->ss.ps.plan->plan_node_id, pstate);
915  node->pstate = pstate;
916 }
struct dsa_area * es_query_dsa
Definition: execnodes.h:584
#define SpinLockInit(lock)
Definition: spin.h:60
int plan_node_id
Definition: plannodes.h:139
Snapshot es_snapshot
Definition: execnodes.h:503
EState * state
Definition: execnodes.h:942
PlanState ps
Definition: execnodes.h:1331
void ConditionVariableInit(ConditionVariable *cv)
ParallelBitmapHeapState * pstate
Definition: execnodes.h:1603
void SerializeSnapshot(Snapshot snapshot, char *start_address)
Definition: snapmgr.c:2102
dsa_pointer tbmiterator
Definition: execnodes.h:1548
Plan * plan
Definition: execnodes.h:940
dsa_pointer prefetch_iterator
Definition: execnodes.h:1549
SharedBitmapState state
Definition: execnodes.h:1553
void * shm_toc_allocate(shm_toc *toc, Size nbytes)
Definition: shm_toc.c:88
char phs_snapshot_data[FLEXIBLE_ARRAY_MEMBER]
Definition: execnodes.h:1555
Definition: dsa.c:354
void shm_toc_insert(shm_toc *toc, uint64 key, void *address)
Definition: shm_toc.c:171
ConditionVariable cv
Definition: execnodes.h:1554
shm_toc * toc
Definition: parallel.h:44

◆ ExecBitmapHeapInitializeWorker()

void ExecBitmapHeapInitializeWorker ( BitmapHeapScanState node,
ParallelWorkerContext pwcxt 
)

Definition at line 954 of file nodeBitmapHeapscan.c.

References Assert, EState::es_query_dsa, ParallelBitmapHeapState::phs_snapshot_data, PlanState::plan, Plan::plan_node_id, ScanState::ps, BitmapHeapScanState::pstate, RestoreSnapshot(), shm_toc_lookup(), BitmapHeapScanState::ss, ScanState::ss_currentScanDesc, PlanState::state, table_scan_update_snapshot(), and ParallelWorkerContext::toc.

Referenced by ExecParallelInitializeWorker().

956 {
957  ParallelBitmapHeapState *pstate;
958  Snapshot snapshot;
959 
960  Assert(node->ss.ps.state->es_query_dsa != NULL);
961 
962  pstate = shm_toc_lookup(pwcxt->toc, node->ss.ps.plan->plan_node_id, false);
963  node->pstate = pstate;
964 
965  snapshot = RestoreSnapshot(pstate->phs_snapshot_data);
967 }
void table_scan_update_snapshot(TableScanDesc scan, Snapshot snapshot)
Definition: tableam.c:110
struct dsa_area * es_query_dsa
Definition: execnodes.h:584
Snapshot RestoreSnapshot(char *start_address)
Definition: snapmgr.c:2161
int plan_node_id
Definition: plannodes.h:139
struct TableScanDescData * ss_currentScanDesc
Definition: execnodes.h:1333
EState * state
Definition: execnodes.h:942
PlanState ps
Definition: execnodes.h:1331
ParallelBitmapHeapState * pstate
Definition: execnodes.h:1603
Plan * plan
Definition: execnodes.h:940
#define Assert(condition)
Definition: c.h:732
char phs_snapshot_data[FLEXIBLE_ARRAY_MEMBER]
Definition: execnodes.h:1555
void * shm_toc_lookup(shm_toc *toc, uint64 key, bool noError)
Definition: shm_toc.c:232

◆ ExecBitmapHeapReInitializeDSM()

void ExecBitmapHeapReInitializeDSM ( BitmapHeapScanState node,
ParallelContext pcxt 
)

Definition at line 925 of file nodeBitmapHeapscan.c.

References BM_INITIAL, DsaPointerIsValid, EState::es_query_dsa, InvalidDsaPointer, ParallelBitmapHeapState::prefetch_iterator, ScanState::ps, BitmapHeapScanState::pstate, BitmapHeapScanState::ss, PlanState::state, ParallelBitmapHeapState::state, tbm_free_shared_area(), and ParallelBitmapHeapState::tbmiterator.

Referenced by ExecParallelReInitializeDSM().

927 {
928  ParallelBitmapHeapState *pstate = node->pstate;
929  dsa_area *dsa = node->ss.ps.state->es_query_dsa;
930 
931  /* If there's no DSA, there are no workers; do nothing. */
932  if (dsa == NULL)
933  return;
934 
935  pstate->state = BM_INITIAL;
936 
937  if (DsaPointerIsValid(pstate->tbmiterator))
938  tbm_free_shared_area(dsa, pstate->tbmiterator);
939 
942 
943  pstate->tbmiterator = InvalidDsaPointer;
945 }
struct dsa_area * es_query_dsa
Definition: execnodes.h:584
#define InvalidDsaPointer
Definition: dsa.h:78
EState * state
Definition: execnodes.h:942
PlanState ps
Definition: execnodes.h:1331
ParallelBitmapHeapState * pstate
Definition: execnodes.h:1603
dsa_pointer tbmiterator
Definition: execnodes.h:1548
void tbm_free_shared_area(dsa_area *dsa, dsa_pointer dp)
Definition: tidbitmap.c:340
dsa_pointer prefetch_iterator
Definition: execnodes.h:1549
SharedBitmapState state
Definition: execnodes.h:1553
#define DsaPointerIsValid(x)
Definition: dsa.h:81
Definition: dsa.c:354

◆ ExecEndBitmapHeapScan()

void ExecEndBitmapHeapScan ( BitmapHeapScanState node)

Definition at line 650 of file nodeBitmapHeapscan.c.

References ExecClearTuple(), ExecEndNode(), ExecFreeExprContext(), InvalidBuffer, outerPlanState, BitmapHeapScanState::prefetch_iterator, ScanState::ps, PlanState::ps_ResultTupleSlot, BitmapHeapScanState::pvmbuffer, ReleaseBuffer(), BitmapHeapScanState::shared_prefetch_iterator, BitmapHeapScanState::shared_tbmiterator, BitmapHeapScanState::ss, ScanState::ss_currentScanDesc, ScanState::ss_ScanTupleSlot, table_endscan(), BitmapHeapScanState::tbm, tbm_end_iterate(), tbm_end_shared_iterate(), tbm_free(), BitmapHeapScanState::tbmiterator, and BitmapHeapScanState::vmbuffer.

Referenced by ExecEndNode().

651 {
652  TableScanDesc scanDesc;
653 
654  /*
655  * extract information from the node
656  */
657  scanDesc = node->ss.ss_currentScanDesc;
658 
659  /*
660  * Free the exprcontext
661  */
662  ExecFreeExprContext(&node->ss.ps);
663 
664  /*
665  * clear out tuple table slots
666  */
667  if (node->ss.ps.ps_ResultTupleSlot)
670 
671  /*
672  * close down subplans
673  */
675 
676  /*
677  * release bitmaps and buffers if any
678  */
679  if (node->tbmiterator)
681  if (node->prefetch_iterator)
683  if (node->tbm)
684  tbm_free(node->tbm);
685  if (node->shared_tbmiterator)
687  if (node->shared_prefetch_iterator)
689  if (node->vmbuffer != InvalidBuffer)
690  ReleaseBuffer(node->vmbuffer);
691  if (node->pvmbuffer != InvalidBuffer)
692  ReleaseBuffer(node->pvmbuffer);
693 
694  /*
695  * close heap scan
696  */
697  table_endscan(scanDesc);
698 }
void tbm_end_iterate(TBMIterator *iterator)
Definition: tidbitmap.c:1145
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
Definition: tuptable.h:426
void ExecEndNode(PlanState *node)
Definition: execProcnode.c:538
TIDBitmap * tbm
Definition: execnodes.h:1586
#define InvalidBuffer
Definition: buf.h:25
struct TableScanDescData * ss_currentScanDesc
Definition: execnodes.h:1333
TupleTableSlot * ss_ScanTupleSlot
Definition: execnodes.h:1334
void ReleaseBuffer(Buffer buffer)
Definition: bufmgr.c:3365
void ExecFreeExprContext(PlanState *planstate)
Definition: execUtils.c:614
PlanState ps
Definition: execnodes.h:1331
TupleTableSlot * ps_ResultTupleSlot
Definition: execnodes.h:978
#define outerPlanState(node)
Definition: execnodes.h:1034
void tbm_free(TIDBitmap *tbm)
Definition: tidbitmap.c:321
TBMSharedIterator * shared_tbmiterator
Definition: execnodes.h:1601
TBMIterator * tbmiterator
Definition: execnodes.h:1587
static void table_endscan(TableScanDesc scan)
Definition: tableam.h:831
TBMIterator * prefetch_iterator
Definition: execnodes.h:1595
TBMSharedIterator * shared_prefetch_iterator
Definition: execnodes.h:1602
void tbm_end_shared_iterate(TBMSharedIterator *iterator)
Definition: tidbitmap.c:1157

◆ ExecInitBitmapHeapScan()

BitmapHeapScanState* ExecInitBitmapHeapScan ( BitmapHeapScan node,
EState estate,
int  eflags 
)

Definition at line 707 of file nodeBitmapHeapscan.c.

References Assert, BitmapHeapScan::bitmapqualorig, BitmapHeapScanState::can_skip_fetch, ComputeIoConcurrency(), effective_io_concurrency, EState::es_snapshot, BitmapHeapScanState::exact_pages, EXEC_FLAG_BACKWARD, EXEC_FLAG_MARK, ExecAssignExprContext(), ExecAssignScanProjectionInfo(), ExecBitmapHeapScan(), ExecInitNode(), ExecInitQual(), ExecInitResultTypeTL(), ExecInitScanTupleSlot(), ExecOpenScanRelation(), PlanState::ExecProcNode, get_tablespace_io_concurrency(), BitmapHeapScanState::initialized, InvalidBuffer, IsMVCCSnapshot, BitmapHeapScanState::lossy_pages, makeNode, NIL, outerPlan, outerPlanState, Scan::plan, PlanState::plan, BitmapHeapScanState::prefetch_iterator, BitmapHeapScanState::prefetch_maximum, BitmapHeapScanState::prefetch_pages, BitmapHeapScanState::prefetch_target, ScanState::ps, BitmapHeapScanState::pscan_len, BitmapHeapScanState::pstate, BitmapHeapScanState::pvmbuffer, Plan::qual, PlanState::qual, RelationData::rd_rel, RelationGetDescr, BitmapHeapScanState::return_empty_tuples, rint(), BitmapHeapScan::scan, Scan::scanrelid, BitmapHeapScanState::shared_prefetch_iterator, BitmapHeapScanState::shared_tbmiterator, BitmapHeapScanState::ss, PlanState::state, table_beginscan_bm(), table_slot_callbacks(), target_prefetch_pages, Plan::targetlist, BitmapHeapScanState::tbm, BitmapHeapScanState::tbmiterator, BitmapHeapScanState::tbmres, and BitmapHeapScanState::vmbuffer.

Referenced by ExecInitNode().

708 {
709  BitmapHeapScanState *scanstate;
710  Relation currentRelation;
711  int io_concurrency;
712 
713  /* check for unsupported flags */
714  Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));
715 
716  /*
717  * Assert caller didn't ask for an unsafe snapshot --- see comments at
718  * head of file.
719  */
721 
722  /*
723  * create state structure
724  */
725  scanstate = makeNode(BitmapHeapScanState);
726  scanstate->ss.ps.plan = (Plan *) node;
727  scanstate->ss.ps.state = estate;
728  scanstate->ss.ps.ExecProcNode = ExecBitmapHeapScan;
729 
730  scanstate->tbm = NULL;
731  scanstate->tbmiterator = NULL;
732  scanstate->tbmres = NULL;
733  scanstate->return_empty_tuples = 0;
734  scanstate->vmbuffer = InvalidBuffer;
735  scanstate->pvmbuffer = InvalidBuffer;
736  scanstate->exact_pages = 0;
737  scanstate->lossy_pages = 0;
738  scanstate->prefetch_iterator = NULL;
739  scanstate->prefetch_pages = 0;
740  scanstate->prefetch_target = 0;
741  /* may be updated below */
743  scanstate->pscan_len = 0;
744  scanstate->initialized = false;
745  scanstate->shared_tbmiterator = NULL;
746  scanstate->shared_prefetch_iterator = NULL;
747  scanstate->pstate = NULL;
748 
749  /*
750  * We can potentially skip fetching heap pages if we do not need any
751  * columns of the table, either for checking non-indexable quals or for
752  * returning data. This test is a bit simplistic, as it checks the
753  * stronger condition that there's no qual or return tlist at all. But in
754  * most cases it's probably not worth working harder than that.
755  */
756  scanstate->can_skip_fetch = (node->scan.plan.qual == NIL &&
757  node->scan.plan.targetlist == NIL);
758 
759  /*
760  * Miscellaneous initialization
761  *
762  * create expression context for node
763  */
764  ExecAssignExprContext(estate, &scanstate->ss.ps);
765 
766  /*
767  * open the scan relation
768  */
769  currentRelation = ExecOpenScanRelation(estate, node->scan.scanrelid, eflags);
770 
771  /*
772  * initialize child nodes
773  */
774  outerPlanState(scanstate) = ExecInitNode(outerPlan(node), estate, eflags);
775 
776  /*
777  * get the scan type from the relation descriptor.
778  */
779  ExecInitScanTupleSlot(estate, &scanstate->ss,
780  RelationGetDescr(currentRelation),
781  table_slot_callbacks(currentRelation));
782 
783  /*
784  * Initialize result type and projection.
785  */
786  ExecInitResultTypeTL(&scanstate->ss.ps);
787  ExecAssignScanProjectionInfo(&scanstate->ss);
788 
789  /*
790  * initialize child expressions
791  */
792  scanstate->ss.ps.qual =
793  ExecInitQual(node->scan.plan.qual, (PlanState *) scanstate);
794  scanstate->bitmapqualorig =
795  ExecInitQual(node->bitmapqualorig, (PlanState *) scanstate);
796 
797  /*
798  * Determine the maximum for prefetch_target. If the tablespace has a
799  * specific IO concurrency set, use that to compute the corresponding
800  * maximum value; otherwise, we already initialized to the value computed
801  * by the GUC machinery.
802  */
803  io_concurrency =
804  get_tablespace_io_concurrency(currentRelation->rd_rel->reltablespace);
805  if (io_concurrency != effective_io_concurrency)
806  {
807  double maximum;
808 
809  if (ComputeIoConcurrency(io_concurrency, &maximum))
810  scanstate->prefetch_maximum = rint(maximum);
811  }
812 
813  scanstate->ss.ss_currentRelation = currentRelation;
814 
815  scanstate->ss.ss_currentScanDesc = table_beginscan_bm(currentRelation,
816  estate->es_snapshot,
817  0,
818  NULL);
819 
820  /*
821  * all done.
822  */
823  return scanstate;
824 }
#define NIL
Definition: pg_list.h:65
List * qual
Definition: plannodes.h:141
int target_prefetch_pages
Definition: bufmgr.c:130
Plan plan
Definition: plannodes.h:340
ExprState * bitmapqualorig
Definition: execnodes.h:1585
Index scanrelid
Definition: plannodes.h:341
#define RelationGetDescr(relation)
Definition: rel.h:445
const TupleTableSlotOps * table_slot_callbacks(Relation relation)
Definition: tableam.c:44
TIDBitmap * tbm
Definition: execnodes.h:1586
#define InvalidBuffer
Definition: buf.h:25
int get_tablespace_io_concurrency(Oid spcid)
Definition: spccache.c:215
struct TableScanDescData * ss_currentScanDesc
Definition: execnodes.h:1333
Snapshot es_snapshot
Definition: execnodes.h:503
Relation ss_currentRelation
Definition: execnodes.h:1332
EState * state
Definition: execnodes.h:942
Form_pg_class rd_rel
Definition: rel.h:83
int effective_io_concurrency
Definition: bufmgr.c:113
ExprState * ExecInitQual(List *qual, PlanState *parent)
Definition: execExpr.c:207
bool ComputeIoConcurrency(int io_concurrency, double *target)
Definition: bufmgr.c:469
PlanState ps
Definition: execnodes.h:1331
static TupleTableSlot * ExecBitmapHeapScan(PlanState *pstate)
void ExecAssignScanProjectionInfo(ScanState *node)
Definition: execScan.c:272
ParallelBitmapHeapState * pstate
Definition: execnodes.h:1603
Relation ExecOpenScanRelation(EState *estate, Index scanrelid, int eflags)
Definition: execUtils.c:693
#define EXEC_FLAG_BACKWARD
Definition: executor.h:58
#define outerPlanState(node)
Definition: execnodes.h:1034
void ExecInitScanTupleSlot(EState *estate, ScanState *scanstate, TupleDesc tupledesc, const TupleTableSlotOps *tts_ops)
Definition: execTuples.c:1776
void ExecInitResultTypeTL(PlanState *planstate)
Definition: execTuples.c:1720
double rint(double x)
Definition: rint.c:21
List * bitmapqualorig
Definition: plannodes.h:475
TBMIterateResult * tbmres
Definition: execnodes.h:1588
#define outerPlan(node)
Definition: plannodes.h:170
ExecProcNodeMtd ExecProcNode
Definition: execnodes.h:946
#define IsMVCCSnapshot(snapshot)
Definition: snapmgr.h:97
Plan * plan
Definition: execnodes.h:940
#define makeNode(_type_)
Definition: nodes.h:573
#define Assert(condition)
Definition: c.h:732
#define EXEC_FLAG_MARK
Definition: executor.h:59
void ExecAssignExprContext(EState *estate, PlanState *planstate)
Definition: execUtils.c:444
TBMSharedIterator * shared_tbmiterator
Definition: execnodes.h:1601
TBMIterator * tbmiterator
Definition: execnodes.h:1587
List * targetlist
Definition: plannodes.h:140
ExprState * qual
Definition: execnodes.h:961
TBMIterator * prefetch_iterator
Definition: execnodes.h:1595
static TableScanDesc table_beginscan_bm(Relation rel, Snapshot snapshot, int nkeys, struct ScanKeyData *key)
Definition: tableam.h:781
PlanState * ExecInitNode(Plan *node, EState *estate, int eflags)
Definition: execProcnode.c:139
TBMSharedIterator * shared_prefetch_iterator
Definition: execnodes.h:1602

◆ ExecReScanBitmapHeapScan()

void ExecReScanBitmapHeapScan ( BitmapHeapScanState node)

Definition at line 603 of file nodeBitmapHeapscan.c.

References PlanState::chgParam, ExecReScan(), ExecScanReScan(), BitmapHeapScanState::initialized, InvalidBuffer, outerPlan, outerPlanState, BitmapHeapScanState::prefetch_iterator, BitmapHeapScanState::pvmbuffer, ReleaseBuffer(), BitmapHeapScanState::shared_prefetch_iterator, BitmapHeapScanState::shared_tbmiterator, BitmapHeapScanState::ss, ScanState::ss_currentScanDesc, table_rescan(), BitmapHeapScanState::tbm, tbm_end_iterate(), tbm_end_shared_iterate(), tbm_free(), BitmapHeapScanState::tbmiterator, BitmapHeapScanState::tbmres, and BitmapHeapScanState::vmbuffer.

Referenced by ExecReScan().

604 {
606 
607  /* rescan to release any page pin */
608  table_rescan(node->ss.ss_currentScanDesc, NULL);
609 
610  /* release bitmaps and buffers if any */
611  if (node->tbmiterator)
613  if (node->prefetch_iterator)
615  if (node->shared_tbmiterator)
617  if (node->shared_prefetch_iterator)
619  if (node->tbm)
620  tbm_free(node->tbm);
621  if (node->vmbuffer != InvalidBuffer)
622  ReleaseBuffer(node->vmbuffer);
623  if (node->pvmbuffer != InvalidBuffer)
624  ReleaseBuffer(node->pvmbuffer);
625  node->tbm = NULL;
626  node->tbmiterator = NULL;
627  node->tbmres = NULL;
628  node->prefetch_iterator = NULL;
629  node->initialized = false;
630  node->shared_tbmiterator = NULL;
631  node->shared_prefetch_iterator = NULL;
632  node->vmbuffer = InvalidBuffer;
633  node->pvmbuffer = InvalidBuffer;
634 
635  ExecScanReScan(&node->ss);
636 
637  /*
638  * if chgParam of subnode is not null then plan will be re-scanned by
639  * first ExecProcNode.
640  */
641  if (outerPlan->chgParam == NULL)
642  ExecReScan(outerPlan);
643 }
void tbm_end_iterate(TBMIterator *iterator)
Definition: tidbitmap.c:1145
TIDBitmap * tbm
Definition: execnodes.h:1586
void ExecReScan(PlanState *node)
Definition: execAmi.c:77
#define InvalidBuffer
Definition: buf.h:25
struct TableScanDescData * ss_currentScanDesc
Definition: execnodes.h:1333
void ReleaseBuffer(Buffer buffer)
Definition: bufmgr.c:3365
static void table_rescan(TableScanDesc scan, struct ScanKeyData *key)
Definition: tableam.h:840
#define outerPlanState(node)
Definition: execnodes.h:1034
void tbm_free(TIDBitmap *tbm)
Definition: tidbitmap.c:321
TBMIterateResult * tbmres
Definition: execnodes.h:1588
Bitmapset * chgParam
Definition: execnodes.h:972
#define outerPlan(node)
Definition: plannodes.h:170
TBMSharedIterator * shared_tbmiterator
Definition: execnodes.h:1601
TBMIterator * tbmiterator
Definition: execnodes.h:1587
TBMIterator * prefetch_iterator
Definition: execnodes.h:1595
void ExecScanReScan(ScanState *node)
Definition: execScan.c:299
TBMSharedIterator * shared_prefetch_iterator
Definition: execnodes.h:1602
void tbm_end_shared_iterate(TBMSharedIterator *iterator)
Definition: tidbitmap.c:1157