analyze.c

/*-------------------------------------------------------------------------
 *
 * analyze.c--
 *	  transform the parse tree into a query tree
 *
 * Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATION
 *	  $Header: /cvsroot/pgsql/src/backend/parser/analyze.c,v 1.39 1997/09/07 04:44:38 momjian Exp $
 *
 *-------------------------------------------------------------------------
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "postgres.h"
#include "nodes/nodes.h"
#include "nodes/params.h"
#include "nodes/primnodes.h"
#include "nodes/parsenodes.h"
#include "nodes/relation.h"
#include "parse.h"				/* for AND, OR, etc. */
#include "catalog/pg_type.h"	/* for INT4OID, etc. */
#include "catalog/pg_proc.h"
#include "utils/elog.h"
#include "utils/builtins.h"		/* namecmp(), textout() */
#include "utils/lsyscache.h"
#include "utils/palloc.h"
#include "utils/mcxt.h"
#include "utils/syscache.h"
#include "utils/acl.h"
#include "parser/parse_query.h"
#include "parser/parse_state.h"
#include "nodes/makefuncs.h"	/* for makeResdom(), etc. */
#include "nodes/nodeFuncs.h"
#include "commands/sequence.h"

#include "optimizer/clauses.h"
#include "access/heapam.h"

#include "miscadmin.h"

#include "port-protos.h"		/* strdup() */

/* convert the parse tree into a query tree */
static Query   *transformStmt(ParseState * pstate, Node * stmt);

static Query   *transformDeleteStmt(ParseState * pstate, DeleteStmt * stmt);
static Query   *transformInsertStmt(ParseState * pstate, AppendStmt * stmt);
static Query   *transformIndexStmt(ParseState * pstate, IndexStmt * stmt);
static Query   *transformExtendStmt(ParseState * pstate, ExtendStmt * stmt);
static Query   *transformRuleStmt(ParseState * query, RuleStmt * stmt);
static Query   *transformSelectStmt(ParseState * pstate, RetrieveStmt * stmt);
static Query   *transformUpdateStmt(ParseState * pstate, ReplaceStmt * stmt);
static Query   *transformCursorStmt(ParseState * pstate, CursorStmt * stmt);
static Node    *handleNestedDots(ParseState * pstate, Attr * attr, int *curr_resno);

#define EXPR_COLUMN_FIRST	 1
#define EXPR_RELATION_FIRST  2
static Node    *transformExpr(ParseState * pstate, Node * expr, int precedence);
static Node    *transformIdent(ParseState * pstate, Node * expr, int precedence);

static void		makeRangeTable(ParseState * pstate, char *relname, List * frmList);
static List    *expandAllTables(ParseState * pstate);
static char    *figureColname(Node * expr, Node * resval);
static List    *makeTargetNames(ParseState * pstate, List * cols);
static List    *transformTargetList(ParseState * pstate, List * targetlist);
static TargetEntry *
make_targetlist_expr(ParseState * pstate,
					 char *colname, Node * expr,
					 List * arrayRef);
static bool		inWhereClause = false;
static Node    *transformWhereClause(ParseState * pstate, Node * a_expr);
static List    *
transformGroupClause(ParseState * pstate, List * grouplist,
					 List * targetlist);
static List    *
transformSortClause(ParseState * pstate,
					List * orderlist, List * targetlist,
					char *uniqueFlag);

static void		parseFromClause(ParseState * pstate, List * frmList);
static Node    *
ParseFunc(ParseState * pstate, char *funcname,
		  List * fargs, int *curr_resno);
static List    *setup_tlist(char *attname, Oid relid);
static List    *setup_base_tlist(Oid typeid);
static void
make_arguments(int nargs, List * fargs, Oid * input_typeids,
			   Oid * function_typeids);
static void		AddAggToParseState(ParseState * pstate, Aggreg * aggreg);
static void		finalizeAggregates(ParseState * pstate, Query * qry);
static void		parseCheckAggregates(ParseState * pstate, Query * qry);
static ParseState *makeParseState(void);

/*****************************************************************************
 *
 *****************************************************************************/

/*
 * makeParseState() --
 *	  allocate and initialize a new ParseState.
 *	the CALLERS is responsible for freeing the ParseState* returned
 *
 */

static ParseState *
makeParseState(void)
{
	ParseState	   *pstate;

	pstate = malloc(sizeof(ParseState));
	pstate->p_last_resno = 1;
	pstate->p_rtable = NIL;
	pstate->p_numAgg = 0;
	pstate->p_aggs = NIL;
	pstate->p_is_insert = false;
	pstate->p_insert_columns = NIL;
	pstate->p_is_update = false;
	pstate->p_is_rule = false;
	pstate->p_target_relation = NULL;
	pstate->p_target_rangetblentry = NULL;

	return (pstate);
}

/*
 * parse_analyze -
 *	  analyze a list of parse trees and transform them if necessary.
 *
 * Returns a list of transformed parse trees. Optimizable statements are
 * all transformed to Query while the rest stays the same.
 *
 * CALLER is responsible for freeing the QueryTreeList* returned
 */
QueryTreeList  *
parse_analyze(List * pl)
{
	QueryTreeList  *result;
	ParseState	   *pstate;
	int				i = 0;

	result = malloc(sizeof(QueryTreeList));
	result->len = length(pl);
	result->qtrees = (Query **) malloc(result->len * sizeof(Query *));

	inWhereClause = false;		/* to avoid nextval(sequence) in WHERE */

	while (pl != NIL)
	{
		pstate = makeParseState();
		result->qtrees[i++] = transformStmt(pstate, lfirst(pl));
		pl = lnext(pl);
		if (pstate->p_target_relation != NULL)
			heap_close(pstate->p_target_relation);
		free(pstate);
	}

	return result;
}

/*
 * transformStmt -
 *	  transform a Parse tree. If it is an optimizable statement, turn it
 *	  into a Query tree.
 */
static Query   *
transformStmt(ParseState * pstate, Node * parseTree)
{
	Query		   *result = NULL;

	switch (nodeTag(parseTree))
	{
		/*------------------------
		 *	Non-optimizable statements
		 *------------------------
		 */
	case T_IndexStmt:
		result = transformIndexStmt(pstate, (IndexStmt *) parseTree);
		break;

	case T_ExtendStmt:
		result = transformExtendStmt(pstate, (ExtendStmt *) parseTree);
		break;

	case T_RuleStmt:
		result = transformRuleStmt(pstate, (RuleStmt *) parseTree);
		break;

	case T_ViewStmt:
		{
			ViewStmt	   *n = (ViewStmt *) parseTree;

			n->query = (Query *) transformStmt(pstate, (Node *) n->query);
			result = makeNode(Query);
			result->commandType = CMD_UTILITY;
			result->utilityStmt = (Node *) n;
		}
		break;

	case T_VacuumStmt:
		{
			MemoryContext	oldcontext;

			/*
			 * make sure that this Query is allocated in TopMemory context
			 * because vacuum spans transactions and we don't want to lose
			 * the vacuum Query due to end-of-transaction free'ing
			 */
			oldcontext = MemoryContextSwitchTo(TopMemoryContext);
			result = makeNode(Query);
			result->commandType = CMD_UTILITY;
			result->utilityStmt = (Node *) parseTree;
			MemoryContextSwitchTo(oldcontext);
			break;

		}
	case T_ExplainStmt:
		{
			ExplainStmt    *n = (ExplainStmt *) parseTree;

			result = makeNode(Query);
			result->commandType = CMD_UTILITY;
			n->query = transformStmt(pstate, (Node *) n->query);
			result->utilityStmt = (Node *) parseTree;
		}
		break;

		/*------------------------
		 *	Optimizable statements
		 *------------------------
		 */
	case T_AppendStmt:
		result = transformInsertStmt(pstate, (AppendStmt *) parseTree);
		break;

	case T_DeleteStmt:
		result = transformDeleteStmt(pstate, (DeleteStmt *) parseTree);
		break;

	case T_ReplaceStmt:
		result = transformUpdateStmt(pstate, (ReplaceStmt *) parseTree);
		break;

	case T_CursorStmt:
		result = transformCursorStmt(pstate, (CursorStmt *) parseTree);
		break;

	case T_RetrieveStmt:
		result = transformSelectStmt(pstate, (RetrieveStmt *) parseTree);
		break;

	default:

		/*
		 * other statments don't require any transformation-- just return
		 * the original parsetree
		 */
		result = makeNode(Query);
		result->commandType = CMD_UTILITY;
		result->utilityStmt = (Node *) parseTree;
		break;
	}
	return result;
}

/*
 * transformDeleteStmt -
 *	  transforms a Delete Statement
 */
static Query   *
transformDeleteStmt(ParseState * pstate, DeleteStmt * stmt)
{
	Query		   *qry = makeNode(Query);

	qry->commandType = CMD_DELETE;

	/* set up a range table */
	makeRangeTable(pstate, stmt->relname, NULL);

	qry->uniqueFlag = NULL;

	/* fix where clause */
	qry->qual = transformWhereClause(pstate, stmt->whereClause);

	qry->rtable = pstate->p_rtable;
	qry->resultRelation = refnameRangeTablePosn(pstate->p_rtable, stmt->relname);

	/* make sure we don't have aggregates in the where clause */
	if (pstate->p_numAgg > 0)
		parseCheckAggregates(pstate, qry);

	return (Query *) qry;
}

/*
 * transformInsertStmt -
 *	  transform an Insert Statement
 */
