{	/* ----------------	 *	free remainder of node	 * ----------------	 */	freeObject(node->refupperindexpr);	freeObject(node->reflowerindexpr);	freeObject(node->refexpr);	freeObject(node->refassgnexpr);	pfree(node);}/* **************************************************************** *						relation.h free functions * **************************************************************** *//* ---------------- *		_freeRelOptInfo * ---------------- */static void_freeRelOptInfo(RelOptInfo *node){	/* ----------------	 *	free remainder of node	 * ----------------	 */	freeList(node->relids);	freeObject(node->targetlist);	freeObject(node->pathlist);	freeObject(node->cheapestpath);	if (node->classlist)		pfree(node->classlist);	if (node->indexkeys)		pfree(node->indexkeys);	freeObject(node->indpred);	if (node->ordering)		pfree(node->ordering);	freeObject(node->restrictinfo);	freeObject(node->joininfo);	freeObject(node->innerjoin);	pfree(node);}/* ---------------- *		FreePathFields * *		This function frees the fields of the Path node.  It is used by *		all the free functions for classes which inherit node Path. * ---------------- */static voidFreePathFields(Path *node){	if (node->pathorder->ordtype == SORTOP_ORDER)	{		if (node->pathorder->ord.sortop)			pfree(node->pathorder->ord.sortop);	}	else		freeObject(node->pathorder->ord.merge);	pfree(node->pathorder);		/* is it an object, but we don't have								 * separate free for it */	freeObject(node->pathkeys);	freeList(node->joinid);	freeObject(node->loc_restrictinfo);}/* ---------------- *		_freePath * ---------------- */static void_freePath(Path *node){	FreePathFields(node);	pfree(node);}/* ---------------- *		_freeIndexPath * ---------------- */static void_freeIndexPath(IndexPath *node){	/* ----------------	 *	free the node superclass fields	 * ----------------	 */	FreePathFields((Path *) node);	/* ----------------	 *	free remainder of node	 * ----------------	 */	freeList(node->indexid);	freeObject(node->indexqual);	if (node->indexkeys)		pfree(node->indexkeys);	pfree(node);}/* ---------------- *		FreeNestPathFields * *		This function frees the fields of the NestPath node.  It is used by *		all the free functions for classes which inherit node NestPath. * ---------------- */static voidFreeNestPathFields(NestPath *node){	freeObject(node->pathinfo);	freeObject(node->outerjoinpath);	freeObject(node->innerjoinpath);}/* ---------------- *		_freeNestPath * ---------------- */static void_freeNestPath(NestPath *node){	/* ----------------	 *	free the node superclass fields	 * ----------------	 */	FreePathFields((Path *) node);	FreeNestPathFields(node);	pfree(node);}/* ---------------- *		_freeMergePath * ---------------- */static void_freeMergePath(MergePath *node){	/* ----------------	 *	free the node superclass fields	 * ----------------	 */	FreePathFields((Path *) node);	FreeNestPathFields((NestPath *) node);	/* ----------------	 *	free the remainder of the node	 * ----------------	 */	freeObject(node->path_mergeclauses);	freeObject(node->outersortkeys);	freeObject(node->innersortkeys);	pfree(node);}/* ---------------- *		_freeHashPath * ---------------- */static void_freeHashPath(HashPath *node){	/* ----------------	 *	free the node superclass fields	 * ----------------	 */	FreePathFields((Path *) node);	FreeNestPathFields((NestPath *) node);	/* ----------------	 *	free remainder of node	 * ----------------	 */	freeObject(node->path_hashclauses);	freeObject(node->outerhashkeys);	freeObject(node->innerhashkeys);	pfree(node);}/* ---------------- *		_freeOrderKey * ---------------- */static void_freeOrderKey(OrderKey *node){	pfree(node);}/* ---------------- *		_freeJoinKey * ---------------- */static void_freeJoinKey(JoinKey *node){	/* ----------------	 *	free remainder of node	 * ----------------	 */	freeObject(node->outer);	freeObject(node->inner);	pfree(node);}/* ---------------- *		_freeMergeOrder * ---------------- */static void_freeMergeOrder(MergeOrder *node){	/* ----------------	 *	free remainder of node	 * ----------------	 */	pfree(node);}/* ---------------- *		_freeRestrictInfo * ---------------- */static void_freeRestrictInfo(RestrictInfo *node){	/* ----------------	 *	free remainder of node	 * ----------------	 */	freeObject(node->clause);	freeObject(node->indexids);	freeObject(node->mergejoinorder);	freeList(node->restrictinfojoinid);	pfree(node);}/* ---------------- *		FreeJoinMethodFields * *		This function frees the fields of the JoinMethod node.	It is used by *		all the free functions for classes which inherit node JoinMethod. * ---------------- */static voidFreeJoinMethodFields(JoinMethod *node){	freeObject(node->jmkeys);	freeObject(node->clauses);	return;}/* ---------------- *		_freeJoinMethod * ---------------- */static void_freeJoinMethod(JoinMethod *node){	FreeJoinMethodFields(node);	pfree(node);}/* ---------------- *		_freeHInfo * ---------------- */static void_freeHashInfo(HashInfo *node){	/* ----------------	 *	free remainder of node	 * ----------------	 */	FreeJoinMethodFields((JoinMethod *) node);	pfree(node);}/* ---------------- *		_freeMInfo * ---------------- */static void_freeMergeInfo(MergeInfo *node){	/* ----------------	 *	free remainder of node	 * ----------------	 */	FreeJoinMethodFields((JoinMethod *) node);	freeObject(node->m_ordering);	pfree(node);}/* ---------------- *		_freeJoinInfo * ---------------- */static void_freeJoinInfo(JoinInfo *node){	/* ----------------	 *	free remainder of node	 * ----------------	 */	freeList(node->unjoined_relids);	freeObject(node->jinfo_restrictinfo);	pfree(node);}static void_freeIter(Iter *node){	freeObject(node->iterexpr);	pfree(node);}static void_freeStream(Stream *node){	freeObject(node->downstream);	pfree(node);}/* *	parsenodes.h routines have no free functions */static void_freeTargetEntry(TargetEntry *node){	freeObject(node->resdom);	freeObject(node->fjoin);	freeObject(node->expr);	pfree(node);}static void_freeRangeTblEntry(RangeTblEntry *node){	if (node->relname)		pfree(node->relname);	if (node->refname)		pfree(node->refname);	pfree(node);}static void_freeRowMark(RowMark *node){	pfree(node);}static void_freeSortClause(SortClause *node){	freeObject(node->resdom);	pfree(node);}static void_freeAConst(A_Const *node){	freeObject(&(node->val));	freeObject(node->typename);	pfree(node);}static void_freeTypeName(TypeName *node){	if (node->name)		pfree(node->name);	freeObject(node->arrayBounds);	pfree(node);}static void_freeQuery(Query *node){	if (node->utilityStmt && nodeTag(node->utilityStmt) == T_NotifyStmt)	{		NotifyStmt *node_notify = (NotifyStmt *) node->utilityStmt;		pfree(node_notify->relname);		pfree(node_notify);	}	if (node->into)		pfree(node->into);	if (node->uniqueFlag)		pfree(node->uniqueFlag);	freeObject(node->sortClause);	freeObject(node->rtable);	freeObject(node->targetList);	freeObject(node->qual);	freeObject(node->groupClause);	freeObject(node->havingQual);	freeObject(node->unionClause);	freeObject(node->limitOffset);	freeObject(node->limitCount);	freeObject(node->rowMark);	pfree(node);}/* *	mnodes.h routines have no free functions *//* **************************************************************** *					pg_list.h free functions * **************************************************************** */static void_freeValue(Value *node){	switch (node->type)	{			case T_String:			pfree(node->val.str);			break;		default:			break;	}	pfree(node);}/* ---------------- *		freeObject free's the node or list. If it is a list, it *		recursively frees its items. * ---------------- */static voidfreeObject(void *node){	if (node == NULL)		return;	switch (nodeTag(node))	{			/*			 * PLAN NODES			 */		case T_Plan:			_freePlan(node);			break;		case T_Result:			_freeResult(node);			break;		case T_Append:			_freeAppend(node);			break;		case T_Scan:			_freeScan(node);			break;		case T_SeqScan:			_freeSeqScan(node);			break;		case T_IndexScan:			_freeIndexScan(node);			break;		case T_Join:			_freeJoin(node);			break;		case T_NestLoop:			_freeNestLoop(node);			break;		case T_MergeJoin:			_freeMergeJoin(node);			break;		case T_HashJoin:			_freeHashJoin(node);			break;		case T_Noname:			_freeNoname(node);			break;		case T_Material:			_freeMaterial(node);			break;		case T_Sort:			_freeSort(node);			break;		case T_Group:			_freeGroup(node);			break;		case T_Agg:			_freeAgg(node);			break;		case T_GroupClause:			_freeGroupClause(node);			break;		case T_Unique:			_freeUnique(node);			break;		case T_Hash:			_freeHash(node);			break;		case T_SubPlan:			_freeSubPlan(node);			break;			/*			 * PRIMITIVE NODES			 */		case T_Resdom:			_freeResdom(node);			break;		case T_Fjoin:			_freeFjoin(node);			break;		case T_Expr:			_freeExpr(node);			break;		case T_Var:			_freeVar(node);			break;		case T_Oper:			_freeOper(node);			break;		case T_Const:			_freeConst(node);			break;		case T_Param:			_freeParam(node);			break;		case T_Func:			_freeFunc(node);			break;		case T_Array:			_freeArray(node);			break;		case T_ArrayRef:			_freeArrayRef(node);			break;		case T_Aggref:			_freeAggref(node);			break;		case T_SubLink:			_freeSubLink(node);			break;		case T_CaseExpr:			_freeCaseExpr(node);			break;		case T_CaseWhen:			_freeCaseWhen(node);			break;			/*			 * RELATION NODES			 */		case T_RelOptInfo:			_freeRelOptInfo(node);			break;		case T_Path:			_freePath(node);			break;		case T_IndexPath:			_freeIndexPath(node);			break;		case T_NestPath:			_freeNestPath(node);			break;		case T_MergePath:			_freeMergePath(node);			break;		case T_HashPath:			_freeHashPath(node);			break;		case T_OrderKey:			_freeOrderKey(node);			break;		case T_JoinKey:			_freeJoinKey(node);			break;		case T_MergeOrder:			_freeMergeOrder(node);			break;		case T_RestrictInfo:			_freeRestrictInfo(node);			break;		case T_JoinMethod:			_freeJoinMethod(node);			break;		case T_HashInfo:			_freeHashInfo(node);			break;		case T_MergeInfo:			_freeMergeInfo(node);			break;		case T_JoinInfo:			_freeJoinInfo(node);			break;		case T_Iter:			_freeIter(node);			break;		case T_Stream:			_freeStream(node);			break;			/*			 * PARSE NODES			 */		case T_Query:			_freeQuery(node);			break;		case T_TargetEntry:			_freeTargetEntry(node);			break;		case T_RangeTblEntry:			_freeRangeTblEntry(node);			break;		case T_RowMark:			_freeRowMark(node);			break;		case T_SortClause:			_freeSortClause(node);			break;		case T_A_Const:			_freeAConst(node);			break;		case T_TypeName:			_freeTypeName(node);			break;			/*			 * VALUE NODES			 */		case T_Integer:		case T_String:		case T_Float:			_freeValue(node);			break;		case T_List:			{				List	   *list = node,						   *l;				foreach(l, list)					freeObject(lfirst(l));				freeList(list);			}			break;		default:			elog(ERROR, "freeObject: don't know how to free %d", nodeTag(node));			break;	}}