*** ./backend/parser/parse_clause.c.orig	Thu May 21 10:19:17 1998
--- ./backend/parser/parse_clause.c	Mon May 25 13:53:37 1998
***************
*** 192,208 ****
  	 *    it will not be projected into the final tuple.
  	 *          daveh@insightdist.com    5/20/98
  	 */  
! 	if ( ! target_result)  {  
  		List   *p_target = tlist;
- 		Ident *missingTargetId = (Ident *)makeNode(Ident);
  		TargetEntry *tent = makeNode(TargetEntry);
  		
- 		/*   Fill in the constructed Ident node   */
- 		missingTargetId->type = T_Ident;
- 		missingTargetId->name = palloc(strlen(sortgroupby->name) + 1);
- 		strcpy(missingTargetId->name, sortgroupby->name);
  
! 		transformTargetId(pstate, missingTargetId, tent, missingTargetId->name, TRUE);
  
  		/* Add to the end of the target list */
  		while (lnext(p_target) != NIL)  {
--- 192,223 ----
  	 *    it will not be projected into the final tuple.
  	 *          daveh@insightdist.com    5/20/98
  	 */  
! 	if ( ! target_result && sortgroupby->name)   {
  		List   *p_target = tlist;
  		TargetEntry *tent = makeNode(TargetEntry);
  		
  
! 		if (sortgroupby->range)  {
! 			Attr *missingTarget = (Attr *)makeNode(Attr);
! 			missingTarget->type = T_Attr;
! 
! 			missingTarget->relname = palloc(strlen(sortgroupby->range) + 1);
! 			strcpy(missingTarget->relname, sortgroupby->range);
! 
! 			missingTarget->attrs = lcons(makeString(sortgroupby->name), NIL);
! 
! 			transformTargetId(pstate, (Node*)missingTarget, tent, sortgroupby->name, TRUE);
! 		}
! 		else  {
! 			Ident *missingTarget = (Ident *)makeNode(Ident);
! 			missingTarget->type = T_Ident;
! 
! 			missingTarget->name = palloc(strlen(sortgroupby->name) + 1);
! 			strcpy(missingTarget->name, sortgroupby->name);
! 
! 			transformTargetId(pstate, (Node*)missingTarget, tent, sortgroupby->name, TRUE);
! 		}
! 
  
  		/* Add to the end of the target list */
  		while (lnext(p_target) != NIL)  {
*** ./backend/parser/parse_target.c.orig	Thu May 21 12:51:33 1998
--- ./backend/parser/parse_target.c	Thu May 21 13:21:09 1998
***************
*** 46,52 ****
   */
  void
  transformTargetId(ParseState *pstate,
! 				Ident *ident,
  				TargetEntry *tent,
  				char *resname,
  				int16 resjunk)
--- 46,52 ----
   */
  void
  transformTargetId(ParseState *pstate,
! 				Node *node,
  				TargetEntry *tent,
  				char *resname,
  				int16 resjunk)
***************
*** 60,66 ****
  	 * relation names (even though they can be stored in
  	 * Ident nodes, too)
  	 */
! 	expr = transformIdent(pstate, (Node *) ident, EXPR_COLUMN_FIRST);
  	type_id = exprType(expr);
  	if (nodeTag(expr) == T_Var)
  		type_mod = ((Var *) expr)->vartypmod;
--- 60,66 ----
  	 * relation names (even though they can be stored in
  	 * Ident nodes, too)
  	 */
! 	expr = transformExpr(pstate, node, EXPR_COLUMN_FIRST);
  	type_id = exprType(expr);
  	if (nodeTag(expr) == T_Var)
  		type_mod = ((Var *) expr)->vartypmod;
***************
*** 105,111 ****
  					identname = ((Ident *) res->val)->name;
  					handleTargetColname(pstate, &res->name, NULL, identname);
  					resname = (res->name) ? res->name : identname;
! 					transformTargetId(pstate, (Ident*)res->val, tent, resname, FALSE);
  					break;
  				}
  			case T_ParamNo:
--- 105,111 ----
  					identname = ((Ident *) res->val)->name;
  					handleTargetColname(pstate, &res->name, NULL, identname);
  					resname = (res->name) ? res->name : identname;
! 					transformTargetId(pstate, (Node*)res->val, tent, resname, FALSE);
  					break;
  				}
  			case T_ParamNo:
*** ./include/parser/parse_target.h.orig	Thu May 21 14:46:09 1998
--- ./include/parser/parse_target.h	Thu May 21 14:46:27 1998
***************
*** 24,30 ****
  
  extern List *transformTargetList(ParseState *pstate, List *targetlist);
  extern List *makeTargetNames(ParseState *pstate, List *cols);
! extern void transformTargetId(ParseState *pstate, Ident *ident,
  	TargetEntry *tent, char *resname, int16 resjunk);
  
  #endif							/* PARSE_TARGET_H */
--- 24,30 ----
  
  extern List *transformTargetList(ParseState *pstate, List *targetlist);
  extern List *makeTargetNames(ParseState *pstate, List *cols);
! extern void transformTargetId(ParseState *pstate, Node *node,
  	TargetEntry *tent, char *resname, int16 resjunk);
  
  #endif							/* PARSE_TARGET_H */
*** ./test/regress/sql/tests.orig	Mon May 25 13:36:24 1998
--- ./test/regress/sql/tests	Mon May 25 13:36:43 1998
***************
*** 60,62 ****
--- 60,63 ----
  select_views
  alter_table
  portals_p2
+ junkfilter

--------------39936BA36BB1A87A01EFF060
Content-Type: text/plain; charset=us-ascii; name="junkfilter.out"
Content-Transfer-Encoding: 7bit
Content-Disposition: inline; filename="junkfilter.out"

QUERY: CREATE TABLE test_missing_target (a int, b int, c char(8));
QUERY: INSERT INTO test_missing_target VALUES (0, 1, 'XXXX');
QUERY: INSERT INTO test_missing_target VALUES (1, 2, 'AAAA');
QUERY: INSERT INTO test_missing_target VALUES (2, 2, 'AAAA');
QUERY: INSERT INTO test_missing_target VALUES (3, 3, 'BBBB');
QUERY: INSERT INTO test_missing_target VALUES (4, 3, 'BBBB');
QUERY: INSERT INTO test_missing_target VALUES (5, 3, 'BBBB');
QUERY: INSERT INTO test_missing_target VALUES (6, 4, 'CCCC');
QUERY: INSERT INTO test_missing_target VALUES (7, 4, 'CCCC');
QUERY: INSERT INTO test_missing_target VALUES (8, 4, 'CCCC');
QUERY: INSERT INTO test_missing_target VALUES (9, 4, 'CCCC');
QUERY: SELECT c, count(*) FROM test_missing_target GROUP BY test_missing_target.c;
c       |count
--------+-----
AAAA    |    2
BBBB    |    3
CCCC    |    4
XXXX    |    1
(4 rows)

QUERY: SELECT count(*) FROM test_missing_target GROUP BY test_missing_target.c;
count
-----
    2
    3
    4
    1
(4 rows)

QUERY: SELECT count(*) FROM test_missing_target GROUP BY a ORDER BY b;
ERROR:  parser: illegal use of aggregates or non-group column in target list
QUERY: SELECT count(*) FROM test_missing_target GROUP BY b ORDER BY b;
count
-----
    1
    2
    3
    4
(4 rows)

QUERY: SELECT test_missing_target.b, count(*) FROM test_missing_target GROUP BY b ORDER BY b;
b|count
-+-----
1|    1
2|    2
3|    3
4|    4
(4 rows)

QUERY: SELECT c FROM test_missing_target ORDER BY a;
c       
--------
XXXX    
AAAA    
AAAA    
BBBB    
BBBB    
BBBB    
CCCC    
CCCC    
CCCC    
CCCC    
(10 rows)

QUERY: SELECT count(*) FROM test_missing_target GROUP BY b ORDER BY b desc;
count
-----
    4
    3
    2
    1
(4 rows)

QUERY: SELECT count(*) FROM test_missing_target ORDER BY 1 desc;
count
-----
   10
(1 row)

QUERY: SELECT c, count(*) FROM test_missing_target GROUP BY 1;
c       |count
--------+-----
AAAA    |    2
BBBB    |    3
CCCC    |    4
XXXX    |    1
(4 rows)

QUERY: SELECT c, count(*) FROM test_missing_target GROUP BY 3;
ERROR:  left hand side of operator < has an unknown type, probably a bad attribute name
QUERY: SELECT count(*) FROM test_missing_target x, test_missing_target y
	WHERE x.a = y.a
	GROUP BY b ORDER BY b;
ERROR:  Column b is ambiguous
QUERY: SELECT x.b, count(*) FROM test_missing_target x, test_missing_target y
	WHERE x.a = y.a
	GROUP BY x.b;
b|count
-+-----
1|    1
2|    2
3|    3
4|    4
(4 rows)

QUERY: SELECT count(*) FROM test_missing_target x, test_missing_target y
	WHERE x.a = y.a
	GROUP BY x.b;
count
-----
    1
    2
    3
    4
(4 rows)

QUERY: SELECT count(*) INTO TABLE test_missing_target2
FROM test_missing_target x, test_missing_target y
	WHERE x.a = y.a
	GROUP BY x.b;
QUERY: SELECT * FROM test_missing_target2;
count
-----
    1
    2
    3
    4
(4 rows)

QUERY: drop table test_missing_target;
QUERY: drop table test_missing_target2;

--------------39936BA36BB1A87A01EFF060
Content-Type: text/plain; charset=us-ascii; name="junkfilter.sql"
Content-Transfer-Encoding: 7bit
Content-Disposition: inline; filename="junkfilter.sql"

-- load test data
CREATE TABLE test_missing_target (a int, b int, c char(8));
INSERT INTO test_missing_target VALUES (0, 1, 'XXXX');
INSERT INTO test_missing_target VALUES (1, 2, 'AAAA');
INSERT INTO test_missing_target VALUES (2, 2, 'AAAA');
INSERT INTO test_missing_target VALUES (3, 3, 'BBBB');
INSERT INTO test_missing_target VALUES (4, 3, 'BBBB');
INSERT INTO test_missing_target VALUES (5, 3, 'BBBB');
INSERT INTO test_missing_target VALUES (6, 4, 'CCCC');
INSERT INTO test_missing_target VALUES (7, 4, 'CCCC');
INSERT INTO test_missing_target VALUES (8, 4, 'CCCC');
INSERT INTO test_missing_target VALUES (9, 4, 'CCCC');


--   w/ existing GROUP BY target
SELECT c, count(*) FROM test_missing_target GROUP BY test_missing_target.c;

--   w/o existing GROUP BY target using a relation name in GROUP BY clause
SELECT count(*) FROM test_missing_target GROUP BY test_missing_target.c;

--   w/o existing GROUP BY target and w/o existing a different ORDER BY target
--   failure expected
SELECT count(*) FROM test_missing_target GROUP BY a ORDER BY b;

--   w/o existing GROUP BY target and w/o existing same ORDER BY target
SELECT count(*) FROM test_missing_target GROUP BY b ORDER BY b;

--   w/ existing GROUP BY target using a relation name in target
SELECT test_missing_target.b, count(*) FROM test_missing_target GROUP BY b ORDER BY b;

--   w/o existing GROUP BY target
SELECT c FROM test_missing_target ORDER BY a;

--   w/o existing ORDER BY target
SELECT count(*) FROM test_missing_target GROUP BY b ORDER BY b desc;

--   group using reference number
SELECT count(*) FROM test_missing_target ORDER BY 1 desc;

--   order using reference number
SELECT c, count(*) FROM test_missing_target GROUP BY 1;

--   group using reference number out of range
--   failure expected
SELECT c, count(*) FROM test_missing_target GROUP BY 3;

--   group w/o existing GROUP BY and ORDER BY target under ambigious condition
--   failure expected
SELECT count(*) FROM test_missing_target x, test_missing_target y 
	WHERE x.a = y.a
	GROUP BY b ORDER BY b;

--   group w/ existing GROUP BY target under ambigious condition
SELECT x.b, count(*) FROM test_missing_target x, test_missing_target y 
	WHERE x.a = y.a
	GROUP BY x.b;

--   group w/o existing GROUP BY target under ambigious condition
SELECT count(*) FROM test_missing_target x, test_missing_target y 
	WHERE x.a = y.a
	GROUP BY x.b;

--   group w/o existing GROUP BY target under ambigious condition
--   into a table
SELECT count(*) INTO TABLE test_missing_target2 
FROM test_missing_target x, test_missing_target y 
	WHERE x.a = y.a
	GROUP BY x.b;
SELECT * FROM test_missing_target2;

--   Cleanup
drop table test_missing_target;
drop table test_missing_target2;