static Query   *
transformInsertStmt(ParseState * pstate, AppendStmt * stmt)
{
	Query		   *qry = makeNode(Query);		/* make a new query tree */

	qry->commandType = CMD_INSERT;
	pstate->p_is_insert = true;

	/* set up a range table */
	makeRangeTable(pstate, stmt->relname, stmt->fromClause);

	qry->uniqueFlag = NULL;

	/* fix the target list */
	pstate->p_insert_columns = makeTargetNames(pstate, stmt->cols);

	qry->targetList = transformTargetList(pstate, stmt->targetList);

	/* fix where clause */
	qry->qual = transformWhereClause(pstate, stmt->whereClause);

	/* now the range table will not change */
	qry->rtable = pstate->p_rtable;
	qry->resultRelation = refnameRangeTablePosn(pstate->p_rtable, stmt->relname);

	if (pstate->p_numAgg > 0)
		finalizeAggregates(pstate, qry);

	return (Query *) qry;
}

/*
 * transformIndexStmt -
 *	  transforms the qualification of the index statement
 */
static Query   *
transformIndexStmt(ParseState * pstate, IndexStmt * stmt)
{
	Query		   *q;

	q = makeNode(Query);
	q->commandType = CMD_UTILITY;

	/* take care of the where clause */
	stmt->whereClause = transformWhereClause(pstate, stmt->whereClause);
	stmt->rangetable = pstate->p_rtable;

	q->utilityStmt = (Node *) stmt;

	return q;
}

/*
 * transformExtendStmt -
 *	  transform the qualifications of the Extend Index Statement
 *
 */
static Query   *
transformExtendStmt(ParseState * pstate, ExtendStmt * stmt)
{
	Query		   *q;

	q = makeNode(Query);
	q->commandType = CMD_UTILITY;

	/* take care of the where clause */
	stmt->whereClause = transformWhereClause(pstate, stmt->whereClause);
	stmt->rangetable = pstate->p_rtable;

	q->utilityStmt = (Node *) stmt;
	return q;
}

/*
 * transformRuleStmt -
 *	  transform a Create Rule Statement. The actions is a list of parse
 *	  trees which is transformed into a list of query trees.
 */
static Query   *
transformRuleStmt(ParseState * pstate, RuleStmt * stmt)
{
	Query		   *q;
	List		   *actions;

	q = makeNode(Query);
	q->commandType = CMD_UTILITY;

	actions = stmt->actions;

	/*
	 * transform each statment, like parse_analyze()
	 */
	while (actions != NIL)
	{

		/*
		 * NOTE: 'CURRENT' must always have a varno equal to 1 and 'NEW'
		 * equal to 2.
		 */
		addRangeTableEntry(pstate, stmt->object->relname, "*CURRENT*",
						   FALSE, FALSE, NULL);
		addRangeTableEntry(pstate, stmt->object->relname, "*NEW*",
						   FALSE, FALSE, NULL);

		pstate->p_last_resno = 1;
		pstate->p_is_rule = true;		/* for expand all */
		pstate->p_numAgg = 0;
		pstate->p_aggs = NULL;

		lfirst(actions) = transformStmt(pstate, lfirst(actions));
		actions = lnext(actions);
	}

	/* take care of the where clause */
	stmt->whereClause = transformWhereClause(pstate, stmt->whereClause);

	q->utilityStmt = (Node *) stmt;
	return q;
}


/*
 * transformSelectStmt -
 *	  transforms a Select Statement
 *
 */
static Query   *
transformSelectStmt(ParseState * pstate, RetrieveStmt * stmt)
{
	Query		   *qry = makeNode(Query);

	qry->commandType = CMD_SELECT;

	/* set up a range table */
	makeRangeTable(pstate, NULL, stmt->fromClause);

	qry->uniqueFlag = stmt->unique;

	qry->into = stmt->into;
	qry->isPortal = FALSE;

	/* fix the target list */
	qry->targetList = transformTargetList(pstate, stmt->targetList);

	/* fix where clause */
	qry->qual = transformWhereClause(pstate, stmt->whereClause);

	/* check subselect clause */
	if (stmt->selectClause)
		elog(NOTICE, "UNION not yet supported; using first SELECT only", NULL);

	/* check subselect clause */
	if (stmt->havingClause)
		elog(NOTICE, "HAVING not yet supported; ignore clause", NULL);

	/* fix order clause */
	qry->sortClause = transformSortClause(pstate,
										  stmt->sortClause,
										  qry->targetList,
										  qry->uniqueFlag);

	/* fix group by clause */
	qry->groupClause = transformGroupClause(pstate,
											stmt->groupClause,
											qry->targetList);
	qry->rtable = pstate->p_rtable;

	if (pstate->p_numAgg > 0)
		finalizeAggregates(pstate, qry);

	return (Query *) qry;
}

/*
 * transformUpdateStmt -
 *	  transforms an update statement
 *
 */
static Query   *
transformUpdateStmt(ParseState * pstate, ReplaceStmt * stmt)
{
	Query		   *qry = makeNode(Query);

	qry->commandType = CMD_UPDATE;
	pstate->p_is_update = true;

	/*
	 * the FROM clause is non-standard SQL syntax. We used to be able to
	 * do this with REPLACE in POSTQUEL so we keep the feature.
	 */
	makeRangeTable(pstate, stmt->relname, stmt->fromClause);

	/* fix the target list */
	qry->targetList = transformTargetList(pstate, stmt->targetList);

	/* fix where clause */
	qry->qual = transformWhereClause(pstate, stmt->whereClause);

	qry->rtable = pstate->p_rtable;
	qry->resultRelation = refnameRangeTablePosn(pstate->p_rtable, stmt->relname);

	/* make sure we don't have aggregates in the where clause */
	if (pstate->p_numAgg > 0)
		parseCheckAggregates(pstate, qry);

	return (Query *) qry;
}

/*
 * transformCursorStmt -
 *	  transform a Create Cursor Statement
 *
 */
static Query   *
transformCursorStmt(ParseState * pstate, CursorStmt * stmt)
{
	Query		   *qry = makeNode(Query);

	/*
	 * in the old days, a cursor statement is a 'retrieve into portal'; If
	 * you change the following, make sure you also go through the code in
	 * various places that tests the kind of operation.
	 */
	qry->commandType = CMD_SELECT;

	/* set up a range table */
	makeRangeTable(pstate, NULL, stmt->fromClause);

	qry->uniqueFlag = stmt->unique;

	qry->into = stmt->portalname;
	qry->isPortal = TRUE;
	qry->isBinary = stmt->binary;		/* internal portal */

	/* fix the target list */
	qry->targetList = transformTargetList(pstate, stmt->targetList);

	/* fix where clause */
	qry->qual = transformWhereClause(pstate, stmt->whereClause);

	/* fix order clause */
	qry->sortClause = transformSortClause(pstate,
										  stmt->sortClause,
										  qry->targetList,
										  qry->uniqueFlag);
	/* fix group by clause */
	qry->groupClause = transformGroupClause(pstate,
											stmt->groupClause,
											qry->targetList);

	qry->rtable = pstate->p_rtable;

	if (pstate->p_numAgg > 0)
		finalizeAggregates(pstate, qry);

	return (Query *) qry;
}

/*****************************************************************************
 *
 * Transform Exprs, Aggs, etc.
 *
 *****************************************************************************/

/*
 * transformExpr -
 *	  analyze and transform expressions. Type checking and type casting is
 *	  done here. The optimizer and the executor cannot handle the original
 *	  (raw) expressions collected by the parse tree. Hence the transformation
 *	  here.
 */
