/* ---------------------------------------------------------------- * ExecEndNestLoop * * closes down scans and frees allocated storage * ---------------------------------------------------------------- */ void ExecEndNestLoop(NestLoopState *node) { NL1_printf("ExecEndNestLoop: %s\n", "ending node processing"); /* * Free the exprcontext */ ExecFreeExprContext(&node->js.ps); /* * clean out the tuple table */ ExecClearTuple(node->js.ps.ps_ResultTupleSlot); /* * close down subplans */ ExecEndNode(outerPlanState(node)); ExecEndNode(innerPlanState(node)); NL1_printf("ExecEndNestLoop: %s\n", "node processing ended"); }
/* ---------------------------------------------------------------- * ExecEndSubqueryScan * * frees any storage allocated through C routines. * ---------------------------------------------------------------- */ void ExecEndSubqueryScan(SubqueryScanState *node) { /* * Free the exprcontext */ ExecFreeExprContext(&node->ss.ps); /* * clean out the upper tuple table */ if (node->ss.ss_ScanTupleSlot != NULL) { ExecClearTuple(node->ss.ps.ps_ResultTupleSlot); node->ss.ss_ScanTupleSlot = NULL; /* not ours to clear */ } /* gpmon */ EndPlanStateGpmonPkt(&node->ss.ps); /* * close down subquery */ ExecEndNode(node->subplan); }
/* ---------------------------------------------------------------- * ExecEndSort(node) * ---------------------------------------------------------------- */ void ExecEndSort(SortState *node) { SO1_printf("ExecEndSort: %s\n", "shutting down sort node"); /* * clean out the tuple table */ ExecClearTuple(node->ss.ss_ScanTupleSlot); /* must drop pointer to sort result tuple */ ExecClearTuple(node->ss.ps.ps_ResultTupleSlot); /* * Release tuplesort resources */ if (node->tuplesortstate != NULL) tuplesort_end((Tuplesortstate *) node->tuplesortstate); node->tuplesortstate = NULL; /* * shut down the subplan */ ExecEndNode(outerPlanState(node)); SO1_printf("ExecEndSort: %s\n", "sort node shutdown"); }
/* --------------------------------------------------------------- * ExecEndHash * * clean up routine for Hash node * ---------------------------------------------------------------- */ void ExecEndHash(Hash *node) { HashState *hashstate; Plan *outerPlan; File *batches; /* ---------------- * get info from the hash state * ---------------- */ hashstate = node->hashstate; batches = hashstate->hashBatches; if (batches != NULL) pfree(batches); /* ---------------- * free projection info. no need to free result type info * because that came from the outer plan... * ---------------- */ ExecFreeProjectionInfo(&hashstate->cstate); /* ---------------- * shut down the subplan * ---------------- */ outerPlan = outerPlan(node); ExecEndNode(outerPlan, (Plan*)node); }
/* ---------------------------------------------------------------- * ExecEndMaterial * ---------------------------------------------------------------- */ void ExecEndMaterial(MaterialState *node) { ExecClearTuple(node->ss.ps.ps_ResultTupleSlot); ExecClearTuple(node->ss.ss_ScanTupleSlot); ExecEagerFreeMaterial(node); /* * Release tuplestore resources for cases where EagerFree doesn't do it */ if (node->ts_state->matstore != NULL) { Material *ma = (Material *) node->ss.ps.plan; if (ma->share_type == SHARE_MATERIAL_XSLICE && node->share_lk_ctxt) { shareinput_writer_waitdone(node->share_lk_ctxt, ma->share_id, ma->nsharer_xslice); } Assert(node->ts_pos); DestroyTupleStore(node); } /* * shut down the subplan */ ExecEndNode(outerPlanState(node)); EndPlanStateGpmonPkt(&node->ss.ps); }
/* ---------------------------------------------------------------- * ExecEndGather * * frees any storage allocated through C routines. * ---------------------------------------------------------------- */ void ExecEndGather(GatherState *node) { ExecShutdownGather(node); ExecFreeExprContext(&node->ps); ExecClearTuple(node->ps.ps_ResultTupleSlot); ExecEndNode(outerPlanState(node)); }
/* ---------------------------------------------------------------- * ExecEndLimit * * This shuts down the subplan and frees resources allocated * to this node. * ---------------------------------------------------------------- */ void ExecEndLimit(LimitState *node) { ExecFreeExprContext(&node->ps); ExecEndNode(outerPlanState(node)); EndPlanStateGpmonPkt(&node->ps); }
/* ---------------------------------------------------------------- * ExecEndGatherMerge * * frees any storage allocated through C routines. * ---------------------------------------------------------------- */ void ExecEndGatherMerge(GatherMergeState *node) { ExecEndNode(outerPlanState(node)); /* let children clean up first */ ExecShutdownGatherMerge(node); ExecFreeExprContext(&node->ps); ExecClearTuple(node->ps.ps_ResultTupleSlot); }
void ExecEndTwice(TwiceState *node) { /* clean up tuple table */ ExecClearTuple(node->ps.ps_ResultTupleSlot); /* recursively clean up nodes in the plan rooted in this node */ ExecEndNode(outerPlanState(node)); }
/* ---------------------------------------------------------------- * ExecEndUnique * * This shuts down the subplan and frees resources allocated * to this node. * ---------------------------------------------------------------- */ void ExecEndUnique(UniqueState *node) { /* clean up tuple table */ ExecClearTuple(node->ps.ps_ResultTupleSlot); MemoryContextDelete(node->tempContext); ExecEndNode(outerPlanState(node)); }
/* ---------------------------------------------------------------- * ExecEndLimit * * This shuts down the subplan and frees resources allocated * to this node. * ---------------------------------------------------------------- */ void ExecEndLimit(LimitState *node) { ExecFreeExprContext(&node->ps); /* clean up tuple table */ ExecClearTuple(node->ps.ps_ResultTupleSlot); ExecEndNode(outerPlanState(node)); }
/* ---------------------------------------------------------------- * ExecEndSetOp * * This shuts down the subplan and frees resources allocated * to this node. * ---------------------------------------------------------------- */ void ExecEndSetOp(SetOpState *node) { /* clean up tuple table */ ExecClearTuple(node->ps.ps_ResultTupleSlot); node->ps.ps_OuterTupleSlot = NULL; MemoryContextDelete(node->tempContext); ExecEndNode(outerPlanState(node)); }
/* ---------------------------------------------------------------- * ExecEndNestLoop * * closes down scans and frees allocated storage * ---------------------------------------------------------------- */ void ExecEndNestLoop(NestLoop *node) { NestLoopState *nlstate; NL1_printf("ExecEndNestLoop: %s\n", "ending node processing"); /* ---------------- * get info from the node * ---------------- */ nlstate = node->nlstate; /* ---------------- * Free the projection info * * Note: we don't ExecFreeResultType(nlstate) * because the rule manager depends on the tupType * returned by ExecMain(). So for now, this * is freed at end-transaction time. -cim 6/2/91 * ---------------- */ ExecFreeProjectionInfo(&nlstate->jstate); /* ---------------- * close down subplans * ---------------- */ ExecEndNode(outerPlan((Plan *) node), (Plan*)node); ExecEndNode(innerPlan((Plan *) node), (Plan*)node); /* ---------------- * clean out the tuple table * ---------------- */ ExecClearTuple(nlstate->jstate.cs_ResultTupleSlot); NL1_printf("ExecEndNestLoop: %s\n", "node processing ended"); }
/* Release Resources Requested by nodeDML. */ void ExecEndDML(DMLState *node) { /* Release explicitly the TupleDesc for result relation */ ReleaseTupleDesc(node->junkfilter->jf_cleanTupType); ExecFreeExprContext(&node->ps); ExecClearTuple(node->ps.ps_ResultTupleSlot); ExecClearTuple(node->cleanedUpSlot); ExecEndNode(outerPlanState(node)); EndPlanStateGpmonPkt(&node->ps); }
/* Cleans up once scanning is finished */ void ExecEndBitmapTableScan(BitmapTableScanState *node) { BitmapTableScanEnd(node); /* * close down subplans */ ExecEndNode(outerPlanState(node)); EndPlanStateGpmonPkt(&node->ss.ps); }
/* ---------------------------------------------------------------- * 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->tbm) tbm_free(node->tbm); if (node->odbm) odbm_free(node->odbm); /* * close heap scan */ heap_endscan(scanDesc); /* * close the heap relation. * * Currently, we do not release the AccessShareLock acquired by * ExecInitBitmapHeapScan. This lock should be held till end of * transaction. (There is a faction that considers this too much locking, * however.) */ heap_close(relation, NoLock); }
/* ---------------------------------------------------------------- * 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); }
/* ------------------------ * ExecEndGroup(node) * * ----------------------- */ void ExecEndGroup(GroupState *node) { PlanState *outerPlan; ExecFreeExprContext(&node->ss.ps); /* clean up tuple table */ ExecClearTuple(node->ss.ss_ScanTupleSlot); outerPlan = outerPlanState(node); ExecEndNode(outerPlan); }
/* ---------------------------------------------------------------- * ExecEndSetOp * * This shuts down the subplan and frees resources allocated * to this node. * ---------------------------------------------------------------- */ void ExecEndSetOp(SetOpState *node) { /* clean up tuple table */ ExecClearTuple(node->ps.ps_ResultTupleSlot); /* free subsidiary stuff including hashtable */ MemoryContextDelete(node->tempContext); if (node->tableContext) MemoryContextDelete(node->tableContext); ExecEndNode(outerPlanState(node)); }
/* ---------------------------------------------------------------- * ExecEndBitmapHeapScan * ---------------------------------------------------------------- */ void ExecEndBitmapHeapScan(BitmapHeapScanState *node) { HeapScanDesc scanDesc; /* * extract information from the node */ scanDesc = node->ss.ss_currentScanDesc; /* * Free the exprcontext */ ExecFreeExprContext(&node->ss.ps); /* * clear out tuple table slots */ if (node->ss.ps.ps_ResultTupleSlot) ExecClearTuple(node->ss.ps.ps_ResultTupleSlot); ExecClearTuple(node->ss.ss_ScanTupleSlot); /* * close down subplans */ ExecEndNode(outerPlanState(node)); /* * release bitmaps and buffers 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); if (node->vmbuffer != InvalidBuffer) ReleaseBuffer(node->vmbuffer); if (node->pvmbuffer != InvalidBuffer) ReleaseBuffer(node->pvmbuffer); /* * close heap scan */ heap_endscan(scanDesc); }
void ExecEndRepeat(RepeatState *node) { /* Free the ExprContext */ ExecFreeExprContext(&node->ps); /* Clean out the tuple table */ ExecClearTuple(node->ps.ps_ResultTupleSlot); /* End the subplans */ ExecEndNode(outerPlanState(node)); EndPlanStateGpmonPkt(&node->ps); }
/* ---------------------------------------------------------------- * ExecEndRecursiveUnionScan * * frees any storage allocated through C routines. * ---------------------------------------------------------------- */ void ExecEndRecursiveUnion(RecursiveUnionState *node) { /* Release tuplestores */ tuplestore_end(node->working_table); tuplestore_end(node->intermediate_table); /* free subsidiary stuff including hashtable */ if (node->tempContext) MemoryContextDelete(node->tempContext); if (node->tableContext) MemoryContextDelete(node->tableContext); /* * clean out the upper tuple table */ ExecClearTuple(node->ps.ps_ResultTupleSlot); /* * close down subplans */ ExecEndNode(outerPlanState(node)); ExecEndNode(innerPlanState(node)); }
/* --------------------------------------------------------------- * ExecEndHash * * clean up routine for Hash node * ---------------------------------------------------------------- */ void ExecEndHash(HashState *node) { PlanState *outerPlan; /* * free exprcontext */ ExecFreeExprContext(&node->ps); /* * shut down the subplan */ outerPlan = outerPlanState(node); ExecEndNode(outerPlan); }
/* ---------------------------------------------------------------- * ExecEndSort(node) * ---------------------------------------------------------------- */ void ExecEndSort(SortState *node) { SO1_printf("ExecEndSort: %s\n", "shutting down sort node"); ExecEagerFreeSort(node); /* * shut down the subplan */ ExecEndNode(outerPlanState(node)); SO1_printf("ExecEndSort: %s\n", "sort node shutdown"); EndPlanStateGpmonPkt(&node->ss.ps); }
/* ---------------------------------------------------------------- * ExecEndResult * * frees up storage allocated through C routines * ---------------------------------------------------------------- */ void ExecEndResult(ResultState *node) { /* * Free the exprcontext */ ExecFreeExprContext(&node->ps); /* * clean out the tuple table */ ExecClearTuple(node->ps.ps_ResultTupleSlot); /* * shut down subplans */ ExecEndNode(outerPlanState(node)); }
/* ---------------------------------------------------------------- * ExecEndSubqueryScan * * frees any storage allocated through C routines. * ---------------------------------------------------------------- */ void ExecEndSubqueryScan(SubqueryScanState *node) { /* * Free the exprcontext */ ExecFreeExprContext(&node->ss.ps); /* * clean out the upper tuple table */ ExecClearTuple(node->ss.ps.ps_ResultTupleSlot); ExecClearTuple(node->ss.ss_ScanTupleSlot); /* * close down subquery */ ExecEndNode(node->subplan); }
/* ---------------------------------------------------------------- * ExecEndMaterial * ---------------------------------------------------------------- */ void ExecEndMaterial(MaterialState *node) { /* * clean out the tuple table */ ExecClearTuple(node->ss.ss_ScanTupleSlot); /* * Release tuplestore resources */ if (node->tuplestorestate != NULL) tuplestore_end((Tuplestorestate *) node->tuplestorestate); node->tuplestorestate = NULL; /* * shut down the subplan */ ExecEndNode(outerPlanState(node)); }
/* ---------------------------------------------------------------- * ExecEndForeignScan * * frees any storage allocated through C routines. * ---------------------------------------------------------------- */ void ExecEndForeignScan(ForeignScanState *node) { /* Let the FDW shut down */ node->fdwroutine->EndForeignScan(node); /* Shut down any outer plan. */ if (outerPlanState(node)) ExecEndNode(outerPlanState(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. */ if (node->ss.ss_currentRelation) ExecCloseScanRelation(node->ss.ss_currentRelation); }
/* ------------------------------------------------------------------ * ExecEndShareInputScan * ------------------------------------------------------------------ */ void ExecEndShareInputScan(ShareInputScanState *node) { /* clean up tuple table */ ExecClearTuple(node->ss.ss_ScanTupleSlot); ExecClearTuple(node->ss.ps.ps_ResultTupleSlot); ShareInputScan * sisc = (ShareInputScan *) node->ss.ps.plan; if(node->share_lk_ctxt) shareinput_reader_notifydone(node->share_lk_ctxt, sisc->share_id); ExecEagerFreeShareInputScan(node); /* * shutdown subplan. First scanner of underlying share input will * do the shutdown, all other scanners are no-op because outerPlanState * is NULL */ ExecEndNode(outerPlanState(node)); EndPlanStateGpmonPkt(&node->ss.ps); }
/* ---------------------------------------------------------------- * ExecEndAppend * * Shuts down the subscans of the append node. * * Returns nothing of interest. * ---------------------------------------------------------------- */ void ExecEndAppend(AppendState *node) { PlanState **appendplans; int nplans; int i; /* * get information from the node */ appendplans = node->appendplans; nplans = node->as_nplans; /* * shut down each of the subscans (that we've initialized) */ for (i = 0; i < nplans; i++) { if (appendplans[i]) ExecEndNode(appendplans[i]); } }