/* ----------------------------------------------------------------
* ExecEndExternalScan
*
* frees any storage allocated through C routines.
* ----------------------------------------------------------------
*/
void
ExecEndExternalScan(ExternalScanState *node)
{
/*
* Free the exprcontext
*/
ExecFreeExprContext(&node->ss.ps);
/*
* clean out the tuple table
*/
ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
ExecClearTuple(node->ss.ss_ScanTupleSlot);
ExecEagerFreeExternalScan(node);
pfree(node->ess_ScanDesc);
/*
* close the external relation.
*
* MPP-8040: make sure we don't close it if it hasn't completed setup, or
* if we've already closed it.
*/
if (node->ss.ss_currentRelation)
{
Relation relation = node->ss.ss_currentRelation;
node->ss.ss_currentRelation = NULL;
ExecCloseScanRelation(relation);
}
EndPlanStateGpmonPkt(&node->ss.ps);
}
/* ----------------------------------------------------------------
* ExecEndSeqScan
*
* frees any storage allocated through C routines.
* ----------------------------------------------------------------
*/
void
ExecEndSeqScan(SeqScanState *node)
{
Relation relation;
HeapScanDesc scanDesc;
/*
* get information from node
*/
relation = node->ss_currentRelation;
scanDesc = node->ss_currentScanDesc;
/*
* Free the exprcontext
*/
ExecFreeExprContext(&node->ps);
/*
* clean out the tuple table
*/
ExecClearTuple(node->ps.ps_ResultTupleSlot);
ExecClearTuple(node->ss_ScanTupleSlot);
/*
* close heap scan
*/
heap_endscan(scanDesc);
/*
* close the heap relation.
*/
ExecCloseScanRelation(relation);
}
/*
* Release resources for one part (this includes closing the index and
* the relation).
*/
static inline void
CleanupOnePartition(IndexScanState *indexState)
{
Assert(NULL != indexState);
/* Reset index state and release locks. */
ExecClearTuple(indexState->ss.ps.ps_ResultTupleSlot);
ExecClearTuple(indexState->ss.ss_ScanTupleSlot);
if ((indexState->ss.scan_state & SCAN_SCAN) != 0)
{
Assert(indexState->iss_ScanDesc != NULL);
Assert(indexState->iss_RelationDesc != NULL);
Assert(indexState->ss.ss_currentRelation != NULL);
index_endscan(indexState->iss_ScanDesc);
indexState->iss_ScanDesc = NULL;
index_close(indexState->iss_RelationDesc, NoLock);
indexState->iss_RelationDesc = NULL;
ExecCloseScanRelation(indexState->ss.ss_currentRelation);
indexState->ss.ss_currentRelation = NULL;
}
indexState->ss.scan_state = SCAN_INIT;
}
/* ----------------------------------------------------------------
* ExecEndAppendOnlyScan
*
* frees any storage allocated through C routines.
* ----------------------------------------------------------------
*/
void
ExecEndAppendOnlyScan(AppendOnlyScanState *node)
{
Relation relation;
AppendOnlyScanDesc scanDesc;
/*
* get information from node
*/
relation = node->ss.ss_currentRelation;
scanDesc = node->aos_ScanDesc;
/*
* Free the exprcontext
*/
ExecFreeExprContext(&node->ss.ps);
/*
* clean out the tuple table
*/
ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
ExecClearTuple(node->ss.ss_ScanTupleSlot);
ExecEagerFreeAppendOnlyScan(node);
/*
* close the heap relation.
*/
ExecCloseScanRelation(relation);
EndPlanStateGpmonPkt(&node->ss.ps);
}
/* ----------------------------------------------------------------
* ExecEndSeqScan
*
* frees any storage allocated through C routines.
* ----------------------------------------------------------------
*/
void
ExecEndSeqScan(SeqScanState *node)
{
Relation relation;
/*
* get information from node
*/
relation = node->ss_currentRelation;
/*
* Free the exprcontext
*/
ExecFreeExprContext(&node->ps);
/*
* clean out the tuple table
*/
ExecClearTuple(node->ps.ps_ResultTupleSlot);
ExecClearTuple(node->ss_ScanTupleSlot);
ExecEagerFreeSeqScan(node);
/*
* close the heap relation.
*/
ExecCloseScanRelation(relation);
/* gpmon */
EndPlanStateGpmonPkt(&node->ps);
}
/*
* FreeScanRelationInternal
* Free ScanState common variables initialized in InitScanStateInternal.
*/
void
FreeScanRelationInternal(ScanState *scanState, bool closeCurrentRelation)
{
ExecFreeExprContext(&scanState->ps);
ExecClearTuple(scanState->ps.ps_ResultTupleSlot);
ExecClearTuple(scanState->ss_ScanTupleSlot);
if (closeCurrentRelation)
{
ExecCloseScanRelation(scanState->ss_currentRelation);
}
}
/* ----------------------------------------------------------------
* ExecEndBitmapHeapScan
* ----------------------------------------------------------------
*/
void
ExecEndBitmapHeapScan(BitmapHeapScanState *node)
{
Relation relation;
HeapScanDesc scanDesc;
/*
* extract information from the node
*/
relation = node->ss.ss_currentRelation;
scanDesc = node->ss.ss_currentScanDesc;
/*
* Free the exprcontext
*/
ExecFreeExprContext(&node->ss.ps);
/*
* clear out tuple table slots
*/
ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
ExecClearTuple(node->ss.ss_ScanTupleSlot);
/*
* close down subplans
*/
ExecEndNode(outerPlanState(node));
/*
* release bitmap if any
*/
if (node->tbmiterator)
tbm_end_iterate(node->tbmiterator);
if (node->prefetch_iterator)
tbm_end_iterate(node->prefetch_iterator);
if (node->tbm)
tbm_free(node->tbm);
if (node->shared_tbmiterator)
tbm_end_shared_iterate(node->shared_tbmiterator);
if (node->shared_prefetch_iterator)
tbm_end_shared_iterate(node->shared_prefetch_iterator);
/*
* close heap scan
*/
heap_endscan(scanDesc);
/*
* close the heap relation.
*/
ExecCloseScanRelation(relation);
}
/*
* CleanupOnePartition
* Cleans up a partition's relation and releases all locks.
*/
static inline void
CleanupOnePartition(ScanState *scanState)
{
Assert(NULL != scanState);
if ((scanState->scan_state & SCAN_SCAN) != 0)
{
EndTableScanRelation(scanState);
Assert(scanState->ss_currentRelation != NULL);
ExecCloseScanRelation(scanState->ss_currentRelation);
scanState->ss_currentRelation = NULL;
}
}
/* ----------------------------------------------------------------
* ExecEndIndexOnlyScan
* ----------------------------------------------------------------
*/
void
ExecEndIndexOnlyScan(IndexOnlyScanState *node)
{
Relation indexRelationDesc;
IndexScanDesc indexScanDesc;
Relation relation;
/*
* extract information from the node
*/
indexRelationDesc = node->ioss_RelationDesc;
indexScanDesc = node->ioss_ScanDesc;
relation = node->ss.ss_currentRelation;
/* Release VM buffer pin, if any. */
if (node->ioss_VMBuffer != InvalidBuffer)
{
ReleaseBuffer(node->ioss_VMBuffer);
node->ioss_VMBuffer = InvalidBuffer;
}
/*
* Free the exprcontext(s) ... now dead code, see ExecFreeExprContext
*/
#ifdef NOT_USED
ExecFreeExprContext(&node->ss.ps);
if (node->ioss_RuntimeContext)
FreeExprContext(node->ioss_RuntimeContext, true);
#endif
/*
* clear out tuple table slots
*/
ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
ExecClearTuple(node->ss.ss_ScanTupleSlot);
/*
* close the index relation (no-op if we didn't open it)
*/
if (indexScanDesc)
index_endscan(indexScanDesc);
if (indexRelationDesc)
index_close(indexRelationDesc, NoLock);
/*
* close the heap relation.
*/
ExecCloseScanRelation(relation);
}
/* ----------------------------------------------------------------
* ExecEndForeignScan
*
* frees any storage allocated through C routines.
* ----------------------------------------------------------------
*/
void
ExecEndForeignScan(ForeignScanState *node)
{
/* Let the FDW shut down */
node->fdwroutine->EndForeignScan(node);
/* Free the exprcontext */
ExecFreeExprContext(&node->ss.ps);
/* clean out the tuple table */
ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
ExecClearTuple(node->ss.ss_ScanTupleSlot);
/* close the relation. */
ExecCloseScanRelation(node->ss.ss_currentRelation);
}
/* ----------------------------------------------------------------
* ExecEndForeignScan
*
* frees any storage allocated through C routines.
* ----------------------------------------------------------------
*/
void
ExecEndForeignScan(foreign_ss *node)
{
/* Let the FDW shut down */
node->fdwroutine->EndForeignScan(node);
/* Free the exprcontext */
exec_free_expr_ctx(&node->ss.ps);
/* clean out the tuple table */
exec_clear_tuple(node->ss.ps.ps_ResultTupleSlot);
exec_clear_tuple(node->ss.ss_ScanTupleSlot);
/* close the relation. */
ExecCloseScanRelation(node->ss.ss_currentRelation);
}
void
ExecEndCustomScan(CustomScanState *node)
{
Assert(node->methods->EndCustomScan != NULL);
node->methods->EndCustomScan(node);
/* Free the exprcontext */
ExecFreeExprContext(&node->ss.ps);
/* Clean out the tuple table */
ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
ExecClearTuple(node->ss.ss_ScanTupleSlot);
/* Close the heap relation */
if (node->ss.ss_currentRelation)
ExecCloseScanRelation(node->ss.ss_currentRelation);
}
/* ----------------------------------------------------------------
* ExecEndIndexScan
* ----------------------------------------------------------------
*/
void
ExecEndIndexScan(IndexScanState *node)
{
Relation indexRelationDesc;
IndexScanDesc indexScanDesc;
Relation relation;
/*
* extract information from the node
*/
indexRelationDesc = node->iss_RelationDesc;
indexScanDesc = node->iss_ScanDesc;
relation = node->ss.ss_currentRelation;
/*
* Free the exprcontext(s) ... now dead code, see ExecFreeExprContext
*/
#ifdef NOT_USED
ExecFreeExprContext(&node->ss.ps);
if (node->iss_RuntimeContext)
FreeExprContext(node->iss_RuntimeContext);
#endif
/*
* clear out tuple table slots
*/
ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
ExecClearTuple(node->ss.ss_ScanTupleSlot);
/*
* close the index relation (no-op if we didn't open it)
*/
ExecEagerFreeIndexScan(node);
if (indexRelationDesc)
index_close(indexRelationDesc, NoLock);
/*
* close the heap relation.
*/
ExecCloseScanRelation(relation);
FreeRuntimeKeysContext(node);
EndPlanStateGpmonPkt(&node->ss.ps);
}
/*
* DynamicScan_CleanupOneRelation
* Cleans up a relation and releases all locks.
*/
static inline void
DynamicScan_CleanupOneRelation(ScanState *scanState, Relation relation, PartitionEndMethod *partitionEndMethod)
{
Assert(NULL != scanState);
Assert(scanState->ss_currentRelation == relation || NULL == scanState->ss_currentRelation);
if (NULL == relation)
{
return;
}
if (NULL != scanState->ss_currentRelation)
{
partitionEndMethod(scanState);
scanState->ss_currentRelation = NULL;
}
ExecCloseScanRelation(relation);
}
/* ----------------------------------------------------------------
* ExecEndIndexScan
* ----------------------------------------------------------------
*/
void
ExecEndIndexScan(index_ss *node)
{
struct relation* indexRelationDesc;
struct index_scan* indexScanDesc;
struct relation* relation;
/*
* extract information from the node
*/
indexRelationDesc = node->iss_RelationDesc;
indexScanDesc = node->iss_ScanDesc;
relation = node->ss.ss_currentRelation;
/*
* Free the exprcontext(s) ... now dead code, see exec_free_expr_ctx
*/
#ifdef NOT_USED
exec_free_expr_ctx(&node->ss.ps);
if (node->iss_RuntimeContext)
free_expr_ctx(node->iss_RuntimeContext, true);
#endif
/*
* clear out tuple table slots
*/
exec_clear_tuple(node->ss.ps.ps_ResultTupleSlot);
exec_clear_tuple(node->ss.ss_ScanTupleSlot);
/*
* close the index relation (no-op if we didn't open it)
*/
if (indexScanDesc)
index_endscan(indexScanDesc);
if (indexRelationDesc)
index_close(indexRelationDesc, NO_LOCK);
/*
* close the heap relation.
*/
ExecCloseScanRelation(relation);
}