static Node    *
transformExpr(ParseState * pstate, Node * expr, int precedence)
{
	Node		   *result = NULL;

	if (expr == NULL)
		return NULL;

	switch (nodeTag(expr))
	{
	case T_Attr:
		{
			Attr		   *att = (Attr *) expr;
			Node		   *temp;

			/* what if att.attrs == "*"?? */
			temp = handleNestedDots(pstate, att, &pstate->p_last_resno);
			if (att->indirection != NIL)
			{
				List		   *idx = att->indirection;

				while (idx != NIL)
				{
					A_Indices	   *ai = (A_Indices *) lfirst(idx);
					Node		   *lexpr = NULL,
								   *uexpr;

					uexpr = transformExpr(pstate, ai->uidx, precedence);		/* must exists */
					if (exprType(uexpr) != INT4OID)
						elog(WARN, "array index expressions must be int4's");
					if (ai->lidx != NULL)
					{
						lexpr = transformExpr(pstate, ai->lidx, precedence);
						if (exprType(lexpr) != INT4OID)
							elog(WARN, "array index expressions must be int4's");
					}
#if 0
					pfree(ai->uidx);
					if (ai->lidx != NULL)
						pfree(ai->lidx);
#endif
					ai->lidx = lexpr;
					ai->uidx = uexpr;

					/*
					 * note we reuse the list of indices, make sure we
					 * don't free them! Otherwise, make a new list here
					 */
					idx = lnext(idx);
				}
				result = (Node *) make_array_ref(temp, att->indirection);
			}
			else
			{
				result = temp;
			}
			break;
		}
	case T_A_Const:
		{
			A_Const		   *con = (A_Const *) expr;
			Value		   *val = &con->val;

			if (con->typename != NULL)
			{
				result = parser_typecast(val, con->typename, -1);
			}
			else
			{
				result = (Node *) make_const(val);
			}
			break;
		}
	case T_ParamNo:
		{
			ParamNo		   *pno = (ParamNo *) expr;
			Oid				toid;
			int				paramno;
			Param		   *param;

			paramno = pno->number;
			toid = param_type(paramno);
			if (!OidIsValid(toid))
			{
				elog(WARN, "Parameter '$%d' is out of range",
					 paramno);
			}
			param = makeNode(Param);
			param->paramkind = PARAM_NUM;
			param->paramid = (AttrNumber) paramno;
			param->paramname = "<unnamed>";
			param->paramtype = (Oid) toid;
			param->param_tlist = (List *) NULL;

			result = (Node *) param;
			break;
		}
	case T_A_Expr:
		{
			A_Expr		   *a = (A_Expr *) expr;

			switch (a->oper)
			{
			case OP:
				{
					Node		   *lexpr = transformExpr(pstate, a->lexpr, precedence);
					Node		   *rexpr = transformExpr(pstate, a->rexpr, precedence);

					result = (Node *) make_op(a->opname, lexpr, rexpr);
				}
				break;
			case ISNULL:
				{
					Node		   *lexpr = transformExpr(pstate, a->lexpr, precedence);

					result = ParseFunc(pstate,
									   "nullvalue", lcons(lexpr, NIL),
									   &pstate->p_last_resno);
				}
				break;
			case NOTNULL:
				{
					Node		   *lexpr = transformExpr(pstate, a->lexpr, precedence);

					result = ParseFunc(pstate,
									   "nonnullvalue", lcons(lexpr, NIL),
									   &pstate->p_last_resno);
				}
				break;
			case AND:
				{
					Expr		   *expr = makeNode(Expr);
					Node		   *lexpr = transformExpr(pstate, a->lexpr, precedence);
					Node		   *rexpr = transformExpr(pstate, a->rexpr, precedence);

					if (exprType(lexpr) != BOOLOID)
						elog(WARN,
						  "left-hand side of AND is type '%s', not bool",
							 tname(get_id_type(exprType(lexpr))));
					if (exprType(rexpr) != BOOLOID)
						elog(WARN,
						 "right-hand side of AND is type '%s', not bool",
							 tname(get_id_type(exprType(rexpr))));
					expr->typeOid = BOOLOID;
					expr->opType = AND_EXPR;
					expr->args = makeList(lexpr, rexpr, -1);
					result = (Node *) expr;
				}
				break;
			case OR:
				{
					Expr		   *expr = makeNode(Expr);
					Node		   *lexpr = transformExpr(pstate, a->lexpr, precedence);
					Node		   *rexpr = transformExpr(pstate, a->rexpr, precedence);

					if (exprType(lexpr) != BOOLOID)
						elog(WARN,
						   "left-hand side of OR is type '%s', not bool",
							 tname(get_id_type(exprType(lexpr))));
					if (exprType(rexpr) != BOOLOID)
						elog(WARN,
						  "right-hand side of OR is type '%s', not bool",
							 tname(get_id_type(exprType(rexpr))));
					expr->typeOid = BOOLOID;
					expr->opType = OR_EXPR;
					expr->args = makeList(lexpr, rexpr, -1);
					result = (Node *) expr;
				}
				break;
			case NOT:
				{
					Expr		   *expr = makeNode(Expr);
					Node		   *rexpr = transformExpr(pstate, a->rexpr, precedence);

					if (exprType(rexpr) != BOOLOID)
						elog(WARN,
							 "argument to NOT is type '%s', not bool",
							 tname(get_id_type(exprType(rexpr))));
					expr->typeOid = BOOLOID;
					expr->opType = NOT_EXPR;
					expr->args = makeList(rexpr, -1);
					result = (Node *) expr;
				}
				break;
			}
			break;
		}
	case T_Ident:
		{

			/*
			 * look for a column name or a relation name (the default
			 * behavior)
			 */
			result = transformIdent(pstate, expr, precedence);
			break;
		}
	case T_FuncCall:
		{
			FuncCall	   *fn = (FuncCall *) expr;
			List		   *args;

			/* transform the list of arguments */
			foreach(args, fn->args)
				lfirst(args) = transformExpr(pstate, (Node *) lfirst(args), precedence);
			result = ParseFunc(pstate,
						  fn->funcname, fn->args, &pstate->p_last_resno);
			break;
		}
	default:
		/* should not reach here */
		elog(WARN, "transformExpr: does not know how to transform %d\n",
			 nodeTag(expr));
		break;
	}

	return result;
}

static Node    *
transformIdent(ParseState * pstate, Node * expr, int precedence)
{
	Ident		   *ident = (Ident *) expr;
	RangeTblEntry  *rte;
	Node		   *column_result,
				   *relation_result,
				   *result;

	column_result = relation_result = result = 0;
	/* try to find the ident as a column */
	if ((rte = colnameRangeTableEntry(pstate, ident->name)) != NULL)
	{
		Attr		   *att = makeNode(Attr);

		att->relname = rte->refname;
		att->attrs = lcons(makeString(ident->name), NIL);
		column_result =
			(Node *) handleNestedDots(pstate, att, &pstate->p_last_resno);
	}

	/* try to find the ident as a relation */
	if (refnameRangeTableEntry(pstate->p_rtable, ident->name) != NULL)
	{
		ident->isRel = TRUE;
		relation_result = (Node *) ident;
	}

	/* choose the right result based on the precedence */
	if (precedence == EXPR_COLUMN_FIRST)
	{
		if (column_result)
			result = column_result;
		else
			result = relation_result;
	}
	else
	{
		if (relation_result)
			result = relation_result;
		else
			result = column_result;
	}

	if (result == NULL)
		elog(WARN, "attribute \"%s\" not found", ident->name);

	return result;
}

/*****************************************************************************
 *
 * From Clause
 *
 *****************************************************************************/

/*
 * parseFromClause -
 *	  turns the table references specified in the from-clause into a
 *	  range table. The range table may grow as we transform the expressions
 *	  in the target list. (Note that this happens because in POSTQUEL, we
 *	  allow references to relations not specified in the from-clause. We
 *	  also allow that in our POST-SQL)
 *
 */
static void
parseFromClause(ParseState * pstate, List * frmList)
{
	List		   *fl;

	foreach(fl, frmList)
	{
		RangeVar	   *r = lfirst(fl);
		RelExpr		   *baserel = r->relExpr;
		char		   *relname = baserel->relname;
		char		   *refname = r->name;
		RangeTblEntry  *rte;

		if (refname == NULL)
			refname = relname;

		/*
		 * marks this entry to indicate it comes from the FROM clause. In
		 * SQL, the target list can only refer to range variables
		 * specified in the from clause but we follow the more powerful
		 * POSTQUEL semantics and automatically generate the range
		 * variable if not specified. However there are times we need to
		 * know whether the entries are legitimate.
		 *
		 * eg. select * from foo f where f.x = 1; will generate wrong answer
		 * if we expand * to foo.x.
		 */
		rte = addRangeTableEntry(pstate, relname, refname, baserel->inh, TRUE,
								 baserel->timeRange);
	}
}

/*
 * makeRangeTable -
 *	  make a range table with the specified relation (optional) and the
 *	  from-clause.
 */
static void
makeRangeTable(ParseState * pstate, char *relname, List * frmList)
{
	RangeTblEntry  *rte;

	parseFromClause(pstate, frmList);

	if (relname == NULL)
		return;

	if (refnameRangeTablePosn(pstate->p_rtable, relname) < 1)
		rte = addRangeTableEntry(pstate, relname, relname, FALSE, FALSE, NULL);
	else
		rte = refnameRangeTableEntry(pstate->p_rtable, relname);

	pstate->p_target_rangetblentry = rte;
	Assert(pstate->p_target_relation == NULL);
	pstate->p_target_relation = heap_open(rte->relid);
	Assert(pstate->p_target_relation != NULL);
	/* will close relation later */
}

/*
 *	exprType -
 *	  returns the Oid of the type of the expression. (Used for typechecking.)
 */
Oid
exprType(Node * expr)
{
	Oid				type = (Oid) 0;

	switch (nodeTag(expr))
	{
	case T_Func:
		type = ((Func *) expr)->functype;
		break;
	case T_Iter:
		type = ((Iter *) expr)->itertype;
		break;
	case T_Var:
		type = ((Var *) expr)->vartype;
		break;
	case T_Expr:
		type = ((Expr *) expr)->typeOid;
		break;
	case T_Const:
		type = ((Const *) expr)->consttype;
		break;
	case T_ArrayRef:
		type = ((ArrayRef *) expr)->refelemtype;
		break;
	case T_Aggreg:
		type = ((Aggreg *) expr)->aggtype;
		break;
	case T_Param:
		type = ((Param *) expr)->paramtype;
		break;
	case T_Ident:
		/* is this right? */
		type = UNKNOWNOID;
		break;
	default:
		elog(WARN, "exprType: don't know how to get type for %d node",
			 nodeTag(expr));
		break;
	}
	return type;
}

/*
 * expandAllTables -
 *	  turns '*' (in the target list) into a list of attributes (of all
 *	  relations in the range table)
 */
