Massive commit to run PGINDENT on all *.c and *.h files.

1 files changed, 1375 insertions, 1290 deletions

diff --git a/src/backend/executor/execQual.c b/src/backend/executor/execQual.c
index 536b0068342..7b8cb18ef25 100644
--- a/src/backend/executor/execQual.c
+++ b/src/backend/executor/execQual.c
@@ -1,32 +1,32 @@
 /*-------------------------------------------------------------------------
  *
  * execQual.c--
- *    Routines to evaluate qualification and targetlist expressions
+ *	  Routines to evaluate qualification and targetlist expressions
  *
  * Copyright (c) 1994, Regents of the University of California
  *
  *
  * IDENTIFICATION
- *    $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.12 1997/08/19 21:31:03 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.13 1997/09/07 04:41:20 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
 /*
- *   INTERFACE ROUTINES
- *    	ExecEvalExpr	- evaluate an expression and return a datum
- *    	ExecQual	- return true/false if qualification is satisified
- *    	ExecTargetList	- form a new tuple by projecting the given tuple
+ *	 INTERFACE ROUTINES
+ *		ExecEvalExpr	- evaluate an expression and return a datum
+ *		ExecQual		- return true/false if qualification is satisified
+ *		ExecTargetList	- form a new tuple by projecting the given tuple
  *
- *   NOTES
- *	ExecEvalExpr() and ExecEvalVar() are hotspots.  making these faster
- *	will speed up the entire system.  Unfortunately they are currently
- *	implemented recursively..  Eliminating the recursion is bound to
- *	improve the speed of the executor.
+ *	 NOTES
+ *		ExecEvalExpr() and ExecEvalVar() are hotspots.	making these faster
+ *		will speed up the entire system.  Unfortunately they are currently
+ *		implemented recursively..  Eliminating the recursion is bound to
+ *		improve the speed of the executor.
  *
- *	ExecTargetList() is used to make tuple projections.  Rather then
- *	trying to speed it up, the execution plan should be pre-processed
- *	to facilitate attribute sharing between nodes wherever possible,
- *	instead of doing needless copying.  -cim 5/31/91
+ *		ExecTargetList() is used to make tuple projections.  Rather then
+ *		trying to speed it up, the execution plan should be pre-processed
+ *		to facilitate attribute sharing between nodes wherever possible,
+ *		instead of doing needless copying.	-cim 5/31/91
  *
  */
 #include <string.h>
@@ -56,7 +56,7 @@
 #include "utils/mcxt.h"
 
 /* ----------------
- *	externs and constants
+ *		externs and constants
  * ----------------
  */
 
@@ -65,1492 +65,1577 @@
  * Currently only used by ExecHashGetBucket and set only by ExecMakeVarConst
  * and by ExecEvalArrayRef.
  */
-bool 	execConstByVal;
-int 	execConstLen;
+bool			execConstByVal;
+int				execConstLen;
 
 /* static functions decls */
-static Datum ExecEvalAggreg(Aggreg *agg, ExprContext *econtext, bool *isNull);
-static Datum ExecEvalArrayRef(ArrayRef *arrayRef, ExprContext *econtext,
-			      bool *isNull, bool *isDone);
-static Datum ExecEvalAnd(Expr *andExpr, ExprContext *econtext, bool *isNull);
-static Datum ExecEvalFunc(Expr *funcClause, ExprContext *econtext,
-			  bool *isNull, bool *isDone);
-static void ExecEvalFuncArgs(FunctionCachePtr fcache, ExprContext *econtext,
-		      List *argList, Datum argV[], bool *argIsDone);
-static Datum ExecEvalNot(Expr *notclause, ExprContext *econtext, bool *isNull);
-static Datum ExecEvalOper(Expr *opClause, ExprContext *econtext,
-			  bool *isNull);
-static Datum ExecEvalOr(Expr *orExpr, ExprContext *econtext, bool *isNull);
-static Datum ExecEvalVar(Var *variable, ExprContext *econtext, bool *isNull);
-static Datum ExecMakeFunctionResult(Node *node, List *arguments,
-		ExprContext *econtext, bool *isNull, bool *isDone);
-static bool ExecQualClause(Node *clause, ExprContext *econtext);
+static Datum	ExecEvalAggreg(Aggreg * agg, ExprContext * econtext, bool * isNull);
+static Datum
+ExecEvalArrayRef(ArrayRef * arrayRef, ExprContext * econtext,
+				 bool * isNull, bool * isDone);
+static Datum	ExecEvalAnd(Expr * andExpr, ExprContext * econtext, bool * isNull);
+static Datum
+ExecEvalFunc(Expr * funcClause, ExprContext * econtext,
+			 bool * isNull, bool * isDone);
+static void
+ExecEvalFuncArgs(FunctionCachePtr fcache, ExprContext * econtext,
+				 List * argList, Datum argV[], bool * argIsDone);
+static Datum	ExecEvalNot(Expr * notclause, ExprContext * econtext, bool * isNull);
+static Datum
+ExecEvalOper(Expr * opClause, ExprContext * econtext,
+			 bool * isNull);
+static Datum	ExecEvalOr(Expr * orExpr, ExprContext * econtext, bool * isNull);
+static Datum	ExecEvalVar(Var * variable, ExprContext * econtext, bool * isNull);
+static Datum
+ExecMakeFunctionResult(Node * node, List * arguments,
+				   ExprContext * econtext, bool * isNull, bool * isDone);
+static bool		ExecQualClause(Node * clause, ExprContext * econtext);
 
 /* --------------------------------
- *    ExecEvalArrayRef
+ *	  ExecEvalArrayRef
  *
- *     This function takes an ArrayRef and returns a Const Node if it
- *     is an array reference or returns the changed Array Node if it is
- *	   an array assignment.
+ *	   This function takes an ArrayRef and returns a Const Node if it
+ *	   is an array reference or returns the changed Array Node if it is
+ *		   an array assignment.
  *
  * --------------------------------
  */
