*** src/backend/parser/analyze.c.orig	Fri Jun  6 11:04:02 2003
--- src/backend/parser/analyze.c	Sun Jun 15 12:05:34 2003
***************
*** 1787,1799 ****
  	 */
  	qry->havingQual = transformWhereClause(pstate, stmt->havingClause);
  
! 	qry->groupClause = transformGroupClause(pstate,
! 											stmt->groupClause,
! 											qry->targetList);
! 
  	qry->sortClause = transformSortClause(pstate,
  										  stmt->sortClause,
  										  qry->targetList);
  
  	qry->distinctClause = transformDistinctClause(pstate,
  												  stmt->distinctClause,
--- 1787,1804 ----
  	 */
  	qry->havingQual = transformWhereClause(pstate, stmt->havingClause);
  
! 	/*
! 	 * Transform sorting/grouping stuff.  Do ORDER BY first because both
! 	 * transformGroupClause and transformDistinctClause need the results.
! 	 */
  	qry->sortClause = transformSortClause(pstate,
  										  stmt->sortClause,
  										  qry->targetList);
+ 
+ 	qry->groupClause = transformGroupClause(pstate,
+ 											stmt->groupClause,
+ 											qry->targetList,
+ 											qry->sortClause);
  
  	qry->distinctClause = transformDistinctClause(pstate,
  												  stmt->distinctClause,
*** src/backend/parser/parse_clause.c.orig	Fri Jun  6 11:04:02 2003
--- src/backend/parser/parse_clause.c	Sun Jun 15 12:19:14 2003
***************
*** 1124,1130 ****
   *	  transform a GROUP BY clause
   */
  List *
! transformGroupClause(ParseState *pstate, List *grouplist, List *targetlist)
  {
  	List	   *glist = NIL,
  			   *gl;
--- 1124,1131 ----
   *	  transform a GROUP BY clause
   */
  List *
! transformGroupClause(ParseState *pstate, List *grouplist,
! 					 List *targetlist, List *sortClause)
  {
  	List	   *glist = NIL,
  			   *gl;
***************
*** 1132,1152 ****
  	foreach(gl, grouplist)
  	{
  		TargetEntry *tle;
  
  		tle = findTargetlistEntry(pstate, lfirst(gl),
  								  targetlist, GROUP_CLAUSE);
  
  		/* avoid making duplicate grouplist entries */
! 		if (!targetIsInSortList(tle, glist))
! 		{
! 			GroupClause *grpcl = makeNode(GroupClause);
! 
! 			grpcl->tleSortGroupRef = assignSortGroupRef(tle, targetlist);
  
! 			grpcl->sortop = ordering_oper_opid(tle->resdom->restype);
! 
! 			glist = lappend(glist, grpcl);
  		}
  	}
  
  	return glist;
--- 1133,1173 ----
  	foreach(gl, grouplist)
  	{
  		TargetEntry *tle;
+ 		Oid			ordering_op;
+ 		GroupClause *grpcl;
  
  		tle = findTargetlistEntry(pstate, lfirst(gl),
  								  targetlist, GROUP_CLAUSE);
  
  		/* avoid making duplicate grouplist entries */
! 		if (targetIsInSortList(tle, glist))
! 			continue;
  
! 		/*
! 		 * If the GROUP BY clause matches the ORDER BY clause, we want to
! 		 * adopt the ordering operators from the latter rather than using
! 		 * the default ops.  This allows "GROUP BY foo ORDER BY foo DESC" to
! 		 * be done with only one sort step.  Note we are assuming that any
! 		 * user-supplied ordering operator will bring equal values together,
! 		 * which is all that GROUP BY needs.
! 		 */
! 		if (sortClause &&
! 			((SortClause *) lfirst(sortClause))->tleSortGroupRef ==
! 			tle->resdom->ressortgroupref)
! 		{
! 			ordering_op = ((SortClause *) lfirst(sortClause))->sortop;
! 			sortClause = lnext(sortClause);
  		}
+ 		else
+ 		{
+ 			ordering_op = ordering_oper_opid(tle->resdom->restype);
+ 			sortClause = NIL;	/* disregard ORDER BY once match fails */
+ 		}
+ 
+ 		grpcl = makeNode(GroupClause);
+ 		grpcl->tleSortGroupRef = assignSortGroupRef(tle, targetlist);
+ 		grpcl->sortop = ordering_op;
+ 		glist = lappend(glist, grpcl);
  	}
  
  	return glist;
*** src/include/parser/parse_clause.h.orig	Fri Mar 21 20:49:38 2003
--- src/include/parser/parse_clause.h	Sun Jun 15 12:03:13 2003
***************
*** 22,28 ****
  extern bool interpretInhOption(InhOption inhOpt);
  extern Node *transformWhereClause(ParseState *pstate, Node *where);
  extern List *transformGroupClause(ParseState *pstate, List *grouplist,
! 					 List *targetlist);
  extern List *transformSortClause(ParseState *pstate, List *orderlist,
  					List *targetlist);
  extern List *transformDistinctClause(ParseState *pstate, List *distinctlist,
--- 22,28 ----
  extern bool interpretInhOption(InhOption inhOpt);
  extern Node *transformWhereClause(ParseState *pstate, Node *where);
  extern List *transformGroupClause(ParseState *pstate, List *grouplist,
! 					 List *targetlist, List *sortClause);
  extern List *transformSortClause(ParseState *pstate, List *orderlist,
  					List *targetlist);
  extern List *transformDistinctClause(ParseState *pstate, List *distinctlist,