static List    *
expandAllTables(ParseState * pstate)
{
	List		   *target = NIL;
	List		   *legit_rtable = NIL;
	List		   *rt,
				   *rtable;

	rtable = pstate->p_rtable;
	if (pstate->p_is_rule)
	{

		/*
		 * skip first two entries, "*new*" and "*current*"
		 */
		rtable = lnext(lnext(pstate->p_rtable));
	}

	/* this should not happen */
	if (rtable == NULL)
		elog(WARN, "cannot expand: null p_rtable");

	/*
	 * go through the range table and make a list of range table entries
	 * which we will expand.
	 */
	foreach(rt, rtable)
	{
		RangeTblEntry  *rte = lfirst(rt);

		/*
		 * we only expand those specify in the from clause. (This will
		 * also prevent us from using the wrong table in inserts: eg.
		 * tenk2 in "insert into tenk2 select * from tenk1;")
		 */
		if (!rte->inFromCl)
			continue;
		legit_rtable = lappend(legit_rtable, rte);
	}

	foreach(rt, legit_rtable)
	{
		RangeTblEntry  *rte = lfirst(rt);
		List		   *temp = target;

		if (temp == NIL)
			target = expandAll(pstate, rte->relname, rte->refname,
							   &pstate->p_last_resno);
		else
		{
			while (temp != NIL && lnext(temp) != NIL)
				temp = lnext(temp);
			lnext(temp) = expandAll(pstate, rte->relname, rte->refname,
									&pstate->p_last_resno);
		}
	}
	return target;
}


/*
 * figureColname -
 *	  if the name of the resulting column is not specified in the target
 *	  list, we have to guess.
 *
 */
static char    *
figureColname(Node * expr, Node * resval)
{
	switch (nodeTag(expr))
	{
		case T_Aggreg:
		return (char *)			/* XXX */
		((Aggreg *) expr)->aggname;
	case T_Expr:
		if (((Expr *) expr)->opType == FUNC_EXPR)
		{
			if (nodeTag(resval) == T_FuncCall)
				return ((FuncCall *) resval)->funcname;
		}
		break;
	default:
		break;
	}

	return "?column?";
}

/*****************************************************************************
 *
 * Target list
 *
 *****************************************************************************/

/*
 * makeTargetNames -
 *	  generate a list of column names if not supplied or
 *	  test supplied column names to make sure they are in target table
 *	  (used exclusively for inserts)
 */
static List    *
makeTargetNames(ParseState * pstate, List * cols)
{
	List		   *tl = NULL;

	/* Generate ResTarget if not supplied */

	if (cols == NIL)
	{
		int				numcol;
		int				i;
		AttributeTupleForm *attr = pstate->p_target_relation->rd_att->attrs;

		numcol = pstate->p_target_relation->rd_rel->relnatts;
		for (i = 0; i < numcol; i++)
		{
			Ident		   *id = makeNode(Ident);

			id->name = palloc(NAMEDATALEN);
			strNcpy(id->name, attr[i]->attname.data, NAMEDATALEN - 1);
			id->indirection = NIL;
			id->isRel = false;
			if (tl == NIL)
				cols = tl = lcons(id, NIL);
			else
			{
				lnext(tl) = lcons(id, NIL);
				tl = lnext(tl);
			}
		}
	}
	else
		foreach(tl, cols)
		/* elog on failure */
			varattno(pstate->p_target_relation, ((Ident *) lfirst(tl))->name);

	return cols;
}

/*
 * transformTargetList -
 *	  turns a list of ResTarget's into a list of TargetEntry's
 */
static List    *
transformTargetList(ParseState * pstate, List * targetlist)
{
	List		   *p_target = NIL;
	List		   *tail_p_target = NIL;

	while (targetlist != NIL)
	{
		ResTarget	   *res = (ResTarget *) lfirst(targetlist);
		TargetEntry    *tent = makeNode(TargetEntry);

		switch (nodeTag(res->val))
		{
		case T_Ident:
			{
				Node		   *expr;
				Oid				type_id;
				int				type_len;
				char		   *identname;
				char		   *resname;

				identname = ((Ident *) res->val)->name;
				handleTargetColname(pstate, &res->name, NULL, identname);

				/*
				 * here we want to look for column names only, not
				 * relation
				 */
				/* names (even though they can be stored in Ident nodes,	*/
				/* too)														*/
				expr = transformIdent(pstate, (Node *) res->val, EXPR_COLUMN_FIRST);
				type_id = exprType(expr);
				type_len = tlen(get_id_type(type_id));
				resname = (res->name) ? res->name : identname;
				tent->resdom = makeResdom((AttrNumber) pstate->p_last_resno++,
										  (Oid) type_id,
										  (Size) type_len,
										  resname,
										  (Index) 0,
										  (Oid) 0,
										  0);

				tent->expr = expr;
				break;
			}
		case T_ParamNo:
		case T_FuncCall:
		case T_A_Const:
		case T_A_Expr:
			{
				Node		   *expr = transformExpr(pstate, (Node *) res->val, EXPR_COLUMN_FIRST);

				handleTargetColname(pstate, &res->name, NULL, NULL);
				/* note indirection has not been transformed */
				if (pstate->p_is_insert && res->indirection != NIL)
				{
					/* this is an array assignment */
					char		   *val;
					char		   *str,
								   *save_str;
					List		   *elt;
					int				i = 0,
									ndims;
					int				lindx[MAXDIM],
									uindx[MAXDIM];
					int				resdomno;
					Relation		rd;
					Value		   *constval;

					if (exprType(expr) != UNKNOWNOID ||
						!IsA(expr, Const))
						elog(WARN, "yyparse: string constant expected");

					val = (char *) textout((struct varlena *)
										   ((Const *) expr)->constvalue);
					str = save_str = (char *) palloc(strlen(val) + MAXDIM * 25 + 2);
					foreach(elt, res->indirection)
					{
						A_Indices	   *aind = (A_Indices *) lfirst(elt);

						aind->uidx = transformExpr(pstate, aind->uidx, EXPR_COLUMN_FIRST);
						if (!IsA(aind->uidx, Const))
							elog(WARN,
								 "Array Index for Append should be a constant");
						uindx[i] = ((Const *) aind->uidx)->constvalue;
						if (aind->lidx != NULL)
						{
							aind->lidx = transformExpr(pstate, aind->lidx, EXPR_COLUMN_FIRST);
							if (!IsA(aind->lidx, Const))
								elog(WARN,
									 "Array Index for Append should be a constant");
							lindx[i] = ((Const *) aind->lidx)->constvalue;
						}
						else
						{
							lindx[i] = 1;
						}
						if (lindx[i] > uindx[i])
							elog(WARN, "yyparse: lower index cannot be greater than upper index");
						sprintf(str, "[%d:%d]", lindx[i], uindx[i]);
						str += strlen(str);
						i++;
					}
					sprintf(str, "=%s", val);
					rd = pstate->p_target_relation;
					Assert(rd != NULL);
					resdomno = varattno(rd, res->name);
					ndims = att_attnelems(rd, resdomno);
					if (i != ndims)
						elog(WARN, "yyparse: array dimensions do not match");
					constval = makeNode(Value);
					constval->type = T_String;
					constval->val.str = save_str;
					tent = make_targetlist_expr(pstate, res->name,
										   (Node *) make_const(constval),
												NULL);
					pfree(save_str);
				}
				else
				{
					char		   *colname = res->name;

					/* this is not an array assignment */
					if (colname == NULL)
					{

						/*
						 * if you're wondering why this is here, look at
						 * the yacc grammar for why a name can be missing.
						 * -ay
						 */
						colname = figureColname(expr, res->val);
					}
					if (res->indirection)
					{
						List		   *ilist = res->indirection;

						while (ilist != NIL)
						{
							A_Indices	   *ind = lfirst(ilist);

							ind->lidx = transformExpr(pstate, ind->lidx, EXPR_COLUMN_FIRST);
							ind->uidx = transformExpr(pstate, ind->uidx, EXPR_COLUMN_FIRST);
							ilist = lnext(ilist);
						}
					}
					res->name = colname;
					tent = make_targetlist_expr(pstate, res->name, expr,
												res->indirection);
				}
				break;
			}
		case T_Attr:
			{
				Oid				type_id;
				int				type_len;
				Attr		   *att = (Attr *) res->val;
				Node		   *result;
				char		   *attrname;
				char		   *resname;
				Resdom		   *resnode;
				List		   *attrs = att->attrs;

				/*
				 * Target item is a single '*', expand all tables (eg.
				 * SELECT * FROM emp)
				 */
				if (att->relname != NULL && !strcmp(att->relname, "*"))
				{
					if (tail_p_target == NIL)
						p_target = tail_p_target = expandAllTables(pstate);
					else
						lnext(tail_p_target) = expandAllTables(pstate);

					while (lnext(tail_p_target) != NIL)
						/* make sure we point to the last target entry */
						tail_p_target = lnext(tail_p_target);

					/*
					 * skip rest of while loop
					 */
					targetlist = lnext(targetlist);
					continue;
				}

				/*
				 * Target item is relation.*, expand the table (eg. SELECT
				 * emp.*, dname FROM emp, dept)
				 */
				attrname = strVal(lfirst(att->attrs));
				if (att->attrs != NIL && !strcmp(attrname, "*"))
				{

					/*
					 * tail_p_target is the target list we're building in
					 * the while loop. Make sure we fix it after appending
					 * more nodes.
					 */
					if (tail_p_target == NIL)
						p_target = tail_p_target = expandAll(pstate, att->relname,
									att->relname, &pstate->p_last_resno);
					else
						lnext(tail_p_target) =
							expandAll(pstate, att->relname, att->relname,
									  &pstate->p_last_resno);
					while (lnext(tail_p_target) != NIL)
						/* make sure we point to the last target entry */
						tail_p_target = lnext(tail_p_target);

					/*
					 * skip the rest of the while loop
					 */
					targetlist = lnext(targetlist);
					continue;
				}


				/*
				 * Target item is fully specified: ie. relation.attribute
				 */
				result = handleNestedDots(pstate, att, &pstate->p_last_resno);
				handleTargetColname(pstate, &res->name, att->relname, attrname);
				if (att->indirection != NIL)
				{
					List		   *ilist = att->indirection;

					while (ilist != NIL)
					{
						A_Indices	   *ind = lfirst(ilist);

						ind->lidx = transformExpr(pstate, ind->lidx, EXPR_COLUMN_FIRST);
						ind->uidx = transformExpr(pstate, ind->uidx, EXPR_COLUMN_FIRST);
						ilist = lnext(ilist);
					}
					result = (Node *) make_array_ref(result, att->indirection);
				}
				type_id = exprType(result);
				type_len = tlen(get_id_type(type_id));
				/* move to last entry */
				while (lnext(attrs) != NIL)
					attrs = lnext(attrs);
				resname = (res->name) ? res->name : strVal(lfirst(attrs));
				resnode = makeResdom((AttrNumber) pstate->p_last_resno++,
									 (Oid) type_id,
									 (Size) type_len,
									 resname,
									 (Index) 0,
									 (Oid) 0,
									 0);
				tent->resdom = resnode;
				tent->expr = result;
				break;
			}
		default:
			/* internal error */
			elog(WARN,
			  "internal error: do not know how to transform targetlist");
			break;
		}

		if (p_target == NIL)
		{
			p_target = tail_p_target = lcons(tent, NIL);
		}
		else
		{
			lnext(tail_p_target) = lcons(tent, NIL);
			tail_p_target = lnext(tail_p_target);
		}
		targetlist = lnext(targetlist);
	}

	return p_target;
}