-static Datum
-ExecEvalArrayRef(ArrayRef *arrayRef,
-		 ExprContext *econtext,
-		 bool *isNull,
-		 bool *isDone)
+static			Datum
+ExecEvalArrayRef(ArrayRef * arrayRef,
+				 ExprContext * econtext,
+				 bool * isNull,
+				 bool * isDone)
 {
-    bool	dummy;
-    int 	i = 0, j = 0;
-    ArrayType 	*array_scanner;
-    List   	*upperIndexpr, *lowerIndexpr;
-    Node	*assgnexpr;
-    List	*elt;
-    IntArray 	upper, lower;
-    int 	*lIndex;
-    char *dataPtr;
-    
-    *isNull       =	false; 
-    array_scanner =	(ArrayType*)ExecEvalExpr(arrayRef->refexpr,
-					     econtext,
-					     isNull,
-					     isDone);
-    if (*isNull) return (Datum)NULL;
-    
-    upperIndexpr = arrayRef->refupperindexpr;
-
-    foreach (elt, upperIndexpr) {
-    	upper.indx[i++] = (int32)ExecEvalExpr((Node*)lfirst(elt),
-					      econtext,
-					      isNull,
-					      &dummy);
-    	if (*isNull) return (Datum)NULL;
-    }
-    
-    lowerIndexpr = arrayRef->reflowerindexpr;
-    lIndex = NULL;
-    if (lowerIndexpr != NIL) {
-	foreach (elt, lowerIndexpr) {
-	    lower.indx[j++] = (int32)ExecEvalExpr((Node*)lfirst(elt),
-						  econtext,
-						  isNull,
-						  &dummy);
-	    if (*isNull) return (Datum)NULL;
+	bool			dummy;
+	int				i = 0,
+					j = 0;
+	ArrayType	   *array_scanner;
+	List		   *upperIndexpr,
+				   *lowerIndexpr;
+	Node		   *assgnexpr;
+	List		   *elt;
+	IntArray		upper,
+					lower;
+	int			   *lIndex;
+	char		   *dataPtr;
+
+	*isNull = false;
+	array_scanner = (ArrayType *) ExecEvalExpr(arrayRef->refexpr,
+											   econtext,
+											   isNull,
+											   isDone);
+	if (*isNull)
+		return (Datum) NULL;
+
+	upperIndexpr = arrayRef->refupperindexpr;
+
+	foreach(elt, upperIndexpr)
+	{
+		upper.indx[i++] = (int32) ExecEvalExpr((Node *) lfirst(elt),
+											   econtext,
+											   isNull,
+											   &dummy);
+		if (*isNull)
+			return (Datum) NULL;
+	}
+
+	lowerIndexpr = arrayRef->reflowerindexpr;
+	lIndex = NULL;
+	if (lowerIndexpr != NIL)
+	{
+		foreach(elt, lowerIndexpr)
+		{
+			lower.indx[j++] = (int32) ExecEvalExpr((Node *) lfirst(elt),
+												   econtext,
+												   isNull,
+												   &dummy);
+			if (*isNull)
+				return (Datum) NULL;
+		}
+		if (i != j)
+			elog(WARN,
+				 "ExecEvalArrayRef: upper and lower indices mismatch");
+		lIndex = lower.indx;
 	}
-	if (i != j)
-	    elog(WARN, 
-		 "ExecEvalArrayRef: upper and lower indices mismatch");
-	lIndex = lower.indx;
-    }
-
-    assgnexpr    = arrayRef->refassgnexpr;
-    if (assgnexpr != NULL) {
-	dataPtr = (char*)ExecEvalExpr((Node *)
-				      assgnexpr, econtext,
-				      isNull, &dummy);
-	if (*isNull) return (Datum)NULL;
-    	execConstByVal = arrayRef->refelembyval;
-    	execConstLen = arrayRef->refelemlength;
+
+	assgnexpr = arrayRef->refassgnexpr;
+	if (assgnexpr != NULL)
+	{
+		dataPtr = (char *) ExecEvalExpr((Node *)
+										assgnexpr, econtext,
+										isNull, &dummy);
+		if (*isNull)
+			return (Datum) NULL;
+		execConstByVal = arrayRef->refelembyval;
+		execConstLen = arrayRef->refelemlength;
+		if (lIndex == NULL)
+			return (Datum) array_set(array_scanner, i, upper.indx, dataPtr,
+									 arrayRef->refelembyval,
+									 arrayRef->refelemlength,
+									 arrayRef->refattrlength, isNull);
+		return (Datum) array_assgn(array_scanner, i, upper.indx,
+								   lower.indx,
+								   (ArrayType *) dataPtr,
+								   arrayRef->refelembyval,
+								   arrayRef->refelemlength, isNull);
+	}
+	execConstByVal = arrayRef->refelembyval;
+	execConstLen = arrayRef->refelemlength;
 	if (lIndex == NULL)
-	    return (Datum) array_set(array_scanner, i, upper.indx, dataPtr, 
-				     arrayRef->refelembyval,
-				     arrayRef->refelemlength,
-				     arrayRef->refattrlength, isNull);
-	return (Datum) array_assgn(array_scanner, i, upper.indx,
-				   lower.indx, 
-				   (ArrayType*)dataPtr, 
-				   arrayRef->refelembyval,
-				   arrayRef->refelemlength, isNull);
-    }
-    execConstByVal = arrayRef->refelembyval;
-    execConstLen = arrayRef->refelemlength;
-    if (lIndex == NULL) 
-	return (Datum) array_ref(array_scanner, i, upper.indx,
-				 arrayRef->refelembyval,
-				 arrayRef->refelemlength,
-				 arrayRef->refattrlength, isNull);
-    return (Datum) array_clip(array_scanner, i, upper.indx, lower.indx,
-			      arrayRef->refelembyval,
-			      arrayRef->refelemlength, isNull);
+		return (Datum) array_ref(array_scanner, i, upper.indx,
+								 arrayRef->refelembyval,
+								 arrayRef->refelemlength,
+								 arrayRef->refattrlength, isNull);
+	return (Datum) array_clip(array_scanner, i, upper.indx, lower.indx,
+							  arrayRef->refelembyval,
+							  arrayRef->refelemlength, isNull);
 }
 
 
 /* ----------------------------------------------------------------
- *    	ExecEvalAggreg
- *    
- *    	Returns a Datum whose value is the value of the precomputed
- *	aggregate found in the given expression context.
+ *		ExecEvalAggreg
+ *
+ *		Returns a Datum whose value is the value of the precomputed
+ *		aggregate found in the given expression context.
  * ----------------------------------------------------------------
  */
-static Datum
-ExecEvalAggreg(Aggreg *agg, ExprContext *econtext, bool *isNull)
+static			Datum
+ExecEvalAggreg(Aggreg * agg, ExprContext * econtext, bool * isNull)
 {
-    
-    *isNull = econtext->ecxt_nulls[agg->aggno];
-    return econtext->ecxt_values[agg->aggno];
+
+	*isNull = econtext->ecxt_nulls[agg->aggno];
+	return econtext->ecxt_values[agg->aggno];
 }
 
 /* ----------------------------------------------------------------
- *    	ExecEvalVar
- *    
- *    	Returns a Datum whose value is the value of a range
- *	variable with respect to given expression context.
+ *		ExecEvalVar
+ *
+ *		Returns a Datum whose value is the value of a range
+ *		variable with respect to given expression context.
+ *
+ *
+ *		As an entry condition, we expect that the the datatype the
+ *		plan expects to get (as told by our "variable" argument) is in
+ *		fact the datatype of the attribute the plan says to fetch (as
+ *		seen in the current context, identified by our "econtext"
+ *		argument).
+ *
+ *		If we fetch a Type A attribute and Caller treats it as if it
+ *		were Type B, there will be undefined results (e.g. crash).
+ *		One way these might mismatch now is that we're accessing a
+ *		catalog class and the type information in the pg_attribute
+ *		class does not match the hardcoded pg_attribute information
+ *		(in pg_attribute.h) for the class in question.
  *
+ *		We have an Assert to make sure this entry condition is met.
  *
- *      As an entry condition, we expect that the the datatype the
- *      plan expects to get (as told by our "variable" argument) is in
- *      fact the datatype of the attribute the plan says to fetch (as
- *      seen in the current context, identified by our "econtext"
- *      argument).
- * 
- *      If we fetch a Type A attribute and Caller treats it as if it
- *      were Type B, there will be undefined results (e.g. crash).
- *      One way these might mismatch now is that we're accessing a
- *      catalog class and the type information in the pg_attribute
- *      class does not match the hardcoded pg_attribute information
- *      (in pg_attribute.h) for the class in question.
- *     
- *      We have an Assert to make sure this entry condition is met.
- * 
  * ---------------------------------------------------------------- */
-static Datum
-ExecEvalVar(Var *variable, ExprContext *econtext, bool *isNull)
+static			Datum
+ExecEvalVar(Var * variable, ExprContext * econtext, bool * isNull)
 {
-    Datum	    	result;
-    TupleTableSlot  	*slot;
-    AttrNumber 		attnum;
-    HeapTuple		heapTuple;
-    TupleDesc		tuple_type;
-    Buffer 		buffer;
-    bool		byval;
-    int16   		len;
-    
-    /* ----------------
-     *	get the slot we want
-     * ----------------
-     */
-    switch(variable->varno) {
-    case INNER: /* get the tuple from the inner node */
-	slot = econtext->ecxt_innertuple;
-	break;
-	
-    case OUTER: /* get the tuple from the outer node */
-	slot = econtext->ecxt_outertuple;
-	break;
-	
-    default: /* get the tuple from the relation being scanned */
-	slot = econtext->ecxt_scantuple;
-	break;
-    } 
-    
-    /* ----------------
-     *   extract tuple information from the slot
-     * ----------------
-     */
-    heapTuple =  slot->val;
-    tuple_type = slot->ttc_tupleDescriptor;
-    buffer =	 slot->ttc_buffer;
-
-    attnum =  	variable->varattno;
-
-    /* (See prolog for explanation of this Assert) */
-    Assert(attnum <= 0 ||
-    	(attnum - 1 <= tuple_type->natts - 1 &&
-     	 tuple_type->attrs[attnum-1] != NULL &&
-         variable->vartype == tuple_type->attrs[attnum-1]->atttypid))
-    
-    /*
-     * If the attribute number is invalid, then we are supposed to
-     * return the entire tuple, we give back a whole slot so that
-     * callers know what the tuple looks like.
-     */
-    if (attnum == InvalidAttrNumber)
+	Datum			result;
+	TupleTableSlot *slot;
+	AttrNumber		attnum;
+	HeapTuple		heapTuple;
+	TupleDesc		tuple_type;
+	Buffer			buffer;
+	bool			byval;
+	int16			len;
+
+	/* ----------------
+	 *	get the slot we want
+	 * ----------------
+	 */
+	switch (variable->varno)
+	{
+	case INNER:			/* get the tuple from the inner node */
+		slot = econtext->ecxt_innertuple;
+		break;
+
+	case OUTER:			/* get the tuple from the outer node */
+		slot = econtext->ecxt_outertuple;
+		break;
+
+	default:					/* get the tuple from the relation being
+								 * scanned */
+		slot = econtext->ecxt_scantuple;
+		break;
+	}
+
+	/* ----------------
+	 *	 extract tuple information from the slot
+	 * ----------------
+	 */
+	heapTuple = slot->val;
+	tuple_type = slot->ttc_tupleDescriptor;
+	buffer = slot->ttc_buffer;
+
+	attnum = variable->varattno;
+
+	/* (See prolog for explanation of this Assert) */
+	Assert(attnum <= 0 ||
+		   (attnum - 1 <= tuple_type->natts - 1 &&
+			tuple_type->attrs[attnum - 1] != NULL &&
+			variable->vartype == tuple_type->attrs[attnum - 1]->atttypid))
+
+	/*
+	 * If the attribute number is invalid, then we are supposed to return
+	 * the entire tuple, we give back a whole slot so that callers know
+	 * what the tuple looks like.
+	 */
+		if (attnum == InvalidAttrNumber)
 	{
-	    TupleTableSlot  *tempSlot;
-	    TupleDesc td;
-	    HeapTuple tup;
-
-	    tempSlot = makeNode(TupleTableSlot);
-	    tempSlot->ttc_shouldFree = false;
-	    tempSlot->ttc_descIsNew = true;
-	    tempSlot->ttc_tupleDescriptor = (TupleDesc)NULL,
-	    tempSlot->ttc_buffer = InvalidBuffer;
-	    tempSlot->ttc_whichplan = -1;
-
-	    tup = heap_copytuple(slot->val);
-	    td = CreateTupleDescCopy(slot->ttc_tupleDescriptor);
-	    
-	    ExecSetSlotDescriptor(tempSlot, td);
-	    
-	    ExecStoreTuple(tup, tempSlot, InvalidBuffer, true);
-	    return (Datum) tempSlot;
+		TupleTableSlot *tempSlot;
+		TupleDesc		td;
+		HeapTuple		tup;
+
+		tempSlot = makeNode(TupleTableSlot);
+		tempSlot->ttc_shouldFree = false;
+		tempSlot->ttc_descIsNew = true;
+		tempSlot->ttc_tupleDescriptor = (TupleDesc) NULL,
+			tempSlot->ttc_buffer = InvalidBuffer;
+		tempSlot->ttc_whichplan = -1;
+
+		tup = heap_copytuple(slot->val);
+		td = CreateTupleDescCopy(slot->ttc_tupleDescriptor);
+
+		ExecSetSlotDescriptor(tempSlot, td);
+
+		ExecStoreTuple(tup, tempSlot, InvalidBuffer, true);
+		return (Datum) tempSlot;
 	}
-    
-    result =  (Datum)
-      heap_getattr(heapTuple,  /* tuple containing attribute */
-		   buffer,     /* buffer associated with tuple */
-		   attnum,     /* attribute number of desired attribute */
-		   tuple_type, /* tuple descriptor of tuple */
-		   isNull);    /* return: is attribute null? */
-    
-    /* ----------------
-     *	return null if att is null
-     * ----------------
-     */
-    if (*isNull)
-	return (Datum) NULL;
-    
-    /* ----------------
-     *   get length and type information..
-     *   ??? what should we do about variable length attributes
-     *	 - variable length attributes have their length stored
-     *     in the first 4 bytes of the memory pointed to by the
-     *     returned value.. If we can determine that the type
-     *     is a variable length type, we can do the right thing.
-     *	   -cim 9/15/89
-     * ----------------
-     */
-    if (attnum < 0) {
+
+	result = (Datum)
+		heap_getattr(heapTuple, /* tuple containing attribute */
+					 buffer,	/* buffer associated with tuple */
+					 attnum,	/* attribute number of desired attribute */
+					 tuple_type,/* tuple descriptor of tuple */
+					 isNull);	/* return: is attribute null? */
+
 	/* ----------------
-	 *  If this is a pseudo-att, we get the type and fake the length.
-	 *  There ought to be a routine to return the real lengths, so
-	 *  we'll mark this one ... XXX -mao
+	 *	return null if att is null
 	 * ----------------
 	 */
-        len = 	heap_sysattrlen(attnum);  	/* XXX see -mao above */
-	byval = heap_sysattrbyval(attnum);	/* XXX see -mao above */
-    } else {
-        len =   tuple_type->attrs[ attnum-1 ]->attlen;
-	byval = tuple_type->attrs[ attnum-1 ]->attbyval ? true : false ;
-    }
-    
-    execConstByVal = byval;
-    execConstLen =   len;
-    
-    return result;
+	if (*isNull)
+		return (Datum) NULL;
+
+	/* ----------------
+	 *	 get length and type information..
+	 *	 ??? what should we do about variable length attributes
+	 *	 - variable length attributes have their length stored
+	 *	   in the first 4 bytes of the memory pointed to by the
+	 *	   returned value.. If we can determine that the type
+	 *	   is a variable length type, we can do the right thing.
+	 *	   -cim 9/15/89
+	 * ----------------
+	 */
+	if (attnum < 0)
+	{
+		/* ----------------
+		 *	If this is a pseudo-att, we get the type and fake the length.
+		 *	There ought to be a routine to return the real lengths, so
+		 *	we'll mark this one ... XXX -mao
+		 * ----------------
+		 */
+		len = heap_sysattrlen(attnum);	/* XXX see -mao above */
+		byval = heap_sysattrbyval(attnum);		/* XXX see -mao above */
+	}
+	else
+	{
+		len = tuple_type->attrs[attnum - 1]->attlen;
+		byval = tuple_type->attrs[attnum - 1]->attbyval ? true : false;
+	}
+
+	execConstByVal = byval;
+	execConstLen = len;
+
+	return result;
 }
 
 /* ----------------------------------------------------------------
- *      ExecEvalParam
+ *		ExecEvalParam
  *
- *      Returns the value of a parameter.  A param node contains
- *	something like ($.name) and the expression context contains
- *	the current parameter bindings (name = "sam") (age = 34)...
- *	so our job is to replace the param node with the datum
- *	containing the appropriate information ("sam").
+ *		Returns the value of a parameter.  A param node contains
+ *		something like ($.name) and the expression context contains
+ *		the current parameter bindings (name = "sam") (age = 34)...
+ *		so our job is to replace the param node with the datum
+ *		containing the appropriate information ("sam").
  *
- *	Q: if we have a parameter ($.foo) without a binding, i.e.
- *	   there is no (foo = xxx) in the parameter list info,
- *	   is this a fatal error or should this be a "not available"
- *	   (in which case we shoud return a Const node with the
- *	    isnull flag) ?  -cim 10/13/89
+ *		Q: if we have a parameter ($.foo) without a binding, i.e.
+ *		   there is no (foo = xxx) in the parameter list info,
+ *		   is this a fatal error or should this be a "not available"
+ *		   (in which case we shoud return a Const node with the
+ *			isnull flag) ?	-cim 10/13/89
  *
- *      Minor modification: Param nodes now have an extra field,
- *      `paramkind' which specifies the type of parameter 
- *      (see params.h). So while searching the paramList for
- *      a paramname/value pair, we have also to check for `kind'.
- *     
- *      NOTE: The last entry in `paramList' is always an
- *      entry with kind == PARAM_INVALID.
+ *		Minor modification: Param nodes now have an extra field,
+ *		`paramkind' which specifies the type of parameter
+ *		(see params.h). So while searching the paramList for
+ *		a paramname/value pair, we have also to check for `kind'.
+ *
+ *		NOTE: The last entry in `paramList' is always an
+ *		entry with kind == PARAM_INVALID.
  * ----------------------------------------------------------------
  */
 Datum
-ExecEvalParam(Param *expression, ExprContext *econtext, bool *isNull)
+ExecEvalParam(Param * expression, ExprContext * econtext, bool * isNull)
 {
-    
-    char  	  	*thisParameterName;
-    int		  	thisParameterKind;
-    AttrNumber		thisParameterId;
-    int 	  	matchFound;
-    ParamListInfo	paramList;
-    
-    thisParameterName = expression->paramname;
-    thisParameterKind = expression->paramkind;
-    thisParameterId =   expression->paramid;
-    paramList = 	econtext->ecxt_param_list_info;
-    
-    *isNull = false;
-    /*
-     * search the list with the parameter info to find a matching name.
-     * An entry with an InvalidName denotes the last element in the array.
-     */
-    matchFound = 0;
-    if (paramList != NULL) {
+
+	char		   *thisParameterName;
+	int				thisParameterKind;
+	AttrNumber		thisParameterId;
+	int				matchFound;
+	ParamListInfo	paramList;
+
+	thisParameterName = expression->paramname;
+	thisParameterKind = expression->paramkind;
+	thisParameterId = expression->paramid;
+	paramList = econtext->ecxt_param_list_info;
+
+	*isNull = false;
+
 	/*
-	 * search for an entry in 'paramList' that matches
-	 * the `expression'.
+	 * search the list with the parameter info to find a matching name. An
+	 * entry with an InvalidName denotes the last element in the array.
 	 */
-	while(paramList->kind != PARAM_INVALID && !matchFound) {
-	    switch (thisParameterKind) {
-	    case PARAM_NAMED:
-		if (thisParameterKind == paramList->kind &&
-		    strcmp(paramList->name, thisParameterName) == 0){
-		    matchFound = 1;
-		} 
-		break;
-	    case PARAM_NUM:
-		if (thisParameterKind == paramList->kind &&
-		    paramList->id == thisParameterId) {
-		    matchFound = 1;
-		}
-		break;
-	    case PARAM_OLD:
-	    case PARAM_NEW:
-		if (thisParameterKind == paramList->kind &&
-		    paramList->id == thisParameterId)
-		    {
-			matchFound = 1;
-			/*
-			 * sanity check
-			 */
-		        if (strcmp(paramList->name, thisParameterName) != 0){
-			    elog(WARN,
-				 "ExecEvalParam: new/old params with same id & diff names");
+	matchFound = 0;
+	if (paramList != NULL)
+	{
+
+		/*
+		 * search for an entry in 'paramList' that matches the
+		 * `expression'.
+		 */
+		while (paramList->kind != PARAM_INVALID && !matchFound)
+		{
+			switch (thisParameterKind)
+			{
+			case PARAM_NAMED:
+				if (thisParameterKind == paramList->kind &&
+					strcmp(paramList->name, thisParameterName) == 0)
+				{
+					matchFound = 1;
+				}
+				break;
+			case PARAM_NUM:
+				if (thisParameterKind == paramList->kind &&
+					paramList->id == thisParameterId)
+				{
+					matchFound = 1;
+				}
+				break;
+			case PARAM_OLD:
+			case PARAM_NEW:
+				if (thisParameterKind == paramList->kind &&
+					paramList->id == thisParameterId)
+				{
+					matchFound = 1;
+
+					/*
+					 * sanity check
+					 */
+					if (strcmp(paramList->name, thisParameterName) != 0)
+					{
+						elog(WARN,
+							 "ExecEvalParam: new/old params with same id & diff names");
+					}
+				}
+				break;
+			default:
+
+				/*
+				 * oops! this is not supposed to happen!
+				 */
+				elog(WARN, "ExecEvalParam: invalid paramkind %d",
+					 thisParameterKind);
 			}
-		    }
-		break;
-	    default:
+			if (!matchFound)
+			{
+				paramList++;
+			}
+		}						/* while */
+	}							/* if */
+
+	if (!matchFound)
+	{
+
 		/*
-		 * oops! this is not supposed to happen!
+		 * ooops! we couldn't find this parameter in the parameter list.
+		 * Signal an error
 		 */
-		elog(WARN, "ExecEvalParam: invalid paramkind %d",
-		     thisParameterKind);
-	    }
-	    if (! matchFound) {
-		paramList++;
-	    }
-	} /*while*/
-    } /*if*/
-    
-    if (!matchFound) {
+		elog(WARN, "ExecEvalParam: Unknown value for parameter %s",
+			 thisParameterName);
+	}
+
 	/*
-	 * ooops! we couldn't find this parameter
-	 * in the parameter list. Signal an error
+	 * return the value.
 	 */
-	elog(WARN, "ExecEvalParam: Unknown value for parameter %s",
-	     thisParameterName);
-    }
-    
-    /*
-     * return the value.
-     */
-    if (paramList->isnull)
+	if (paramList->isnull)
 	{
-	    *isNull = true;
-	    return (Datum)NULL;
+		*isNull = true;
+		return (Datum) NULL;
 	}
-    
-    if (expression->param_tlist != NIL)
+
+	if (expression->param_tlist != NIL)
 	{
-	    HeapTuple      tup;
-	    Datum          value;
-	    List           *tlist = expression->param_tlist;
-	    TargetEntry	   *tle = (TargetEntry *)lfirst(tlist);
-	    TupleTableSlot *slot = (TupleTableSlot *)paramList->value;
-	    
-	    tup = slot->val;
-	    value = ProjectAttribute(slot->ttc_tupleDescriptor,
-				     tle, tup, isNull);
-	    return value;
+		HeapTuple		tup;
+		Datum			value;
+		List		   *tlist = expression->param_tlist;
+		TargetEntry    *tle = (TargetEntry *) lfirst(tlist);
+		TupleTableSlot *slot = (TupleTableSlot *) paramList->value;
+
+		tup = slot->val;
+		value = ProjectAttribute(slot->ttc_tupleDescriptor,
+								 tle, tup, isNull);
+		return value;
 	}
-    return(paramList->value);
+	return (paramList->value);
 }
 
 
 /* ----------------------------------------------------------------
- *    	ExecEvalOper / ExecEvalFunc support routines
+ *		ExecEvalOper / ExecEvalFunc support routines
  * ----------------------------------------------------------------
  */
 
 /* ----------------
- *	GetAttributeByName
- *	GetAttributeByNum
+ *		GetAttributeByName
+ *		GetAttributeByNum
  *
- *	These are functions which return the value of the
- *	named attribute out of the tuple from the arg slot.  User defined
- *	C functions which take a tuple as an argument are expected
- *	to use this.  Ex: overpaid(EMP) might call GetAttributeByNum().
+ *		These are functions which return the value of the
+ *		named attribute out of the tuple from the arg slot.  User defined
+ *		C functions which take a tuple as an argument are expected
+ *		to use this.  Ex: overpaid(EMP) might call GetAttributeByNum().
  * ----------------
  */
 #ifdef NOT_USED
-static char *
-GetAttributeByNum(TupleTableSlot  *slot,
-		  AttrNumber attrno,
-		  bool *isNull)
+static char    *
+GetAttributeByNum(TupleTableSlot * slot,
+				  AttrNumber attrno,
+				  bool * isNull)
 {
-    Datum retval;
-    
-    if (!AttributeNumberIsValid(attrno))
-	elog(WARN, "GetAttributeByNum: Invalid attribute number");
-    
-    if (!AttrNumberIsForUserDefinedAttr(attrno))
-	elog(WARN, "GetAttributeByNum: cannot access system attributes here");
-    
-    if (isNull == (bool *)NULL)
-	elog(WARN, "GetAttributeByNum: a NULL isNull flag was passed");
-    
-    if (TupIsNull(slot))
+	Datum			retval;
+
+	if (!AttributeNumberIsValid(attrno))
+		elog(WARN, "GetAttributeByNum: Invalid attribute number");
+
+	if (!AttrNumberIsForUserDefinedAttr(attrno))
+		elog(WARN, "GetAttributeByNum: cannot access system attributes here");
+
+	if (isNull == (bool *) NULL)
+		elog(WARN, "GetAttributeByNum: a NULL isNull flag was passed");
+
+	if (TupIsNull(slot))
 	{
-	    *isNull = true;
-	    return (char *) NULL;
+		*isNull = true;
+		return (char *) NULL;
 	}
-    
-    retval = (Datum)
-	heap_getattr(slot->val,
-		     slot->ttc_buffer,
-		     attrno,
-		     slot->ttc_tupleDescriptor,
-		     isNull);
-    if (*isNull)
-	return (char *) NULL;
-    return (char *) retval;
+
+	retval = (Datum)
+		heap_getattr(slot->val,
+					 slot->ttc_buffer,
+					 attrno,
+					 slot->ttc_tupleDescriptor,
+					 isNull);
+	if (*isNull)
+		return (char *) NULL;
+	return (char *) retval;
 }
+
 #endif
 
 /* XXX char16 name for catalogs */
 #ifdef NOT_USED
-char *
-att_by_num(TupleTableSlot *slot,
-	   AttrNumber attrno,
-	   bool *isNull)
+char		   *
+att_by_num(TupleTableSlot * slot,
+		   AttrNumber attrno,
+		   bool * isNull)
 {
-    return(GetAttributeByNum(slot, attrno, isNull));
+	return (GetAttributeByNum(slot, attrno, isNull));
 }
+
 #endif
 
-char *
-GetAttributeByName(TupleTableSlot *slot, char *attname, bool *isNull)
+char		   *
+GetAttributeByName(TupleTableSlot * slot, char *attname, bool * isNull)
 {
-    AttrNumber attrno;
-    TupleDesc tupdesc;
-    HeapTuple tuple;
-    Datum retval;
-    int natts;
-    int i;
-    
-    if (attname == NULL)
-	elog(WARN, "GetAttributeByName: Invalid attribute name");
-    
-    if (isNull == (bool *)NULL)
-	elog(WARN, "GetAttributeByName: a NULL isNull flag was passed");
-    
-    if (TupIsNull(slot))
+	AttrNumber		attrno;
+	TupleDesc		tupdesc;
+	HeapTuple		tuple;
+	Datum			retval;
+	int				natts;
+	int				i;
+
+	if (attname == NULL)
+		elog(WARN, "GetAttributeByName: Invalid attribute name");
+
+	if (isNull == (bool *) NULL)
+		elog(WARN, "GetAttributeByName: a NULL isNull flag was passed");
+
+	if (TupIsNull(slot))
 	{
-	    *isNull = true;
-	    return (char *) NULL;
+		*isNull = true;
+		return (char *) NULL;
 	}
-    
-    tupdesc = slot->ttc_tupleDescriptor;
-    tuple = slot->val;
-    
-    natts = tuple->t_natts;
-    
-    attrno = InvalidAttrNumber;
-    for (i=0;i<tupdesc->natts;i++) {
-	if (namestrcmp(&(tupdesc->attrs[i]->attname), attname) == 0) {
-	    attrno = tupdesc->attrs[i]->attnum;
-	    break;
+
+	tupdesc = slot->ttc_tupleDescriptor;
+	tuple = slot->val;
+
+	natts = tuple->t_natts;
+
+	attrno = InvalidAttrNumber;
+	for (i = 0; i < tupdesc->natts; i++)
+	{
+		if (namestrcmp(&(tupdesc->attrs[i]->attname), attname) == 0)
+		{
+			attrno = tupdesc->attrs[i]->attnum;
+			break;
+		}
 	}
-    }
-
-    if (attrno == InvalidAttrNumber)
-	elog(WARN, "GetAttributeByName: attribute %s not found", attname);
-    
-    retval = (Datum)
-	heap_getattr(slot->val,
-		     slot->ttc_buffer,
-		     attrno,
-		     tupdesc,
-		     isNull);
-    if (*isNull)
-	return (char *) NULL;
-    return (char *) retval;
+
+	if (attrno == InvalidAttrNumber)
+		elog(WARN, "GetAttributeByName: attribute %s not found", attname);
+
+	retval = (Datum)
+		heap_getattr(slot->val,
+					 slot->ttc_buffer,
+					 attrno,
+					 tupdesc,
+					 isNull);
+	if (*isNull)
+		return (char *) NULL;
+	return (char *) retval;
 }
 
 /* XXX char16 name for catalogs */
 #ifdef NOT_USED
-char *
-att_by_name(TupleTableSlot *slot, char *attname, bool *isNull)
+char		   *
+att_by_name(TupleTableSlot * slot, char *attname, bool * isNull)
 {
-    return(GetAttributeByName(slot, attname, isNull));
+	return (GetAttributeByName(slot, attname, isNull));
 }
+
 #endif
 
 static void
 ExecEvalFuncArgs(FunctionCachePtr fcache,
-		 ExprContext *econtext,
-		 List *argList,
-		 Datum argV[],
-		 bool *argIsDone)
+				 ExprContext * econtext,
+				 List * argList,
+				 Datum argV[],
+				 bool * argIsDone)
 {
-    int i;
-    bool argIsNull, *nullVect;
-    List *arg;
-    
-    nullVect = fcache->nullVect;
-    
-    i = 0;
-    foreach (arg, argList) {
-	/* ----------------
-	 *   evaluate the expression, in general functions cannot take
-	 *   sets as arguments but we make an exception in the case of
-	 *   nested dot expressions.  We have to watch out for this case
-	 *   here.
-	 * ----------------
-	 */
-	argV[i] = (Datum)
-	    ExecEvalExpr((Node *) lfirst(arg),
-			 econtext,
-			 &argIsNull,
-			 argIsDone);
-	if (! (*argIsDone))
-	    {
-		Assert(i == 0);
-		fcache->setArg = (char *)argV[0];
-		fcache->hasSetArg = true;
-	    }
-	if (argIsNull)
-	    nullVect[i] = true;
-	else
-	    nullVect[i] = false;
-	i++;
-    }
+	int				i;
+	bool			argIsNull,
+				   *nullVect;
+	List		   *arg;
+
+	nullVect = fcache->nullVect;
+
+	i = 0;
+	foreach(arg, argList)
+	{
+		/* ----------------
+		 *	 evaluate the expression, in general functions cannot take
+		 *	 sets as arguments but we make an exception in the case of
+		 *	 nested dot expressions.  We have to watch out for this case
+		 *	 here.
+		 * ----------------
+		 */
+		argV[i] = (Datum)
+			ExecEvalExpr((Node *) lfirst(arg),
+						 econtext,
+						 &argIsNull,
+						 argIsDone);
+		if (!(*argIsDone))
+		{
+			Assert(i == 0);
+			fcache->setArg = (char *) argV[0];
+			fcache->hasSetArg = true;
+		}
+		if (argIsNull)
+			nullVect[i] = true;
+		else
+			nullVect[i] = false;
+		i++;
+	}
 }
 
 /* ----------------
- *	ExecMakeFunctionResult
+ *		ExecMakeFunctionResult
  * ----------------
  */
-static Datum
-ExecMakeFunctionResult(Node *node,
-		       List *arguments,
-		       ExprContext *econtext,
-		       bool *isNull,
-		       bool *isDone)
+static			Datum
+ExecMakeFunctionResult(Node * node,
+					   List * arguments,
+					   ExprContext * econtext,
+					   bool * isNull,
+					   bool * isDone)
 {
-    Datum	argv[MAXFMGRARGS];
-    FunctionCachePtr fcache;
-    Func	*funcNode = NULL;
-    Oper	*operNode = NULL;
-    bool        funcisset = false;
-    
-    /*
-     * This is kind of ugly, Func nodes now have targetlists so that
-     * we know when and what to project out from postquel function results.
-     * This means we have to pass the func node all the way down instead
-     * of using only the fcache struct as before.  ExecMakeFunctionResult
-     * becomes a little bit more of a dual personality as a result.
-     */
-    if (IsA(node,Func))
+	Datum			argv[MAXFMGRARGS];
+	FunctionCachePtr fcache;
+	Func		   *funcNode = NULL;
+	Oper		   *operNode = NULL;
+	bool			funcisset = false;
+
+	/*
+	 * This is kind of ugly, Func nodes now have targetlists so that we
+	 * know when and what to project out from postquel function results.
+	 * This means we have to pass the func node all the way down instead
+	 * of using only the fcache struct as before.  ExecMakeFunctionResult
+	 * becomes a little bit more of a dual personality as a result.
+	 */
+	if (IsA(node, Func))
 	{
-	    funcNode = (Func *)node;
-	    fcache = funcNode->func_fcache;
+		funcNode = (Func *) node;
+		fcache = funcNode->func_fcache;
 	}
-    else
+	else
 	{
-	    operNode = (Oper *)node;
-	    fcache = operNode->op_fcache;
+		operNode = (Oper *) node;
+		fcache = operNode->op_fcache;
 	}
-    
-    /* ----------------
-     *	arguments is a list of expressions to evaluate
-     *  before passing to the function manager.
-     *  We collect the results of evaluating the expressions
-     *  into a datum array (argv) and pass this array to arrayFmgr()
-     * ----------------
-     */
-    if (fcache->nargs != 0) {
-	bool argDone;
-	
-	if (fcache->nargs > MAXFMGRARGS) 
-	    elog(WARN, "ExecMakeFunctionResult: too many arguments");
-	
-	/*
-	 * If the setArg in the fcache is set we have an argument
-	 * returning a set of tuples (i.e. a nested dot expression).  We
-	 * don't want to evaluate the arguments again until the function
-	 * is done. hasSetArg will always be false until we eval the args
-	 * for the first time. We should set this in the parser.
+
+	/* ----------------
+	 *	arguments is a list of expressions to evaluate
+	 *	before passing to the function manager.
+	 *	We collect the results of evaluating the expressions
+	 *	into a datum array (argv) and pass this array to arrayFmgr()
+	 * ----------------
 	 */
-	if ((fcache->hasSetArg) && fcache->setArg != NULL)
-	    {
-		argv[0] = (Datum)fcache->setArg;
-		argDone = false;
-	    }
-	else
-	    ExecEvalFuncArgs(fcache, econtext, arguments, argv, &argDone);
-	
-	if ((fcache->hasSetArg) && (argDone)) {
-	    if (isDone) *isDone = true;
-	    return (Datum)NULL;
-	}
-    }
-    
-    /* If this function is really a set, we have to diddle with things.
-     * If the function has already been called at least once, then the 
-     * setArg field of the fcache holds
-     * the OID of this set in pg_proc.  (This is not quite legit, since
-     * the setArg field is really for functions which take sets of tuples
-     * as input - set functions take no inputs at all.  But it's a nice
-     * place to stash this value, for now.)
-     *
-     * If this is the first call of the set's function, then
-     * the call to ExecEvalFuncArgs above just returned the OID of 
-     * the pg_proc tuple which defines this set.  So replace the existing
-     * funcid in the funcnode with the set's OID.  Also, we want a new
-     * fcache which points to the right function, so get that, now that
-     * we have the right OID.  Also zero out the argv, since the real
-     * set doesn't take any arguments.
-     */
-    if (((Func *)node)->funcid == SetEvalRegProcedure) {
-	funcisset = true;
-	if (fcache->setArg) {
-	    argv[0] = 0;
-
-	    ((Func *)node)->funcid = (Oid) PointerGetDatum(fcache->setArg);
-		       
-	} else {
-	    ((Func *)node)->funcid = (Oid) argv[0];
-	    setFcache(node, argv[0], NIL,econtext);
-	    fcache = ((Func *)node)->func_fcache;
-	    fcache->setArg = (char*)argv[0];
-	    argv[0] = (Datum)0;
+	if (fcache->nargs != 0)
+	{
+		bool			argDone;
+
+		if (fcache->nargs > MAXFMGRARGS)
+			elog(WARN, "ExecMakeFunctionResult: too many arguments");
+
+		/*
+		 * If the setArg in the fcache is set we have an argument
+		 * returning a set of tuples (i.e. a nested dot expression).  We
+		 * don't want to evaluate the arguments again until the function
+		 * is done. hasSetArg will always be false until we eval the args
+		 * for the first time. We should set this in the parser.
+		 */
+		if ((fcache->hasSetArg) && fcache->setArg != NULL)
+		{
+			argv[0] = (Datum) fcache->setArg;
+			argDone = false;
+		}
+		else
+			ExecEvalFuncArgs(fcache, econtext, arguments, argv, &argDone);
+
+		if ((fcache->hasSetArg) && (argDone))
+		{
+			if (isDone)
+				*isDone = true;
+			return (Datum) NULL;
+		}
 	}
-    }
-    
-    /* ----------------
-     *   now return the value gotten by calling the function manager, 
-     *   passing the function the evaluated parameter values. 
-     * ----------------
-     */
-    if (fcache->language == SQLlanguageId) {
-	Datum result;
-	
-	Assert(funcNode);
-	result = postquel_function (funcNode, (char **) argv, isNull, isDone);
+
 	/*
-	 * finagle the situation where we are iterating through all results
-	 * in a nested dot function (whose argument function returns a set
-	 * of tuples) and the current function finally finishes.  We need to
-	 * get the next argument in the set and run the function all over
-	 * again.  This is getting unclean.
+	 * If this function is really a set, we have to diddle with things. If
+	 * the function has already been called at least once, then the setArg
+	 * field of the fcache holds the OID of this set in pg_proc.  (This is
+	 * not quite legit, since the setArg field is really for functions
+	 * which take sets of tuples as input - set functions take no inputs
+	 * at all.	But it's a nice place to stash this value, for now.)
+	 *
+	 * If this is the first call of the set's function, then the call to
+	 * ExecEvalFuncArgs above just returned the OID of the pg_proc tuple
+	 * which defines this set.	So replace the existing funcid in the
+	 * funcnode with the set's OID.  Also, we want a new fcache which
+	 * points to the right function, so get that, now that we have the
+	 * right OID.  Also zero out the argv, since the real set doesn't take
+	 * any arguments.
 	 */
-	if ((*isDone) && (fcache->hasSetArg)) {
-	    bool argDone;
-	    
-	    ExecEvalFuncArgs(fcache, econtext, arguments, argv, &argDone);
-	    
-	    if (argDone) {
-	        fcache->setArg = (char *)NULL;
-		*isDone = true;
-		result = (Datum)NULL;
-	    }
-	    else
-		result = postquel_function(funcNode,
-					   (char **) argv,
-					   isNull,
-					   isDone);
+	if (((Func *) node)->funcid == SetEvalRegProcedure)
+	{
+		funcisset = true;
+		if (fcache->setArg)
+		{
+			argv[0] = 0;
+
+			((Func *) node)->funcid = (Oid) PointerGetDatum(fcache->setArg);
+
+		}
+		else
+		{
+			((Func *) node)->funcid = (Oid) argv[0];
+			setFcache(node, argv[0], NIL, econtext);
+			fcache = ((Func *) node)->func_fcache;
+			fcache->setArg = (char *) argv[0];
+			argv[0] = (Datum) 0;
+		}
 	}
-	if (funcisset) {
-	    /* reset the funcid so that next call to this routine will
-	     * still recognize this func as a set.
-	     * Note that for now we assume that the set function in
-	     * pg_proc must be a Postquel function - the funcid is
-	     * not reset below for C functions.
-	     */
-	    ((Func *)node)->funcid = SetEvalRegProcedure;
-	    /* If we're done with the results of this function, get rid
-	     * of its func cache.
-	     */
-	    if (*isDone) {
-		((Func *)node)->func_fcache = NULL;
-	    }
+
+	/* ----------------
+	 *	 now return the value gotten by calling the function manager,
+	 *	 passing the function the evaluated parameter values.
+	 * ----------------
+	 */
+	if (fcache->language == SQLlanguageId)
+	{
+		Datum			result;
+
+		Assert(funcNode);
+		result = postquel_function(funcNode, (char **) argv, isNull, isDone);
+
+		/*
+		 * finagle the situation where we are iterating through all
+		 * results in a nested dot function (whose argument function
+		 * returns a set of tuples) and the current function finally
+		 * finishes.  We need to get the next argument in the set and run
+		 * the function all over again.  This is getting unclean.
+		 */
+		if ((*isDone) && (fcache->hasSetArg))
+		{
+			bool			argDone;
+
+			ExecEvalFuncArgs(fcache, econtext, arguments, argv, &argDone);
+
+			if (argDone)
+			{
+				fcache->setArg = (char *) NULL;
+				*isDone = true;
+				result = (Datum) NULL;
+			}
+			else
+				result = postquel_function(funcNode,
+										   (char **) argv,
+										   isNull,
+										   isDone);
+		}
+		if (funcisset)
+		{
+
+			/*
+			 * reset the funcid so that next call to this routine will
+			 * still recognize this func as a set. Note that for now we
+			 * assume that the set function in pg_proc must be a Postquel
+			 * function - the funcid is not reset below for C functions.
+			 */
+			((Func *) node)->funcid = SetEvalRegProcedure;
+
+			/*
+			 * If we're done with the results of this function, get rid of
+			 * its func cache.
+			 */
+			if (*isDone)
+			{
+				((Func *) node)->func_fcache = NULL;
+			}
+		}
+		return result;
 	}
-	return result;
-    }
-    else 
+	else
 	{
-	    int i;
-	    
-	    if (isDone) *isDone = true;
-	    for (i = 0; i < fcache->nargs; i++) 
-		if (fcache->nullVect[i] == true) *isNull = true;
-	    
-	    return((Datum) fmgr_c(fcache->func, fcache->foid, fcache->nargs,
-				  (FmgrValues *) argv, isNull));
+		int				i;
+
+		if (isDone)
+			*isDone = true;
+		for (i = 0; i < fcache->nargs; i++)
+			if (fcache->nullVect[i] == true)
+				*isNull = true;
+
+		return ((Datum) fmgr_c(fcache->func, fcache->foid, fcache->nargs,
+							   (FmgrValues *) argv, isNull));
 	}
 }
 
 
 /* ----------------------------------------------------------------
- *    	ExecEvalOper
- *    	ExecEvalFunc
- *    
- *    	Evaluate the functional result of a list of arguments by calling the
- *    	function manager.  Note that in the case of operator expressions, the
- *    	optimizer had better have already replaced the operator OID with the
- *    	appropriate function OID or we're hosed.
+ *		ExecEvalOper
+ *		ExecEvalFunc
+ *
+ *		Evaluate the functional result of a list of arguments by calling the
+ *		function manager.  Note that in the case of operator expressions, the
+ *		optimizer had better have already replaced the operator OID with the
+ *		appropriate function OID or we're hosed.
  *
  * old comments
- *    	Presumably the function manager will not take null arguments, so we
- *    	check for null arguments before sending the arguments to (fmgr).
- *    
- *    	Returns the value of the functional expression.
+ *		Presumably the function manager will not take null arguments, so we
+ *		check for null arguments before sending the arguments to (fmgr).
+ *
+ *		Returns the value of the functional expression.
  * ----------------------------------------------------------------
  */
 
 /* ----------------------------------------------------------------
- *	ExecEvalOper
+ *		ExecEvalOper
  * ----------------------------------------------------------------
  */
-static Datum
-ExecEvalOper(Expr *opClause, ExprContext *econtext, bool *isNull)
+static			Datum
+ExecEvalOper(Expr * opClause, ExprContext * econtext, bool * isNull)
 {
-    Oper	*op; 
-    List	*argList;
-    FunctionCachePtr fcache;
-    bool	isDone;
-
-    /* ----------------
-     *  an opclause is a list (op args).  (I think)
-     *
-     *  we extract the oid of the function associated with
-     *  the op and then pass the work onto ExecMakeFunctionResult
-     *  which evaluates the arguments and returns the result of
-     *  calling the function on the evaluated arguments.
-     * ----------------
-     */
-    op = 	(Oper *) opClause->oper;
-    argList =   opClause->args;
-    
-    /*
-     * get the fcache from the Oper node.
-     * If it is NULL, then initialize it
-     */
-    fcache = op->op_fcache;
-    if (fcache == NULL) {
-        setFcache((Node*)op, op->opid, argList, econtext);
-    	fcache = op->op_fcache;
-    }
-    
-    /* -----------
-     *  call ExecMakeFunctionResult() with a dummy isDone that we ignore.
-     *  We don't have operator whose arguments are sets.
-     * -----------
-     */
-    return
-	ExecMakeFunctionResult((Node *)op, argList, econtext, isNull, &isDone);
+	Oper		   *op;
+	List		   *argList;
+	FunctionCachePtr fcache;
+	bool			isDone;
+
+	/* ----------------
+	 *	an opclause is a list (op args).  (I think)
+	 *
+	 *	we extract the oid of the function associated with
+	 *	the op and then pass the work onto ExecMakeFunctionResult
+	 *	which evaluates the arguments and returns the result of
+	 *	calling the function on the evaluated arguments.
+	 * ----------------
+	 */
+	op = (Oper *) opClause->oper;
+	argList = opClause->args;
+
+	/*
+	 * get the fcache from the Oper node. If it is NULL, then initialize
+	 * it
+	 */
+	fcache = op->op_fcache;
+	if (fcache == NULL)
+	{
+		setFcache((Node *) op, op->opid, argList, econtext);
+		fcache = op->op_fcache;
+	}
+
+	/* -----------
+	 *	call ExecMakeFunctionResult() with a dummy isDone that we ignore.
+	 *	We don't have operator whose arguments are sets.
+	 * -----------
+	 */
+	return
+		ExecMakeFunctionResult((Node *) op, argList, econtext, isNull, &isDone);
 }
 
 /* ----------------------------------------------------------------
- *	ExecEvalFunc
+ *		ExecEvalFunc
  * ----------------------------------------------------------------
  */
 
-static Datum
-ExecEvalFunc(Expr *funcClause,
-	     ExprContext *econtext,
-	     bool *isNull,
-	     bool *isDone)
+static			Datum
+ExecEvalFunc(Expr * funcClause,
+			 ExprContext * econtext,
+			 bool * isNull,
+			 bool * isDone)
 {
-    Func	*func;
-    List	*argList;
-    FunctionCachePtr fcache;
-    
-    /* ----------------
-     *  an funcclause is a list (func args).  (I think)
-     *
-     *  we extract the oid of the function associated with
-     *  the func node and then pass the work onto ExecMakeFunctionResult
-     *  which evaluates the arguments and returns the result of
-     *  calling the function on the evaluated arguments.
-     *
-     *  this is nearly identical to the ExecEvalOper code.
-     * ----------------
-     */
-    func =	(Func *)funcClause->oper;
-    argList =   funcClause->args;
-    
-    /*
-     * get the fcache from the Func node.
-     * If it is NULL, then initialize it
-     */
-    fcache = func->func_fcache;
-    if (fcache == NULL) {
-    	setFcache((Node*)func, func->funcid, argList, econtext);
-    	fcache = func->func_fcache;
-    }
-    
-    return
-	ExecMakeFunctionResult((Node*)func, argList, econtext, isNull, isDone);
+	Func		   *func;
+	List		   *argList;
+	FunctionCachePtr fcache;
+
+	/* ----------------
+	 *	an funcclause is a list (func args).  (I think)
+	 *
+	 *	we extract the oid of the function associated with
+	 *	the func node and then pass the work onto ExecMakeFunctionResult
+	 *	which evaluates the arguments and returns the result of
+	 *	calling the function on the evaluated arguments.
+	 *
+	 *	this is nearly identical to the ExecEvalOper code.
+	 * ----------------
+	 */
+	func = (Func *) funcClause->oper;
+	argList = funcClause->args;
+
+	/*
+	 * get the fcache from the Func node. If it is NULL, then initialize
+	 * it
+	 */
+	fcache = func->func_fcache;
+	if (fcache == NULL)
+	{
+		setFcache((Node *) func, func->funcid, argList, econtext);
+		fcache = func->func_fcache;
+	}
+
+	return
+		ExecMakeFunctionResult((Node *) func, argList, econtext, isNull, isDone);
 }
 
 /* ----------------------------------------------------------------
- *    	ExecEvalNot
- *    	ExecEvalOr
- *	ExecEvalAnd
- *    
- *    	Evaluate boolean expressions.  Evaluation of 'or' is
- *	short-circuited when the first true (or null) value is found.
+ *		ExecEvalNot
+ *		ExecEvalOr
+ *		ExecEvalAnd
  *
- *	The query planner reformulates clause expressions in the
- *	qualification to conjunctive normal form.  If we ever get
- *	an AND to evaluate, we can be sure that it's not a top-level
- *	clause in the qualification, but appears lower (as a function
- *	argument, for example), or in the target list.  Not that you
- *	need to know this, mind you...
+ *		Evaluate boolean expressions.  Evaluation of 'or' is
+ *		short-circuited when the first true (or null) value is found.
+ *
+ *		The query planner reformulates clause expressions in the
+ *		qualification to conjunctive normal form.  If we ever get
+ *		an AND to evaluate, we can be sure that it's not a top-level
+ *		clause in the qualification, but appears lower (as a function
+ *		argument, for example), or in the target list.	Not that you
+ *		need to know this, mind you...
  * ----------------------------------------------------------------
  */
-static Datum
-ExecEvalNot(Expr *notclause, ExprContext *econtext, bool *isNull)
+static			Datum
+ExecEvalNot(Expr * notclause, ExprContext * econtext, bool * isNull)
 {
-    Datum expr_value;
-    Node *clause;
-    bool  isDone;
-    
-    clause = lfirst(notclause->args);
-    
-    /* ----------------
-     *  We don't iterate over sets in the quals, so pass in an isDone
-     *  flag, but ignore it.
-     * ----------------
-     */
-    expr_value = ExecEvalExpr(clause, econtext, isNull, &isDone);
-    
-    /* ----------------
-     *	if the expression evaluates to null, then we just
-     *  cascade the null back to whoever called us.
-     * ----------------
-     */
-    if (*isNull)
-	return expr_value;
-    
-    /* ----------------
-     *  evaluation of 'not' is simple.. expr is false, then
-     *  return 'true' and vice versa.
-     * ----------------
-     */
-    if (DatumGetInt32(expr_value) == 0)
-	return (Datum) true;
-    
-    return (Datum) false;
-}
+	Datum			expr_value;
+	Node		   *clause;
+	bool			isDone;
+
+	clause = lfirst(notclause->args);
 
-/* ----------------------------------------------------------------
- *	ExecEvalOr
- * ----------------------------------------------------------------
- */
-static Datum
-ExecEvalOr(Expr *orExpr, ExprContext *econtext, bool *isNull)
-{
-    List   *clauses;
-    List   *clause;
-    bool   isDone;
-    bool IsNull;
-    Datum  const_value = 0;
-    
-    IsNull = false; 
-    clauses = orExpr->args;
-    
-    /* ----------------
-     *  we use three valued logic functions here...
-     *	we evaluate each of the clauses in turn,
-     *  as soon as one is true we return that
-     *  value.  If none is true and  none of the
-     *  clauses evaluate to NULL we return
-     *  the value of the last clause evaluated (which
-     *  should be false) with *isNull set to false else 
-     *  if none is true and at least one clause evaluated
-     *  to NULL we set *isNull flag to true -  
-     * ----------------
-     */
-    foreach (clause, clauses) {
-	
 	/* ----------------
-	 *  We don't iterate over sets in the quals, so pass in an isDone
-	 *  flag, but ignore it.
+	 *	We don't iterate over sets in the quals, so pass in an isDone
+	 *	flag, but ignore it.
 	 * ----------------
 	 */
-	const_value = ExecEvalExpr((Node *) lfirst(clause),
-				   econtext,
-				   isNull,
-				   &isDone);
-	
+	expr_value = ExecEvalExpr(clause, econtext, isNull, &isDone);
+
 	/* ----------------
-	 *  if the expression evaluates to null, then we 
-	 *  remember it in the local IsNull flag, if none of the
-	 *  clauses are true then we need to set *isNull
-	 *  to true again.
+	 *	if the expression evaluates to null, then we just
+	 *	cascade the null back to whoever called us.
 	 * ----------------
 	 */
 	if (*isNull)
-	    IsNull = *isNull;
-	
+		return expr_value;
+
 	/* ----------------
-	 *   if we have a true result, then we return it.
+	 *	evaluation of 'not' is simple.. expr is false, then
+	 *	return 'true' and vice versa.
 	 * ----------------
 	 */
-	if (DatumGetInt32(const_value) != 0)
-	    return const_value;
-    }
-    
-    /* IsNull is true if at least one clause evaluated to NULL */	
-    *isNull = IsNull;
-    return const_value;
+	if (DatumGetInt32(expr_value) == 0)
+		return (Datum) true;
+
+	return (Datum) false;
 }
 
 /* ----------------------------------------------------------------
- *	ExecEvalAnd
+ *		ExecEvalOr
  * ----------------------------------------------------------------
  */
-static Datum
-ExecEvalAnd(Expr *andExpr, ExprContext *econtext, bool *isNull)
+static			Datum
+ExecEvalOr(Expr * orExpr, ExprContext * econtext, bool * isNull)
 {
-    List   *clauses;
-    List   *clause;
-    Datum  const_value = 0;
-    bool   isDone;
-    bool IsNull;
-    
-    IsNull = false;
-    
-    clauses = andExpr->args;
-    
-    /* ----------------
-     *	we evaluate each of the clauses in turn,
-     *  as soon as one is false we return that
-     *  value.  If none are false or NULL then we return
-     *  the value of the last clause evaluated, which
-     *  should be true. 
-     * ----------------
-     */
-    foreach (clause, clauses) {
-	
-	/* ----------------
-	 *  We don't iterate over sets in the quals, so pass in an isDone
-	 *  flag, but ignore it.
-	 * ----------------
-	 */
-	const_value = ExecEvalExpr((Node *) lfirst(clause),
-				   econtext,
-				   isNull,
-				   &isDone);
-	
+	List		   *clauses;
+	List		   *clause;
+	bool			isDone;
+	bool			IsNull;
+	Datum			const_value = 0;
+
+	IsNull = false;
+	clauses = orExpr->args;
+
 	/* ----------------
-	 *  if the expression evaluates to null, then we 
-	 *  remember it in IsNull, if none of the clauses after
-	 *  this evaluates to false we will have to set *isNull
-	 *  to true again.
+	 *	we use three valued logic functions here...
+	 *	we evaluate each of the clauses in turn,
+	 *	as soon as one is true we return that
+	 *	value.	If none is true and  none of the
+	 *	clauses evaluate to NULL we return
+	 *	the value of the last clause evaluated (which
+	 *	should be false) with *isNull set to false else
+	 *	if none is true and at least one clause evaluated
+	 *	to NULL we set *isNull flag to true -
 	 * ----------------
 	 */
-	if (*isNull)
-	    IsNull = *isNull;
-	
+	foreach(clause, clauses)
+	{
+
+		/* ----------------
+		 *	We don't iterate over sets in the quals, so pass in an isDone
+		 *	flag, but ignore it.
+		 * ----------------
+		 */
+		const_value = ExecEvalExpr((Node *) lfirst(clause),
+								   econtext,
+								   isNull,
+								   &isDone);
+
+		/* ----------------
+		 *	if the expression evaluates to null, then we
+		 *	remember it in the local IsNull flag, if none of the
+		 *	clauses are true then we need to set *isNull
+		 *	to true again.
+		 * ----------------
+		 */
+		if (*isNull)
+			IsNull = *isNull;
+
+		/* ----------------
+		 *	 if we have a true result, then we return it.
+		 * ----------------
+		 */
+		if (DatumGetInt32(const_value) != 0)
+			return const_value;
+	}
+
+	/* IsNull is true if at least one clause evaluated to NULL */
+	*isNull = IsNull;
+	return const_value;
+}
+
+/* ----------------------------------------------------------------
+ *		ExecEvalAnd
+ * ----------------------------------------------------------------
+ */
+static			Datum
+ExecEvalAnd(Expr * andExpr, ExprContext * econtext, bool * isNull)
+{
+	List		   *clauses;
+	List		   *clause;
+	Datum			const_value = 0;
+	bool			isDone;
+	bool			IsNull;
+
+	IsNull = false;
+
+	clauses = andExpr->args;
+
 	/* ----------------
-	 *   if we have a false result, then we return it, since the
-	 *   conjunction must be false.
+	 *	we evaluate each of the clauses in turn,
+	 *	as soon as one is false we return that
+	 *	value.	If none are false or NULL then we return
+	 *	the value of the last clause evaluated, which
+	 *	should be true.
 	 * ----------------
 	 */
-	if (DatumGetInt32(const_value) == 0)
-	    return const_value;
-    }
-    
-    *isNull = IsNull;
-    return const_value;
+	foreach(clause, clauses)
+	{
+
+		/* ----------------
+		 *	We don't iterate over sets in the quals, so pass in an isDone
+		 *	flag, but ignore it.
+		 * ----------------
+		 */
+		const_value = ExecEvalExpr((Node *) lfirst(clause),
+								   econtext,
+								   isNull,
+								   &isDone);
+
+		/* ----------------
+		 *	if the expression evaluates to null, then we
+		 *	remember it in IsNull, if none of the clauses after
+		 *	this evaluates to false we will have to set *isNull
+		 *	to true again.
+		 * ----------------
+		 */
+		if (*isNull)
+			IsNull = *isNull;
+
+		/* ----------------
+		 *	 if we have a false result, then we return it, since the
+		 *	 conjunction must be false.
+		 * ----------------
+		 */
+		if (DatumGetInt32(const_value) == 0)
+			return const_value;
+	}
+
+	*isNull = IsNull;
+	return const_value;
 }
 
-/* ----------------------------------------------------------------  
- *    	ExecEvalExpr
- *    
- *    	Recursively evaluate a targetlist or qualification expression.
+/* ----------------------------------------------------------------
+ *		ExecEvalExpr
+ *
+ *		Recursively evaluate a targetlist or qualification expression.
  *
- *    	This routine is an inner loop routine and should be as fast
- *      as possible.
+ *		This routine is an inner loop routine and should be as fast
+ *		as possible.
  *
- *      Node comparison functions were replaced by macros for speed and to plug
- *      memory leaks incurred by using the planner's Lispy stuff for
- *      comparisons.  Order of evaluation of node comparisons IS IMPORTANT;
- *      the macros do no checks.  Order of evaluation:
- *      
- *      o an isnull check, largely to avoid coredumps since greg doubts this
- *        routine is called with a null ptr anyway in proper operation, but is
- *        not completely sure...
- *      o ExactNodeType checks.
- *      o clause checks or other checks where we look at the lfirst of something.
+ *		Node comparison functions were replaced by macros for speed and to plug
+ *		memory leaks incurred by using the planner's Lispy stuff for
+ *		comparisons.  Order of evaluation of node comparisons IS IMPORTANT;
+ *		the macros do no checks.  Order of evaluation:
+ *
+ *		o an isnull check, largely to avoid coredumps since greg doubts this
+ *		  routine is called with a null ptr anyway in proper operation, but is
+ *		  not completely sure...
+ *		o ExactNodeType checks.
+ *		o clause checks or other checks where we look at the lfirst of something.
  * ----------------------------------------------------------------
  */
 Datum
-ExecEvalExpr(Node *expression,
-	     ExprContext *econtext,
-	     bool *isNull,
-	     bool *isDone)
+ExecEvalExpr(Node * expression,
+			 ExprContext * econtext,
+			 bool * isNull,
+			 bool * isDone)
 {
-    Datum retDatum = 0;
-    
-    *isNull = false;
-    
-    /*
-     * Some callers don't care about is done and only want 1 result.  They
-     * indicate this by passing NULL
-     */
-    if (isDone)
-	*isDone = true;
-    
-    /* ----------------
-     *	here we dispatch the work to the appropriate type
-     *  of function given the type of our expression.
-     * ----------------
-     */
-    if (expression == NULL) {
-	*isNull = true;
-	return (Datum) true;
-    }
-
-    switch(nodeTag(expression)) {
-    case T_Var:
-	retDatum = (Datum) ExecEvalVar((Var *) expression, econtext, isNull);
-	break;
-    case T_Const: {
-	Const *con = (Const *)expression;
-
-	if (con->constisnull)
-	    *isNull = true;
-    	retDatum = con->constvalue;
-	break;
-    }
-    case T_Param:
-	retDatum = (Datum)ExecEvalParam((Param *)expression, econtext, isNull);
-	break;
-    case T_Iter:
-	retDatum = (Datum)  ExecEvalIter((Iter *) expression,
-					 econtext,
-					 isNull,
-					 isDone);
-	break;
-    case T_Aggreg:
-	retDatum = (Datum) ExecEvalAggreg((Aggreg *)expression,
-					  econtext,
-					  isNull);
-	break;
-    case T_ArrayRef:
-	retDatum = (Datum)  ExecEvalArrayRef((ArrayRef *) expression,
-					     econtext,
-					     isNull,
-					     isDone);
-	break;
-    case T_Expr: {
-	Expr *expr = (Expr *)expression;
-	switch (expr->opType) {
-	case OP_EXPR:
-	    retDatum = (Datum) ExecEvalOper(expr, econtext, isNull);
-	    break;
-	case FUNC_EXPR:
-	    retDatum = (Datum) ExecEvalFunc(expr, econtext, isNull, isDone);
-	    break;
-	case OR_EXPR:
-	    retDatum = (Datum) ExecEvalOr(expr, econtext, isNull);
-	    break;
-	case AND_EXPR:
-	    retDatum = (Datum)  ExecEvalAnd(expr, econtext, isNull);
-	    break;
-	case NOT_EXPR:
-	    retDatum = (Datum) ExecEvalNot(expr, econtext, isNull);
-	    break;
+	Datum			retDatum = 0;
+
+	*isNull = false;
+
+	/*
+	 * Some callers don't care about is done and only want 1 result.  They
+	 * indicate this by passing NULL
+	 */
+	if (isDone)
+		*isDone = true;
+
+	/* ----------------
+	 *	here we dispatch the work to the appropriate type
+	 *	of function given the type of our expression.
+	 * ----------------
+	 */
+	if (expression == NULL)
+	{
+		*isNull = true;
+		return (Datum) true;
+	}
+
+	switch (nodeTag(expression))
+	{
+	case T_Var:
+		retDatum = (Datum) ExecEvalVar((Var *) expression, econtext, isNull);
+		break;
+	case T_Const:
+		{
+			Const		   *con = (Const *) expression;
+
+			if (con->constisnull)
+				*isNull = true;
+			retDatum = con->constvalue;
+			break;
+		}
+	case T_Param:
+		retDatum = (Datum) ExecEvalParam((Param *) expression, econtext, isNull);
+		break;
+	case T_Iter:
+		retDatum = (Datum) ExecEvalIter((Iter *) expression,
+										econtext,
+										isNull,
+										isDone);
+		break;
+	case T_Aggreg:
+		retDatum = (Datum) ExecEvalAggreg((Aggreg *) expression,
+										  econtext,
+										  isNull);
+		break;
+	case T_ArrayRef:
+		retDatum = (Datum) ExecEvalArrayRef((ArrayRef *) expression,
+											econtext,
+											isNull,
+											isDone);
+		break;
+	case T_Expr:
+		{
+			Expr		   *expr = (Expr *) expression;
+
+			switch (expr->opType)
+			{
+			case OP_EXPR:
+				retDatum = (Datum) ExecEvalOper(expr, econtext, isNull);
+				break;
+			case FUNC_EXPR:
+				retDatum = (Datum) ExecEvalFunc(expr, econtext, isNull, isDone);
+				break;
+			case OR_EXPR:
+				retDatum = (Datum) ExecEvalOr(expr, econtext, isNull);
+				break;
+			case AND_EXPR:
+				retDatum = (Datum) ExecEvalAnd(expr, econtext, isNull);
+				break;
+			case NOT_EXPR:
+				retDatum = (Datum) ExecEvalNot(expr, econtext, isNull);
+				break;
+			default:
+				elog(WARN, "ExecEvalExpr: unknown expression type");
+				break;
+			}
+			break;
+		}
 	default:
-	    elog(WARN, "ExecEvalExpr: unknown expression type");
-	    break;
+		elog(WARN, "ExecEvalExpr: unknown expression type");
+		break;
 	}
-	break;
-    }
-    default:
-	elog(WARN, "ExecEvalExpr: unknown expression type");
-	break;
-    }
-    
-    return retDatum;
+
+	return retDatum;
 }
 
 /* ----------------------------------------------------------------
- *		     ExecQual / ExecTargetList 
+ *					 ExecQual / ExecTargetList
  * ----------------------------------------------------------------
  */
 
 /* ----------------------------------------------------------------
- *    	ExecQualClause
+ *		ExecQualClause
  *
- *	this is a workhorse for ExecQual.  ExecQual has to deal
- *	with a list of qualifications, so it passes each qualification
- *	in the list to this function one at a time.  ExecQualClause
- *	returns true when the qualification *fails* and false if
- *	the qualification succeeded (meaning we have to test the
- *	rest of the qualification)
+ *		this is a workhorse for ExecQual.  ExecQual has to deal
+ *		with a list of qualifications, so it passes each qualification
+ *		in the list to this function one at a time.  ExecQualClause
+ *		returns true when the qualification *fails* and false if
+ *		the qualification succeeded (meaning we have to test the
+ *		rest of the qualification)
  * ----------------------------------------------------------------
  */
-static bool
-ExecQualClause(Node *clause, ExprContext *econtext)
+static			bool
+ExecQualClause(Node * clause, ExprContext * econtext)
 {
-    Datum   expr_value;
-    bool isNull;
-    bool isDone;
-    
-    /* when there is a null clause, consider the qualification to be true */
-    if (clause == NULL)
-      return true;
-
-    /*
-     * pass isDone, but ignore it.  We don't iterate over multiple
-     * returns in the qualifications.
-     */
-    expr_value = (Datum)
-	ExecEvalExpr(clause, econtext, &isNull, &isDone);
-    
-    /* ----------------
-     *	this is interesting behaviour here.  When a clause evaluates
-     *  to null, then we consider this as passing the qualification.
-     *  it seems kind of like, if the qual is NULL, then there's no
-     *  qual.. 
-     * ----------------
-     */
-    if (isNull)
-	return true;
-    
-    /* ----------------
-     *  remember, we return true when the qualification fails..
-     * ----------------
-     */
-    if (DatumGetInt32(expr_value) == 0)
-	return true;
-    
-    return false;
+	Datum			expr_value;
+	bool			isNull;
+	bool			isDone;
+
+	/* when there is a null clause, consider the qualification to be true */
+	if (clause == NULL)
+		return true;
+
+	/*
+	 * pass isDone, but ignore it.	We don't iterate over multiple returns
+	 * in the qualifications.
+	 */
+	expr_value = (Datum)
+		ExecEvalExpr(clause, econtext, &isNull, &isDone);
+
+	/* ----------------
+	 *	this is interesting behaviour here.  When a clause evaluates
+	 *	to null, then we consider this as passing the qualification.
+	 *	it seems kind of like, if the qual is NULL, then there's no
+	 *	qual..
+	 * ----------------
+	 */
+	if (isNull)
+		return true;
+
+	/* ----------------
+	 *	remember, we return true when the qualification fails..
+	 * ----------------
+	 */
+	if (DatumGetInt32(expr_value) == 0)
+		return true;
+
+	return false;
 }
 
 /* ----------------------------------------------------------------
- *    	ExecQual
- *    
- *    	Evaluates a conjunctive boolean expression and returns t
- *	iff none of the subexpressions are false (or null).
+ *		ExecQual
+ *
+ *		Evaluates a conjunctive boolean expression and returns t
+ *		iff none of the subexpressions are false (or null).
  * ----------------------------------------------------------------
  */
 bool
-ExecQual(List *qual, ExprContext *econtext)
+ExecQual(List * qual, ExprContext * econtext)
 {
-    List 		*clause;
-    bool 		result;
-    
-    /* ----------------
-     *	debugging stuff
-     * ----------------
-     */
-    EV_printf("ExecQual: qual is ");
-    EV_nodeDisplay(qual);
-    EV_printf("\n");
-    
-    IncrProcessed();
-    
-    /* ----------------
-     *	return true immediately if no qual
-     * ----------------
-     */
-    if (qual == NIL)
-	return true;
-    
-    /* ----------------
-     *  a "qual" is a list of clauses.  To evaluate the
-     *  qual, we evaluate each of the clauses in the list.
-     *
-     *  ExecQualClause returns true when we know the qualification
-     *  *failed* so we just pass each clause in qual to it until
-     *  we know the qual failed or there are no more clauses.
-     * ----------------
-     */
-    result = false;
-    foreach (clause, qual) {
-	result = ExecQualClause((Node *)lfirst(clause), econtext);
+	List		   *clause;
+	bool			result;
+
+	/* ----------------
+	 *	debugging stuff
+	 * ----------------
+	 */
+	EV_printf("ExecQual: qual is ");
+	EV_nodeDisplay(qual);
+	EV_printf("\n");
+
+	IncrProcessed();
+
+	/* ----------------
+	 *	return true immediately if no qual
+	 * ----------------
+	 */
+	if (qual == NIL)
+		return true;
+
+	/* ----------------
+	 *	a "qual" is a list of clauses.	To evaluate the
+	 *	qual, we evaluate each of the clauses in the list.
+	 *
+	 *	ExecQualClause returns true when we know the qualification
+	 *	*failed* so we just pass each clause in qual to it until
+	 *	we know the qual failed or there are no more clauses.
+	 * ----------------
+	 */
+	result = false;
+	foreach(clause, qual)
+	{
+		result = ExecQualClause((Node *) lfirst(clause), econtext);
+		if (result == true)
+			break;
+	}
+
+	/* ----------------
+	 *	if result is true, then it means a clause failed so we
+	 *	return false.  if result is false then it means no clause
+	 *	failed so we return true.
+	 * ----------------
+	 */
 	if (result == true)
-	    break;
-    }
-    
-    /* ----------------
-     *	if result is true, then it means a clause failed so we
-     *  return false.  if result is false then it means no clause
-     *  failed so we return true.
-     * ----------------
-     */
-    if (result == true)
-	return false;
-    
-    return true;
+		return false;
+
+	return true;
 }
 
 int
-ExecTargetListLength(List *targetlist)
+ExecTargetListLength(List * targetlist)
 {
-    int len;
-    List *tl;
-    TargetEntry *curTle;
-    
-    len = 0;
-    foreach (tl, targetlist) {
-	curTle = lfirst(tl);
-	
-	if (curTle->resdom != NULL)
-	    len++;
-	else
-	    len += curTle->fjoin->fj_nNodes;
-    }
-    return len;
+	int				len;
+	List		   *tl;
+	TargetEntry    *curTle;
+
+	len = 0;
+	foreach(tl, targetlist)
+	{
+		curTle = lfirst(tl);
+
+		if (curTle->resdom != NULL)
+			len++;
+		else
+			len += curTle->fjoin->fj_nNodes;
+	}
+	return len;
 }
 
 /* ----------------------------------------------------------------
- *    	ExecTargetList
- *    
- *    	Evaluates a targetlist with respect to the current
- *	expression context and return a tuple.
+ *		ExecTargetList
+ *
+ *		Evaluates a targetlist with respect to the current
+ *		expression context and return a tuple.
  * ----------------------------------------------------------------
  */
-static HeapTuple
-ExecTargetList(List *targetlist,
-	       int nodomains, 
-	       TupleDesc targettype,
-	       Datum *values,
-	       ExprContext *econtext,
-	       bool *isDone)
+static			HeapTuple
+ExecTargetList(List * targetlist,
+			   int nodomains,
+			   TupleDesc targettype,
+			   Datum * values,
+			   ExprContext * econtext,
+			   bool * isDone)
 {
-    char		nulls_array[64];
-    bool		fjNullArray[64];
-    bool		*fjIsNull;
-    char		*null_head;
-    List 		*tl;
-    TargetEntry		*tle;
-    Node 		*expr;
-    Resdom    	  	*resdom;
-    AttrNumber		resind;
-    Datum 		constvalue;
-    HeapTuple 		newTuple;
-    bool 		isNull;
-    
-    /* ----------------
-     *	debugging stuff
-     * ----------------
-     */
-    EV_printf("ExecTargetList: tl is ");
-    EV_nodeDisplay(targetlist);
-    EV_printf("\n");
-    
-    /* ----------------
-     * Return a dummy tuple if the targetlist is empty .
-     * the dummy tuple is necessary to differentiate 
-     * between passing and failing the qualification.
-     * ----------------
-     */
-    if (targetlist == NIL) {
+	char			nulls_array[64];
+	bool			fjNullArray[64];
+	bool		   *fjIsNull;
+	char		   *null_head;
+	List		   *tl;
+	TargetEntry    *tle;
+	Node		   *expr;
+	Resdom		   *resdom;
+	AttrNumber		resind;
+	Datum			constvalue;
+	HeapTuple		newTuple;
+	bool			isNull;
+
 	/* ----------------
-	 *	I now think that the only time this makes
-	 *	any sence is when we run a delete query.  Then
-	 *	we need to return something other than nil
-	 *	so we know to delete the tuple associated
-	 *      with the saved tupleid.. see what ExecutePlan
-	 *      does with the returned tuple.. -cim 9/21/89
-	 *
-	 *      It could also happen in queries like:
-	 *	    retrieve (foo.all) where bar.a = 3
-	 *
-	 *      is this a new phenomenon? it might cause bogus behavior
-	 *      if we try to free this tuple later!! I put a hook in
-	 *      ExecProject to watch out for this case -mer 24 Aug 1992
+	 *	debugging stuff
 	 * ----------------
 	 */
-	CXT1_printf("ExecTargetList: context is %d\n", CurrentMemoryContext);
-	*isDone = true;
-	return (HeapTuple) true;
-    }
-    
-    /* ----------------
-     *  allocate an array of char's to hold the "null" information
-     *  only if we have a really large targetlist.  otherwise we use
-     *  the stack.
-     * ----------------
-     */
-    if (nodomains > 64) {
-        null_head = (char *) palloc(nodomains+1);
-	fjIsNull = (bool *) palloc(nodomains+1);
-    } else {
-	null_head = &nulls_array[0];
-	fjIsNull = &fjNullArray[0];
-    }
-    
-    /* ----------------
-     *	evaluate all the expressions in the target list
-     * ----------------
-     */
-    EV_printf("ExecTargetList: setting target list values\n");
-    
-    *isDone = true;
-    foreach (tl, targetlist) {
+	EV_printf("ExecTargetList: tl is ");
+	EV_nodeDisplay(targetlist);
+	EV_printf("\n");
+
 	/* ----------------
-	 *    remember, a target list is a list of lists:
-	 *
-	 *	((<resdom | fjoin> expr) (<resdom | fjoin> expr) ...)
-	 *
-	 *    tl is a pointer to successive cdr's of the targetlist
-	 *    tle is a pointer to the target list entry in tl
+	 * Return a dummy tuple if the targetlist is empty .
+	 * the dummy tuple is necessary to differentiate
+	 * between passing and failing the qualification.
+	 * ----------------
+	 */
+	if (targetlist == NIL)
+	{
+		/* ----------------
+		 *		I now think that the only time this makes
+		 *		any sence is when we run a delete query.  Then
+		 *		we need to return something other than nil
+		 *		so we know to delete the tuple associated
+		 *		with the saved tupleid.. see what ExecutePlan
+		 *		does with the returned tuple.. -cim 9/21/89
+		 *
+		 *		It could also happen in queries like:
+		 *			retrieve (foo.all) where bar.a = 3
+		 *
+		 *		is this a new phenomenon? it might cause bogus behavior
+		 *		if we try to free this tuple later!! I put a hook in
+		 *		ExecProject to watch out for this case -mer 24 Aug 1992
+		 * ----------------
+		 */
+		CXT1_printf("ExecTargetList: context is %d\n", CurrentMemoryContext);
+		*isDone = true;
+		return (HeapTuple) true;
+	}
+
+	/* ----------------
+	 *	allocate an array of char's to hold the "null" information
+	 *	only if we have a really large targetlist.	otherwise we use
+	 *	the stack.
 	 * ----------------
 	 */
-	tle = lfirst(tl);
-
-	if (tle->resdom != NULL) {
-	    expr       = tle->expr;
-	    resdom     = tle->resdom;
-	    resind     = resdom->resno - 1;
-	    constvalue = (Datum) ExecEvalExpr(expr,
-					      econtext,
-					      &isNull,
-					      isDone);
-	    
-	    if ((IsA(expr,Iter)) && (*isDone))
-		return (HeapTuple)NULL;
-	    
-	    values[resind] = constvalue;
-	    
-	    if (!isNull)
-		null_head[resind] = ' ';
-	    else
-		null_head[resind] = 'n';
-	}else {
-	    int      curNode;
-	    Resdom   *fjRes;
-	    List     *fjTlist   = (List *)tle->expr;
-	    Fjoin    *fjNode    = tle->fjoin;
- 	    int      nNodes    = fjNode->fj_nNodes;
-	    DatumPtr results   = fjNode->fj_results;
-	    
-	    ExecEvalFjoin(tle, econtext, fjIsNull, isDone);
-	    if (*isDone)
-		return (HeapTuple)NULL;
-	    
-	    /*
-	     * get the result from the inner node
-	     */
-	    fjRes = (Resdom *)fjNode->fj_innerNode;
-	    resind = fjRes->resno - 1;
-	    if (fjIsNull[0])
-		null_head[resind] = 'n';
-	    else {
-		null_head[resind] = ' ';
-		values[resind] = results[0];
-	    }
-	    
-	    /*
-	     * Get results from all of the outer nodes
-	     */
-	    for (curNode = 1;
-		 curNode < nNodes;
-		 curNode++, fjTlist = lnext(fjTlist))
+	if (nodomains > 64)
+	{
+		null_head = (char *) palloc(nodomains + 1);
+		fjIsNull = (bool *) palloc(nodomains + 1);
+	}
+	else
+	{
+		null_head = &nulls_array[0];
+		fjIsNull = &fjNullArray[0];
+	}
+
+	/* ----------------
+	 *	evaluate all the expressions in the target list
+	 * ----------------
+	 */
+	EV_printf("ExecTargetList: setting target list values\n");
+
+	*isDone = true;
+	foreach(tl, targetlist)
+	{
+		/* ----------------
+		 *	  remember, a target list is a list of lists:
+		 *
+		 *		((<resdom | fjoin> expr) (<resdom | fjoin> expr) ...)
+		 *
+		 *	  tl is a pointer to successive cdr's of the targetlist
+		 *	  tle is a pointer to the target list entry in tl
+		 * ----------------
+		 */
+		tle = lfirst(tl);
+
+		if (tle->resdom != NULL)
+		{
+			expr = tle->expr;
+			resdom = tle->resdom;
+			resind = resdom->resno - 1;
+			constvalue = (Datum) ExecEvalExpr(expr,
+											  econtext,
+											  &isNull,
+											  isDone);
+
+			if ((IsA(expr, Iter)) && (*isDone))
+				return (HeapTuple) NULL;
+
+			values[resind] = constvalue;
+
+			if (!isNull)
+				null_head[resind] = ' ';
+			else
+				null_head[resind] = 'n';
+		}
+		else
 		{
-#if 0 /* what is this?? */
-		    Node *outernode = lfirst(fjTlist);
-		    fjRes = (Resdom *)outernode->iterexpr;
-#endif		    
-		    resind = fjRes->resno - 1;
-		    if (fjIsNull[curNode]) {
-			null_head[resind] = 'n';
-		    }else {
-			null_head[resind] = ' ';
-			values[resind] = results[curNode];
-		    }
+			int				curNode;
+			Resdom		   *fjRes;
+			List		   *fjTlist = (List *) tle->expr;
+			Fjoin		   *fjNode = tle->fjoin;
+			int				nNodes = fjNode->fj_nNodes;
+			DatumPtr		results = fjNode->fj_results;
+
+			ExecEvalFjoin(tle, econtext, fjIsNull, isDone);
+			if (*isDone)
+				return (HeapTuple) NULL;
+
+			/*
+			 * get the result from the inner node
+			 */
+			fjRes = (Resdom *) fjNode->fj_innerNode;
+			resind = fjRes->resno - 1;
+			if (fjIsNull[0])
+				null_head[resind] = 'n';
+			else
+			{
+				null_head[resind] = ' ';
+				values[resind] = results[0];
+			}
+
+			/*
+			 * Get results from all of the outer nodes
+			 */
+			for (curNode = 1;
+				 curNode < nNodes;
+				 curNode++, fjTlist = lnext(fjTlist))
+			{
+#if 0							/* what is this?? */
+				Node		   *outernode = lfirst(fjTlist);
+
+				fjRes = (Resdom *) outernode->iterexpr;
+#endif
+				resind = fjRes->resno - 1;
+				if (fjIsNull[curNode])
+				{
+					null_head[resind] = 'n';
+				}
+				else
+				{
+					null_head[resind] = ' ';
+					values[resind] = results[curNode];
+				}
+			}
 		}
 	}
-    }
-    
-    /* ----------------
-     * 	form the new result tuple (in the "normal" context)
-     * ----------------
-     */
-    newTuple = (HeapTuple)
-	heap_formtuple(targettype, values, null_head);
-    
-    /* ----------------
-     *	free the nulls array if we allocated one..
-     * ----------------
-     */
-    if (nodomains > 64) pfree(null_head);
-    
-    return
-	newTuple;
+
+	/* ----------------
+	 *	form the new result tuple (in the "normal" context)
+	 * ----------------
+	 */
+	newTuple = (HeapTuple)
+		heap_formtuple(targettype, values, null_head);
+
+	/* ----------------
+	 *	free the nulls array if we allocated one..
+	 * ----------------
+	 */
+	if (nodomains > 64)
+		pfree(null_head);
+
+	return
+		newTuple;
 }
 
 /* ----------------------------------------------------------------
- *    	ExecProject
- *    
- *	projects a tuple based in projection info and stores
- *	it in the specified tuple table slot.
+ *		ExecProject
+ *
+ *		projects a tuple based in projection info and stores
+ *		it in the specified tuple table slot.
  *
- *	Note: someday soon the executor can be extended to eliminate
- *	      redundant projections by storing pointers to datums
- *	      in the tuple table and then passing these around when
- *	      possible.  this should make things much quicker.
- *	      -cim 6/3/91
+ *		Note: someday soon the executor can be extended to eliminate
+ *			  redundant projections by storing pointers to datums
+ *			  in the tuple table and then passing these around when
+ *			  possible.  this should make things much quicker.
+ *			  -cim 6/3/91
  * ----------------------------------------------------------------
  */
 TupleTableSlot *
-ExecProject(ProjectionInfo *projInfo, bool *isDone)
+ExecProject(ProjectionInfo * projInfo, bool * isDone)
 {
-    TupleTableSlot	*slot;
-    List 	 	*targetlist;
-    int 	 	len;
-    TupleDesc	 	tupType;
-    Datum 	 	*tupValue;
-    ExprContext	 	*econtext;
-    HeapTuple		newTuple;
-    
-    /* ----------------
-     *	sanity checks
-     * ----------------
-     */
-    if (projInfo == NULL)
-	return (TupleTableSlot *) NULL;
-
-    /* ----------------
-     *  get the projection info we want
-     * ----------------
-     */
-    slot = 		projInfo->pi_slot;
-    targetlist = 	projInfo->pi_targetlist;
-    len = 		projInfo->pi_len;
-    tupType = 		slot->ttc_tupleDescriptor;
-    
-    tupValue = 		projInfo->pi_tupValue;
-    econtext = 		projInfo->pi_exprContext;
-    
-    if (targetlist == NIL) {
-      *isDone = true;
-      return (TupleTableSlot *) NULL;
-    }
-
-    /* ----------------
-     *  form a new (result) tuple
-     * ----------------
-     */
-    newTuple = ExecTargetList(targetlist,
-			      len,
-			      tupType,
-			      tupValue,
-			      econtext,
-			      isDone);
-    
-    /* ----------------
-     *	store the tuple in the projection slot and return the slot.
-     *
-     *  If there's no projection target list we don't want to pfree
-     *  the bogus tuple that ExecTargetList passes back to us.
-     *       -mer 24 Aug 1992
-     * ----------------
-     */
-    return (TupleTableSlot *)
-	ExecStoreTuple(newTuple, /* tuple to store */
-		       slot,     /* slot to store in */
-		       InvalidBuffer, 	   /* tuple has no buffer */
-		       true);
-}
+	TupleTableSlot *slot;
+	List		   *targetlist;
+	int				len;
+	TupleDesc		tupType;
+	Datum		   *tupValue;
+	ExprContext    *econtext;
+	HeapTuple		newTuple;
+
+	/* ----------------
+	 *	sanity checks
+	 * ----------------
+	 */
+	if (projInfo == NULL)
+		return (TupleTableSlot *) NULL;
 
+	/* ----------------
+	 *	get the projection info we want
+	 * ----------------
+	 */
+	slot = projInfo->pi_slot;
+	targetlist = projInfo->pi_targetlist;
+	len = projInfo->pi_len;
+	tupType = slot->ttc_tupleDescriptor;
+
+	tupValue = projInfo->pi_tupValue;
+	econtext = projInfo->pi_exprContext;
+
+	if (targetlist == NIL)
+	{
+		*isDone = true;
+		return (TupleTableSlot *) NULL;
+	}
+
+	/* ----------------
+	 *	form a new (result) tuple
+	 * ----------------
+	 */
+	newTuple = ExecTargetList(targetlist,
+							  len,
+							  tupType,
+							  tupValue,
+							  econtext,
+							  isDone);
+
+	/* ----------------
+	 *	store the tuple in the projection slot and return the slot.
+	 *
+	 *	If there's no projection target list we don't want to pfree
+	 *	the bogus tuple that ExecTargetList passes back to us.
+	 *		 -mer 24 Aug 1992
+	 * ----------------
+	 */
+	return (TupleTableSlot *)
+		ExecStoreTuple(newTuple,/* tuple to store */
+					   slot,	/* slot to store in */
+					   InvalidBuffer,	/* tuple has no buffer */
+					   true);
+}