extern TupleTableSlot *
ExecTuplestoreScan(TuplestoreScanState *node)
{
return ExecScan((ScanState *) node,
(ExecScanAccessMtd) TuplestoreNext,
(ExecScanRecheckMtd) TuplestoreRecheck);
}
/* ----------------------------------------------------------------
* ExecSeqScan(node)
*
* Scans the relation sequentially and returns the next qualifying
* tuple.
* We call the ExecScan() routine and pass it the appropriate
* access method functions.
* ----------------------------------------------------------------
*/
TupleTableSlot *
ExecSeqScan(SeqScanState *node)
{
return ExecScan((ScanState *) node,
(ExecScanAccessMtd) SeqNext,
(ExecScanRecheckMtd) SeqRecheck);
}
/*
* ExecTableScanRelation
* Scan the relation and return the next qualifying tuple.
*
* This is a wrapper function for ExecScan. The access method is determined
* based on the type of the table being scanned.
*/
TupleTableSlot *
ExecTableScanRelation(ScanState *scanState)
{
Assert(scanState->tableType >= 0 && scanState->tableType < TableTypeInvalid);
return ExecScan(scanState, getScanMethod(scanState->tableType)->accessMethod);
}
/* ----------------------------------------------------------------
* ExecFunctionScan(node)
*
* Scans the function sequentially and returns the next qualifying
* tuple.
* We call the ExecScan() routine and pass it the appropriate
* access method functions.
* ----------------------------------------------------------------
*/
TupleTableSlot *
ExecFunctionScan(FunctionScanState *node)
{
return ExecScan(&node->ss,
(ExecScanAccessMtd) FunctionNext,
(ExecScanRecheckMtd) FunctionRecheck);
}
/*
* Executes underlying scan method to fetch the next matching tuple.
*/
TupleTableSlot *
BitmapTableScanFetchNext(ScanState *node)
{
BitmapTableScanState *scanState = (BitmapTableScanState *) node;
TupleTableSlot *slot = BitmapTableScanPlanQualTuple(scanState);
while (TupIsNull(slot))
{
/* If we haven't already obtained the required bitmap, do so */
readBitmap(scanState);
/* If we have exhausted the current bitmap page, fetch the next one */
if (!scanState->needNewBitmapPage || fetchNextBitmapPage(scanState))
{
slot = ExecScan(&scanState->ss, (ExecScanAccessMtd) getBitmapTableScanMethod(scanState->ss.tableType)->accessMethod);
}
else
{
/*
* Needed a new bitmap page, but couldn't fetch one. Therefore,
* try the next partition.
*/
break;
}
}
return slot;
}
/* ----------------------------------------------------------------
* ExecBitmapHeapScan(node)
* ----------------------------------------------------------------
*/
TupleTableSlot *
ExecBitmapHeapScan(BitmapHeapScanState *node)
{
return ExecScan(&node->ss,
(ExecScanAccessMtd) BitmapHeapNext,
(ExecScanRecheckMtd) BitmapHeapRecheck);
}
/* ----------------------------------------------------------------
* ExecForeignScan(node)
*
* Fetches the next tuple from the FDW, checks local quals, and
* returns it.
* We call the ExecScan() routine and pass it the appropriate
* access method functions.
* ----------------------------------------------------------------
*/
TupleTableSlot *
ExecForeignScan(ForeignScanState *node)
{
return ExecScan((ScanState *) node,
(ExecScanAccessMtd) ForeignNext,
(ExecScanRecheckMtd) ForeignRecheck);
}
TupleTableSlot *
ExecSeqScan(SeqScanState *node)
{
/*
* use SeqNext as access method
*/
TupleTableSlot *slot;
if((node->scan_state & SCAN_SCAN) == 0)
OpenScanRelation(node);
slot = ExecScan((ScanState *) node, (ExecScanAccessMtd) SeqNext);
if (!TupIsNull(slot))
{
Gpmon_M_Incr_Rows_Out(GpmonPktFromSeqScanState(node));
CheckSendPlanStateGpmonPkt(&node->ps);
}
if(TupIsNull(slot) && !node->ps.delayEagerFree)
{
CloseScanRelation(node);
}
return slot;
}
/* ----------------------------------------------------------------
* ExecCteScan(node)
*
* Scans the CTE sequentially and returns the next qualifying tuple.
* We call the ExecScan() routine and pass it the appropriate
* access method functions.
* ----------------------------------------------------------------
*/
TupleTableSlot *
ExecCteScan(CteScanState *node)
{
return ExecScan(&node->ss,
(ExecScanAccessMtd) CteScanNext,
(ExecScanRecheckMtd) CteScanRecheck);
}
/* ----------------------------------------------------------------
* ExecSubqueryScan(node)
*
* Scans the subquery sequentially and returns the next qualifying
* tuple.
* We call the ExecScan() routine and pass it the appropriate
* access method functions.
* ----------------------------------------------------------------
*/
TupleTableSlot *
ExecSubqueryScan(SubqueryScanState *node)
{
return ExecScan(&node->ss,
(ExecScanAccessMtd) SubqueryNext,
(ExecScanRecheckMtd) SubqueryRecheck);
}
/* ----------------------------------------------------------------
* ExecForeignScan(node)
*
* Fetches the next tuple from the FDW, checks local quals, and
* returns it.
* We call the ExecScan() routine and pass it the appropriate
* access method functions.
* ----------------------------------------------------------------
*/
struct tupslot *
ExecForeignScan(foreign_ss *node)
{
return ExecScan((scan_state_ps *) node,
(exec_scan_access_mtd_f*) ForeignNext,
(exec_scan_recheck_mtd_f*) ForeignRecheck);
}
TupleTableSlot *
ExecFunctionScan(FunctionScanState *node)
{
/*
* use FunctionNext as access method
*/
return ExecScan(&node->ss, (ExecScanAccessMtd) FunctionNext);
}
TupleTableSlot *
ExecSeqScan(SeqScanState *node)
{
/*
* use SeqNext as access method
*/
return ExecScan((ScanState *) node, (ExecScanAccessMtd) SeqNext);
}
/* ----------------------------------------------------------------
* ExecBitmapHeapScan(node)
* ----------------------------------------------------------------
*/
TupleTableSlot *
ExecBitmapHeapScan(BitmapHeapScanState *node)
{
/*
* use BitmapHeapNext as access method
*/
return ExecScan(&node->ss, (ExecScanAccessMtd) BitmapHeapNext);
}
/* ----------------------------------------------------------------
* ExecSubqueryScan(node)
*
* Scans the subquery sequentially and returns the next qualifying
* tuple.
* We call the ExecScan() routine and pass it the appropriate
* access method functions.
* ----------------------------------------------------------------
*/
struct tupslot*
ExecSubqueryScan(subquery_ss *node)
{
return ExecScan(
&node->ss,
(exec_scan_access_mtd_f*) SubqueryNext,
(exec_scan_recheck_mtd_f*) SubqueryRecheck);
}
TupleTableSlot *
ExecSubqueryScan(SubqueryScanState *node)
{
/*
* use SubqueryNext as access method
*/
return ExecScan(&node->ss, (ExecScanAccessMtd) SubqueryNext);
}
TupleTableSlot *
ExecExternalScan(ExternalScanState *node)
{
/*
* use SeqNext as access method
*/
return ExecScan(&node->ss, (ExecScanAccessMtd) ExternalNext);
}
/* ----------------------------------------------------------------
* ExecBitmapHeapScan(node)
* ----------------------------------------------------------------
*/
static TupleTableSlot *
ExecBitmapHeapScan(PlanState *pstate)
{
BitmapHeapScanState *node = castNode(BitmapHeapScanState, pstate);
return ExecScan(&node->ss,
(ExecScanAccessMtd) BitmapHeapNext,
(ExecScanRecheckMtd) BitmapHeapRecheck);
}
/* ----------------------------------------------------------------
* ExecCteScan(node)
*
* Scans the CTE sequentially and returns the next qualifying tuple.
* We call the ExecScan() routine and pass it the appropriate
* access method functions.
* ----------------------------------------------------------------
*/
static TupleTableSlot *
ExecCteScan(PlanState *pstate)
{
CteScanState *node = castNode(CteScanState, pstate);
return ExecScan(&node->ss,
(ExecScanAccessMtd) CteScanNext,
(ExecScanRecheckMtd) CteScanRecheck);
}
/* ----------------------------------------------------------------
* ExecSubqueryScan(node)
*
* Scans the subquery sequentially and returns the next qualifying
* tuple.
* We call the ExecScan() routine and pass it the appropriate
* access method functions.
* ----------------------------------------------------------------
*/
static TupleTableSlot *
ExecSubqueryScan(PlanState *pstate)
{
SubqueryScanState *node = castNode(SubqueryScanState, pstate);
return ExecScan(&node->ss,
(ExecScanAccessMtd) SubqueryNext,
(ExecScanRecheckMtd) SubqueryRecheck);
}
/* ----------------------------------------------------------------
* ExecSeqScan(node)
*
* Scans the relation sequentially and returns the next qualifying
* tuple.
* We call the ExecScan() routine and pass it the appropriate
* access method functions.
* ----------------------------------------------------------------
*/
static TupleTableSlot *
ExecSeqScan(PlanState *pstate)
{
SeqScanState *node = castNode(SeqScanState, pstate);
return ExecScan(&node->ss,
(ExecScanAccessMtd) SeqNext,
(ExecScanRecheckMtd) SeqRecheck);
}
/* ----------------------------------------------------------------
* ExecSeqScan(node)
*
* Scans the relation sequentially and returns the next qualifying
* tuple.
* We call the ExecScan() routine and pass it the appropriate
* access method functions.
* For serializable transactions, we first acquire a predicate
* lock on the entire relation.
* ----------------------------------------------------------------
*/
TupleTableSlot *
ExecSeqScan(SeqScanState *node)
{
PredicateLockRelation(node->ss_currentRelation);
node->ss_currentScanDesc->rs_relpredicatelocked = true;
return ExecScan((ScanState *) node,
(ExecScanAccessMtd) SeqNext,
(ExecScanRecheckMtd) SeqRecheck);
}
TupleTableSlot *
ExecSeqScan(SeqScanState *node)
{
//elog(WARNING, "ExecScanRelation");
/*
* use SeqNext as access method
*/
return ExecScan((ScanState *) node, (ExecScanAccessMtd) SeqNext);
}
/* ----------------------------------------------------------------
* ExecIndexScan(node)
* ----------------------------------------------------------------
*/
TupleTableSlot *
ExecIndexScan(IndexScanState *node)
{
/*
* If we have runtime keys and they've not already been set up, do it now.
*/
if (node->iss_NumRuntimeKeys != 0 && !node->iss_RuntimeKeysReady)
ExecReScan((PlanState *) node);
return ExecScan(&node->ss,
(ExecScanAccessMtd) IndexNext,
(ExecScanRecheckMtd) IndexRecheck);
}
/* ----------------------------------------------------------------
* ExecIndexScan(node)
* ----------------------------------------------------------------
*/
struct tupslot *
ExecIndexScan(index_ss *node)
{
/*
* If we have runtime keys and they've not already been set up, do it now.
*/
if (node->iss_NumRuntimeKeys != 0
&& !node->iss_RuntimeKeysReady)
ExecReScan((plan_state_n *) node);
return ExecScan(&node->ss,
(exec_scan_access_mtd_f*) IndexNext,
(exec_scan_recheck_mtd_f*) IndexRecheck);
}
/* ----------------------------------------------------------------
* ExecIndexScan(node)
* ----------------------------------------------------------------
*/
TupleTableSlot *
ExecIndexScan(IndexScanState *node)
{
/*
* If we have runtime keys and they've not already been set up, do it now.
*/
if (node->iss_NumRuntimeKeys != 0 && !node->iss_RuntimeKeysReady)
ExecReScan((PlanState *) node, NULL);
/*
* use IndexNext as access method
*/
return ExecScan(&node->ss, (ExecScanAccessMtd) IndexNext);
}
/* ----------------------------------------------------------------
* ExecIndexOnlyScan(node)
* ----------------------------------------------------------------
*/
static TupleTableSlot *
ExecIndexOnlyScan(PlanState *pstate)
{
IndexOnlyScanState *node = castNode(IndexOnlyScanState, pstate);
/*
* If we have runtime keys and they've not already been set up, do it now.
*/
if (node->ioss_NumRuntimeKeys != 0 && !node->ioss_RuntimeKeysReady)
ExecReScan((PlanState *) node);
return ExecScan(&node->ss,
(ExecScanAccessMtd) IndexOnlyNext,
(ExecScanRecheckMtd) IndexOnlyRecheck);
}
/* ----------------------------------------------------------------
* ExecCteScan(node)
*
* Scans the CTE sequentially and returns the next qualifying tuple.
* We call the ExecScan() routine and pass it the appropriate
* access method functions.
* ----------------------------------------------------------------
*/
TupleTableSlot *
ExecCteScan(CteScanState *node)
{
TupleTableSlot *slot;
CteScan *plan;
slot = ExecScan(&node->ss,
(ExecScanAccessMtd) CteScanNext,
(ExecScanRecheckMtd) CteScanRecheck);
plan = (CteScan *) node->ss.ps.plan;
if (!TupIsNull(slot) && plan->cteStop)
((RecursiveUnionState *) node->cteplanstate)->end = true;
return slot;
}
/*
* Execution of DynamicIndexScan
*/
TupleTableSlot *
ExecDynamicIndexScan(DynamicIndexScanState *node)
{
Assert(node);
IndexScanState *indexState = &(node->indexScanState);
TupleTableSlot *slot = NULL;
/*
* If this is called the first time, find the pid index that contains all unique
* partition pids for this node to scan.
*/
if (node->pidxIndex == NULL)
{
setPidIndex(node);
Assert(node->pidxIndex != NULL);
hash_seq_init(&node->pidxStatus, node->pidxIndex);
node->shouldCallHashSeqTerm = true;
}
/*
* Scan index to find next tuple to return. If the current index
* is exhausted, close it and open the next index for scan.
*/
while (TupIsNull(slot) &&
initNextIndexToScan(node))
{
slot = ExecScan(&indexState->ss, (ExecScanAccessMtd) IndexNext);
if (!TupIsNull(slot))
{
/* Report output rows to Gpmon */
Gpmon_M_Incr_Rows_Out(GpmonPktFromDynamicIndexScanState(node));
CheckSendPlanStateGpmonPkt(&indexState->ss.ps);
}
else
{
CleanupOnePartition(indexState);
}
}
return slot;
}
/* ----------------------------------------------------------------
* ExecWorkTableScan(node)
*
* Scans the worktable sequentially and returns the next qualifying tuple.
* We call the ExecScan() routine and pass it the appropriate
* access method functions.
* ----------------------------------------------------------------
*/
static TupleTableSlot *
ExecWorkTableScan(PlanState *pstate)
{
WorkTableScanState *node = castNode(WorkTableScanState, pstate);
/*
* On the first call, find the ancestor RecursiveUnion's state via the
* Param slot reserved for it. (We can't do this during node init because
* there are corner cases where we'll get the init call before the
* RecursiveUnion does.)
*/
if (node->rustate == NULL)
{
WorkTableScan *plan = (WorkTableScan *) node->ss.ps.plan;
EState *estate = node->ss.ps.state;
ParamExecData *param;
param = &(estate->es_param_exec_vals[plan->wtParam]);
Assert(param->execPlan == NULL);
Assert(!param->isnull);
node->rustate = castNode(RecursiveUnionState, DatumGetPointer(param->value));
Assert(node->rustate);
/*
* The scan tuple type (ie, the rowtype we expect to find in the work
* table) is the same as the result rowtype of the ancestor
* RecursiveUnion node. Note this depends on the assumption that
* RecursiveUnion doesn't allow projection.
*/
ExecAssignScanType(&node->ss,
ExecGetResultType(&node->rustate->ps));
/*
* Now we can initialize the projection info. This must be completed
* before we can call ExecScan().
*/
ExecAssignScanProjectionInfo(&node->ss);
}
return ExecScan(&node->ss,
(ExecScanAccessMtd) WorkTableScanNext,
(ExecScanRecheckMtd) WorkTableScanRecheck);
}