/*
 * make_targetlist_expr -
 *	  make a TargetEntry from an expression
 *
 * arrayRef is a list of transformed A_Indices
 */
static TargetEntry *
make_targetlist_expr(ParseState * pstate,
					 char *colname,
					 Node * expr,
					 List * arrayRef)
{
	Oid				type_id,
					attrtype;
	int				type_len,
					attrlen;
	int				resdomno;
	Relation		rd;
	bool			attrisset;
	TargetEntry    *tent;
	Resdom		   *resnode;

	if (expr == NULL)
		elog(WARN, "make_targetlist_expr: invalid use of NULL expression");

	type_id = exprType(expr);
	if (type_id == InvalidOid)
	{
		type_len = 0;
	}
	else
		type_len = tlen(get_id_type(type_id));

	/* I have no idea what the following does! */
	/* It appears to process target columns that will be receiving results */
	if (pstate->p_is_insert || pstate->p_is_update)
	{

		/*
		 * append or replace query -- append, replace work only on one
		 * relation, so multiple occurence of same resdomno is bogus
		 */
		rd = pstate->p_target_relation;
		Assert(rd != NULL);
		resdomno = varattno(rd, colname);
		attrisset = varisset(rd, colname);
		attrtype = att_typeid(rd, resdomno);
		if ((arrayRef != NIL) && (lfirst(arrayRef) == NIL))
			attrtype = GetArrayElementType(attrtype);
		if (attrtype == BPCHAROID || attrtype == VARCHAROID)
		{
			attrlen = rd->rd_att->attrs[resdomno - 1]->attlen;
		}
		else
		{
			attrlen = tlen(get_id_type(attrtype));
		}
#if 0
		if (Input_is_string && Typecast_ok)
		{
			Datum			val;

			if (type_id == typeid(type("unknown")))
			{
				val = (Datum) textout((struct varlena *)
									  ((Const) lnext(expr))->constvalue);
			}
			else
			{
				val = ((Const) lnext(expr))->constvalue;
			}
			if (attrisset)
			{
				lnext(expr) = makeConst(attrtype,
										attrlen,
										val,
										false,
										true,
										true,	/* is set */
										false);
			}
			else
			{
				lnext(expr) =
					makeConst(attrtype,
							  attrlen,
							  (Datum) fmgr(typeid_get_retinfunc(attrtype),
										 val, get_typelem(attrtype), -1),
							  false,
							  true /* Maybe correct-- 80% chance */ ,
							  false,	/* is not a set */
							  false);
			}
		}
		else if ((Typecast_ok) && (attrtype != type_id))
		{
			lnext(expr) =
				parser_typecast2(expr, get_id_type(attrtype));
		}
		else if (attrtype != type_id)
		{
			if ((attrtype == INT2OID) && (type_id == INT4OID))
				lfirst(expr) = lispInteger(INT2OID);	/* handle CASHOID too */
			else if ((attrtype == FLOAT4OID) && (type_id == FLOAT8OID))
				lfirst(expr) = lispInteger(FLOAT4OID);
			else
				elog(WARN, "unequal type in tlist : %s \n", colname);
		}

		Input_is_string = false;
		Input_is_integer = false;
		Typecast_ok = true;
#endif

		if (attrtype != type_id)
		{
			if (IsA(expr, Const))
			{
				/* try to cast the constant */
				if (arrayRef && !(((A_Indices *) lfirst(arrayRef))->lidx))
				{
					/* updating a single item */
					Oid				typelem = get_typelem(attrtype);

					expr = (Node *) parser_typecast2(expr,
													 type_id,
													 get_id_type(typelem),
													 attrlen);
				}
				else
					expr = (Node *) parser_typecast2(expr,
													 type_id,
												   get_id_type(attrtype),
													 attrlen);
			}
			else
			{
				/* currently, we can't handle casting of expressions */
				elog(WARN, "parser: attribute '%s' is of type '%s' but expression is of type '%s'",
					 colname,
					 get_id_typname(attrtype),
					 get_id_typname(type_id));
			}
		}

		if (arrayRef != NIL)
		{
			Expr		   *target_expr;
			Attr		   *att = makeNode(Attr);
			List		   *ar = arrayRef;
			List		   *upperIndexpr = NIL;
			List		   *lowerIndexpr = NIL;

			att->relname = pstrdup(RelationGetRelationName(rd)->data);
			att->attrs = lcons(makeString(colname), NIL);
			target_expr = (Expr *) handleNestedDots(pstate, att,
												  &pstate->p_last_resno);
			while (ar != NIL)
			{
				A_Indices	   *ind = lfirst(ar);

				if (lowerIndexpr || (!upperIndexpr && ind->lidx))
				{

					/*
					 * XXX assume all lowerIndexpr is non-null in this
					 * case
					 */
					lowerIndexpr = lappend(lowerIndexpr, ind->lidx);
				}
				upperIndexpr = lappend(upperIndexpr, ind->uidx);
				ar = lnext(ar);
			}

			expr = (Node *) make_array_set(target_expr,
										   upperIndexpr,
										   lowerIndexpr,
										   (Expr *) expr);
			attrtype = att_typeid(rd, resdomno);
			attrlen = tlen(get_id_type(attrtype));
		}
	}
	else
	{
		resdomno = pstate->p_last_resno++;
		attrtype = type_id;
		attrlen = type_len;
	}
	tent = makeNode(TargetEntry);

	resnode = makeResdom((AttrNumber) resdomno,
						 (Oid) attrtype,
						 (Size) attrlen,
						 colname,
						 (Index) 0,
						 (Oid) 0,
						 0);

	tent->resdom = resnode;
	tent->expr = expr;

	return tent;
}


/*****************************************************************************
 *
 * Where Clause
 *
 *****************************************************************************/

/*
 * transformWhereClause -
 *	  transforms the qualification and make sure it is of type Boolean
 *
 */
static Node    *
transformWhereClause(ParseState * pstate, Node * a_expr)
{
	Node		   *qual;

	if (a_expr == NULL)
		return (Node *) NULL;	/* no qualifiers */

	inWhereClause = true;
	qual = transformExpr(pstate, a_expr, EXPR_COLUMN_FIRST);
	inWhereClause = false;
	if (exprType(qual) != BOOLOID)
	{
		elog(WARN,
			 "where clause must return type bool, not %s",
			 tname(get_id_type(exprType(qual))));
	}
	return qual;
}

/*****************************************************************************
 *
 * Sort Clause
 *
 *****************************************************************************/

/*
 *	find_targetlist_entry -
 *	  returns the Resdom in the target list matching the specified varname
 *	  and range
 *
 */
static TargetEntry *
find_targetlist_entry(ParseState * pstate, SortGroupBy * sortgroupby, List * tlist)
{
	List		   *i;
	int				real_rtable_pos = 0,
					target_pos = 0;
	TargetEntry    *target_result = NULL;

	if (sortgroupby->range)
		real_rtable_pos = refnameRangeTablePosn(pstate->p_rtable,
												sortgroupby->range);

	foreach(i, tlist)
	{
		TargetEntry    *target = (TargetEntry *) lfirst(i);
		Resdom		   *resnode = target->resdom;
		Var			   *var = (Var *) target->expr;
		char		   *resname = resnode->resname;
		int				test_rtable_pos = var->varno;

#ifdef PARSEDEBUG
		printf("find_targetlist_entry- target name is %s, position %d, resno %d\n",
			   (sortgroupby->name ? sortgroupby->name : "(null)"), target_pos + 1, sortgroupby->resno);
#endif

		if (!sortgroupby->name)
		{
			if (sortgroupby->resno == ++target_pos)
			{
				target_result = target;
				break;
			}
		}
		else
		{
			if (!strcmp(resname, sortgroupby->name))
			{
				if (sortgroupby->range)
				{
					if (real_rtable_pos == test_rtable_pos)
					{
						if (target_result != NULL)
							elog(WARN, "Order/Group By %s is ambiguous", sortgroupby->name);
						else
							target_result = target;
					}
				}
				else
				{
					if (target_result != NULL)
						elog(WARN, "Order/Group By %s is ambiguous", sortgroupby->name);
					else
						target_result = target;
				}
			}
		}
	}
	return target_result;
}

