自学教程：C++ ExecEndNode函数代码示例

/* ---------------------------------------------------------------- *		ExecEndNestLoop * *		closes down scans and frees allocated storage * ---------------------------------------------------------------- */voidExecEndNestLoop(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. * ---------------------------------------------------------------- */voidExecEndSubqueryScan(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) * ---------------------------------------------------------------- */voidExecEndSort(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 * ---------------------------------------------------------------- */voidExecEndHash(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 * ---------------------------------------------------------------- */voidExecEndMaterial(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. * ---------------------------------------------------------------- */voidExecEndGather(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. * ---------------------------------------------------------------- */voidExecEndLimit(LimitState *node){	ExecFreeExprContext(&node->ps);	ExecEndNode(outerPlanState(node));	EndPlanStateGpmonPkt(&node->ps);}

/* ---------------------------------------------------------------- *		ExecEndGatherMerge * *		frees any storage allocated through C routines. * ---------------------------------------------------------------- */voidExecEndGatherMerge(GatherMergeState *node){	ExecEndNode(outerPlanState(node));	/* let children clean up first */	ExecShutdownGatherMerge(node);	ExecFreeExprContext(&node->ps);	ExecClearTuple(node->ps.ps_ResultTupleSlot);}

voidExecEndTwice(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. * ---------------------------------------------------------------- */voidExecEndUnique(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. * ---------------------------------------------------------------- */voidExecEndLimit(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. * ---------------------------------------------------------------- */voidExecEndSetOp(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 * ---------------------------------------------------------------- */voidExecEndNestLoop(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. */voidExecEndDML(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 */voidExecEndBitmapTableScan(BitmapTableScanState *node){	BitmapTableScanEnd(node);	/*	 * close down subplans	 */	ExecEndNode(outerPlanState(node));	EndPlanStateGpmonPkt(&node->ss.ps);}

/* ---------------------------------------------------------------- *		ExecEndBitmapHeapScan * ---------------------------------------------------------------- */voidExecEndBitmapHeapScan(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 * ---------------------------------------------------------------- */voidExecEndBitmapHeapScan(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) * * ----------------------- */voidExecEndGroup(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. * ---------------------------------------------------------------- */voidExecEndSetOp(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 * ---------------------------------------------------------------- */voidExecEndBitmapHeapScan(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);}

voidExecEndRepeat(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. * ---------------------------------------------------------------- */voidExecEndRecursiveUnion(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 * ---------------------------------------------------------------- */voidExecEndHash(HashState *node){	PlanState  *outerPlan;	/*	 * free exprcontext	 */	ExecFreeExprContext(&node->ps);	/*	 * shut down the subplan	 */	outerPlan = outerPlanState(node);	ExecEndNode(outerPlan);}

/* ---------------------------------------------------------------- *		ExecEndSort(node) * ---------------------------------------------------------------- */voidExecEndSort(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 * ---------------------------------------------------------------- */voidExecEndResult(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. * ---------------------------------------------------------------- */voidExecEndSubqueryScan(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 * ---------------------------------------------------------------- */voidExecEndMaterial(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. * ---------------------------------------------------------------- */voidExecEndForeignScan(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. * ---------------------------------------------------------------- */voidExecEndAppend(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]);	}}