static			Oid
any_ordering_op(int restype)
{
	Operator		order_op;
	Oid				order_opid;

	order_op = oper("<", restype, restype, false);
	order_opid = oprid(order_op);

	return order_opid;
}

/*
 * transformGroupClause -
 *	  transform a Group By clause
 *
 */
static List    *
transformGroupClause(ParseState * pstate, List * grouplist, List * targetlist)
{
	List		   *glist = NIL,
				   *gl = NIL;

	while (grouplist != NIL)
	{
		GroupClause    *grpcl = makeNode(GroupClause);
		TargetEntry    *restarget;
		Resdom		   *resdom;

		restarget = find_targetlist_entry(pstate, lfirst(grouplist), targetlist);

		if (restarget == NULL)
			elog(WARN, "The field being grouped by must appear in the target list");

		grpcl->entry = restarget;
		resdom = restarget->resdom;
		grpcl->grpOpoid = oprid(oper("<",
									 resdom->restype,
									 resdom->restype, false));
		if (glist == NIL)
			gl = glist = lcons(grpcl, NIL);
		else
		{
			lnext(gl) = lcons(grpcl, NIL);
			gl = lnext(gl);
		}
		grouplist = lnext(grouplist);
	}

	return glist;
}

/*
 * transformSortClause -
 *	  transform an Order By clause
 *
 */
static List    *
transformSortClause(ParseState * pstate,
					List * orderlist, List * targetlist,
					char *uniqueFlag)
{
	List		   *sortlist = NIL;
	List		   *s = NIL,
				   *i;

	while (orderlist != NIL)
	{
		SortGroupBy    *sortby = lfirst(orderlist);
		SortClause	   *sortcl = makeNode(SortClause);
		TargetEntry    *restarget;
		Resdom		   *resdom;

		restarget = find_targetlist_entry(pstate, sortby, targetlist);
		if (restarget == NULL)
			elog(WARN, "The field being ordered by must appear in the target list");

		sortcl->resdom = resdom = restarget->resdom;
		sortcl->opoid = oprid(oper(sortby->useOp,
								   resdom->restype,
								   resdom->restype, false));
		if (sortlist == NIL)
		{
			s = sortlist = lcons(sortcl, NIL);
		}
		else
		{
			lnext(s) = lcons(sortcl, NIL);
			s = lnext(s);
		}
		orderlist = lnext(orderlist);
	}

	if (uniqueFlag)
	{
		if (uniqueFlag[0] == '*')
		{

			/*
			 * concatenate all elements from target list that are not
			 * already in the sortby list
			 */
			foreach(i, targetlist)
			{
				TargetEntry    *tlelt = (TargetEntry *) lfirst(i);

				s = sortlist;
				while (s != NIL)
				{
					SortClause	   *sortcl = lfirst(s);

					if (sortcl->resdom == tlelt->resdom)
						break;
					s = lnext(s);
				}
				if (s == NIL)
				{
					/* not a member of the sortclauses yet */
					SortClause	   *sortcl = makeNode(SortClause);

					sortcl->resdom = tlelt->resdom;
					sortcl->opoid = any_ordering_op(tlelt->resdom->restype);

					sortlist = lappend(sortlist, sortcl);
				}
			}
		}
		else
		{
			TargetEntry    *tlelt = NULL;
			char		   *uniqueAttrName = uniqueFlag;

			/* only create sort clause with the specified unique attribute */
			foreach(i, targetlist)
			{
				tlelt = (TargetEntry *) lfirst(i);
				if (strcmp(tlelt->resdom->resname, uniqueAttrName) == 0)
					break;
			}
			if (i == NIL)
			{
				elog(WARN, "The field specified in the UNIQUE ON clause is not in the targetlist");
			}
			s = sortlist;
			foreach(s, sortlist)
			{
				SortClause	   *sortcl = lfirst(s);

				if (sortcl->resdom == tlelt->resdom)
					break;
			}
			if (s == NIL)
			{
				/* not a member of the sortclauses yet */
				SortClause	   *sortcl = makeNode(SortClause);

				sortcl->resdom = tlelt->resdom;
				sortcl->opoid = any_ordering_op(tlelt->resdom->restype);

				sortlist = lappend(sortlist, sortcl);
			}
		}

	}

	return sortlist;
}

/*
 ** HandleNestedDots --
 **    Given a nested dot expression (i.e. (relation func ... attr), build up
 ** a tree with of Iter and Func nodes.
 */
static Node    *
handleNestedDots(ParseState * pstate, Attr * attr, int *curr_resno)
{
	List		   *mutator_iter;
	Node		   *retval = NULL;

	if (attr->paramNo != NULL)
	{
		Param		   *param = (Param *) transformExpr(pstate, (Node *) attr->paramNo, EXPR_RELATION_FIRST);

		retval =
			ParseFunc(pstate, strVal(lfirst(attr->attrs)),
					  lcons(param, NIL),
					  curr_resno);
	}
	else
	{
		Ident		   *ident = makeNode(Ident);

		ident->name = attr->relname;
		ident->isRel = TRUE;
		retval =
			ParseFunc(pstate, strVal(lfirst(attr->attrs)),
					  lcons(ident, NIL),
					  curr_resno);
	}

	foreach(mutator_iter, lnext(attr->attrs))
	{
		retval = ParseFunc(pstate, strVal(lfirst(mutator_iter)),
						   lcons(retval, NIL),
						   curr_resno);
	}

	return (retval);
}

/*
 ** make_arguments --
 **   Given the number and types of arguments to a function, and the
 **   actual arguments and argument types, do the necessary typecasting.
 */
static void
make_arguments(int nargs,
			   List * fargs,
			   Oid * input_typeids,
			   Oid * function_typeids)
{

	/*
	 * there are two ways an input typeid can differ from a function
	 * typeid : either the input type inherits the function type, so no
	 * typecasting is necessary, or the input type can be typecast into
	 * the function type. right now, we only typecast unknowns, and that
	 * is all we check for.
	 */

	List		   *current_fargs;
	int				i;

	for (i = 0, current_fargs = fargs;
		 i < nargs;
		 i++, current_fargs = lnext(current_fargs))
	{

		if (input_typeids[i] == UNKNOWNOID && function_typeids[i] != InvalidOid)
		{
			lfirst(current_fargs) =
				parser_typecast2(lfirst(current_fargs),
								 input_typeids[i],
								 get_id_type(function_typeids[i]),
								 -1);
		}
	}
}

/*
 ** setup_tlist --
 **		Build a tlist that says which attribute to project to.
 **		This routine is called by ParseFunc() to set up a target list
 **		on a tuple parameter or return value.  Due to a bug in 4.0,
 **		it's not possible to refer to system attributes in this case.
 */
static List    *
setup_tlist(char *attname, Oid relid)
{
	TargetEntry    *tle;
	Resdom		   *resnode;
	Var			   *varnode;
	Oid				typeid;
	int				attno;

	attno = get_attnum(relid, attname);
	if (attno < 0)
		elog(WARN, "cannot reference attribute %s of tuple params/return values for functions", attname);

	typeid = find_atttype(relid, attname);
	resnode = makeResdom(1,
						 typeid,
						 tlen(get_id_type(typeid)),
						 get_attname(relid, attno),
						 0,
						 (Oid) 0,
						 0);
	varnode = makeVar(-1, attno, typeid, -1, attno);

	tle = makeNode(TargetEntry);
	tle->resdom = resnode;
	tle->expr = (Node *) varnode;
	return (lcons(tle, NIL));
}

/*
 ** setup_base_tlist --
 **		Build a tlist that extracts a base type from the tuple
 **		returned by the executor.
 */
static List    *
setup_base_tlist(Oid typeid)
{
	TargetEntry    *tle;
	Resdom		   *resnode;
	Var			   *varnode;

	resnode = makeResdom(1,
						 typeid,
						 tlen(get_id_type(typeid)),
						 "<noname>",
						 0,
						 (Oid) 0,
						 0);
	varnode = makeVar(-1, 1, typeid, -1, 1);
	tle = makeNode(TargetEntry);
	tle->resdom = resnode;
	tle->expr = (Node *) varnode;

	return (lcons(tle, NIL));
}

/*
 * ParseComplexProjection -
 *	  handles function calls with a single argument that is of complex type.
 *	  This routine returns NULL if it can't handle the projection (eg. sets).
 */
static Node    *
ParseComplexProjection(ParseState * pstate,
					   char *funcname,
					   Node * first_arg,
					   bool * attisset)
{
	Oid				argtype;
	Oid				argrelid;
	Name			relname;
	Relation		rd;
	Oid				relid;
	int				attnum;

	switch (nodeTag(first_arg))
	{
	case T_Iter:
		{
			Func		   *func;
			Iter		   *iter;

			iter = (Iter *) first_arg;
			func = (Func *) ((Expr *) iter->iterexpr)->oper;
			argtype = funcid_get_rettype(func->funcid);
			argrelid = typeid_get_relid(argtype);
			if (argrelid &&
				((attnum = get_attnum(argrelid, funcname))
				 != InvalidAttrNumber))
			{

				/*
				 * the argument is a function returning a tuple, so
				 * funcname may be a projection
				 */

				/* add a tlist to the func node and return the Iter */
				rd = heap_openr(tname(get_id_type(argtype)));
				if (RelationIsValid(rd))
				{
					relid = RelationGetRelationId(rd);
					relname = RelationGetRelationName(rd);
					heap_close(rd);
				}
				if (RelationIsValid(rd))
				{
					func->func_tlist =
						setup_tlist(funcname, argrelid);
					iter->itertype = att_typeid(rd, attnum);
					return ((Node *) iter);
				}
				else
				{
					elog(WARN,
						 "Function %s has bad returntype %d",
						 funcname, argtype);
				}
			}
			else
			{
				/* drop through */
				;
			}
			break;
		}
	case T_Var:
		{

			/*
			 * The argument is a set, so this is either a projection or a
			 * function call on this set.
			 */
			*attisset = true;
			break;
		}
	case T_Expr:
		{
			Expr		   *expr = (Expr *) first_arg;
			Func		   *funcnode;

			if (expr->opType != FUNC_EXPR)
				break;

			funcnode = (Func *) expr->oper;
			argtype = funcid_get_rettype(funcnode->funcid);
			argrelid = typeid_get_relid(argtype);

			/*
			 * the argument is a function returning a tuple, so funcname
			 * may be a projection
			 */
			if (argrelid &&
				(attnum = get_attnum(argrelid, funcname))
				!= InvalidAttrNumber)
			{

				/* add a tlist to the func node */
				rd = heap_openr(tname(get_id_type(argtype)));
				if (RelationIsValid(rd))
				{
					relid = RelationGetRelationId(rd);
					relname = RelationGetRelationName(rd);
					heap_close(rd);
				}
				if (RelationIsValid(rd))
				{
					Expr		   *newexpr;

					funcnode->func_tlist =
						setup_tlist(funcname, argrelid);
					funcnode->functype = att_typeid(rd, attnum);

					newexpr = makeNode(Expr);
					newexpr->typeOid = funcnode->functype;
					newexpr->opType = FUNC_EXPR;
					newexpr->oper = (Node *) funcnode;
					newexpr->args = lcons(first_arg, NIL);

					return ((Node *) newexpr);
				}

			}

			elog(WARN, "Function %s has bad returntype %d",
				 funcname, argtype);
			break;
		}
	case T_Param:
		{
			Param		   *param = (Param *) first_arg;

			/*
			 * If the Param is a complex type, this could be a projection
			 */
			rd = heap_openr(tname(get_id_type(param->paramtype)));
			if (RelationIsValid(rd))
			{
				relid = RelationGetRelationId(rd);
				relname = RelationGetRelationName(rd);
				heap_close(rd);
			}
			if (RelationIsValid(rd) &&
				(attnum = get_attnum(relid, funcname))
				!= InvalidAttrNumber)
			{

				param->paramtype = att_typeid(rd, attnum);
				param->param_tlist = setup_tlist(funcname, relid);
				return ((Node *) param);
			}
			break;
		}
	default:
		break;
	}

	return NULL;
}

static Node    *
ParseFunc(ParseState * pstate, char *funcname, List * fargs, int *curr_resno)
{
	Oid				rettype = (Oid) 0;
	Oid				argrelid = (Oid) 0;
	Oid				funcid = (Oid) 0;
	List		   *i = NIL;
	Node		   *first_arg = NULL;
	char		   *relname = NULL;
	char		   *refname = NULL;
	Relation		rd;
	Oid				relid;
	int				nargs;
	Func		   *funcnode;
	Oid				oid_array[8];
	Oid			   *true_oid_array;
	Node		   *retval;
	bool			retset;
	bool			exists;
	bool			attisset = false;
	Oid				toid = (Oid) 0;
	Expr		   *expr;

	if (fargs)
	{
		first_arg = lfirst(fargs);
		if (first_arg == NULL)
			elog(WARN, "function %s does not allow NULL input", funcname);
	}

	/*
	 * * check for projection methods: if function takes one argument, and *
	 * that argument is a relation, param, or PQ function returning a
	 * complex * type, then the function could be a projection.
	 */
	if (length(fargs) == 1)
	{

		if (nodeTag(first_arg) == T_Ident && ((Ident *) first_arg)->isRel)
		{
			RangeTblEntry  *rte;
			Ident		   *ident = (Ident *) first_arg;

			/*
			 * first arg is a relation. This could be a projection.
			 */
			refname = ident->name;

			rte = refnameRangeTableEntry(pstate->p_rtable, refname);
			if (rte == NULL)
				rte = addRangeTableEntry(pstate, refname, refname, FALSE, FALSE, NULL);

			relname = rte->relname;
			relid = rte->relid;

			/*
			 * If the attr isn't a set, just make a var for it.  If it is
			 * a set, treat it like a function and drop through.
			 */
			if (get_attnum(relid, funcname) != InvalidAttrNumber)
			{
				Oid				dummyTypeId;

				return
					((Node *) make_var(pstate,
									   refname,
									   funcname,
									   &dummyTypeId));
			}
			else
			{
				/* drop through - attr is a set */
				;
			}
		}
		else if (ISCOMPLEX(exprType(first_arg)))
		{

			/*
			 * Attempt to handle projection of a complex argument. If
			 * ParseComplexProjection can't handle the projection, we have
			 * to keep going.
			 */
			retval = ParseComplexProjection(pstate,
											funcname,
											first_arg,
											&attisset);
			if (attisset)
			{
				toid = exprType(first_arg);
				rd = heap_openr(tname(get_id_type(toid)));
				if (RelationIsValid(rd))
				{
					relname = RelationGetRelationName(rd)->data;
					heap_close(rd);
				}
				else
					elog(WARN,
						 "Type %s is not a relation type",
						 tname(get_id_type(toid)));
				argrelid = typeid_get_relid(toid);

				/*
				 * A projection contains either an attribute name or the
				 * "*".
				 */
				if ((get_attnum(argrelid, funcname) == InvalidAttrNumber)
					&& strcmp(funcname, "*"))
				{
					elog(WARN, "Functions on sets are not yet supported");
				}
			}

			if (retval)
				return retval;
		}
		else
		{

			/*
			 * Parsing aggregates.
			 */
			Oid				basetype;

			/*
			 * the aggregate count is a special case, ignore its base
			 * type.  Treat it as zero
			 */
			if (strcmp(funcname, "count") == 0)
				basetype = 0;
			else
				basetype = exprType(lfirst(fargs));
			if (SearchSysCacheTuple(AGGNAME,
									PointerGetDatum(funcname),
									ObjectIdGetDatum(basetype),
									0, 0))
			{
				Aggreg		   *aggreg = ParseAgg(funcname, basetype, lfirst(fargs));

				AddAggToParseState(pstate, aggreg);
				return (Node *) aggreg;
			}
		}
	}


	/*
	 * * If we dropped through to here it's really a function (or a set,
	 * which * is implemented as a function.) * extract arg type info and
	 * transform relation name arguments into * varnodes of the
	 * appropriate form.
	 */
	memset(&oid_array[0], 0, 8 * sizeof(Oid));

	nargs = 0;
	foreach(i, fargs)
	{
		int				vnum;
		RangeTblEntry  *rte;
		Node		   *pair = lfirst(i);

		if (nodeTag(pair) == T_Ident && ((Ident *) pair)->isRel)
		{

			/*
			 * a relation
			 */
			refname = ((Ident *) pair)->name;

			rte = refnameRangeTableEntry(pstate->p_rtable, refname);
			if (rte == NULL)
				rte = addRangeTableEntry(pstate, refname, refname,
										 FALSE, FALSE, NULL);
			relname = rte->relname;

			vnum = refnameRangeTablePosn(pstate->p_rtable, rte->refname);

			/*
			 * for func(relname), the param to the function is the tuple
			 * under consideration.  we build a special VarNode to reflect
			 * this -- it has varno set to the correct range table entry,
			 * but has varattno == 0 to signal that the whole tuple is the
			 * argument.
			 */
			toid = typeid(type(relname));
			/* replace it in the arg list */
			lfirst(fargs) =
				makeVar(vnum, 0, toid, vnum, 0);
		}
		else if (!attisset)
		{						/* set functions don't have parameters */

			/*
			 * any functiona args which are typed "unknown", but aren't
			 * constants, we don't know what to do with, because we can't
			 * cast them	- jolly
			 */
			if (exprType(pair) == UNKNOWNOID &&
				!IsA(pair, Const))
			{
				elog(WARN, "ParseFunc: no function named %s that takes in an unknown type as argument #%d", funcname, nargs);
			}
			else
				toid = exprType(pair);
		}

		oid_array[nargs++] = toid;
	}

	/*
	 * func_get_detail looks up the function in the catalogs, does
	 * disambiguation for polymorphic functions, handles inheritance, and
	 * returns the funcid and type and set or singleton status of the
	 * function's return value.  it also returns the true argument types
	 * to the function.  if func_get_detail returns true, the function
	 * exists.	otherwise, there was an error.
	 */
	if (attisset)
	{							/* we know all of these fields already */

		/*
		 * We create a funcnode with a placeholder function SetEval.
		 * SetEval() never actually gets executed.	When the function
		 * evaluation routines see it, they use the funcid projected out
		 * from the relation as the actual function to call. Example:
		 * retrieve (emp.mgr.name) The plan for this will scan the emp
		 * relation, projecting out the mgr attribute, which is a funcid.
		 * This function is then called (instead of SetEval) and "name" is
		 * projected from its result.
		 */
		funcid = SetEvalRegProcedure;
		rettype = toid;
		retset = true;
		true_oid_array = oid_array;
		exists = true;
	}
	else
	{
		exists = func_get_detail(funcname, nargs, oid_array, &funcid,
								 &rettype, &retset, &true_oid_array);
	}

	if (!exists)
		elog(WARN, "no such attribute or function %s", funcname);

	/* got it */
	funcnode = makeNode(Func);
	funcnode->funcid = funcid;
	funcnode->functype = rettype;
	funcnode->funcisindex = false;
	funcnode->funcsize = 0;
	funcnode->func_fcache = NULL;
	funcnode->func_tlist = NIL;
	funcnode->func_planlist = NIL;

	/* perform the necessary typecasting */
	make_arguments(nargs, fargs, oid_array, true_oid_array);

	/*
	 * for functions returning base types, we want to project out the
	 * return value.  set up a target list to do that.	the executor will
	 * ignore these for c functions, and do the right thing for postquel
	 * functions.
	 */

	if (typeid_get_relid(rettype) == InvalidOid)
		funcnode->func_tlist = setup_base_tlist(rettype);

	/*
	 * For sets, we want to make a targetlist to project out this
	 * attribute of the set tuples.
	 */
	if (attisset)
	{
		if (!strcmp(funcname, "*"))
		{
			funcnode->func_tlist =
				expandAll(pstate, relname, refname, curr_resno);
		}
		else
		{
			funcnode->func_tlist = setup_tlist(funcname, argrelid);
			rettype = find_atttype(argrelid, funcname);
		}
	}

	/*
	 * Sequence handling.
	 */
	if (funcid == SeqNextValueRegProcedure ||
		funcid == SeqCurrValueRegProcedure)
	{
		Const		   *seq;
		char		   *seqrel;
		int32			aclcheck_result = -1;

		Assert(length(fargs) == 1);
		seq = (Const *) lfirst(fargs);
		if (!IsA((Node *) seq, Const))
			elog(WARN, "%s: only constant sequence names are acceptable", funcname);
		seqrel = textout((struct varlena *) (seq->constvalue));

		if ((aclcheck_result = pg_aclcheck(seqrel, GetPgUserName(),
			   ((funcid == SeqNextValueRegProcedure) ? ACL_WR : ACL_RD)))
			!= ACLCHECK_OK)
			elog(WARN, "%s.%s: %s",
			  seqrel, funcname, aclcheck_error_strings[aclcheck_result]);

		pfree(seqrel);

		if (funcid == SeqNextValueRegProcedure && inWhereClause)
			elog(WARN, "nextval of a sequence in WHERE disallowed");
	}

	expr = makeNode(Expr);
	expr->typeOid = rettype;
	expr->opType = FUNC_EXPR;
	expr->oper = (Node *) funcnode;
	expr->args = fargs;
	retval = (Node *) expr;

	/*
	 * if the function returns a set of values, then we need to iterate
	 * over all the returned values in the executor, so we stick an iter
	 * node here.  if it returns a singleton, then we don't need the iter
	 * node.
	 */

	if (retset)
	{
		Iter		   *iter = makeNode(Iter);

		iter->itertype = rettype;
		iter->iterexpr = retval;
		retval = (Node *) iter;
	}

	return (retval);
}

/*****************************************************************************
 *
 *****************************************************************************/

/*
 * AddAggToParseState -
 *	  add the aggregate to the list of unique aggregates in pstate.
 *
 * SIDE EFFECT: aggno in target list entry will be modified
 */
static void
AddAggToParseState(ParseState * pstate, Aggreg * aggreg)
{
	List		   *ag;
	int				i;

	/*
	 * see if we have the aggregate already (we only need to record the
	 * aggregate once)
	 */
	i = 0;
	foreach(ag, pstate->p_aggs)
	{
		Aggreg		   *a = lfirst(ag);

		if (!strcmp(a->aggname, aggreg->aggname) &&
			equal(a->target, aggreg->target))
		{

			/* fill in the aggno and we're done */
			aggreg->aggno = i;
			return;
		}
		i++;
	}

	/* not found, new aggregate */
	aggreg->aggno = i;
	pstate->p_numAgg++;
	pstate->p_aggs = lappend(pstate->p_aggs, aggreg);
	return;
}

/*
 * finalizeAggregates -
 *	  fill in qry_aggs from pstate. Also checks to make sure that aggregates
 *	  are used in the proper place.
 */
static void
finalizeAggregates(ParseState * pstate, Query * qry)
{
	List		   *l;
	int				i;

	parseCheckAggregates(pstate, qry);

	qry->qry_numAgg = pstate->p_numAgg;
	qry->qry_aggs =
		(Aggreg **) palloc(sizeof(Aggreg *) * qry->qry_numAgg);
	i = 0;
	foreach(l, pstate->p_aggs)
		qry->qry_aggs[i++] = (Aggreg *) lfirst(l);
}

/*
 * contain_agg_clause--
 *	  Recursively find aggreg nodes from a clause.
 *
 *	  Returns true if any aggregate found.
 */
static			bool
contain_agg_clause(Node * clause)
{
	if (clause == NULL)
		return FALSE;
	else if (IsA(clause, Aggreg))
		return TRUE;
	else if (IsA(clause, Iter))
		return contain_agg_clause(((Iter *) clause)->iterexpr);
	else if (single_node(clause))
		return FALSE;
	else if (or_clause(clause))
	{
		List		   *temp;

		foreach(temp, ((Expr *) clause)->args)
			if (contain_agg_clause(lfirst(temp)))
			return TRUE;
		return FALSE;
	}
	else if (is_funcclause(clause))
	{
		List		   *temp;

		foreach(temp, ((Expr *) clause)->args)
			if (contain_agg_clause(lfirst(temp)))
			return TRUE;
		return FALSE;
	}
	else if (IsA(clause, ArrayRef))
	{
		List		   *temp;

		foreach(temp, ((ArrayRef *) clause)->refupperindexpr)
			if (contain_agg_clause(lfirst(temp)))
			return TRUE;
		foreach(temp, ((ArrayRef *) clause)->reflowerindexpr)
			if (contain_agg_clause(lfirst(temp)))
			return TRUE;
		if (contain_agg_clause(((ArrayRef *) clause)->refexpr))
			return TRUE;
		if (contain_agg_clause(((ArrayRef *) clause)->refassgnexpr))
			return TRUE;
		return FALSE;
	}
	else if (not_clause(clause))
		return contain_agg_clause((Node *) get_notclausearg((Expr *) clause));
	else if (is_opclause(clause))
		return (contain_agg_clause((Node *) get_leftop((Expr *) clause)) ||
			  contain_agg_clause((Node *) get_rightop((Expr *) clause)));

	return FALSE;
}

/*
 * exprIsAggOrGroupCol -
 *	  returns true if the expression does not contain non-group columns.
 */
static			bool
exprIsAggOrGroupCol(Node * expr, List * groupClause)
{
	List		   *gl;

	if (expr == NULL || IsA(expr, Const) ||
		IsA(expr, Param) || IsA(expr, Aggreg))
		return TRUE;

	foreach(gl, groupClause)
	{
		GroupClause    *grpcl = lfirst(gl);

		if (equal(expr, grpcl->entry->expr))
			return TRUE;
	}

	if (IsA(expr, Expr))
	{
		List		   *temp;

		foreach(temp, ((Expr *) expr)->args)
			if (!exprIsAggOrGroupCol(lfirst(temp), groupClause))
			return FALSE;
		return TRUE;
	}

	return FALSE;
}

/*
 * tleIsAggOrGroupCol -
 *	  returns true if the TargetEntry is Agg or GroupCol.
 */
static			bool
tleIsAggOrGroupCol(TargetEntry * tle, List * groupClause)
{
	Node		   *expr = tle->expr;
	List		   *gl;

	if (expr == NULL || IsA(expr, Const) || IsA(expr, Param))
		return TRUE;

	foreach(gl, groupClause)
	{
		GroupClause    *grpcl = lfirst(gl);

		if (tle->resdom->resno == grpcl->entry->resdom->resno)
		{
			if (contain_agg_clause((Node *) expr))
				elog(WARN, "parser: aggregates not allowed in GROUP BY clause");
			return TRUE;
		}
	}

	if (IsA(expr, Aggreg))
		return TRUE;

	if (IsA(expr, Expr))
	{
		List		   *temp;

		foreach(temp, ((Expr *) expr)->args)
			if (!exprIsAggOrGroupCol(lfirst(temp), groupClause))
			return FALSE;
		return TRUE;
	}

	return FALSE;
}

/*
 * parseCheckAggregates -
 *	  this should really be done earlier but the current grammar
 *	  cannot differentiate functions from aggregates. So we have do check
 *	  here when the target list and the qualifications are finalized.
 */
static void
parseCheckAggregates(ParseState * pstate, Query * qry)
{
	List		   *tl;

	Assert(pstate->p_numAgg > 0);

	/*
	 * aggregates never appear in WHERE clauses. (we have to check where
	 * clause first because if there is an aggregate, the check for
	 * non-group column in target list may fail.)
	 */
	if (contain_agg_clause(qry->qual))
		elog(WARN, "parser: aggregates not allowed in WHERE clause");

	/*
	 * the target list can only contain aggregates, group columns and
	 * functions thereof.
	 */
	foreach(tl, qry->targetList)
	{
		TargetEntry    *tle = lfirst(tl);

		if (!tleIsAggOrGroupCol(tle, qry->groupClause))
			elog(WARN,
				 "parser: illegal use of aggregates or non-group column in target list");
	}

	/*
	 * the expression specified in the HAVING clause has the same
	 * restriction as those in the target list.
	 */
/*
 * Need to change here when we get HAVING works. Currently
 * qry->havingQual is NULL.		- vadim 04/05/97
	if (!exprIsAggOrGroupCol(qry->havingQual, qry->groupClause))
		elog(WARN,
			 "parser: illegal use of aggregates or non-group column in HAVING clause");
 */
	return;
}