Index: src/backend/access/transam/transam.c
===================================================================
RCS file: /projects/cvsroot/pgsql/src/backend/access/transam/transam.c,v
retrieving revision 1.51
diff -c -r1.51 transam.c
*** src/backend/access/transam/transam.c	2002/05/25 20:00:11	1.51
--- src/backend/access/transam/transam.c	2002/06/10 17:44:24
***************
*** 201,207 ****
  
  /*
   * Now this func in shmem.c and gives quality answer by scanning
!  * PROC structures of all running backend. - vadim 11/26/96
   *
   * Old comments:
   * true if given transaction has neither committed nor aborted
--- 201,207 ----
  
  /*
   * Now this func in shmem.c and gives quality answer by scanning
!  * PGPROC structures of all running backend. - vadim 11/26/96
   *
   * Old comments:
   * true if given transaction has neither committed nor aborted
Index: src/backend/access/transam/varsup.c
===================================================================
RCS file: /projects/cvsroot/pgsql/src/backend/access/transam/varsup.c,v
retrieving revision 1.49
diff -c -r1.49 varsup.c
*** src/backend/access/transam/varsup.c	2002/05/25 20:00:11	1.49
--- src/backend/access/transam/varsup.c	2002/06/10 17:44:24
***************
*** 61,83 ****
  	 * Must set MyProc->xid before releasing XidGenLock.  This ensures
  	 * that when GetSnapshotData calls ReadNewTransactionId, all active
  	 * XIDs before the returned value of nextXid are already present in
! 	 * the shared PROC array.  Else we have a race condition.
  	 *
  	 * XXX by storing xid into MyProc without acquiring SInvalLock, we are
  	 * relying on fetch/store of an xid to be atomic, else other backends
  	 * might see a partially-set xid here.	But holding both locks at once
  	 * would be a nasty concurrency hit (and in fact could cause a
  	 * deadlock against GetSnapshotData).  So for now, assume atomicity.
! 	 * Note that readers of PROC xid field should be careful to fetch the
  	 * value only once, rather than assume they can read it multiple times
  	 * and get the same answer each time.
  	 *
! 	 * A solution to the atomic-store problem would be to give each PROC its
! 	 * own spinlock used only for fetching/storing that PROC's xid.
  	 * (SInvalLock would then mean primarily that PROCs couldn't be added/
  	 * removed while holding the lock.)
  	 */
! 	if (MyProc != (PROC *) NULL)
  		MyProc->xid = xid;
  
  	LWLockRelease(XidGenLock);
--- 61,83 ----
  	 * Must set MyProc->xid before releasing XidGenLock.  This ensures
  	 * that when GetSnapshotData calls ReadNewTransactionId, all active
  	 * XIDs before the returned value of nextXid are already present in
! 	 * the shared PGPROC array.  Else we have a race condition.
  	 *
  	 * XXX by storing xid into MyProc without acquiring SInvalLock, we are
  	 * relying on fetch/store of an xid to be atomic, else other backends
  	 * might see a partially-set xid here.	But holding both locks at once
  	 * would be a nasty concurrency hit (and in fact could cause a
  	 * deadlock against GetSnapshotData).  So for now, assume atomicity.
! 	 * Note that readers of PGPROC xid field should be careful to fetch the
  	 * value only once, rather than assume they can read it multiple times
  	 * and get the same answer each time.
  	 *
! 	 * A solution to the atomic-store problem would be to give each PGPROC its
! 	 * own spinlock used only for fetching/storing that PGPROC's xid.
  	 * (SInvalLock would then mean primarily that PROCs couldn't be added/
  	 * removed while holding the lock.)
  	 */
! 	if (MyProc != (PGPROC *) NULL)
  		MyProc->xid = xid;
  
  	LWLockRelease(XidGenLock);
Index: src/backend/access/transam/xact.c
===================================================================
RCS file: /projects/cvsroot/pgsql/src/backend/access/transam/xact.c,v
retrieving revision 1.125
diff -c -r1.125 xact.c
*** src/backend/access/transam/xact.c	2002/05/25 20:00:12	1.125
--- src/backend/access/transam/xact.c	2002/06/10 17:44:26
***************
*** 602,608 ****
  	MyLastRecPtr.xrecoff = 0;
  	MyXactMadeXLogEntry = false;
  
! 	/* Show myself as out of the transaction in PROC array */
  	MyProc->logRec.xrecoff = 0;
  
  	if (leak)
--- 602,608 ----
  	MyLastRecPtr.xrecoff = 0;
  	MyXactMadeXLogEntry = false;
  
! 	/* Show myself as out of the transaction in PGPROC array */
  	MyProc->logRec.xrecoff = 0;
  
  	if (leak)
***************
*** 727,733 ****
  	MyLastRecPtr.xrecoff = 0;
  	MyXactMadeXLogEntry = false;
  
! 	/* Show myself as out of the transaction in PROC array */
  	MyProc->logRec.xrecoff = 0;
  
  	/*
--- 727,733 ----
  	MyLastRecPtr.xrecoff = 0;
  	MyXactMadeXLogEntry = false;
  
! 	/* Show myself as out of the transaction in PGPROC array */
  	MyProc->logRec.xrecoff = 0;
  
  	/*
***************
*** 960,966 ****
  	 * as running as well or it will see two tuple versions - one deleted
  	 * by xid 1 and one inserted by xid 0.	See notes in GetSnapshotData.
  	 */
! 	if (MyProc != (PROC *) NULL)
  	{
  		/* Lock SInvalLock because that's what GetSnapshotData uses. */
  		LWLockAcquire(SInvalLock, LW_EXCLUSIVE);
--- 960,966 ----
  	 * as running as well or it will see two tuple versions - one deleted
  	 * by xid 1 and one inserted by xid 0.	See notes in GetSnapshotData.
  	 */
! 	if (MyProc != (PGPROC *) NULL)
  	{
  		/* Lock SInvalLock because that's what GetSnapshotData uses. */
  		LWLockAcquire(SInvalLock, LW_EXCLUSIVE);
***************
*** 1069,1075 ****
  	 * this must be done _before_ releasing locks we hold and _after_
  	 * RecordTransactionAbort.
  	 */
! 	if (MyProc != (PROC *) NULL)
  	{
  		/* Lock SInvalLock because that's what GetSnapshotData uses. */
  		LWLockAcquire(SInvalLock, LW_EXCLUSIVE);
--- 1069,1075 ----
  	 * this must be done _before_ releasing locks we hold and _after_
  	 * RecordTransactionAbort.
  	 */
! 	if (MyProc != (PGPROC *) NULL)
  	{
  		/* Lock SInvalLock because that's what GetSnapshotData uses. */
  		LWLockAcquire(SInvalLock, LW_EXCLUSIVE);
Index: src/backend/access/transam/xlog.c
===================================================================
RCS file: /projects/cvsroot/pgsql/src/backend/access/transam/xlog.c,v
retrieving revision 1.96
diff -c -r1.96 xlog.c
*** src/backend/access/transam/xlog.c	2002/06/07 21:47:45	1.96
--- src/backend/access/transam/xlog.c	2002/06/10 17:44:27
***************
*** 753,759 ****
  	/* Compute record's XLOG location */
  	INSERT_RECPTR(RecPtr, Insert, curridx);
  
! 	/* If first XLOG record of transaction, save it in PROC array */
  	if (MyLastRecPtr.xrecoff == 0 && !no_tran)
  	{
  		/*
--- 753,759 ----
  	/* Compute record's XLOG location */
  	INSERT_RECPTR(RecPtr, Insert, curridx);
  
! 	/* If first XLOG record of transaction, save it in PGPROC array */
  	if (MyLastRecPtr.xrecoff == 0 && !no_tran)
  	{
  		/*
***************
*** 3026,3032 ****
  	}
  
  	/*
! 	 * Get UNDO record ptr - this is oldest of PROC->logRec values. We do
  	 * this while holding insert lock to ensure that we won't miss any
  	 * about-to-commit transactions (UNDO must include all xacts that have
  	 * commits after REDO point).
--- 3026,3032 ----
  	}
  
  	/*
! 	 * Get UNDO record ptr - this is oldest of PGPROC->logRec values. We do
  	 * this while holding insert lock to ensure that we won't miss any
  	 * about-to-commit transactions (UNDO must include all xacts that have
  	 * commits after REDO point).
Index: src/backend/bootstrap/bootparse.y
===================================================================
RCS file: /projects/cvsroot/pgsql/src/backend/bootstrap/bootparse.y,v
retrieving revision 1.46
diff -c -r1.46 bootparse.y
*** src/backend/bootstrap/bootparse.y	2002/04/27 21:24:33	1.46
--- src/backend/bootstrap/bootparse.y	2002/06/10 17:44:27
***************
*** 93,99 ****
  %type <ival>  boot_tuple boot_tuplelist
  %type <oidval> optoideq
  
! %token <ival> CONST ID
  %token OPEN XCLOSE XCREATE INSERT_TUPLE
  %token STRING XDEFINE
  %token XDECLARE INDEX ON USING XBUILD INDICES UNIQUE
--- 93,99 ----
  %type <ival>  boot_tuple boot_tuplelist
  %type <oidval> optoideq
  
! %token <ival> CONST_P ID
  %token OPEN XCLOSE XCREATE INSERT_TUPLE
  %token STRING XDEFINE
  %token XDECLARE INDEX ON USING XBUILD INDICES UNIQUE
***************
*** 329,335 ****
  		;
  
  boot_const :
! 		  CONST { $$=yylval.ival; }
  		;
  
  boot_ident :
--- 329,335 ----
  		;
  
  boot_const :
! 		  CONST_P { $$=yylval.ival; }
  		;
  
  boot_ident :
Index: src/backend/bootstrap/bootscanner.l
===================================================================
RCS file: /projects/cvsroot/pgsql/src/backend/bootstrap/bootscanner.l,v
retrieving revision 1.22
diff -c -r1.22 bootscanner.l
*** src/backend/bootstrap/bootscanner.l	2002/04/27 21:24:33	1.22
--- src/backend/bootstrap/bootscanner.l	2002/06/10 17:44:27
***************
*** 121,127 ****
  (-)?{D}*"."{D}+({Exp})? |
  (-)?{D}+{Exp}			{
  							yylval.ival = EnterString((char*)yytext);
! 							return(CONST);
  						}
  
  .				{
--- 121,127 ----
  (-)?{D}*"."{D}+({Exp})? |
  (-)?{D}+{Exp}			{
  							yylval.ival = EnterString((char*)yytext);
! 							return(CONST_P);
  						}
  
  .				{
Index: src/backend/commands/schemacmds.c
===================================================================
RCS file: /projects/cvsroot/pgsql/src/backend/commands/schemacmds.c,v
retrieving revision 1.3
diff -c -r1.3 schemacmds.c
*** src/backend/commands/schemacmds.c	2002/05/17 20:53:33	1.3
--- src/backend/commands/schemacmds.c	2002/06/10 17:44:27
***************
*** 50,56 ****
  	if (!authId)
  	{
  		owner_userid = saved_userid;
! 		owner_name = GetUserName(owner_userid);
  	}
  	else if (superuser())
  	{
--- 50,56 ----
  	if (!authId)
  	{
  		owner_userid = saved_userid;
! 		owner_name = GetUserNameFromId(owner_userid);
  	}
  	else if (superuser())
  	{
***************
*** 68,74 ****
  	else /* not superuser */
  	{
  		owner_userid = saved_userid;
! 		owner_name = GetUserName(owner_userid);
  		if (strcmp(authId, owner_name) != 0)
  			elog(ERROR, "CREATE SCHEMA: permission denied"
  				 "\n\t\"%s\" is not a superuser, so cannot create a schema for \"%s\"",
--- 68,74 ----
  	else /* not superuser */
  	{
  		owner_userid = saved_userid;
! 		owner_name = GetUserNameFromId(owner_userid);
  		if (strcmp(authId, owner_name) != 0)
  			elog(ERROR, "CREATE SCHEMA: permission denied"
  				 "\n\t\"%s\" is not a superuser, so cannot create a schema for \"%s\"",
Index: src/backend/commands/user.c
===================================================================
RCS file: /projects/cvsroot/pgsql/src/backend/commands/user.c,v
retrieving revision 1.103
diff -c -r1.103 user.c
*** src/backend/commands/user.c	2002/05/21 22:05:54	1.103
--- src/backend/commands/user.c	2002/06/10 17:44:27
***************
*** 724,730 ****
  		  createuser < 0 &&
  		  !validUntil &&
  		  password &&
! 		  strcmp(GetUserName(GetUserId()), stmt->user) == 0))
  		elog(ERROR, "ALTER USER: permission denied");
  
  	/* changes to the flat password file cannot be rolled back */
--- 724,730 ----
  		  createuser < 0 &&
  		  !validUntil &&
  		  password &&
! 		  strcmp(GetUserNameFromId(GetUserId()), stmt->user) == 0))
  		elog(ERROR, "ALTER USER: permission denied");
  
  	/* changes to the flat password file cannot be rolled back */
Index: src/backend/commands/variable.c
===================================================================
RCS file: /projects/cvsroot/pgsql/src/backend/commands/variable.c,v
retrieving revision 1.67
diff -c -r1.67 variable.c
*** src/backend/commands/variable.c	2002/05/17 01:19:17	1.67
--- src/backend/commands/variable.c	2002/06/10 17:44:27
***************
*** 583,587 ****
  const char *
  show_session_authorization(void)
  {
! 	return GetUserName(GetSessionUserId());
  }
--- 583,587 ----
  const char *
  show_session_authorization(void)
  {
! 	return GetUserNameFromId(GetSessionUserId());
  }
Index: src/backend/parser/gram.y
===================================================================
RCS file: /projects/cvsroot/pgsql/src/backend/parser/gram.y,v
retrieving revision 2.319
diff -c -r2.319 gram.y
*** src/backend/parser/gram.y	2002/05/22 17:20:59	2.319
--- src/backend/parser/gram.y	2002/06/10 17:44:28
***************
*** 321,345 ****
  	BACKWARD, BEFORE, BEGIN_TRANS, BETWEEN, BIGINT, BINARY, BIT, BOTH,
  	BOOLEAN, BY,
  
! 	CACHE, CALLED, CASCADE, CASE, CAST, CHAIN, CHAR, CHARACTER,
  	CHARACTERISTICS, CHECK, CHECKPOINT, CLOSE, CLUSTER, COALESCE, COLLATE,
  	COLUMN, COMMENT, COMMIT, COMMITTED, CONSTRAINT, CONSTRAINTS, COPY,
  	CREATE, CREATEDB, CREATEUSER, CROSS, CURRENT_DATE, CURRENT_TIME,
  	CURRENT_TIMESTAMP, CURRENT_USER, CURSOR, CYCLE,
  
  	DATABASE, DAY_P, DEC, DECIMAL, DECLARE, DEFAULT, DEFERRABLE, DEFERRED,
! 	DEFINER, DELETE, DELIMITERS, DESC, DISTINCT, DO, DOMAIN_P, DOUBLE, DROP,
  
  	EACH, ELSE, ENCODING, ENCRYPTED, END_TRANS, ESCAPE, EXCEPT, EXCLUSIVE,
  	EXECUTE, EXISTS, EXPLAIN, EXTERNAL, EXTRACT,
  
! 	FALSE_P, FETCH, FLOAT, FOR, FORCE, FOREIGN, FORWARD, FREEZE, FROM,
  	FULL, FUNCTION,
  
! 	GLOBAL, GRANT, GROUP,
  	HANDLER, HAVING, HOUR_P,
  
! 	ILIKE, IMMEDIATE, IMMUTABLE, IMPLICIT, IN, INCREMENT, INDEX, INHERITS,
  	INITIALLY, INNER_P, INOUT, INPUT, INSENSITIVE, INSERT, INSTEAD, INT,
  	INTEGER, INTERSECT, INTERVAL, INTO, INVOKER, IS, ISNULL, ISOLATION,
  
--- 321,345 ----
  	BACKWARD, BEFORE, BEGIN_TRANS, BETWEEN, BIGINT, BINARY, BIT, BOTH,
  	BOOLEAN, BY,
  
! 	CACHE, CALLED, CASCADE, CASE, CAST, CHAIN, CHAR_P, CHARACTER,
  	CHARACTERISTICS, CHECK, CHECKPOINT, CLOSE, CLUSTER, COALESCE, COLLATE,
  	COLUMN, COMMENT, COMMIT, COMMITTED, CONSTRAINT, CONSTRAINTS, COPY,
  	CREATE, CREATEDB, CREATEUSER, CROSS, CURRENT_DATE, CURRENT_TIME,
  	CURRENT_TIMESTAMP, CURRENT_USER, CURSOR, CYCLE,
  
  	DATABASE, DAY_P, DEC, DECIMAL, DECLARE, DEFAULT, DEFERRABLE, DEFERRED,
! 	DEFINER, DELETE_P, DELIMITERS, DESC, DISTINCT, DO, DOMAIN_P, DOUBLE, DROP,
  
  	EACH, ELSE, ENCODING, ENCRYPTED, END_TRANS, ESCAPE, EXCEPT, EXCLUSIVE,
  	EXECUTE, EXISTS, EXPLAIN, EXTERNAL, EXTRACT,
  
! 	FALSE_P, FETCH, FLOAT_P, FOR, FORCE, FOREIGN, FORWARD, FREEZE, FROM,
  	FULL, FUNCTION,
  
! 	GLOBAL, GRANT, GROUP_P,
  	HANDLER, HAVING, HOUR_P,
  
! 	ILIKE, IMMEDIATE, IMMUTABLE, IMPLICIT, IN_P, INCREMENT, INDEX, INHERITS,
  	INITIALLY, INNER_P, INOUT, INPUT, INSENSITIVE, INSERT, INSTEAD, INT,
  	INTEGER, INTERSECT, INTERVAL, INTO, INVOKER, IS, ISNULL, ISOLATION,
  
***************
*** 356,362 ****
  	NUMERIC,
  
  	OF, OFF, OFFSET, OIDS, OLD, ON, ONLY, OPERATOR, OPTION, OR, ORDER,
! 	OUT, OUTER_P, OVERLAPS, OWNER,
  
  	PARTIAL, PASSWORD, PATH_P, PENDANT, POSITION, PRECISION, PRIMARY,
  	PRIOR, PRIVILEGES, PROCEDURE, PROCEDURAL,
--- 356,362 ----
  	NUMERIC,
  
  	OF, OFF, OFFSET, OIDS, OLD, ON, ONLY, OPERATOR, OPTION, OR, ORDER,
! 	OUT_P, OUTER_P, OVERLAPS, OWNER,
  
  	PARTIAL, PASSWORD, PATH_P, PENDANT, POSITION, PRECISION, PRIMARY,
  	PRIOR, PRIVILEGES, PROCEDURE, PROCEDURAL,
***************
*** 406,412 ****
  %nonassoc	ESCAPE
  %nonassoc	OVERLAPS
  %nonassoc	BETWEEN
! %nonassoc	IN
  %left		POSTFIXOP		/* dummy for postfix Op rules */
  %left		Op OPERATOR		/* multi-character ops and user-defined operators */
  %nonassoc	NOTNULL
--- 406,412 ----
  %nonassoc	ESCAPE
  %nonassoc	OVERLAPS
  %nonassoc	BETWEEN
! %nonassoc	IN_P
  %left		POSTFIXOP		/* dummy for postfix Op rules */
  %left		Op OPERATOR		/* multi-character ops and user-defined operators */
  %nonassoc	NOTNULL
***************
*** 647,653 ****
  					$$->defname = "createuser";
  					$$->arg = (Node *)makeInteger(FALSE);
  				}
! 			| IN GROUP user_list
  				{ 
  					$$ = makeNode(DefElem);
  					$$->defname = "groupElts";
--- 647,653 ----
  					$$->defname = "createuser";
  					$$->arg = (Node *)makeInteger(FALSE);
  				}
! 			| IN_P GROUP_P user_list
  				{ 
  					$$ = makeNode(DefElem);
  					$$->defname = "groupElts";
***************
*** 680,693 ****
   *
   *****************************************************************************/
  
! CreateGroupStmt:  CREATE GROUP UserId OptGroupList
  				{
  					CreateGroupStmt *n = makeNode(CreateGroupStmt);
  					n->name = $3;
  					n->options = $4;
  					$$ = (Node *)n;
  				}
! 			| CREATE GROUP UserId WITH OptGroupList
  				{
  					CreateGroupStmt *n = makeNode(CreateGroupStmt);
  					n->name = $3;
--- 680,693 ----
   *
   *****************************************************************************/
  
! CreateGroupStmt:  CREATE GROUP_P UserId OptGroupList
  				{
  					CreateGroupStmt *n = makeNode(CreateGroupStmt);
  					n->name = $3;
  					n->options = $4;
  					$$ = (Node *)n;
  				}
! 			| CREATE GROUP_P UserId WITH OptGroupList
  				{
  					CreateGroupStmt *n = makeNode(CreateGroupStmt);
  					n->name = $3;
***************
*** 725,731 ****
   *
   *****************************************************************************/
  
! AlterGroupStmt:  ALTER GROUP UserId ADD USER user_list
  				{
  					AlterGroupStmt *n = makeNode(AlterGroupStmt);
  					n->name = $3;
--- 725,731 ----
   *
   *****************************************************************************/
  
! AlterGroupStmt:  ALTER GROUP_P UserId ADD USER user_list
  				{
  					AlterGroupStmt *n = makeNode(AlterGroupStmt);
  					n->name = $3;
***************
*** 733,739 ****
  					n->listUsers = $6;
  					$$ = (Node *)n;
  				}
! 			| ALTER GROUP UserId DROP USER user_list
  				{
  					AlterGroupStmt *n = makeNode(AlterGroupStmt);
  					n->name = $3;
--- 733,739 ----
  					n->listUsers = $6;
  					$$ = (Node *)n;
  				}
! 			| ALTER GROUP_P UserId DROP USER user_list
  				{
  					AlterGroupStmt *n = makeNode(AlterGroupStmt);
  					n->name = $3;
***************
*** 751,757 ****
   *
   *****************************************************************************/
  
! DropGroupStmt: DROP GROUP UserId
  				{
  					DropGroupStmt *n = makeNode(DropGroupStmt);
  					n->name = $3;
--- 751,757 ----
   *
   *****************************************************************************/
  
! DropGroupStmt: DROP GROUP_P UserId
  				{
  					DropGroupStmt *n = makeNode(DropGroupStmt);
  					n->name = $3;
***************
*** 1671,1677 ****
  		| /*EMPTY*/						{ $$ = 0; }
  		;
  
! key_delete:  ON DELETE key_reference	{ $$ = $3 << FKCONSTR_ON_DELETE_SHIFT; }
  		;
  
  key_update:  ON UPDATE key_reference	{ $$ = $3 << FKCONSTR_ON_UPDATE_SHIFT; }
--- 1671,1677 ----
  		| /*EMPTY*/						{ $$ = 0; }
  		;
  
! key_delete:  ON DELETE_P key_reference	{ $$ = $3 << FKCONSTR_ON_DELETE_SHIFT; }
  		;
  
  key_update:  ON UPDATE key_reference	{ $$ = $3 << FKCONSTR_ON_UPDATE_SHIFT; }
***************
*** 1963,1969 ****
  		;
  
  TriggerOneEvent:  INSERT					{ $$ = 'i'; }
! 			| DELETE						{ $$ = 'd'; }
  			| UPDATE						{ $$ = 'u'; }
  		;
  
--- 1963,1969 ----
  		;
  
  TriggerOneEvent:  INSERT					{ $$ = 'i'; }
! 			| DELETE_P						{ $$ = 'd'; }
  			| UPDATE						{ $$ = 'u'; }
  		;
  
***************
*** 2472,2478 ****
  		| PRIOR							{ $$ = -1; }
  		;
  
! from_in:  IN							{ }
  	| FROM								{ }
  	;
  
--- 2472,2478 ----
  		| PRIOR							{ $$ = -1; }
  		;
  
! from_in:  IN_P							{ }
  	| FROM								{ }
  	;
  
***************
*** 2524,2530 ****
  privilege: SELECT    { $$ = ACL_SELECT; }
  		| INSERT     { $$ = ACL_INSERT; }
  		| UPDATE     { $$ = ACL_UPDATE; }
! 		| DELETE     { $$ = ACL_DELETE; }
  		| RULE       { $$ = ACL_RULE; }
  		| REFERENCES { $$ = ACL_REFERENCES; }
  		| TRIGGER    { $$ = ACL_TRIGGER; }
--- 2524,2530 ----
  privilege: SELECT    { $$ = ACL_SELECT; }
  		| INSERT     { $$ = ACL_INSERT; }
  		| UPDATE     { $$ = ACL_UPDATE; }
! 		| DELETE_P   { $$ = ACL_DELETE; }
  		| RULE       { $$ = ACL_RULE; }
  		| REFERENCES { $$ = ACL_REFERENCES; }
  		| TRIGGER    { $$ = ACL_TRIGGER; }
***************
*** 2598,2604 ****
  					n->groupname = NULL;
  					$$ = (Node *)n;
  				}
! 		| GROUP ColId
  				{
  					PrivGrantee *n = makeNode(PrivGrantee);
  					/* Treat GROUP PUBLIC as a synonym for PUBLIC */
--- 2598,2604 ----
  					n->groupname = NULL;
  					$$ = (Node *)n;
  				}
! 		| GROUP_P ColId
  				{
  					PrivGrantee *n = makeNode(PrivGrantee);
  					/* Treat GROUP PUBLIC as a synonym for PUBLIC */
***************
*** 2807,2817 ****
  				}
  		;
  
! opt_arg:  IN
  				{
  					$$ = FALSE;
  				}
! 		| OUT
  				{
  					elog(ERROR, "CREATE FUNCTION / OUT parameters are not supported");
  					$$ = TRUE;
--- 2807,2817 ----
  				}
  		;
  
! opt_arg:  IN_P
  				{
  					$$ = FALSE;
  				}
! 		| OUT_P
  				{
  					elog(ERROR, "CREATE FUNCTION / OUT parameters are not supported");
  					$$ = TRUE;
***************
*** 3143,3149 ****
  /* change me to select, update, etc. some day */
  event:	SELECT							{ $$ = CMD_SELECT; }
  		| UPDATE						{ $$ = CMD_UPDATE; }
! 		| DELETE						{ $$ = CMD_DELETE; }
  		| INSERT						{ $$ = CMD_INSERT; }
  		 ;
  
--- 3143,3149 ----
  /* change me to select, update, etc. some day */
  event:	SELECT							{ $$ = CMD_SELECT; }
  		| UPDATE						{ $$ = CMD_UPDATE; }
! 		| DELETE_P						{ $$ = CMD_DELETE; }
  		| INSERT						{ $$ = CMD_INSERT; }
  		 ;
  
***************
*** 3728,3734 ****
   *
   *****************************************************************************/
  
! DeleteStmt:  DELETE FROM relation_expr where_clause
  				{
  					DeleteStmt *n = makeNode(DeleteStmt);
  					n->relation = $3;
--- 3728,3734 ----
   *
   *****************************************************************************/
  
! DeleteStmt:  DELETE_P FROM relation_expr where_clause
  				{
  					DeleteStmt *n = makeNode(DeleteStmt);
  					n->relation = $3;
***************
*** 3747,3753 ****
  				}
  		;
  
! opt_lock:  IN lock_type MODE	{ $$ = $2; }
  		| /*EMPTY*/				{ $$ = AccessExclusiveLock; }
  		;
  
--- 3747,3753 ----
  				}
  		;
  
! opt_lock:  IN_P lock_type MODE	{ $$ = $2; }
  		| /*EMPTY*/				{ $$ = AccessExclusiveLock; }
  		;
  
***************
*** 4134,4140 ****
   *	cases for these.
   */
  
! group_clause:  GROUP BY expr_list				{ $$ = $3; }
  		| /*EMPTY*/								{ $$ = NIL; }
  		;
  
--- 4134,4140 ----
   *	cases for these.
   */
  
! group_clause:  GROUP_P BY expr_list				{ $$ = $3; }
  		| /*EMPTY*/								{ $$ = NIL; }
  		;
  
***************
*** 4535,4541 ****
  				{
  					$$ = SystemTypeName("float4");
  				}
! 		| FLOAT opt_float
  				{
  					$$ = $2;
  				}
--- 4535,4541 ----
  				{
  					$$ = SystemTypeName("float4");
  				}
! 		| FLOAT_P opt_float
  				{
  					$$ = $2;
  				}
***************
*** 4726,4735 ****
  		;
  
  character:  CHARACTER opt_varying				{ $$ = $2 ? "varchar": "bpchar"; }
! 		| CHAR opt_varying						{ $$ = $2 ? "varchar": "bpchar"; }
  		| VARCHAR								{ $$ = "varchar"; }
  		| NATIONAL CHARACTER opt_varying		{ $$ = $3 ? "varchar": "bpchar"; }
! 		| NATIONAL CHAR opt_varying				{ $$ = $3 ? "varchar": "bpchar"; }
  		| NCHAR opt_varying						{ $$ = $2 ? "varchar": "bpchar"; }
  		;
  
--- 4726,4735 ----
  		;
  
  character:  CHARACTER opt_varying				{ $$ = $2 ? "varchar": "bpchar"; }
! 		| CHAR_P opt_varying						{ $$ = $2 ? "varchar": "bpchar"; }
  		| VARCHAR								{ $$ = "varchar"; }
  		| NATIONAL CHARACTER opt_varying		{ $$ = $3 ? "varchar": "bpchar"; }
! 		| NATIONAL CHAR_P opt_varying				{ $$ = $3 ? "varchar": "bpchar"; }
  		| NCHAR opt_varying						{ $$ = $2 ? "varchar": "bpchar"; }
  		;
  
***************
*** 4842,4848 ****
   * Define row_descriptor to allow yacc to break the reduce/reduce conflict
   *  with singleton expressions.
   */
! row_expr: '(' row_descriptor ')' IN select_with_parens
  				{
  					SubLink *n = makeNode(SubLink);
  					n->lefthand = $2;
--- 4842,4848 ----
   * Define row_descriptor to allow yacc to break the reduce/reduce conflict
   *  with singleton expressions.
   */
! row_expr: '(' row_descriptor ')' IN_P select_with_parens
  				{
  					SubLink *n = makeNode(SubLink);
  					n->lefthand = $2;
***************
*** 4852,4858 ****
  					n->subselect = $5;
  					$$ = (Node *)n;
  				}
! 		| '(' row_descriptor ')' NOT IN select_with_parens
  				{
  					SubLink *n = makeNode(SubLink);
  					n->lefthand = $2;
--- 4852,4858 ----
  					n->subselect = $5;
  					$$ = (Node *)n;
  				}
! 		| '(' row_descriptor ')' NOT IN_P select_with_parens
  				{
  					SubLink *n = makeNode(SubLink);
  					n->lefthand = $2;
***************
*** 5190,5196 ****
  						(Node *) makeSimpleA_Expr(OP, "<", $1, $4),
  						(Node *) makeSimpleA_Expr(OP, ">", $1, $6));
  				}
! 		| a_expr IN in_expr
  				{
  					/* in_expr returns a SubLink or a list of a_exprs */
  					if (IsA($3, SubLink))
--- 5190,5196 ----
  						(Node *) makeSimpleA_Expr(OP, "<", $1, $4),
  						(Node *) makeSimpleA_Expr(OP, ">", $1, $6));
  				}
! 		| a_expr IN_P in_expr
  				{
  					/* in_expr returns a SubLink or a list of a_exprs */
  					if (IsA($3, SubLink))
***************
*** 5220,5226 ****
  						$$ = n;
  					}
  				}
! 		| a_expr NOT IN in_expr
  				{
  					/* in_expr returns a SubLink or a list of a_exprs */
  					if (IsA($4, SubLink))
--- 5220,5226 ----
  						$$ = n;
  					}
  				}
! 		| a_expr NOT IN_P in_expr
  				{
  					/* in_expr returns a SubLink or a list of a_exprs */
  					if (IsA($4, SubLink))
***************
*** 5708,5714 ****
  
  /* position_list uses b_expr not a_expr to avoid conflict with general IN */
  
! position_list:  b_expr IN b_expr
  				{	$$ = makeList2($3, $1); }
  		| /*EMPTY*/
  				{	$$ = NIL; }
--- 5708,5714 ----
  
  /* position_list uses b_expr not a_expr to avoid conflict with general IN */
  
! position_list:  b_expr IN_P b_expr
  				{	$$ = makeList2($3, $1); }
  		| /*EMPTY*/
  				{	$$ = NIL; }
***************
*** 6242,6248 ****
  		| DECLARE
  		| DEFERRED
  		| DEFINER
! 		| DELETE
  		| DELIMITERS
  		| DOMAIN_P
  		| DOUBLE
--- 6242,6248 ----
  		| DECLARE
  		| DEFERRED
  		| DEFINER
! 		| DELETE_P
  		| DELIMITERS
  		| DOMAIN_P
  		| DOUBLE
***************
*** 6303,6309 ****
  		| OIDS
  		| OPERATOR
  		| OPTION
! 		| OUT
  		| OWNER
  		| PARTIAL
  		| PASSWORD
--- 6303,6309 ----
  		| OIDS
  		| OPERATOR
  		| OPTION
! 		| OUT_P
  		| OWNER
  		| PARTIAL
  		| PASSWORD
***************
*** 6389,6402 ****
  		  BIGINT
  		| BIT
  		| BOOLEAN
! 		| CHAR
  		| CHARACTER
  		| COALESCE
  		| DEC
  		| DECIMAL
  		| EXISTS
  		| EXTRACT
! 		| FLOAT
  		| INT
  		| INTEGER
  		| INTERVAL
--- 6389,6402 ----
  		  BIGINT
  		| BIT
  		| BOOLEAN
! 		| CHAR_P
  		| CHARACTER
  		| COALESCE
  		| DEC
  		| DECIMAL
  		| EXISTS
  		| EXTRACT
! 		| FLOAT_P
  		| INT
  		| INTEGER
  		| INTERVAL
***************
*** 6433,6439 ****
  		| FREEZE
  		| FULL
  		| ILIKE
! 		| IN
  		| INNER_P
  		| IS
  		| ISNULL
--- 6433,6439 ----
  		| FREEZE
  		| FULL
  		| ILIKE
! 		| IN_P
  		| INNER_P
  		| IS
  		| ISNULL
***************
*** 6487,6493 ****
  		| FOREIGN
  		| FROM
  		| GRANT
! 		| GROUP
  		| HAVING
  		| INITIALLY
  		| INTERSECT
--- 6487,6493 ----
  		| FOREIGN
  		| FROM
  		| GRANT
! 		| GROUP_P
  		| HAVING
  		| INITIALLY
  		| INTERSECT
Index: src/backend/parser/keywords.c
===================================================================
RCS file: /projects/cvsroot/pgsql/src/backend/parser/keywords.c,v
retrieving revision 1.111
diff -c -r1.111 keywords.c
*** src/backend/parser/keywords.c	2002/05/22 17:20:59	1.111
--- src/backend/parser/keywords.c	2002/06/10 17:44:28
***************
*** 62,68 ****
  	{"case", CASE},
  	{"cast", CAST},
  	{"chain", CHAIN},
! 	{"char", CHAR},
  	{"character", CHARACTER},
  	{"characteristics", CHARACTERISTICS},
  	{"check", CHECK},
--- 62,68 ----
  	{"case", CASE},
  	{"cast", CAST},
  	{"chain", CHAIN},
! 	{"char", CHAR_P},
  	{"character", CHARACTER},
  	{"characteristics", CHARACTERISTICS},
  	{"check", CHECK},
***************
*** 97,103 ****
  	{"deferrable", DEFERRABLE},
  	{"deferred", DEFERRED},
  	{"definer", DEFINER},
! 	{"delete", DELETE},
  	{"delimiters", DELIMITERS},
  	{"desc", DESC},
  	{"distinct", DISTINCT},
--- 97,103 ----
  	{"deferrable", DEFERRABLE},
  	{"deferred", DEFERRED},
  	{"definer", DEFINER},
! 	{"delete", DELETE_P},
  	{"delimiters", DELIMITERS},
  	{"desc", DESC},
  	{"distinct", DISTINCT},
***************
*** 120,126 ****
  	{"extract", EXTRACT},
  	{"false", FALSE_P},
  	{"fetch", FETCH},
! 	{"float", FLOAT},
  	{"for", FOR},
  	{"force", FORCE},
  	{"foreign", FOREIGN},
--- 120,126 ----
  	{"extract", EXTRACT},
  	{"false", FALSE_P},
  	{"fetch", FETCH},
! 	{"float", FLOAT_P},
  	{"for", FOR},
  	{"force", FORCE},
  	{"foreign", FOREIGN},
***************
*** 131,137 ****
  	{"function", FUNCTION},
  	{"global", GLOBAL},
  	{"grant", GRANT},
! 	{"group", GROUP},
  	{"handler", HANDLER},
  	{"having", HAVING},
  	{"hour", HOUR_P},
--- 131,137 ----
  	{"function", FUNCTION},
  	{"global", GLOBAL},
  	{"grant", GRANT},
! 	{"group", GROUP_P},
  	{"handler", HANDLER},
  	{"having", HAVING},
  	{"hour", HOUR_P},
***************
*** 139,145 ****
  	{"immediate", IMMEDIATE},
  	{"immutable", IMMUTABLE},
  	{"implicit", IMPLICIT},
! 	{"in", IN},
  	{"increment", INCREMENT},
  	{"index", INDEX},
  	{"inherits", INHERITS},
--- 139,145 ----
  	{"immediate", IMMEDIATE},
  	{"immutable", IMMUTABLE},
  	{"implicit", IMPLICIT},
! 	{"in", IN_P},
  	{"increment", INCREMENT},
  	{"index", INDEX},
  	{"inherits", INHERITS},
***************
*** 208,214 ****
  	{"option", OPTION},
  	{"or", OR},
  	{"order", ORDER},
! 	{"out", OUT},
  	{"outer", OUTER_P},
  	{"overlaps", OVERLAPS},
  	{"owner", OWNER},
--- 208,214 ----
  	{"option", OPTION},
  	{"or", OR},
  	{"order", ORDER},
! 	{"out", OUT_P},
  	{"outer", OUTER_P},
  	{"overlaps", OVERLAPS},
  	{"owner", OWNER},
Index: src/backend/postmaster/postmaster.c
===================================================================
RCS file: /projects/cvsroot/pgsql/src/backend/postmaster/postmaster.c,v
retrieving revision 1.275
diff -c -r1.275 postmaster.c
*** src/backend/postmaster/postmaster.c	2002/05/28 23:56:51	1.275
--- src/backend/postmaster/postmaster.c	2002/06/10 17:44:29
***************
*** 14,20 ****
   *
   *	  The postmaster process creates the shared memory and semaphore
   *	  pools during startup, but as a rule does not touch them itself.
!  *	  In particular, it is not a member of the PROC array of backends
   *	  and so it cannot participate in lock-manager operations.	Keeping
   *	  the postmaster away from shared memory operations makes it simpler
   *	  and more reliable.  The postmaster is almost always able to recover
--- 14,20 ----
   *
   *	  The postmaster process creates the shared memory and semaphore
   *	  pools during startup, but as a rule does not touch them itself.
!  *	  In particular, it is not a member of the PGPROC array of backends
   *	  and so it cannot participate in lock-manager operations.	Keeping
   *	  the postmaster away from shared memory operations makes it simpler
   *	  and more reliable.  The postmaster is almost always able to recover
Index: src/backend/storage/ipc/sinval.c
===================================================================
RCS file: /projects/cvsroot/pgsql/src/backend/storage/ipc/sinval.c,v
retrieving revision 1.47
diff -c -r1.47 sinval.c
*** src/backend/storage/ipc/sinval.c	2002/05/24 18:57:56	1.47
--- src/backend/storage/ipc/sinval.c	2002/06/10 17:44:29
***************
*** 97,103 ****
  		 * The routines later in this file that use shared mode are okay with
  		 * this, because they aren't looking at the ProcState fields
  		 * associated with SI message transfer; they only use the
! 		 * ProcState array as an easy way to find all the PROC structures.
  		 */
  		LWLockAcquire(SInvalLock, LW_SHARED);
  		getResult = SIGetDataEntry(shmInvalBuffer, MyBackendId, &data);
--- 97,103 ----
  		 * The routines later in this file that use shared mode are okay with
  		 * this, because they aren't looking at the ProcState fields
  		 * associated with SI message transfer; they only use the
! 		 * ProcState array as an easy way to find all the PGPROC structures.
  		 */
  		LWLockAcquire(SInvalLock, LW_SHARED);
  		getResult = SIGetDataEntry(shmInvalBuffer, MyBackendId, &data);
***************
*** 130,141 ****
  
  
  /****************************************************************************/
! /* Functions that need to scan the PROC structures of all running backends. */
  /* It's a bit strange to keep these in sinval.c, since they don't have any	*/
  /* direct relationship to shared-cache invalidation.  But the procState		*/
  /* array in the SI segment is the only place in the system where we have	*/
  /* an array of per-backend data, so it is the most convenient place to keep */
! /* pointers to the backends' PROC structures.  We used to implement these	*/
  /* functions with a slow, ugly search through the ShmemIndex hash table --- */
  /* now they are simple loops over the SI ProcState array.					*/
  /****************************************************************************/
--- 130,141 ----
  
  
  /****************************************************************************/
! /* Functions that need to scan the PGPROC structures of all running backends. */
  /* It's a bit strange to keep these in sinval.c, since they don't have any	*/
  /* direct relationship to shared-cache invalidation.  But the procState		*/
  /* array in the SI segment is the only place in the system where we have	*/
  /* an array of per-backend data, so it is the most convenient place to keep */
! /* pointers to the backends' PGPROC structures.  We used to implement these	*/
  /* functions with a slow, ugly search through the ShmemIndex hash table --- */
  /* now they are simple loops over the SI ProcState array.					*/
  /****************************************************************************/
***************
*** 171,177 ****
  
  		if (pOffset != INVALID_OFFSET)
  		{
! 			PROC	   *proc = (PROC *) MAKE_PTR(pOffset);
  
  			if (proc->databaseId == databaseId)
  			{
--- 171,177 ----
  
  		if (pOffset != INVALID_OFFSET)
  		{
! 			PGPROC	   *proc = (PGPROC *) MAKE_PTR(pOffset);
  
  			if (proc->databaseId == databaseId)
  			{
***************
*** 208,214 ****
  
  		if (pOffset != INVALID_OFFSET)
  		{
! 			PROC	   *proc = (PROC *) MAKE_PTR(pOffset);
  
  			/* Fetch xid just once - see GetNewTransactionId */
  			TransactionId pxid = proc->xid;
--- 208,214 ----
  
  		if (pOffset != INVALID_OFFSET)
  		{
! 			PGPROC	   *proc = (PGPROC *) MAKE_PTR(pOffset);
  
  			/* Fetch xid just once - see GetNewTransactionId */
  			TransactionId pxid = proc->xid;
***************
*** 260,266 ****
  
  		if (pOffset != INVALID_OFFSET)
  		{
! 			PROC	   *proc = (PROC *) MAKE_PTR(pOffset);
  
  			if (allDbs || proc->databaseId == MyDatabaseId)
  			{
--- 260,266 ----
  
  		if (pOffset != INVALID_OFFSET)
  		{
! 			PGPROC	   *proc = (PGPROC *) MAKE_PTR(pOffset);
  
  			if (allDbs || proc->databaseId == MyDatabaseId)
  			{
***************
*** 371,377 ****
  
  		if (pOffset != INVALID_OFFSET)
  		{
! 			PROC	   *proc = (PROC *) MAKE_PTR(pOffset);
  
  			/* Fetch xid just once - see GetNewTransactionId */
  			TransactionId xid = proc->xid;
--- 371,377 ----
  
  		if (pOffset != INVALID_OFFSET)
  		{
! 			PGPROC	   *proc = (PGPROC *) MAKE_PTR(pOffset);
  
  			/* Fetch xid just once - see GetNewTransactionId */
  			TransactionId xid = proc->xid;
***************
*** 460,466 ****
  
  		if (pOffset != INVALID_OFFSET)
  		{
! 			PROC	   *proc = (PROC *) MAKE_PTR(pOffset);
  
  			if (proc == MyProc)
  				continue;		/* do not count myself */
--- 460,466 ----
  
  		if (pOffset != INVALID_OFFSET)
  		{
! 			PGPROC	   *proc = (PGPROC *) MAKE_PTR(pOffset);
  
  			if (proc == MyProc)
  				continue;		/* do not count myself */
***************
*** 476,482 ****
  }
  
  /*
!  * GetUndoRecPtr -- returns oldest PROC->logRec.
   */
  XLogRecPtr
  GetUndoRecPtr(void)
--- 476,482 ----
  }
  
  /*
!  * GetUndoRecPtr -- returns oldest PGPROC->logRec.
   */
  XLogRecPtr
  GetUndoRecPtr(void)
***************
*** 495,501 ****
  
  		if (pOffset != INVALID_OFFSET)
  		{
! 			PROC	   *proc = (PROC *) MAKE_PTR(pOffset);
  
  			tempr = proc->logRec;
  			if (tempr.xrecoff == 0)
--- 495,501 ----
  
  		if (pOffset != INVALID_OFFSET)
  		{
! 			PGPROC	   *proc = (PGPROC *) MAKE_PTR(pOffset);
  
  			tempr = proc->logRec;
  			if (tempr.xrecoff == 0)
***************
*** 512,524 ****
  }
  
  /*
!  * BackendIdGetProc - given a BackendId, find its PROC structure
   *
   * This is a trivial lookup in the ProcState array.  We assume that the caller
   * knows that the backend isn't going to go away, so we do not bother with
   * locking.
   */
! struct PROC *
  BackendIdGetProc(BackendId procId)
  {
  	SISeg	   *segP = shmInvalBuffer;
--- 512,524 ----
  }
  
  /*
!  * BackendIdGetProc - given a BackendId, find its PGPROC structure
   *
   * This is a trivial lookup in the ProcState array.  We assume that the caller
   * knows that the backend isn't going to go away, so we do not bother with
   * locking.
   */
! struct PGPROC *
  BackendIdGetProc(BackendId procId)
  {
  	SISeg	   *segP = shmInvalBuffer;
***************
*** 530,536 ****
  
  		if (pOffset != INVALID_OFFSET)
  		{
! 			PROC	   *proc = (PROC *) MAKE_PTR(pOffset);
  
  			return proc;
  		}
--- 530,536 ----
  
  		if (pOffset != INVALID_OFFSET)
  		{
! 			PGPROC	   *proc = (PGPROC *) MAKE_PTR(pOffset);
  
  			return proc;
  		}
Index: src/backend/storage/lmgr/deadlock.c
===================================================================
RCS file: /projects/cvsroot/pgsql/src/backend/storage/lmgr/deadlock.c,v
retrieving revision 1.8
diff -c -r1.8 deadlock.c
*** src/backend/storage/lmgr/deadlock.c	2001/10/28 06:25:50	1.8
--- src/backend/storage/lmgr/deadlock.c	2002/06/10 17:44:29
***************
*** 31,38 ****
  /* One edge in the waits-for graph */
  typedef struct
  {
! 	PROC	   *waiter;			/* the waiting process */
! 	PROC	   *blocker;		/* the process it is waiting for */
  	int			pred;			/* workspace for TopoSort */
  	int			link;			/* workspace for TopoSort */
  } EDGE;
--- 31,38 ----
  /* One edge in the waits-for graph */
  typedef struct
  {
! 	PGPROC	   *waiter;			/* the waiting process */
! 	PGPROC	   *blocker;		/* the process it is waiting for */
  	int			pred;			/* workspace for TopoSort */
  	int			link;			/* workspace for TopoSort */
  } EDGE;
***************
*** 41,60 ****
  typedef struct
  {
  	LOCK	   *lock;			/* the lock whose wait queue is described */
! 	PROC	  **procs;			/* array of PROC *'s in new wait order */
  	int			nProcs;
  } WAIT_ORDER;
  
  
! static bool DeadLockCheckRecurse(PROC *proc);
! static bool TestConfiguration(PROC *startProc);
! static bool FindLockCycle(PROC *checkProc,
  			  EDGE *softEdges, int *nSoftEdges);
! static bool FindLockCycleRecurse(PROC *checkProc,
  					 EDGE *softEdges, int *nSoftEdges);
  static bool ExpandConstraints(EDGE *constraints, int nConstraints);
  static bool TopoSort(LOCK *lock, EDGE *constraints, int nConstraints,
! 		 PROC **ordering);
  
  #ifdef DEBUG_DEADLOCK
  static void PrintLockQueue(LOCK *lock, const char *info);
--- 41,60 ----
  typedef struct
  {
  	LOCK	   *lock;			/* the lock whose wait queue is described */
! 	PGPROC	  **procs;			/* array of PGPROC *'s in new wait order */
  	int			nProcs;
  } WAIT_ORDER;
  
  
! static bool DeadLockCheckRecurse(PGPROC *proc);
! static bool TestConfiguration(PGPROC *startProc);
! static bool FindLockCycle(PGPROC *checkProc,
  			  EDGE *softEdges, int *nSoftEdges);
! static bool FindLockCycleRecurse(PGPROC *checkProc,
  					 EDGE *softEdges, int *nSoftEdges);
  static bool ExpandConstraints(EDGE *constraints, int nConstraints);
  static bool TopoSort(LOCK *lock, EDGE *constraints, int nConstraints,
! 		 PGPROC **ordering);
  
  #ifdef DEBUG_DEADLOCK
  static void PrintLockQueue(LOCK *lock, const char *info);
***************
*** 66,83 ****
   */
  
  /* Workspace for FindLockCycle */
! static PROC **visitedProcs;		/* Array of visited procs */
  static int	nVisitedProcs;
  
  /* Workspace for TopoSort */
! static PROC **topoProcs;		/* Array of not-yet-output procs */
  static int *beforeConstraints;	/* Counts of remaining before-constraints */
  static int *afterConstraints;	/* List head for after-constraints */
  
  /* Output area for ExpandConstraints */
  static WAIT_ORDER *waitOrders;	/* Array of proposed queue rearrangements */
  static int	nWaitOrders;
! static PROC **waitOrderProcs;	/* Space for waitOrders queue contents */
  
  /* Current list of constraints being considered */
  static EDGE *curConstraints;
--- 66,83 ----
   */
  
  /* Workspace for FindLockCycle */
! static PGPROC **visitedProcs;		/* Array of visited procs */
  static int	nVisitedProcs;
  
  /* Workspace for TopoSort */
! static PGPROC **topoProcs;		/* Array of not-yet-output procs */
  static int *beforeConstraints;	/* Counts of remaining before-constraints */
  static int *afterConstraints;	/* List head for after-constraints */
  
  /* Output area for ExpandConstraints */
  static WAIT_ORDER *waitOrders;	/* Array of proposed queue rearrangements */
  static int	nWaitOrders;
! static PGPROC **waitOrderProcs;	/* Space for waitOrders queue contents */
  
  /* Current list of constraints being considered */
  static EDGE *curConstraints;
***************
*** 111,117 ****
  	/*
  	 * FindLockCycle needs at most MaxBackends entries in visitedProcs[]
  	 */
! 	visitedProcs = (PROC **) palloc(MaxBackends * sizeof(PROC *));
  
  	/*
  	 * TopoSort needs to consider at most MaxBackends wait-queue entries,
--- 111,117 ----
  	/*
  	 * FindLockCycle needs at most MaxBackends entries in visitedProcs[]
  	 */
! 	visitedProcs = (PGPROC **) palloc(MaxBackends * sizeof(PGPROC *));
  
  	/*
  	 * TopoSort needs to consider at most MaxBackends wait-queue entries,
***************
*** 128,134 ****
  	 * than MaxBackends total waiters.
  	 */
  	waitOrders = (WAIT_ORDER *) palloc((MaxBackends / 2) * sizeof(WAIT_ORDER));
! 	waitOrderProcs = (PROC **) palloc(MaxBackends * sizeof(PROC *));
  
  	/*
  	 * Allow at most MaxBackends distinct constraints in a configuration.
--- 128,134 ----
  	 * than MaxBackends total waiters.
  	 */
  	waitOrders = (WAIT_ORDER *) palloc((MaxBackends / 2) * sizeof(WAIT_ORDER));
! 	waitOrderProcs = (PGPROC **) palloc(MaxBackends * sizeof(PGPROC *));
  
  	/*
  	 * Allow at most MaxBackends distinct constraints in a configuration.
***************
*** 176,182 ****
   * interlocked!
   */
  bool
! DeadLockCheck(PROC *proc)
  {
  	int			i,
  				j;
--- 176,182 ----
   * interlocked!
   */
  bool
! DeadLockCheck(PGPROC *proc)
  {
  	int			i,
  				j;
***************
*** 194,200 ****
  	for (i = 0; i < nWaitOrders; i++)
  	{
  		LOCK	   *lock = waitOrders[i].lock;
! 		PROC	  **procs = waitOrders[i].procs;
  		int			nProcs = waitOrders[i].nProcs;
  		PROC_QUEUE *waitQueue = &(lock->waitProcs);
  
--- 194,200 ----
  	for (i = 0; i < nWaitOrders; i++)
  	{
  		LOCK	   *lock = waitOrders[i].lock;
! 		PGPROC	  **procs = waitOrders[i].procs;
  		int			nProcs = waitOrders[i].nProcs;
  		PROC_QUEUE *waitQueue = &(lock->waitProcs);
  
***************
*** 234,240 ****
   * rearrangements of lock wait queues (if any).
   */
  static bool
! DeadLockCheckRecurse(PROC *proc)
  {
  	int			nEdges;
  	int			oldPossibleConstraints;
--- 234,240 ----
   * rearrangements of lock wait queues (if any).
   */
  static bool
! DeadLockCheckRecurse(PGPROC *proc)
  {
  	int			nEdges;
  	int			oldPossibleConstraints;
***************
*** 300,306 ****
   *--------------------
   */
  static bool
! TestConfiguration(PROC *startProc)
  {
  	int			softFound = 0;
  	EDGE	   *softEdges = possibleConstraints + nPossibleConstraints;
--- 300,306 ----
   *--------------------
   */
  static bool
! TestConfiguration(PGPROC *startProc)
  {
  	int			softFound = 0;
  	EDGE	   *softEdges = possibleConstraints + nPossibleConstraints;
***************
*** 365,371 ****
   * be believed in preference to the actual ordering seen in the locktable.
   */
  static bool
! FindLockCycle(PROC *checkProc,
  			  EDGE *softEdges,	/* output argument */
  			  int *nSoftEdges)	/* output argument */
  {
--- 365,371 ----
   * be believed in preference to the actual ordering seen in the locktable.
   */
  static bool
! FindLockCycle(PGPROC *checkProc,
  			  EDGE *softEdges,	/* output argument */
  			  int *nSoftEdges)	/* output argument */
  {
***************
*** 375,385 ****
  }
  
  static bool
! FindLockCycleRecurse(PROC *checkProc,
  					 EDGE *softEdges,	/* output argument */
  					 int *nSoftEdges)	/* output argument */
  {
! 	PROC	   *proc;
  	LOCK	   *lock;
  	HOLDER	   *holder;
  	SHM_QUEUE  *lockHolders;
--- 375,385 ----
  }
  
  static bool
! FindLockCycleRecurse(PGPROC *checkProc,
  					 EDGE *softEdges,	/* output argument */
  					 int *nSoftEdges)	/* output argument */
  {
! 	PGPROC	   *proc;
  	LOCK	   *lock;
  	HOLDER	   *holder;
  	SHM_QUEUE  *lockHolders;
***************
*** 438,444 ****
  
  	while (holder)
  	{
! 		proc = (PROC *) MAKE_PTR(holder->tag.proc);
  
  		/* A proc never blocks itself */
  		if (proc != checkProc)
--- 438,444 ----
  
  	while (holder)
  	{
! 		proc = (PGPROC *) MAKE_PTR(holder->tag.proc);
  
  		/* A proc never blocks itself */
  		if (proc != checkProc)
***************
*** 480,486 ****
  	if (i < nWaitOrders)
  	{
  		/* Use the given hypothetical wait queue order */
! 		PROC	  **procs = waitOrders[i].procs;
  
  		queue_size = waitOrders[i].nProcs;
  
--- 480,486 ----
  	if (i < nWaitOrders)
  	{
  		/* Use the given hypothetical wait queue order */
! 		PGPROC	  **procs = waitOrders[i].procs;
  
  		queue_size = waitOrders[i].nProcs;
  
***************
*** 517,523 ****
  		waitQueue = &(lock->waitProcs);
  		queue_size = waitQueue->size;
  
! 		proc = (PROC *) MAKE_PTR(waitQueue->links.next);
  
  		while (queue_size-- > 0)
  		{
--- 517,523 ----
  		waitQueue = &(lock->waitProcs);
  		queue_size = waitQueue->size;
  
! 		proc = (PGPROC *) MAKE_PTR(waitQueue->links.next);
  
  		while (queue_size-- > 0)
  		{
***************
*** 543,549 ****
  				}
  			}
  
! 			proc = (PROC *) MAKE_PTR(proc->links.next);
  		}
  	}
  
--- 543,549 ----
  				}
  			}
  
! 			proc = (PGPROC *) MAKE_PTR(proc->links.next);
  		}
  	}
  
***************
*** 559,565 ****
   *		specific new orderings for affected wait queues
   *
   * Input is a list of soft edges to be reversed.  The output is a list
!  * of nWaitOrders WAIT_ORDER structs in waitOrders[], with PROC array
   * workspace in waitOrderProcs[].
   *
   * Returns TRUE if able to build an ordering that satisfies all the
--- 559,565 ----
   *		specific new orderings for affected wait queues
   *
   * Input is a list of soft edges to be reversed.  The output is a list
!  * of nWaitOrders WAIT_ORDER structs in waitOrders[], with PGPROC array
   * workspace in waitOrderProcs[].
   *
   * Returns TRUE if able to build an ordering that satisfies all the
***************
*** 582,588 ****
  	 */
  	for (i = nConstraints; --i >= 0;)
  	{
! 		PROC	   *proc = constraints[i].waiter;
  		LOCK	   *lock = proc->waitLock;
  
  		/* Did we already make a list for this lock? */
--- 582,588 ----
  	 */
  	for (i = nConstraints; --i >= 0;)
  	{
! 		PGPROC	   *proc = constraints[i].waiter;
  		LOCK	   *lock = proc->waitLock;
  
  		/* Did we already make a list for this lock? */
***************
*** 628,634 ****
   * slowness of the algorithm won't really matter.
   *
   * The initial queue ordering is taken directly from the lock's wait queue.
!  * The output is an array of PROC pointers, of length equal to the lock's
   * wait queue length (the caller is responsible for providing this space).
   * The partial order is specified by an array of EDGE structs.	Each EDGE
   * is one that we need to reverse, therefore the "waiter" must appear before
--- 628,634 ----
   * slowness of the algorithm won't really matter.
   *
   * The initial queue ordering is taken directly from the lock's wait queue.
!  * The output is an array of PGPROC pointers, of length equal to the lock's
   * wait queue length (the caller is responsible for providing this space).
   * The partial order is specified by an array of EDGE structs.	Each EDGE
   * is one that we need to reverse, therefore the "waiter" must appear before
***************
*** 642,663 ****
  TopoSort(LOCK *lock,
  		 EDGE *constraints,
  		 int nConstraints,
! 		 PROC **ordering)		/* output argument */
  {
  	PROC_QUEUE *waitQueue = &(lock->waitProcs);
  	int			queue_size = waitQueue->size;
! 	PROC	   *proc;
  	int			i,
  				j,
  				k,
  				last;
  
  	/* First, fill topoProcs[] array with the procs in their current order */
! 	proc = (PROC *) MAKE_PTR(waitQueue->links.next);
  	for (i = 0; i < queue_size; i++)
  	{
  		topoProcs[i] = proc;
! 		proc = (PROC *) MAKE_PTR(proc->links.next);
  	}
  
  	/*
--- 642,663 ----
  TopoSort(LOCK *lock,
  		 EDGE *constraints,
  		 int nConstraints,
! 		 PGPROC **ordering)		/* output argument */
  {
  	PROC_QUEUE *waitQueue = &(lock->waitProcs);
  	int			queue_size = waitQueue->size;
! 	PGPROC	   *proc;
  	int			i,
  				j,
  				k,
  				last;
  
  	/* First, fill topoProcs[] array with the procs in their current order */
! 	proc = (PGPROC *) MAKE_PTR(waitQueue->links.next);
  	for (i = 0; i < queue_size; i++)
  	{
  		topoProcs[i] = proc;
! 		proc = (PGPROC *) MAKE_PTR(proc->links.next);
  	}
  
  	/*
***************
*** 743,757 ****
  {
  	PROC_QUEUE *waitQueue = &(lock->waitProcs);
  	int			queue_size = waitQueue->size;
! 	PROC	   *proc;
  	int			i;
  
  	printf("%s lock %lx queue ", info, MAKE_OFFSET(lock));
! 	proc = (PROC *) MAKE_PTR(waitQueue->links.next);
  	for (i = 0; i < queue_size; i++)
  	{
  		printf(" %d", proc->pid);
! 		proc = (PROC *) MAKE_PTR(proc->links.next);
  	}
  	printf("\n");
  	fflush(stdout);
--- 743,757 ----
  {
  	PROC_QUEUE *waitQueue = &(lock->waitProcs);
  	int			queue_size = waitQueue->size;
! 	PGPROC	   *proc;
  	int			i;
  
  	printf("%s lock %lx queue ", info, MAKE_OFFSET(lock));
! 	proc = (PGPROC *) MAKE_PTR(waitQueue->links.next);
  	for (i = 0; i < queue_size; i++)
  	{
  		printf(" %d", proc->pid);
! 		proc = (PGPROC *) MAKE_PTR(proc->links.next);
  	}
  	printf("\n");
  	fflush(stdout);
Index: src/backend/storage/lmgr/lock.c
===================================================================
RCS file: /projects/cvsroot/pgsql/src/backend/storage/lmgr/lock.c,v
retrieving revision 1.106
diff -c -r1.106 lock.c
*** src/backend/storage/lmgr/lock.c	2002/03/06 06:10:06	1.106
--- src/backend/storage/lmgr/lock.c	2002/06/10 17:44:29
***************
*** 49,55 ****
  
  static int WaitOnLock(LOCKMETHOD lockmethod, LOCKMODE lockmode,
  		   LOCK *lock, HOLDER *holder);
! static void LockCountMyLocks(SHMEM_OFFSET lockOffset, PROC *proc,
  				 int *myHolding);
  
  static char *lock_mode_names[] =
--- 49,55 ----
  
  static int WaitOnLock(LOCKMETHOD lockmethod, LOCKMODE lockmode,
  		   LOCK *lock, HOLDER *holder);
! static void LockCountMyLocks(SHMEM_OFFSET lockOffset, PGPROC *proc,
  				 int *myHolding);
  
  static char *lock_mode_names[] =
***************
*** 746,752 ****
  				   LOCKMODE lockmode,
  				   LOCK *lock,
  				   HOLDER *holder,
! 				   PROC *proc,
  				   int *myHolding)		/* myHolding[] array or NULL */
  {
  	LOCKMETHODCTL *lockctl = lockMethodTable->ctl;
--- 746,752 ----
  				   LOCKMODE lockmode,
  				   LOCK *lock,
  				   HOLDER *holder,
! 				   PGPROC *proc,
  				   int *myHolding)		/* myHolding[] array or NULL */
  {
  	LOCKMETHODCTL *lockctl = lockMethodTable->ctl;
***************
*** 820,826 ****
   * be a net slowdown.
   */
  static void
! LockCountMyLocks(SHMEM_OFFSET lockOffset, PROC *proc, int *myHolding)
  {
  	SHM_QUEUE  *procHolders = &(proc->procHolders);
  	HOLDER	   *holder;
--- 820,826 ----
   * be a net slowdown.
   */
  static void
! LockCountMyLocks(SHMEM_OFFSET lockOffset, PGPROC *proc, int *myHolding)
  {
  	SHM_QUEUE  *procHolders = &(proc->procHolders);
  	HOLDER	   *holder;
***************
*** 944,950 ****
   * this routine can only happen if we are aborting the transaction.)
   */
  void
! RemoveFromWaitQueue(PROC *proc)
  {
  	LOCK	   *waitLock = proc->waitLock;
  	LOCKMODE	lockmode = proc->waitLockMode;
--- 944,950 ----
   * this routine can only happen if we are aborting the transaction.)
   */
  void
! RemoveFromWaitQueue(PGPROC *proc)
  {
  	LOCK	   *waitLock = proc->waitLock;
  	LOCKMODE	lockmode = proc->waitLockMode;
***************
*** 1182,1188 ****
   * specified XID are released.
   */
  bool
! LockReleaseAll(LOCKMETHOD lockmethod, PROC *proc,
  			   bool allxids, TransactionId xid)
  {
  	SHM_QUEUE  *procHolders = &(proc->procHolders);
--- 1182,1188 ----
   * specified XID are released.
   */
  bool
! LockReleaseAll(LOCKMETHOD lockmethod, PGPROC *proc,
  			   bool allxids, TransactionId xid)
  {
  	SHM_QUEUE  *procHolders = &(proc->procHolders);
***************
*** 1354,1360 ****
  	long		max_table_size = NLOCKENTS(maxBackends);
  
  	size += MAXALIGN(sizeof(PROC_HDR)); /* ProcGlobal */
! 	size += maxBackends * MAXALIGN(sizeof(PROC));		/* each MyProc */
  	size += MAX_LOCK_METHODS * MAXALIGN(sizeof(LOCKMETHODCTL)); /* each
  																 * lockMethodTable->ctl */
  
--- 1354,1360 ----
  	long		max_table_size = NLOCKENTS(maxBackends);
  
  	size += MAXALIGN(sizeof(PROC_HDR)); /* ProcGlobal */
! 	size += maxBackends * MAXALIGN(sizeof(PGPROC));		/* each MyProc */
  	size += MAX_LOCK_METHODS * MAXALIGN(sizeof(LOCKMETHODCTL)); /* each
  																 * lockMethodTable->ctl */
  
***************
*** 1383,1389 ****
  void
  DumpLocks(void)
  {
! 	PROC	   *proc;
  	SHM_QUEUE  *procHolders;
  	HOLDER	   *holder;
  	LOCK	   *lock;
--- 1383,1389 ----
  void
  DumpLocks(void)
  {
! 	PGPROC	   *proc;
  	SHM_QUEUE  *procHolders;
  	HOLDER	   *holder;
  	LOCK	   *lock;
***************
*** 1427,1433 ****
  void
  DumpAllLocks(void)
  {
! 	PROC	   *proc;
  	HOLDER	   *holder;
  	LOCK	   *lock;
  	int			lockmethod = DEFAULT_LOCKMETHOD;
--- 1427,1433 ----
  void
  DumpAllLocks(void)
  {
! 	PGPROC	   *proc;
  	HOLDER	   *holder;
  	LOCK	   *lock;
  	int			lockmethod = DEFAULT_LOCKMETHOD;
Index: src/backend/storage/lmgr/lwlock.c
===================================================================
RCS file: /projects/cvsroot/pgsql/src/backend/storage/lmgr/lwlock.c,v
retrieving revision 1.10
diff -c -r1.10 lwlock.c
*** src/backend/storage/lmgr/lwlock.c	2002/05/05 00:03:28	1.10
--- src/backend/storage/lmgr/lwlock.c	2002/06/10 17:44:30
***************
*** 29,40 ****
  
  typedef struct LWLock
  {
! 	slock_t		mutex;			/* Protects LWLock and queue of PROCs */
  	bool		releaseOK;		/* T if ok to release waiters */
  	char		exclusive;		/* # of exclusive holders (0 or 1) */
  	int			shared;			/* # of shared holders (0..MaxBackends) */
! 	PROC	   *head;			/* head of list of waiting PROCs */
! 	PROC	   *tail;			/* tail of list of waiting PROCs */
  	/* tail is undefined when head is NULL */
  } LWLock;
  
--- 29,40 ----
  
  typedef struct LWLock
  {
! 	slock_t		mutex;			/* Protects LWLock and queue of PGPROCs */
  	bool		releaseOK;		/* T if ok to release waiters */
  	char		exclusive;		/* # of exclusive holders (0 or 1) */
  	int			shared;			/* # of shared holders (0..MaxBackends) */
! 	PGPROC	   *head;			/* head of list of waiting PGPROCs */
! 	PGPROC	   *tail;			/* tail of list of waiting PGPROCs */
  	/* tail is undefined when head is NULL */
  } LWLock;
  
***************
*** 197,203 ****
  LWLockAcquire(LWLockId lockid, LWLockMode mode)
  {
  	volatile LWLock *lock = LWLockArray + lockid;
! 	PROC	   *proc = MyProc;
  	bool		retry = false;
  	int			extraWaits = 0;
  
--- 197,203 ----
  LWLockAcquire(LWLockId lockid, LWLockMode mode)
  {
  	volatile LWLock *lock = LWLockArray + lockid;
! 	PGPROC	   *proc = MyProc;
  	bool		retry = false;
  	int			extraWaits = 0;
  
***************
*** 266,277 ****
  		/*
  		 * Add myself to wait queue.
  		 *
! 		 * If we don't have a PROC structure, there's no way to wait. This
  		 * should never occur, since MyProc should only be null during
  		 * shared memory initialization.
  		 */
  		if (proc == NULL)
! 			elog(FATAL, "LWLockAcquire: can't wait without a PROC structure");
  
  		proc->lwWaiting = true;
  		proc->lwExclusive = (mode == LW_EXCLUSIVE);
--- 266,277 ----
  		/*
  		 * Add myself to wait queue.
  		 *
! 		 * If we don't have a PGPROC structure, there's no way to wait. This
  		 * should never occur, since MyProc should only be null during
  		 * shared memory initialization.
  		 */
  		if (proc == NULL)
! 			elog(FATAL, "LWLockAcquire: can't wait without a PGPROC structure");
  
  		proc->lwWaiting = true;
  		proc->lwExclusive = (mode == LW_EXCLUSIVE);
***************
*** 401,408 ****
  LWLockRelease(LWLockId lockid)
  {
  	volatile LWLock *lock = LWLockArray + lockid;
! 	PROC	   *head;
! 	PROC	   *proc;
  	int			i;
  
  	PRINT_LWDEBUG("LWLockRelease", lockid, lock);
--- 401,408 ----
  LWLockRelease(LWLockId lockid)
  {
  	volatile LWLock *lock = LWLockArray + lockid;
! 	PGPROC	   *head;
! 	PGPROC	   *proc;
  	int			i;
  
  	PRINT_LWDEBUG("LWLockRelease", lockid, lock);
***************
*** 446,452 ****
  		if (lock->exclusive == 0 && lock->shared == 0 && lock->releaseOK)
  		{
  			/*
! 			 * Remove the to-be-awakened PROCs from the queue.  If the
  			 * front waiter wants exclusive lock, awaken him only.
  			 * Otherwise awaken as many waiters as want shared access.
  			 */
--- 446,452 ----
  		if (lock->exclusive == 0 && lock->shared == 0 && lock->releaseOK)
  		{
  			/*
! 			 * Remove the to-be-awakened PGPROCs from the queue.  If the
  			 * front waiter wants exclusive lock, awaken him only.
  			 * Otherwise awaken as many waiters as want shared access.
  			 */
***************
*** 459,465 ****
  					proc = proc->lwWaitLink;
  				}
  			}
! 			/* proc is now the last PROC to be released */
  			lock->head = proc->lwWaitLink;
  			proc->lwWaitLink = NULL;
  			/* prevent additional wakeups until retryer gets to run */
--- 459,465 ----
  					proc = proc->lwWaitLink;
  				}
  			}
! 			/* proc is now the last PGPROC to be released */
  			lock->head = proc->lwWaitLink;
  			proc->lwWaitLink = NULL;
  			/* prevent additional wakeups until retryer gets to run */
Index: src/backend/storage/lmgr/proc.c
===================================================================
RCS file: /projects/cvsroot/pgsql/src/backend/storage/lmgr/proc.c,v
retrieving revision 1.119
diff -c -r1.119 proc.c
*** src/backend/storage/lmgr/proc.c	2002/05/05 00:03:28	1.119
--- src/backend/storage/lmgr/proc.c	2002/06/10 17:44:30
***************
*** 55,66 ****
  
  int			DeadlockTimeout = 1000;
  
! PROC	   *MyProc = NULL;
  
  /*
!  * This spinlock protects the freelist of recycled PROC structures.
   * We cannot use an LWLock because the LWLock manager depends on already
!  * having a PROC and a wait semaphore!  But these structures are touched
   * relatively infrequently (only at backend startup or shutdown) and not for
   * very long, so a spinlock is okay.
   */
--- 55,66 ----
  
  int			DeadlockTimeout = 1000;
  
! PGPROC	   *MyProc = NULL;
  
  /*
!  * This spinlock protects the freelist of recycled PGPROC structures.
   * We cannot use an LWLock because the LWLock manager depends on already
!  * having a PGPROC and a wait semaphore!  But these structures are touched
   * relatively infrequently (only at backend startup or shutdown) and not for
   * very long, so a spinlock is okay.
   */
***************
*** 68,74 ****
  
  static PROC_HDR *ProcGlobal = NULL;
  
! static PROC *DummyProc = NULL;
  
  static bool waitingForLock = false;
  static bool waitingForSignal = false;
--- 68,74 ----
  
  static PROC_HDR *ProcGlobal = NULL;
  
! static PGPROC *DummyProc = NULL;
  
  static bool waitingForLock = false;
  static bool waitingForSignal = false;
***************
*** 129,157 ****
  		ProcGlobal->freeProcs = INVALID_OFFSET;
  
  		/*
! 		 * Pre-create the PROC structures and create a semaphore for each.
  		 */
  		for (i = 0; i < maxBackends; i++)
  		{
! 			PROC   *proc;
  
! 			proc = (PROC *) ShmemAlloc(sizeof(PROC));
  			if (!proc)
  				elog(FATAL, "cannot create new proc: out of memory");
! 			MemSet(proc, 0, sizeof(PROC));
  			PGSemaphoreCreate(&proc->sem);
  			proc->links.next = ProcGlobal->freeProcs;
  			ProcGlobal->freeProcs = MAKE_OFFSET(proc);
  		}
  
  		/*
! 		 * Pre-allocate a PROC structure for dummy (checkpoint) processes,
  		 * too.  This does not get linked into the freeProcs list.
  		 */
! 		DummyProc = (PROC *) ShmemAlloc(sizeof(PROC));
  		if (!DummyProc)
  			elog(FATAL, "cannot create new proc: out of memory");
! 		MemSet(DummyProc, 0, sizeof(PROC));
  		DummyProc->pid = 0;		/* marks DummyProc as not in use */
  		PGSemaphoreCreate(&DummyProc->sem);
  
--- 129,157 ----
  		ProcGlobal->freeProcs = INVALID_OFFSET;
  
  		/*
! 		 * Pre-create the PGPROC structures and create a semaphore for each.
  		 */
  		for (i = 0; i < maxBackends; i++)
  		{
! 			PGPROC   *proc;
  
! 			proc = (PGPROC *) ShmemAlloc(sizeof(PGPROC));
  			if (!proc)
  				elog(FATAL, "cannot create new proc: out of memory");
! 			MemSet(proc, 0, sizeof(PGPROC));
  			PGSemaphoreCreate(&proc->sem);
  			proc->links.next = ProcGlobal->freeProcs;
  			ProcGlobal->freeProcs = MAKE_OFFSET(proc);
  		}
  
  		/*
! 		 * Pre-allocate a PGPROC structure for dummy (checkpoint) processes,
  		 * too.  This does not get linked into the freeProcs list.
  		 */
! 		DummyProc = (PGPROC *) ShmemAlloc(sizeof(PGPROC));
  		if (!DummyProc)
  			elog(FATAL, "cannot create new proc: out of memory");
! 		MemSet(DummyProc, 0, sizeof(PGPROC));
  		DummyProc->pid = 0;		/* marks DummyProc as not in use */
  		PGSemaphoreCreate(&DummyProc->sem);
  
***************
*** 183,189 ****
  
  	/*
  	 * Try to get a proc struct from the free list.  If this fails,
! 	 * we must be out of PROC structures (not to mention semaphores).
  	 */
  	SpinLockAcquire(ProcStructLock);
  
--- 183,189 ----
  
  	/*
  	 * Try to get a proc struct from the free list.  If this fails,
! 	 * we must be out of PGPROC structures (not to mention semaphores).
  	 */
  	SpinLockAcquire(ProcStructLock);
  
***************
*** 191,204 ****
  
  	if (myOffset != INVALID_OFFSET)
  	{
! 		MyProc = (PROC *) MAKE_PTR(myOffset);
  		procglobal->freeProcs = MyProc->links.next;
  		SpinLockRelease(ProcStructLock);
  	}
  	else
  	{
  		/*
! 		 * If we reach here, all the PROCs are in use.  This is one of
  		 * the possible places to detect "too many backends", so give the
  		 * standard error message.
  		 */
--- 191,204 ----
  
  	if (myOffset != INVALID_OFFSET)
  	{
! 		MyProc = (PGPROC *) MAKE_PTR(myOffset);
  		procglobal->freeProcs = MyProc->links.next;
  		SpinLockRelease(ProcStructLock);
  	}
  	else
  	{
  		/*
! 		 * If we reach here, all the PGPROCs are in use.  This is one of
  		 * the possible places to detect "too many backends", so give the
  		 * standard error message.
  		 */
***************
*** 236,242 ****
  	PGSemaphoreReset(&MyProc->sem);
  
  	/*
! 	 * Now that we have a PROC, we could try to acquire locks, so
  	 * initialize the deadlock checker.
  	 */
  	InitDeadLockChecking();
--- 236,242 ----
  	PGSemaphoreReset(&MyProc->sem);
  
  	/*
! 	 * Now that we have a PGPROC, we could try to acquire locks, so
  	 * initialize the deadlock checker.
  	 */
  	InitDeadLockChecking();
***************
*** 246,252 ****
   * InitDummyProcess -- create a dummy per-process data structure
   *
   * This is called by checkpoint processes so that they will have a MyProc
!  * value that's real enough to let them wait for LWLocks.  The PROC and
   * sema that are assigned are the extra ones created during InitProcGlobal.
   */
  void
--- 246,252 ----
   * InitDummyProcess -- create a dummy per-process data structure
   *
   * This is called by checkpoint processes so that they will have a MyProc
!  * value that's real enough to let them wait for LWLocks.  The PGPROC and
   * sema that are assigned are the extra ones created during InitProcGlobal.
   */
  void
***************
*** 402,412 ****
  
  	SpinLockAcquire(ProcStructLock);
  
! 	/* Return PROC structure (and semaphore) to freelist */
  	MyProc->links.next = procglobal->freeProcs;
  	procglobal->freeProcs = MAKE_OFFSET(MyProc);
  
! 	/* PROC struct isn't mine anymore */
  	MyProc = NULL;
  
  	SpinLockRelease(ProcStructLock);
--- 402,412 ----
  
  	SpinLockAcquire(ProcStructLock);
  
! 	/* Return PGPROC structure (and semaphore) to freelist */
  	MyProc->links.next = procglobal->freeProcs;
  	procglobal->freeProcs = MAKE_OFFSET(MyProc);
  
! 	/* PGPROC struct isn't mine anymore */
  	MyProc = NULL;
  
  	SpinLockRelease(ProcStructLock);
***************
*** 414,420 ****
  
  /*
   * DummyProcKill() -- Cut-down version of ProcKill for dummy (checkpoint)
!  *		processes.	The PROC and sema are not released, only marked
   *		as not-in-use.
   */
  static void
--- 414,420 ----
  
  /*
   * DummyProcKill() -- Cut-down version of ProcKill for dummy (checkpoint)
!  *		processes.	The PGPROC and sema are not released, only marked
   *		as not-in-use.
   */
  static void
***************
*** 433,439 ****
  	/* Mark DummyProc no longer in use */
  	MyProc->pid = 0;
  
! 	/* PROC struct isn't mine anymore */
  	MyProc = NULL;
  }
  
--- 433,439 ----
  	/* Mark DummyProc no longer in use */
  	MyProc->pid = 0;
  
! 	/* PGPROC struct isn't mine anymore */
  	MyProc = NULL;
  }
  
***************
*** 506,512 ****
  	PROC_QUEUE *waitQueue = &(lock->waitProcs);
  	int			myHeldLocks = MyProc->heldLocks;
  	bool		early_deadlock = false;
! 	PROC	   *proc;
  	int			i;
  
  	/*
--- 506,512 ----
  	PROC_QUEUE *waitQueue = &(lock->waitProcs);
  	int			myHeldLocks = MyProc->heldLocks;
  	bool		early_deadlock = false;
! 	PGPROC	   *proc;
  	int			i;
  
  	/*
***************
*** 531,537 ****
  	{
  		int			aheadRequests = 0;
  
! 		proc = (PROC *) MAKE_PTR(waitQueue->links.next);
  		for (i = 0; i < waitQueue->size; i++)
  		{
  			/* Must he wait for me? */
--- 531,537 ----
  	{
  		int			aheadRequests = 0;
  
! 		proc = (PGPROC *) MAKE_PTR(waitQueue->links.next);
  		for (i = 0; i < waitQueue->size; i++)
  		{
  			/* Must he wait for me? */
***************
*** 568,574 ****
  			}
  			/* Nope, so advance to next waiter */
  			aheadRequests |= (1 << proc->waitLockMode);
! 			proc = (PROC *) MAKE_PTR(proc->links.next);
  		}
  
  		/*
--- 568,574 ----
  			}
  			/* Nope, so advance to next waiter */
  			aheadRequests |= (1 << proc->waitLockMode);
! 			proc = (PGPROC *) MAKE_PTR(proc->links.next);
  		}
  
  		/*
***************
*** 579,585 ****
  	else
  	{
  		/* I hold no locks, so I can't push in front of anyone. */
! 		proc = (PROC *) &(waitQueue->links);
  	}
  
  	/*
--- 579,585 ----
  	else
  	{
  		/* I hold no locks, so I can't push in front of anyone. */
! 		proc = (PGPROC *) &(waitQueue->links);
  	}
  
  	/*
***************
*** 591,597 ****
  
  	lock->waitMask |= (1 << lockmode);
  
! 	/* Set up wait information in PROC object, too */
  	MyProc->waitLock = lock;
  	MyProc->waitHolder = holder;
  	MyProc->waitLockMode = lockmode;
--- 591,597 ----
  
  	lock->waitMask |= (1 << lockmode);
  
! 	/* Set up wait information in PGPROC object, too */
  	MyProc->waitLock = lock;
  	MyProc->waitHolder = holder;
  	MyProc->waitLockMode = lockmode;
***************
*** 685,704 ****
   * works correctly for that case.  To clean up in failure case, would need
   * to twiddle the lock's request counts too --- see RemoveFromWaitQueue.
   */
! PROC *
! ProcWakeup(PROC *proc, int errType)
  {
! 	PROC	   *retProc;
  
  	/* assume that masterLock has been acquired */
  
  	/* Proc should be sleeping ... */
  	if (proc->links.prev == INVALID_OFFSET ||
  		proc->links.next == INVALID_OFFSET)
! 		return (PROC *) NULL;
  
  	/* Save next process before we zap the list link */
! 	retProc = (PROC *) MAKE_PTR(proc->links.next);
  
  	/* Remove process from wait queue */
  	SHMQueueDelete(&(proc->links));
--- 685,704 ----
   * works correctly for that case.  To clean up in failure case, would need
   * to twiddle the lock's request counts too --- see RemoveFromWaitQueue.
   */
! PGPROC *
! ProcWakeup(PGPROC *proc, int errType)
  {
! 	PGPROC	   *retProc;
  
  	/* assume that masterLock has been acquired */
  
  	/* Proc should be sleeping ... */
  	if (proc->links.prev == INVALID_OFFSET ||
  		proc->links.next == INVALID_OFFSET)
! 		return (PGPROC *) NULL;
  
  	/* Save next process before we zap the list link */
! 	retProc = (PGPROC *) MAKE_PTR(proc->links.next);
  
  	/* Remove process from wait queue */
  	SHMQueueDelete(&(proc->links));
***************
*** 726,732 ****
  	LOCKMETHODCTL *lockctl = lockMethodTable->ctl;
  	PROC_QUEUE *waitQueue = &(lock->waitProcs);
  	int			queue_size = waitQueue->size;
! 	PROC	   *proc;
  	int			aheadRequests = 0;
  
  	Assert(queue_size >= 0);
--- 726,732 ----
  	LOCKMETHODCTL *lockctl = lockMethodTable->ctl;
  	PROC_QUEUE *waitQueue = &(lock->waitProcs);
  	int			queue_size = waitQueue->size;
! 	PGPROC	   *proc;
  	int			aheadRequests = 0;
  
  	Assert(queue_size >= 0);
***************
*** 734,740 ****
  	if (queue_size == 0)
  		return;
  
! 	proc = (PROC *) MAKE_PTR(waitQueue->links.next);
  
  	while (queue_size-- > 0)
  	{
--- 734,740 ----
  	if (queue_size == 0)
  		return;
  
! 	proc = (PGPROC *) MAKE_PTR(waitQueue->links.next);
  
  	while (queue_size-- > 0)
  	{
***************
*** 769,775 ****
  			 * checks.
  			 */
  			aheadRequests |= (1 << lockmode);
! 			proc = (PROC *) MAKE_PTR(proc->links.next);
  		}
  	}
  
--- 769,775 ----
  			 * checks.
  			 */
  			aheadRequests |= (1 << lockmode);
! 			proc = (PGPROC *) MAKE_PTR(proc->links.next);
  		}
  	}
  
***************
*** 902,908 ****
  void
  ProcSendSignal(BackendId procId)
  {
! 	PROC	   *proc = BackendIdGetProc(procId);
  
  	if (proc != NULL)
  		PGSemaphoreUnlock(&proc->sem);
--- 902,908 ----
  void
  ProcSendSignal(BackendId procId)
  {
! 	PGPROC	   *proc = BackendIdGetProc(procId);
  
  	if (proc != NULL)
  		PGSemaphoreUnlock(&proc->sem);
Index: src/backend/utils/adt/date.c
===================================================================
RCS file: /projects/cvsroot/pgsql/src/backend/utils/adt/date.c,v
retrieving revision 1.67
diff -c -r1.67 date.c
*** src/backend/utils/adt/date.c	2002/06/01 15:52:15	1.67
--- src/backend/utils/adt/date.c	2002/06/10 17:44:30
***************
*** 69,75 ****
  		case DTK_CURRENT:
  			elog(ERROR, "Date CURRENT no longer supported"
  				 "\n\tdate_in() internal coding error");
! 			GetCurrentTime(tm);
  			break;
  
  		case DTK_EPOCH:
--- 69,75 ----
  		case DTK_CURRENT:
  			elog(ERROR, "Date CURRENT no longer supported"
  				 "\n\tdate_in() internal coding error");
! 			GetCurrentDateTime(tm);
  			break;
  
  		case DTK_EPOCH:
***************
*** 1697,1703 ****
  	fsec_t		fsec;
  	int			tz;
  
! 	GetCurrentTime(tm);
  	time2tm(time, tm, &fsec);
  	tz = DetermineLocalTimeZone(tm);
  
--- 1697,1703 ----
  	fsec_t		fsec;
  	int			tz;
  
! 	GetCurrentDateTime(tm);
  	time2tm(time, tm, &fsec);
  	tz = DetermineLocalTimeZone(tm);
  
Index: src/backend/utils/adt/datetime.c
===================================================================
RCS file: /projects/cvsroot/pgsql/src/backend/utils/adt/datetime.c,v
retrieving revision 1.90
diff -c -r1.90 datetime.c
*** src/backend/utils/adt/datetime.c	2002/05/17 01:19:18	1.90
--- src/backend/utils/adt/datetime.c	2002/06/10 17:44:31
***************
*** 83,89 ****
  	{"acst", DTZ, NEG(24)},		/* Atlantic/Porto Acre */
  	{"act", TZ, NEG(30)},		/* Atlantic/Porto Acre */
  	{DA_D, ADBC, AD},			/* "ad" for years >= 0 */
! 	{"abstime", IGNORE, 0},		/* for pre-v6.1 "Invalid Abstime" */
  	{"adt", DTZ, NEG(18)},		/* Atlantic Daylight Time */
  	{"aesst", DTZ, 66},			/* E. Australia */
  	{"aest", TZ, 60},			/* Australia Eastern Std Time */
--- 83,89 ----
  	{"acst", DTZ, NEG(24)},		/* Atlantic/Porto Acre */
  	{"act", TZ, NEG(30)},		/* Atlantic/Porto Acre */
  	{DA_D, ADBC, AD},			/* "ad" for years >= 0 */
! 	{"abstime", IGNORE_DTF, 0},		/* for pre-v6.1 "Invalid Abstime" */
  	{"adt", DTZ, NEG(18)},		/* Atlantic Daylight Time */
  	{"aesst", DTZ, 66},			/* E. Australia */
  	{"aest", TZ, 60},			/* Australia Eastern Std Time */
***************
*** 115,121 ****
  	{"apr", MONTH, 4},
  	{"april", MONTH, 4},
  	{"ast", TZ, NEG(24)},		/* Atlantic Std Time (Canada) */
! 	{"at", IGNORE, 0},			/* "at" (throwaway) */
  	{"aug", MONTH, 8},
  	{"august", MONTH, 8},
  	{"awsst", DTZ, 54},			/* W. Australia */
--- 115,121 ----
  	{"apr", MONTH, 4},
  	{"april", MONTH, 4},
  	{"ast", TZ, NEG(24)},		/* Atlantic Std Time (Canada) */
! 	{"at", IGNORE_DTF, 0},			/* "at" (throwaway) */
  	{"aug", MONTH, 8},
  	{"august", MONTH, 8},
  	{"awsst", DTZ, 54},			/* W. Australia */
***************
*** 348,354 ****
  	{"october", MONTH, 10},
  	{"omsst", DTZ, 42},			/* Omsk Summer Time */
  	{"omst", TZ, 36},			/* Omsk Time */
! 	{"on", IGNORE, 0},			/* "on" (throwaway) */
  	{"pdt", DTZ, NEG(42)},		/* Pacific Daylight Time */
  #if 0
  pest
--- 348,354 ----
  	{"october", MONTH, 10},
  	{"omsst", DTZ, 42},			/* Omsk Summer Time */
  	{"omst", TZ, 36},			/* Omsk Time */
! 	{"on", IGNORE_DTF, 0},			/* "on" (throwaway) */
  	{"pdt", DTZ, NEG(42)},		/* Pacific Daylight Time */
  #if 0
  pest
***************
*** 494,500 ****
  
  static datetkn deltatktbl[] = {
  	/* text, token, lexval */
! 	{"@", IGNORE, 0},			/* postgres relative prefix */
  	{DAGO, AGO, 0},				/* "ago" indicates negative time offset */
  	{"c", UNITS, DTK_CENTURY},	/* "century" relative */
  	{"cent", UNITS, DTK_CENTURY},		/* "century" relative */
--- 494,500 ----
  
  static datetkn deltatktbl[] = {
  	/* text, token, lexval */
! 	{"@", IGNORE_DTF, 0},			/* postgres relative prefix */
  	{DAGO, AGO, 0},				/* "ago" indicates negative time offset */
  	{"c", UNITS, DTK_CENTURY},	/* "century" relative */
  	{"cent", UNITS, DTK_CENTURY},		/* "century" relative */
***************
*** 536,542 ****
  	{"msecs", UNITS, DTK_MILLISEC},
  	{"qtr", UNITS, DTK_QUARTER},	/* "quarter" relative */
  	{DQUARTER, UNITS, DTK_QUARTER},		/* "quarter" relative */
! 	{"reltime", IGNORE, 0},		/* pre-v6.1 "Undefined Reltime" */
  	{"s", UNITS, DTK_SECOND},
  	{"sec", UNITS, DTK_SECOND},
  	{DSECOND, UNITS, DTK_SECOND},
--- 536,542 ----
  	{"msecs", UNITS, DTK_MILLISEC},
  	{"qtr", UNITS, DTK_QUARTER},	/* "quarter" relative */
  	{DQUARTER, UNITS, DTK_QUARTER},		/* "quarter" relative */
! 	{"reltime", IGNORE_DTF, 0},		/* pre-v6.1 "Undefined Reltime" */
  	{"s", UNITS, DTK_SECOND},
  	{"sec", UNITS, DTK_SECOND},
  	{DSECOND, UNITS, DTK_SECOND},
***************
*** 1198,1204 ****
  			case DTK_STRING:
  			case DTK_SPECIAL:
  				type = DecodeSpecial(i, field[i], &val);
! 				if (type == IGNORE)
  					continue;
  
  				tmask = DTK_M(type);
--- 1198,1204 ----
  			case DTK_STRING:
  			case DTK_SPECIAL:
  				type = DecodeSpecial(i, field[i], &val);
! 				if (type == IGNORE_DTF)
  					continue;
  
  				tmask = DTK_M(type);
***************
*** 1223,1229 ****
  							case DTK_YESTERDAY:
  								tmask = DTK_DATE_M;
  								*dtype = DTK_DATE;
! 								GetCurrentTime(tm);
  								j2date((date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) - 1),
  								&tm->tm_year, &tm->tm_mon, &tm->tm_mday);
  								tm->tm_hour = 0;
--- 1223,1229 ----
  							case DTK_YESTERDAY:
  								tmask = DTK_DATE_M;
  								*dtype = DTK_DATE;
! 								GetCurrentDateTime(tm);
  								j2date((date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) - 1),
  								&tm->tm_year, &tm->tm_mon, &tm->tm_mday);
  								tm->tm_hour = 0;
***************
*** 1234,1240 ****
  							case DTK_TODAY:
  								tmask = DTK_DATE_M;
  								*dtype = DTK_DATE;
! 								GetCurrentTime(tm);
  								tm->tm_hour = 0;
  								tm->tm_min = 0;
  								tm->tm_sec = 0;
--- 1234,1240 ----
  							case DTK_TODAY:
  								tmask = DTK_DATE_M;
  								*dtype = DTK_DATE;
! 								GetCurrentDateTime(tm);
  								tm->tm_hour = 0;
  								tm->tm_min = 0;
  								tm->tm_sec = 0;
***************
*** 1243,1249 ****
  							case DTK_TOMORROW:
  								tmask = DTK_DATE_M;
  								*dtype = DTK_DATE;
! 								GetCurrentTime(tm);
  								j2date((date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) + 1),
  								&tm->tm_year, &tm->tm_mon, &tm->tm_mday);
  								tm->tm_hour = 0;
--- 1243,1249 ----
  							case DTK_TOMORROW:
  								tmask = DTK_DATE_M;
  								*dtype = DTK_DATE;
! 								GetCurrentDateTime(tm);
  								j2date((date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) + 1),
  								&tm->tm_year, &tm->tm_mon, &tm->tm_mday);
  								tm->tm_hour = 0;
***************
*** 1319,1325 ****
  						ftype[i] = DTK_TZ;
  						break;
  
! 					case IGNORE:
  						break;
  
  					case AMPM:
--- 1319,1325 ----
  						ftype[i] = DTK_TZ;
  						break;
  
! 					case IGNORE_DTF:
  						break;
  
  					case AMPM:
***************
*** 1815,1821 ****
  			case DTK_STRING:
  			case DTK_SPECIAL:
  				type = DecodeSpecial(i, field[i], &val);
! 				if (type == IGNORE)
  					continue;
  
  				tmask = DTK_M(type);
--- 1815,1821 ----
  			case DTK_STRING:
  			case DTK_SPECIAL:
  				type = DecodeSpecial(i, field[i], &val);
! 				if (type == IGNORE_DTF)
  					continue;
  
  				tmask = DTK_M(type);
***************
*** 1885,1891 ****
  						ftype[i] = DTK_TZ;
  						break;
  
! 					case IGNORE:
  						break;
  
  					case AMPM:
--- 1885,1891 ----
  						ftype[i] = DTK_TZ;
  						break;
  
! 					case IGNORE_DTF:
  						break;
  
  					case AMPM:
***************
*** 1967,1973 ****
  
  		if ((fmask & DTK_DATE_M) == 0)
  		{
! 			GetCurrentTime(tmp);
  		}
  		else
  		{
--- 1967,1973 ----
  
  		if ((fmask & DTK_DATE_M) == 0)
  		{
! 			GetCurrentDateTime(tmp);
  		}
  		else
  		{
***************
*** 2043,2049 ****
  		if (isalpha((unsigned char) *field[i]))
  		{
  			type = DecodeSpecial(i, field[i], &val);
! 			if (type == IGNORE)
  				continue;
  
  			dmask = DTK_M(type);
--- 2043,2049 ----
  		if (isalpha((unsigned char) *field[i]))
  		{
  			type = DecodeSpecial(i, field[i], &val);
! 			if (type == IGNORE_DTF)
  				continue;
  
  			dmask = DTK_M(type);
***************
*** 2576,2582 ****
  
  	*dtype = DTK_DELTA;
  
! 	type = IGNORE;
  	tm->tm_year = 0;
  	tm->tm_mon = 0;
  	tm->tm_mday = 0;
--- 2576,2582 ----
  
  	*dtype = DTK_DELTA;
  
! 	type = IGNORE_DTF;
  	tm->tm_year = 0;
  	tm->tm_mon = 0;
  	tm->tm_mday = 0;
***************
*** 2633,2639 ****
  					tmask = DTK_M(TZ);
  					break;
  				}
! 				else if (type == IGNORE)
  				{
  					if (*cp == '.')
  					{
--- 2633,2639 ----
  					tmask = DTK_M(TZ);
  					break;
  				}
! 				else if (type == IGNORE_DTF)
  				{
  					if (*cp == '.')
  					{
***************
*** 2658,2664 ****
  			case DTK_NUMBER:
  				val = strtol(field[i], &cp, 10);
  
! 				if (type == IGNORE)
  					type = DTK_SECOND;
  
  				if (*cp == '.')
--- 2658,2664 ----
  			case DTK_NUMBER:
  				val = strtol(field[i], &cp, 10);
  
! 				if (type == IGNORE_DTF)
  					type = DTK_SECOND;
  
  				if (*cp == '.')
***************
*** 2826,2832 ****
  			case DTK_STRING:
  			case DTK_SPECIAL:
  				type = DecodeUnits(i, field[i], &val);
! 				if (type == IGNORE)
  					continue;
  
  				tmask = 0;		/* DTK_M(type); */
--- 2826,2832 ----
  			case DTK_STRING:
  			case DTK_SPECIAL:
  				type = DecodeUnits(i, field[i], &val);
! 				if (type == IGNORE_DTF)
  					continue;
  
  				tmask = 0;		/* DTK_M(type); */
Index: src/backend/utils/adt/nabstime.c
===================================================================
RCS file: /projects/cvsroot/pgsql/src/backend/utils/adt/nabstime.c,v
retrieving revision 1.93
diff -c -r1.93 nabstime.c
*** src/backend/utils/adt/nabstime.c	2002/04/21 19:48:12	1.93
--- src/backend/utils/adt/nabstime.c	2002/06/10 17:44:31
***************
*** 239,252 ****
  
  
  void
! GetCurrentTime(struct tm * tm)
  {
  	int			tz;
  
  	abstime2tm(GetCurrentTransactionStartTime(), &tz, tm, NULL);
  
  	return;
! }	/* GetCurrentTime() */
  
  
  void
--- 239,252 ----
  
  
  void
! GetCurrentDateTime(struct tm * tm)
  {
  	int			tz;
  
  	abstime2tm(GetCurrentTransactionStartTime(), &tz, tm, NULL);
  
  	return;
! }	/* GetCurrentDateTime() */
  
  
  void
Index: src/backend/utils/adt/name.c
===================================================================
RCS file: /projects/cvsroot/pgsql/src/backend/utils/adt/name.c,v
retrieving revision 1.35
diff -c -r1.35 name.c
*** src/backend/utils/adt/name.c	2002/05/17 20:53:33	1.35
--- src/backend/utils/adt/name.c	2002/06/10 17:44:31
***************
*** 219,231 ****
  Datum
  current_user(PG_FUNCTION_ARGS)
  {
! 	PG_RETURN_DATUM(DirectFunctionCall1(namein, CStringGetDatum(GetUserName(GetUserId()))));
  }
  
  Datum
  session_user(PG_FUNCTION_ARGS)
  {
! 	PG_RETURN_DATUM(DirectFunctionCall1(namein, CStringGetDatum(GetUserName(GetSessionUserId()))));
  }
  
  
--- 219,231 ----
  Datum
  current_user(PG_FUNCTION_ARGS)
  {
! 	PG_RETURN_DATUM(DirectFunctionCall1(namein, CStringGetDatum(GetUserNameFromId(GetUserId()))));
  }
  
  Datum
  session_user(PG_FUNCTION_ARGS)
  {
! 	PG_RETURN_DATUM(DirectFunctionCall1(namein, CStringGetDatum(GetUserNameFromId(GetSessionUserId()))));
  }
  
  
Index: src/backend/utils/init/miscinit.c
===================================================================
RCS file: /projects/cvsroot/pgsql/src/backend/utils/init/miscinit.c,v
retrieving revision 1.91
diff -c -r1.91 miscinit.c
*** src/backend/utils/init/miscinit.c	2002/05/17 01:19:18	1.91
--- src/backend/utils/init/miscinit.c	2002/06/10 17:44:31
***************
*** 676,682 ****
   * Get user name from user id
   */
  char *
! GetUserName(Oid userid)
  {
  	HeapTuple	tuple;
  	char	   *result;
--- 676,682 ----
   * Get user name from user id
   */
  char *
! GetUserNameFromId(Oid userid)
  {
  	HeapTuple	tuple;
  	char	   *result;
Index: src/backend/utils/init/postinit.c
===================================================================
RCS file: /projects/cvsroot/pgsql/src/backend/utils/init/postinit.c,v
retrieving revision 1.106
diff -c -r1.106 postinit.c
*** src/backend/utils/init/postinit.c	2002/05/20 23:51:43	1.106
--- src/backend/utils/init/postinit.c	2002/06/10 17:44:31
***************
*** 286,294 ****
  	 */
  
  	/*
! 	 * Set up my per-backend PROC struct in shared memory.	(We need to
  	 * know MyDatabaseId before we can do this, since it's entered into
! 	 * the PROC struct.)
  	 */
  	InitProcess();
  
--- 286,294 ----
  	 */
  
  	/*
! 	 * Set up my per-backend PGPROC struct in shared memory.	(We need to
  	 * know MyDatabaseId before we can do this, since it's entered into
! 	 * the PGPROC struct.)
  	 */
  	InitProcess();
  
Index: src/include/miscadmin.h
===================================================================
RCS file: /projects/cvsroot/pgsql/src/include/miscadmin.h,v
retrieving revision 1.104
diff -c -r1.104 miscadmin.h
*** src/include/miscadmin.h	2002/05/17 01:19:19	1.104
--- src/include/miscadmin.h	2002/06/10 17:44:31
***************
*** 203,209 ****
  extern void SetDatabaseName(const char *name);
  extern void SetDatabasePath(const char *path);
  
! extern char *GetUserName(Oid userid);
  
  extern Oid	GetUserId(void);
  extern void SetUserId(Oid userid);
--- 203,209 ----
  extern void SetDatabaseName(const char *name);
  extern void SetDatabasePath(const char *path);
  
! extern char *GetUserNameFromId(Oid userid);
  
  extern Oid	GetUserId(void);
  extern void SetUserId(Oid userid);
Index: src/include/storage/lock.h
===================================================================
RCS file: /projects/cvsroot/pgsql/src/include/storage/lock.h,v
retrieving revision 1.59
diff -c -r1.59 lock.h
*** src/include/storage/lock.h	2001/11/05 17:46:35	1.59
--- src/include/storage/lock.h	2002/06/10 17:44:31
***************
*** 22,33 ****
  /* originally in procq.h */
  typedef struct PROC_QUEUE
  {
! 	SHM_QUEUE	links;			/* head of list of PROC objects */
  	int			size;			/* number of entries in list */
  } PROC_QUEUE;
  
! /* struct PROC is declared in storage/proc.h, but must forward-reference it */
! typedef struct PROC PROC;
  
  
  extern int	max_locks_per_xact;
--- 22,33 ----
  /* originally in procq.h */
  typedef struct PROC_QUEUE
  {
! 	SHM_QUEUE	links;			/* head of list of PGPROC objects */
  	int			size;			/* number of entries in list */
  } PROC_QUEUE;
  
! /* struct PGPROC is declared in storage/proc.h, but must forward-reference it */
! typedef struct PGPROC PGPROC;
  
  
  extern int	max_locks_per_xact;
***************
*** 161,167 ****
  	int			grantMask;		/* bitmask for lock types already granted */
  	int			waitMask;		/* bitmask for lock types awaited */
  	SHM_QUEUE	lockHolders;	/* list of HOLDER objects assoc. with lock */
! 	PROC_QUEUE	waitProcs;		/* list of PROC objects waiting on lock */
  	int			requested[MAX_LOCKMODES];		/* counts of requested
  												 * locks */
  	int			nRequested;		/* total of requested[] array */
--- 161,167 ----
  	int			grantMask;		/* bitmask for lock types already granted */
  	int			waitMask;		/* bitmask for lock types awaited */
  	SHM_QUEUE	lockHolders;	/* list of HOLDER objects assoc. with lock */
! 	PROC_QUEUE	waitProcs;		/* list of PGPROC objects waiting on lock */
  	int			requested[MAX_LOCKMODES];		/* counts of requested
  												 * locks */
  	int			nRequested;		/* total of requested[] array */
***************
*** 181,188 ****
   * holder hashtable.  A HOLDERTAG value uniquely identifies a lock holder.
   *
   * There are two possible kinds of holder tags: a transaction (identified
!  * both by the PROC of the backend running it, and the xact's own ID) and
!  * a session (identified by backend PROC, with xid = InvalidTransactionId).
   *
   * Currently, session holders are used for user locks and for cross-xact
   * locks obtained for VACUUM.  We assume that a session lock never conflicts
--- 181,188 ----
   * holder hashtable.  A HOLDERTAG value uniquely identifies a lock holder.
   *
   * There are two possible kinds of holder tags: a transaction (identified
!  * both by the PGPROC of the backend running it, and the xact's own ID) and
!  * a session (identified by backend PGPROC, with xid = InvalidTransactionId).
   *
   * Currently, session holders are used for user locks and for cross-xact
   * locks obtained for VACUUM.  We assume that a session lock never conflicts
***************
*** 195,209 ****
   * as soon as convenient.
   *
   * Each HOLDER object is linked into lists for both the associated LOCK object
!  * and the owning PROC object.	Note that the HOLDER is entered into these
   * lists as soon as it is created, even if no lock has yet been granted.
!  * A PROC that is waiting for a lock to be granted will also be linked into
   * the lock's waitProcs queue.
   */
  typedef struct HOLDERTAG
  {
  	SHMEM_OFFSET lock;			/* link to per-lockable-object information */
! 	SHMEM_OFFSET proc;			/* link to PROC of owning backend */
  	TransactionId xid;			/* xact ID, or InvalidTransactionId */
  } HOLDERTAG;
  
--- 195,209 ----
   * as soon as convenient.
   *
   * Each HOLDER object is linked into lists for both the associated LOCK object
!  * and the owning PGPROC object.	Note that the HOLDER is entered into these
   * lists as soon as it is created, even if no lock has yet been granted.
!  * A PGPROC that is waiting for a lock to be granted will also be linked into
   * the lock's waitProcs queue.
   */
  typedef struct HOLDERTAG
  {
  	SHMEM_OFFSET lock;			/* link to per-lockable-object information */
! 	SHMEM_OFFSET proc;			/* link to PGPROC of owning backend */
  	TransactionId xid;			/* xact ID, or InvalidTransactionId */
  } HOLDERTAG;
  
***************
*** 235,250 ****
  			TransactionId xid, LOCKMODE lockmode, bool dontWait);
  extern bool LockRelease(LOCKMETHOD lockmethod, LOCKTAG *locktag,
  			TransactionId xid, LOCKMODE lockmode);
! extern bool LockReleaseAll(LOCKMETHOD lockmethod, PROC *proc,
  			   bool allxids, TransactionId xid);
  extern int LockCheckConflicts(LOCKMETHODTABLE *lockMethodTable,
  				   LOCKMODE lockmode,
! 				   LOCK *lock, HOLDER *holder, PROC *proc,
  				   int *myHolding);
  extern void GrantLock(LOCK *lock, HOLDER *holder, LOCKMODE lockmode);
! extern void RemoveFromWaitQueue(PROC *proc);
  extern int	LockShmemSize(int maxBackends);
! extern bool DeadLockCheck(PROC *proc);
  extern void InitDeadLockChecking(void);
  
  #ifdef LOCK_DEBUG
--- 235,250 ----
  			TransactionId xid, LOCKMODE lockmode, bool dontWait);
  extern bool LockRelease(LOCKMETHOD lockmethod, LOCKTAG *locktag,
  			TransactionId xid, LOCKMODE lockmode);
! extern bool LockReleaseAll(LOCKMETHOD lockmethod, PGPROC *proc,
  			   bool allxids, TransactionId xid);
  extern int LockCheckConflicts(LOCKMETHODTABLE *lockMethodTable,
  				   LOCKMODE lockmode,
! 				   LOCK *lock, HOLDER *holder, PGPROC *proc,
  				   int *myHolding);
  extern void GrantLock(LOCK *lock, HOLDER *holder, LOCKMODE lockmode);
! extern void RemoveFromWaitQueue(PGPROC *proc);
  extern int	LockShmemSize(int maxBackends);
! extern bool DeadLockCheck(PGPROC *proc);
  extern void InitDeadLockChecking(void);
  
  #ifdef LOCK_DEBUG
Index: src/include/storage/proc.h
===================================================================
RCS file: /projects/cvsroot/pgsql/src/include/storage/proc.h,v
retrieving revision 1.55
diff -c -r1.55 proc.h
*** src/include/storage/proc.h	2002/05/05 00:03:29	1.55
--- src/include/storage/proc.h	2002/06/10 17:44:31
***************
*** 21,34 ****
  
  
  /*
!  * Each backend has a PROC struct in shared memory.  There is also a list of
!  * currently-unused PROC structs that will be reallocated to new backends.
   *
!  * links: list link for any list the PROC is in.  When waiting for a lock,
!  * the PROC is linked into that lock's waitProcs queue.  A recycled PROC
   * is linked into ProcGlobal's freeProcs list.
   */
! struct PROC
  {
  	/* proc->links MUST BE FIRST IN STRUCT (see ProcSleep,ProcWakeup,etc) */
  	SHM_QUEUE	links;			/* list link if process is in a list */
--- 21,34 ----
  
  
  /*
!  * Each backend has a PGPROC struct in shared memory.  There is also a list of
!  * currently-unused PGPROC structs that will be reallocated to new backends.
   *
!  * links: list link for any list the PGPROC is in.  When waiting for a lock,
!  * the PGPROC is linked into that lock's waitProcs queue.  A recycled PGPROC
   * is linked into ProcGlobal's freeProcs list.
   */
! struct PGPROC
  {
  	/* proc->links MUST BE FIRST IN STRUCT (see ProcSleep,ProcWakeup,etc) */
  	SHM_QUEUE	links;			/* list link if process is in a list */
***************
*** 56,62 ****
  	/* Info about LWLock the process is currently waiting for, if any. */
  	bool		lwWaiting;		/* true if waiting for an LW lock */
  	bool		lwExclusive;	/* true if waiting for exclusive access */
! 	struct PROC *lwWaitLink;	/* next waiter for same LW lock */
  
  	/* Info about lock the process is currently waiting for, if any. */
  	/* waitLock and waitHolder are NULL if not currently waiting. */
--- 56,62 ----
  	/* Info about LWLock the process is currently waiting for, if any. */
  	bool		lwWaiting;		/* true if waiting for an LW lock */
  	bool		lwExclusive;	/* true if waiting for exclusive access */
! 	struct PGPROC *lwWaitLink;	/* next waiter for same LW lock */
  
  	/* Info about lock the process is currently waiting for, if any. */
  	/* waitLock and waitHolder are NULL if not currently waiting. */
***************
*** 70,79 ****
  								 * or awaited by this backend */
  };
  
! /* NOTE: "typedef struct PROC PROC" appears in storage/lock.h. */
  
  
! extern PROC *MyProc;
  
  
  /*
--- 70,79 ----
  								 * or awaited by this backend */
  };
  
! /* NOTE: "typedef struct PGPROC PGPROC" appears in storage/lock.h. */
  
  
! extern PGPROC *MyProc;
  
  
  /*
***************
*** 81,87 ****
   */
  typedef struct PROC_HDR
  {
! 	/* Head of list of free PROC structures */
  	SHMEM_OFFSET freeProcs;
  } PROC_HDR;
  
--- 81,87 ----
   */
  typedef struct PROC_HDR
  {
! 	/* Head of list of free PGPROC structures */
  	SHMEM_OFFSET freeProcs;
  } PROC_HDR;
  
***************
*** 102,108 ****
  extern void ProcQueueInit(PROC_QUEUE *queue);
  extern int ProcSleep(LOCKMETHODTABLE *lockMethodTable, LOCKMODE lockmode,
  		  LOCK *lock, HOLDER *holder);
! extern PROC *ProcWakeup(PROC *proc, int errType);
  extern void ProcLockWakeup(LOCKMETHODTABLE *lockMethodTable, LOCK *lock);
  extern bool LockWaitCancel(void);
  extern void HandleDeadLock(SIGNAL_ARGS);
--- 102,108 ----
  extern void ProcQueueInit(PROC_QUEUE *queue);
  extern int ProcSleep(LOCKMETHODTABLE *lockMethodTable, LOCKMODE lockmode,
  		  LOCK *lock, HOLDER *holder);
! extern PGPROC *ProcWakeup(PGPROC *proc, int errType);
  extern void ProcLockWakeup(LOCKMETHODTABLE *lockMethodTable, LOCK *lock);
  extern bool LockWaitCancel(void);
  extern void HandleDeadLock(SIGNAL_ARGS);
Index: src/include/storage/sinval.h
===================================================================
RCS file: /projects/cvsroot/pgsql/src/include/storage/sinval.h,v
retrieving revision 1.26
diff -c -r1.26 sinval.h
*** src/include/storage/sinval.h	2002/03/03 17:47:56	1.26
--- src/include/storage/sinval.h	2002/06/10 17:44:31
***************
*** 86,92 ****
  extern TransactionId GetOldestXmin(bool allDbs);
  extern int	CountActiveBackends(void);
  
! /* Use "struct PROC", not PROC, to avoid including proc.h here */
! extern struct PROC *BackendIdGetProc(BackendId procId);
  
  #endif   /* SINVAL_H */
--- 86,92 ----
  extern TransactionId GetOldestXmin(bool allDbs);
  extern int	CountActiveBackends(void);
  
! /* Use "struct PGPROC", not PGPROC, to avoid including proc.h here */
! extern struct PGPROC *BackendIdGetProc(BackendId procId);
  
  #endif   /* SINVAL_H */
Index: src/include/storage/sinvaladt.h
===================================================================
RCS file: /projects/cvsroot/pgsql/src/include/storage/sinvaladt.h,v
retrieving revision 1.30
diff -c -r1.30 sinvaladt.h
*** src/include/storage/sinvaladt.h	2001/11/05 17:46:35	1.30
--- src/include/storage/sinvaladt.h	2002/06/10 17:44:31
***************
*** 71,77 ****
  	/* nextMsgNum is -1 in an inactive ProcState array entry. */
  	int			nextMsgNum;		/* next message number to read, or -1 */
  	bool		resetState;		/* true, if backend has to reset its state */
! 	SHMEM_OFFSET procStruct;	/* location of backend's PROC struct */
  } ProcState;
  
  /* Shared cache invalidation memory segment */
--- 71,77 ----
  	/* nextMsgNum is -1 in an inactive ProcState array entry. */
  	int			nextMsgNum;		/* next message number to read, or -1 */
  	bool		resetState;		/* true, if backend has to reset its state */
! 	SHMEM_OFFSET procStruct;	/* location of backend's PGPROC struct */
  } ProcState;
  
  /* Shared cache invalidation memory segment */
Index: src/include/utils/datetime.h
===================================================================
RCS file: /projects/cvsroot/pgsql/src/include/utils/datetime.h,v
retrieving revision 1.30
diff -c -r1.30 datetime.h
*** src/include/utils/datetime.h	2002/05/17 01:19:19	1.30
--- src/include/utils/datetime.h	2002/06/10 17:44:31
***************
*** 95,101 ****
  #define TZ		5
  #define DTZ		6
  #define DTZMOD	7
! #define IGNORE	8
  #define AMPM	9
  #define HOUR	10
  #define MINUTE	11
--- 95,101 ----
  #define TZ		5
  #define DTZ		6
  #define DTZMOD	7
! #define IGNORE_DTF	8
  #define AMPM	9
  #define HOUR	10
  #define MINUTE	11
***************
*** 260,266 ****
    || (((m) == UTIME_MAXMONTH) && ((d) <= UTIME_MAXDAY))))))
  
  
! extern void GetCurrentTime(struct tm * tm);
  extern void GetCurrentTimeUsec(struct tm * tm, fsec_t *fsec);
  extern void j2date(int jd, int *year, int *month, int *day);
  extern int	date2j(int year, int month, int day);
--- 260,266 ----
    || (((m) == UTIME_MAXMONTH) && ((d) <= UTIME_MAXDAY))))))
  
  
! extern void GetCurrentDateTime(struct tm * tm);
  extern void GetCurrentTimeUsec(struct tm * tm, fsec_t *fsec);
  extern void j2date(int jd, int *year, int *month, int *day);
  extern int	date2j(int year, int month, int day);
Index: src/include/utils/exc.h
===================================================================
RCS file: /projects/cvsroot/pgsql/src/include/utils/exc.h,v
retrieving revision 1.22
diff -c -r1.22 exc.h
*** src/include/utils/exc.h	2001/11/05 17:46:36	1.22
--- src/include/utils/exc.h	2002/06/10 17:44:31
***************
*** 40,46 ****
  /* These are not used anywhere 1998/6/15 */
  #define ExcBegin() \
  do { \
! 	ExcFrame		exception; \
  	\
  	exception.link = ExcCurFrameP; \
  	if (sigsetjmp(exception.context, 1) == 0) \
--- 40,46 ----
  /* These are not used anywhere 1998/6/15 */
  #define ExcBegin() \
  do { \
! 	ExcFrame	exception; \
  	\
  	exception.link = ExcCurFrameP; \
  	if (sigsetjmp(exception.context, 1) == 0) \
Index: src/interfaces/ecpg/preproc/c_keywords.c
===================================================================
RCS file: /projects/cvsroot/pgsql/src/interfaces/ecpg/preproc/c_keywords.c,v
retrieving revision 1.12
diff -c -r1.12 c_keywords.c
*** src/interfaces/ecpg/preproc/c_keywords.c	2002/05/20 09:29:41	1.12
--- src/interfaces/ecpg/preproc/c_keywords.c	2002/06/10 17:44:31
***************
*** 23,34 ****
  	{"VARCHAR", VARCHAR},
  	{"auto", S_AUTO},
  	{"bool", SQL_BOOL},
! 	{"char", CHAR},
  	{"const", S_CONST},
  	{"double", DOUBLE},
  	{"enum", SQL_ENUM},
  	{"extern", S_EXTERN},
! 	{"float", FLOAT},
  	{"int", INT},
  	{"long", SQL_LONG},
  	{"register", S_REGISTER},
--- 23,34 ----
  	{"VARCHAR", VARCHAR},
  	{"auto", S_AUTO},
  	{"bool", SQL_BOOL},
! 	{"char", CHAR_P},
  	{"const", S_CONST},
  	{"double", DOUBLE},
  	{"enum", SQL_ENUM},
  	{"extern", S_EXTERN},
! 	{"float", FLOAT_P},
  	{"int", INT},
  	{"long", SQL_LONG},
  	{"register", S_REGISTER},
Index: src/interfaces/ecpg/preproc/keywords.c
===================================================================
RCS file: /projects/cvsroot/pgsql/src/interfaces/ecpg/preproc/keywords.c,v
retrieving revision 1.48
diff -c -r1.48 keywords.c
*** src/interfaces/ecpg/preproc/keywords.c	2002/05/19 20:00:53	1.48
--- src/interfaces/ecpg/preproc/keywords.c	2002/06/10 17:44:31
***************
*** 62,68 ****
  	{"case", CASE},
  	{"cast", CAST},
  	{"chain", CHAIN},
! 	{"char", CHAR},
  	{"character", CHARACTER},
  	{"characteristics", CHARACTERISTICS},
  	{"check", CHECK},
--- 62,68 ----
  	{"case", CASE},
  	{"cast", CAST},
  	{"chain", CHAIN},
! 	{"char", CHAR_P},
  	{"character", CHARACTER},
  	{"characteristics", CHARACTERISTICS},
  	{"check", CHECK},
***************
*** 97,103 ****
  	{"deferrable", DEFERRABLE},
  	{"deferred", DEFERRED},
  	{"definer", DEFINER},
! 	{"delete", DELETE},
  	{"delimiters", DELIMITERS},
  	{"desc", DESC},
  	{"distinct", DISTINCT},
--- 97,103 ----
  	{"deferrable", DEFERRABLE},
  	{"deferred", DEFERRED},
  	{"definer", DEFINER},
! 	{"delete", DELETE_P},
  	{"delimiters", DELIMITERS},
  	{"desc", DESC},
  	{"distinct", DISTINCT},
***************
*** 120,126 ****
  	{"extract", EXTRACT},
  	{"false", FALSE_P},
  	{"fetch", FETCH},
! 	{"float", FLOAT},
  	{"for", FOR},
  	{"force", FORCE},
  	{"foreign", FOREIGN},
--- 120,126 ----
  	{"extract", EXTRACT},
  	{"false", FALSE_P},
  	{"fetch", FETCH},
! 	{"float", FLOAT_P},
  	{"for", FOR},
  	{"force", FORCE},
  	{"foreign", FOREIGN},
***************
*** 131,137 ****
  	{"function", FUNCTION},
  	{"global", GLOBAL},
  	{"grant", GRANT},
! 	{"group", GROUP},
  	{"handler", HANDLER},
  	{"having", HAVING},
  	{"hour", HOUR_P},
--- 131,137 ----
  	{"function", FUNCTION},
  	{"global", GLOBAL},
  	{"grant", GRANT},
! 	{"group", GROUP_P},
  	{"handler", HANDLER},
  	{"having", HAVING},
  	{"hour", HOUR_P},
***************
*** 139,145 ****
  	{"immediate", IMMEDIATE},
  	{"immutable", IMMUTABLE},
  	{"implicit", IMPLICIT},
! 	{"in", IN},
  	{"increment", INCREMENT},
  	{"index", INDEX},
  	{"inherits", INHERITS},
--- 139,145 ----
  	{"immediate", IMMEDIATE},
  	{"immutable", IMMUTABLE},
  	{"implicit", IMPLICIT},
! 	{"in", IN_P},
  	{"increment", INCREMENT},
  	{"index", INDEX},
  	{"inherits", INHERITS},
***************
*** 208,214 ****
  	{"option", OPTION},
  	{"or", OR},
  	{"order", ORDER},
! 	{"out", OUT},
  	{"outer", OUTER_P},
  	{"overlaps", OVERLAPS},
  	{"owner", OWNER},
--- 208,214 ----
  	{"option", OPTION},
  	{"or", OR},
  	{"order", ORDER},
! 	{"out", OUT_P},
  	{"outer", OUTER_P},
  	{"overlaps", OVERLAPS},
  	{"owner", OWNER},
Index: src/interfaces/ecpg/preproc/preproc.y
===================================================================
RCS file: /projects/cvsroot/pgsql/src/interfaces/ecpg/preproc/preproc.y,v
retrieving revision 1.189
diff -c -r1.189 preproc.y
*** src/interfaces/ecpg/preproc/preproc.y	2002/05/20 09:29:41	1.189
--- src/interfaces/ecpg/preproc/preproc.y	2002/06/10 17:44:32
***************
*** 184,207 ****
          BACKWARD, BEFORE, BEGIN_TRANS, BETWEEN, BIGINT, BINARY, BIT, BOTH,
          BOOLEAN, BY,
  
!         CACHE, CALLED, CASCADE, CASE, CAST, CHAIN, CHAR, CHARACTER,
          CHARACTERISTICS, CHECK, CHECKPOINT, CLOSE, CLUSTER, COALESCE, COLLATE,
          COLUMN, COMMENT, COMMIT, COMMITTED, CONSTRAINT, CONSTRAINTS, COPY,
          CREATE, CREATEDB, CREATEUSER, CROSS, CURRENT_DATE, CURRENT_TIME,
          CURRENT_TIMESTAMP, CURRENT_USER, CURSOR, CYCLE,
  
          DATABASE, DAY_P, DEC, DECIMAL, DECLARE, DEFAULT, DEFERRABLE, DEFERRED,
!         DEFINER, DELETE, DELIMITERS, DESC, DISTINCT, DO, DOMAIN_P, DOUBLE, DROP,
          EACH, ELSE, ENCODING, ENCRYPTED, END_TRANS, ESCAPE, EXCEPT, EXCLUSIVE,
          EXECUTE, EXISTS, EXPLAIN, EXTERNAL, EXTRACT,
  
!         FALSE_P, FETCH, FLOAT, FOR, FORCE, FOREIGN, FORWARD, FREEZE, FROM,
          FULL, FUNCTION,
  
! 	GLOBAL, GRANT, GROUP,
          HANDLER, HAVING, HOUR_P,
  
! 	ILIKE, IMMEDIATE, IMMUTABLE, IMPLICIT, IN, INCREMENT, INDEX, INHERITS,
          INITIALLY, INNER_P, INOUT, INPUT, INSENSITIVE, INSERT, INSTEAD, INT,
          INTEGER, INTERSECT, INTERVAL, INTO, INVOKER, IS, ISNULL, ISOLATION,
  			
--- 184,207 ----
          BACKWARD, BEFORE, BEGIN_TRANS, BETWEEN, BIGINT, BINARY, BIT, BOTH,
          BOOLEAN, BY,
  
!         CACHE, CALLED, CASCADE, CASE, CAST, CHAIN, CHAR_P, CHARACTER,
          CHARACTERISTICS, CHECK, CHECKPOINT, CLOSE, CLUSTER, COALESCE, COLLATE,
          COLUMN, COMMENT, COMMIT, COMMITTED, CONSTRAINT, CONSTRAINTS, COPY,
          CREATE, CREATEDB, CREATEUSER, CROSS, CURRENT_DATE, CURRENT_TIME,
          CURRENT_TIMESTAMP, CURRENT_USER, CURSOR, CYCLE,
  
          DATABASE, DAY_P, DEC, DECIMAL, DECLARE, DEFAULT, DEFERRABLE, DEFERRED,
!         DEFINER, DELETE_P, DELIMITERS, DESC, DISTINCT, DO, DOMAIN_P, DOUBLE, DROP,
          EACH, ELSE, ENCODING, ENCRYPTED, END_TRANS, ESCAPE, EXCEPT, EXCLUSIVE,
          EXECUTE, EXISTS, EXPLAIN, EXTERNAL, EXTRACT,
  
!         FALSE_P, FETCH, FLOAT_P, FOR, FORCE, FOREIGN, FORWARD, FREEZE, FROM,
          FULL, FUNCTION,
  
! 	GLOBAL, GRANT, GROUP_P,
          HANDLER, HAVING, HOUR_P,
  
! 	ILIKE, IMMEDIATE, IMMUTABLE, IMPLICIT, IN_P, INCREMENT, INDEX, INHERITS,
          INITIALLY, INNER_P, INOUT, INPUT, INSENSITIVE, INSERT, INSTEAD, INT,
          INTEGER, INTERSECT, INTERVAL, INTO, INVOKER, IS, ISNULL, ISOLATION,
  			
***************
*** 218,224 ****
          NUMERIC,
  
  	OF, OFF, OFFSET, OIDS, OLD, ON, ONLY, OPERATOR, OPTION, OR, ORDER,
!         OUT, OUTER_P, OVERLAPS, OWNER,
  
  	PARTIAL, PASSWORD, PATH_P, PENDANT, POSITION, PRECISION, PRIMARY,
  	PRIOR, PRIVILEGES, PROCEDURE, PROCEDURAL,
--- 218,224 ----
          NUMERIC,
  
  	OF, OFF, OFFSET, OIDS, OLD, ON, ONLY, OPERATOR, OPTION, OR, ORDER,
!         OUT_P, OUTER_P, OVERLAPS, OWNER,
  
  	PARTIAL, PASSWORD, PATH_P, PENDANT, POSITION, PRECISION, PRIMARY,
  	PRIOR, PRIVILEGES, PROCEDURE, PROCEDURAL,
***************
*** 268,274 ****
  %nonassoc	ESCAPE
  %nonassoc	OVERLAPS
  %nonassoc	BETWEEN
! %nonassoc	IN
  %left			POSTFIXOP					/* dummy for postfix Op rules */
  %left		Op				/* multi-character ops and user-defined operators */
  %nonassoc	NOTNULL
--- 268,274 ----
  %nonassoc	ESCAPE
  %nonassoc	OVERLAPS
  %nonassoc	BETWEEN
! %nonassoc	IN_P
  %left			POSTFIXOP					/* dummy for postfix Op rules */
  %left		Op				/* multi-character ops and user-defined operators */
  %nonassoc	NOTNULL
***************
*** 713,719 ****
  			{ $$ = make_str("createuser"); }
  		| NOCREATEUSER
  			{ $$ = make_str("nocreateuser"); }
! 		| IN GROUP user_list
  			{ $$ = cat2_str(make_str("in group"), $3); }
  		| VALID UNTIL Sconst
  			{ $$ = cat2_str(make_str("valid until"), $3); }
--- 713,719 ----
  			{ $$ = make_str("createuser"); }
  		| NOCREATEUSER
  			{ $$ = make_str("nocreateuser"); }
! 		| IN_P GROUP_P user_list
  			{ $$ = cat2_str(make_str("in group"), $3); }
  		| VALID UNTIL Sconst
  			{ $$ = cat2_str(make_str("valid until"), $3); }
***************
*** 731,739 ****
   *
   *
   ****************************************************************************/
! CreateGroupStmt:  CREATE GROUP UserId OptGroupList
  			{ $$ = cat_str(3, make_str("create group"), $3, $4); }
! 		| CREATE GROUP UserId WITH OptGroupList
  			{ $$ = cat_str(4, make_str("create group"), $3, make_str("with"), $5); }
  		;
  
--- 731,739 ----
   *
   *
   ****************************************************************************/
! CreateGroupStmt:  CREATE GROUP_P UserId OptGroupList
  			{ $$ = cat_str(3, make_str("create group"), $3, $4); }
! 		| CREATE GROUP_P UserId WITH OptGroupList
  			{ $$ = cat_str(4, make_str("create group"), $3, make_str("with"), $5); }
  		;
  
***************
*** 757,765 ****
   *
   *
   *****************************************************************************/
! AlterGroupStmt: ALTER GROUP UserId ADD USER user_list
  			{ $$ = cat_str(4, make_str("alter group"), $3, make_str("add user"), $6); }
! 		| ALTER GROUP UserId DROP USER user_list
  			{ $$ = cat_str(4, make_str("alter group"), $3, make_str("drop user"), $6); }
  		;
  
--- 757,765 ----
   *
   *
   *****************************************************************************/
! AlterGroupStmt: ALTER GROUP_P UserId ADD USER user_list
  			{ $$ = cat_str(4, make_str("alter group"), $3, make_str("add user"), $6); }
! 		| ALTER GROUP_P UserId DROP USER user_list
  			{ $$ = cat_str(4, make_str("alter group"), $3, make_str("drop user"), $6); }
  		;
  
***************
*** 769,775 ****
   *
   *
   *****************************************************************************/
! DropGroupStmt: DROP GROUP UserId
  			{ $$ = cat2_str(make_str("drop group"), $3); }
  		;
  
--- 769,775 ----
   *
   *
   *****************************************************************************/
! DropGroupStmt: DROP GROUP_P UserId
  			{ $$ = cat2_str(make_str("drop group"), $3); }
  		;
  
***************
*** 1234,1240 ****
  		| /*EMPTY*/					{ $$ = EMPTY; }
  		;
  
! key_delete: ON DELETE key_reference 
  			{ $$ = cat2_str(make_str("on delete"), $3); }
  		;
  
--- 1234,1240 ----
  		| /*EMPTY*/					{ $$ = EMPTY; }
  		;
  
! key_delete: ON DELETE_P key_reference 
  			{ $$ = cat2_str(make_str("on delete"), $3); }
  		;
  
***************
*** 1396,1402 ****
  		;
  
  TriggerOneEvent:  INSERT	{ $$ = make_str("insert"); }
! 		| DELETE			{ $$ = make_str("delete"); }
  		| UPDATE			{ $$ = make_str("update"); }
  		;
  
--- 1396,1402 ----
  		;
  
  TriggerOneEvent:  INSERT	{ $$ = make_str("insert"); }
! 		| DELETE_P			{ $$ = make_str("delete"); }
  		| UPDATE			{ $$ = make_str("update"); }
  		;
  
***************
*** 1611,1617 ****
  		| PRIOR				{ $$ = make_str("prior"); }
  		;
  
! from_in: IN					{ $$ = make_str("in"); }
  		| FROM				{ $$ = make_str("from"); }
  		;
  
--- 1611,1617 ----
  		| PRIOR				{ $$ = make_str("prior"); }
  		;
  
! from_in: IN_P				{ $$ = make_str("in"); }
  		| FROM				{ $$ = make_str("from"); }
  		;
  
***************
*** 1687,1693 ****
  privilege:	SELECT			{ $$ = make_str("select"); }
  		| INSERT			{ $$ = make_str("insert"); }
  		| UPDATE			{ $$ = make_str("update"); }
! 		| DELETE			{ $$ = make_str("delete"); }
  		| RULE				{ $$ = make_str("rule"); }
  		| REFERENCES		{ $$ = make_str("references"); }
  		| TRIGGER			{ $$ = make_str("trigger"); }
--- 1687,1693 ----
  privilege:	SELECT			{ $$ = make_str("select"); }
  		| INSERT			{ $$ = make_str("insert"); }
  		| UPDATE			{ $$ = make_str("update"); }
! 		| DELETE_P			{ $$ = make_str("delete"); }
  		| RULE				{ $$ = make_str("rule"); }
  		| REFERENCES		{ $$ = make_str("references"); }
  		| TRIGGER			{ $$ = make_str("trigger"); }
***************
*** 1719,1725 ****
  		;
  
  grantee:  ColId			{ $$ = $1; }
! 		| GROUP ColId		{ $$ = cat2_str(make_str("group"), $2); }
  		;
  
  opt_grant_grant_option:  WITH GRANT OPTION
--- 1719,1725 ----
  		;
  
  grantee:  ColId			{ $$ = $1; }
! 		| GROUP_P ColId		{ $$ = cat2_str(make_str("group"), $2); }
  		;
  
  opt_grant_grant_option:  WITH GRANT OPTION
***************
*** 1854,1861 ****
  		| func_type		{ $$ = $1; }
  		;
  
! opt_arg:  IN	{ $$ = make_str("in"); }
! 		| OUT
  		{
  			mmerror(PARSE_ERROR, ET_WARNING, "Currently unsupported CREATE FUNCTION/OUT will be passed to backend");
  
--- 1854,1861 ----
  		| func_type		{ $$ = $1; }
  		;
  
! opt_arg:  IN_P	{ $$ = make_str("in"); }
! 		| OUT_P
  		{
  			mmerror(PARSE_ERROR, ET_WARNING, "Currently unsupported CREATE FUNCTION/OUT will be passed to backend");
  
***************
*** 2049,2055 ****
  /* change me to select, update, etc. some day */
  event:	SELECT				{ $$ = make_str("select"); }
  		| UPDATE			{ $$ = make_str("update"); }
! 		| DELETE			{ $$ = make_str("delete"); }
  		| INSERT			{ $$ = make_str("insert"); }
  		 ;
  
--- 2049,2055 ----
  /* change me to select, update, etc. some day */
  event:	SELECT				{ $$ = make_str("select"); }
  		| UPDATE			{ $$ = make_str("update"); }
! 		| DELETE_P			{ $$ = make_str("delete"); }
  		| INSERT			{ $$ = make_str("insert"); }
  		 ;
  
***************
*** 2354,2360 ****
   *
   *****************************************************************************/
  
! DeleteStmt:  DELETE FROM relation_expr where_clause
  			{ $$ = cat_str(3, make_str("delete from"), $3, $4); }
  		;
  
--- 2354,2360 ----
   *
   *****************************************************************************/
  
! DeleteStmt:  DELETE_P FROM relation_expr where_clause
  			{ $$ = cat_str(3, make_str("delete from"), $3, $4); }
  		;
  
***************
*** 2362,2368 ****
  			{ $$ = cat_str(4, make_str("lock"), $2, $3, $4); }
  		;
  
! opt_lock:  IN lock_type MODE
  			{ $$ = cat_str(3, make_str("in"), $2, make_str("mode")); }
  		| /*EMPTY*/
  			{ $$ = EMPTY;}
--- 2362,2368 ----
  			{ $$ = cat_str(4, make_str("lock"), $2, $3, $4); }
  		;
  
! opt_lock:  IN_P lock_type MODE
  			{ $$ = cat_str(3, make_str("in"), $2, make_str("mode")); }
  		| /*EMPTY*/
  			{ $$ = EMPTY;}
***************
*** 2600,2606 ****
   *	...however, recursive addattr and rename supported.  make special
   *	cases for these.
   */
! group_clause:  GROUP BY expr_list
  			{ $$ = cat2_str(make_str("group by"), $3); }
  		| /*EMPTY*/
  			{ $$ = EMPTY; }
--- 2600,2606 ----
   *	...however, recursive addattr and rename supported.  make special
   *	cases for these.
   */
! group_clause:  GROUP_P BY expr_list
  			{ $$ = cat2_str(make_str("group by"), $3); }
  		| /*EMPTY*/
  			{ $$ = EMPTY; }
***************
*** 2837,2843 ****
  			{ $$ = make_str("bigint"); }
  		| REAL
  			{ $$ = make_str("real"); }
! 		| FLOAT opt_float
  			{ $$ = cat2_str(make_str("float"), $2); }
  		| DOUBLE PRECISION
  			{ $$ = make_str("double precision"); }
--- 2837,2843 ----
  			{ $$ = make_str("bigint"); }
  		| REAL
  			{ $$ = make_str("real"); }
! 		| FLOAT_P opt_float
  			{ $$ = cat2_str(make_str("float"), $2); }
  		| DOUBLE PRECISION
  			{ $$ = make_str("double precision"); }
***************
*** 2896,2908 ****
  
  character:	CHARACTER opt_varying
  			{ $$ = cat2_str(make_str("character"), $2); }
! 		| CHAR opt_varying
  			{ $$ = cat2_str(make_str("char"), $2); }
  		| VARCHAR
  			{ $$ = make_str("varchar"); }
  		| NATIONAL CHARACTER opt_varying
  			{ $$ = cat2_str(make_str("national character"), $3); }
! 		| NATIONAL CHAR opt_varying
  			{ $$ = cat2_str(make_str("national char"), $3); }
  		| NCHAR opt_varying
  			{ $$ = cat2_str(make_str("nchar"), $2); }
--- 2896,2908 ----
  
  character:	CHARACTER opt_varying
  			{ $$ = cat2_str(make_str("character"), $2); }
! 		| CHAR_P opt_varying
  			{ $$ = cat2_str(make_str("char"), $2); }
  		| VARCHAR
  			{ $$ = make_str("varchar"); }
  		| NATIONAL CHARACTER opt_varying
  			{ $$ = cat2_str(make_str("national character"), $3); }
! 		| NATIONAL CHAR_P opt_varying
  			{ $$ = cat2_str(make_str("national char"), $3); }
  		| NCHAR opt_varying
  			{ $$ = cat2_str(make_str("nchar"), $2); }
***************
*** 2975,2983 ****
   * Define row_descriptor to allow yacc to break the reduce/reduce conflict
   *	with singleton expressions.
   */
! row_expr: '(' row_descriptor ')' IN select_with_parens
  			{ $$ = cat_str(4, make_str("("), $2, make_str(") in "), $5); }
! 		| '(' row_descriptor ')' NOT IN select_with_parens
  			{ $$ = cat_str(4, make_str("("), $2, make_str(") not in "), $6); }
  		| '(' row_descriptor ')' all_Op sub_type select_with_parens
  			{ $$ = cat_str(6, make_str("("), $2, make_str(")"), $4, $5, $6); }
--- 2975,2983 ----
   * Define row_descriptor to allow yacc to break the reduce/reduce conflict
   *	with singleton expressions.
   */
! row_expr: '(' row_descriptor ')' IN_P select_with_parens
  			{ $$ = cat_str(4, make_str("("), $2, make_str(") in "), $5); }
! 		| '(' row_descriptor ')' NOT IN_P select_with_parens
  			{ $$ = cat_str(4, make_str("("), $2, make_str(") not in "), $6); }
  		| '(' row_descriptor ')' all_Op sub_type select_with_parens
  			{ $$ = cat_str(6, make_str("("), $2, make_str(")"), $4, $5, $6); }
***************
*** 3140,3148 ****
  			{ $$ = cat_str(5, $1, make_str("between"), $3, make_str("and"), $5); }
  		| a_expr NOT BETWEEN b_expr AND b_expr	%prec BETWEEN
  			{ $$ = cat_str(5, $1, make_str("not between"), $4, make_str("and"), $6); }
! 		| a_expr IN in_expr
  			{ $$ = cat_str(3, $1, make_str(" in"), $3); }
! 		| a_expr NOT IN in_expr
  			{ $$ = cat_str(3, $1, make_str(" not in "), $4); }
  		| a_expr all_Op sub_type select_with_parens %prec Op
  			{ $$ = cat_str(4, $1, $2, $3, $4); }
--- 3140,3148 ----
  			{ $$ = cat_str(5, $1, make_str("between"), $3, make_str("and"), $5); }
  		| a_expr NOT BETWEEN b_expr AND b_expr	%prec BETWEEN
  			{ $$ = cat_str(5, $1, make_str("not between"), $4, make_str("and"), $6); }
! 		| a_expr IN_P in_expr
  			{ $$ = cat_str(3, $1, make_str(" in"), $3); }
! 		| a_expr NOT IN_P in_expr
  			{ $$ = cat_str(3, $1, make_str(" not in "), $4); }
  		| a_expr all_Op sub_type select_with_parens %prec Op
  			{ $$ = cat_str(4, $1, $2, $3, $4); }
***************
*** 3307,3313 ****
  		;
  
  /* position_list uses b_expr not a_expr to avoid conflict with general IN */
! position_list:	b_expr IN b_expr
  			{ $$ = cat_str(3, $1, make_str("in"), $3); }
  		| /* EMPTY */
  			{ $$ = EMPTY; }
--- 3307,3313 ----
  		;
  
  /* position_list uses b_expr not a_expr to avoid conflict with general IN */
! position_list:	b_expr IN_P b_expr
  			{ $$ = cat_str(3, $1, make_str("in"), $3); }
  		| /* EMPTY */
  			{ $$ = EMPTY; }
***************
*** 4146,4152 ****
  			$$ = ECPGt_unsigned_long;
  #endif
  		}
! 		| SQL_UNSIGNED CHAR			{ $$ = ECPGt_unsigned_char; }
  		;
  
  signed_type: SQL_SHORT				{ $$ = ECPGt_short; }
--- 4146,4152 ----
  			$$ = ECPGt_unsigned_long;
  #endif
  		}
! 		| SQL_UNSIGNED CHAR_P			{ $$ = ECPGt_unsigned_char; }
  		;
  
  signed_type: SQL_SHORT				{ $$ = ECPGt_short; }
***************
*** 4171,4177 ****
  #endif
  		}
  		| SQL_BOOL					{ $$ = ECPGt_bool; }
! 		| CHAR						{ $$ = ECPGt_char; }
  		;
  
  opt_signed: SQL_SIGNED
--- 4171,4177 ----
  #endif
  		}
  		| SQL_BOOL					{ $$ = ECPGt_bool; }
! 		| CHAR_P					{ $$ = ECPGt_char; }
  		;
  
  opt_signed: SQL_SIGNED
***************
*** 4823,4829 ****
  		| unreserved_keyword			{ $$ = $1; }
  		| col_name_keyword				{ $$ = $1; }
  		| ECPGKeywords					{ $$ = $1; }
! 		| CHAR							{ $$ = make_str("char"); }
  		;
  
  /* Type identifier --- names that can be type names.
--- 4823,4829 ----
  		| unreserved_keyword			{ $$ = $1; }
  		| col_name_keyword				{ $$ = $1; }
  		| ECPGKeywords					{ $$ = $1; }
! 		| CHAR_P						{ $$ = make_str("char"); }
  		;
  
  /* Type identifier --- names that can be type names.
***************
*** 4847,4853 ****
   */
  ColLabel:  ECPGColLabel					{ $$ = $1; }
  		| ECPGTypeName					{ $$ = $1; }
! 		| CHAR							{ $$ = make_str("char"); }
  		| INT							{ $$ = make_str("int"); }
  		| UNION							{ $$ = make_str("union"); }
  		;
--- 4847,4853 ----
   */
  ColLabel:  ECPGColLabel					{ $$ = $1; }
  		| ECPGTypeName					{ $$ = $1; }
! 		| CHAR_P						{ $$ = make_str("char"); }
  		| INT							{ $$ = make_str("int"); }
  		| UNION							{ $$ = make_str("union"); }
  		;
***************
*** 4907,4913 ****
  		| DAY_P							{ $$ = make_str("day"); }
  		| DECLARE						{ $$ = make_str("declare"); }
  		| DEFERRED						{ $$ = make_str("deferred"); }
! 		| DELETE						{ $$ = make_str("delete"); }
  		| DELIMITERS					{ $$ = make_str("delimiters"); }
  		| DOMAIN_P					{ $$ = make_str("domain"); }
  		| DOUBLE						{ $$ = make_str("double"); }
--- 4907,4913 ----
  		| DAY_P							{ $$ = make_str("day"); }
  		| DECLARE						{ $$ = make_str("declare"); }
  		| DEFERRED						{ $$ = make_str("deferred"); }
! 		| DELETE_P						{ $$ = make_str("delete"); }
  		| DELIMITERS					{ $$ = make_str("delimiters"); }
  		| DOMAIN_P					{ $$ = make_str("domain"); }
  		| DOUBLE						{ $$ = make_str("double"); }
***************
*** 4963,4969 ****
  		| OIDS							{ $$ = make_str("oids"); }
  		| OPERATOR						{ $$ = make_str("operator"); }
  		| OPTION						{ $$ = make_str("option"); }
! 		| OUT							{ $$ = make_str("out"); }
  		| OWNER							{ $$ = make_str("owner"); }
  		| PARTIAL						{ $$ = make_str("partial"); }
  		| PASSWORD						{ $$ = make_str("password"); }
--- 4963,4969 ----
  		| OIDS							{ $$ = make_str("oids"); }
  		| OPERATOR						{ $$ = make_str("operator"); }
  		| OPTION						{ $$ = make_str("option"); }
! 		| OUT_P							{ $$ = make_str("out"); }
  		| OWNER							{ $$ = make_str("owner"); }
  		| PARTIAL						{ $$ = make_str("partial"); }
  		| PASSWORD						{ $$ = make_str("password"); }
***************
*** 5044,5050 ****
  		BIGINT			{ $$ = make_str("bigint");}
  		| BIT			{ $$ = make_str("bit"); }
  /* CHAR must be excluded from ECPGColLabel because of conflict with UNSIGNED
! 		| CHAR			{ $$ = make_str("char"); }
   */
  		| CHARACTER		{ $$ = make_str("character"); }
  		| COALESCE		{ $$ = make_str("coalesce"); }
--- 5044,5050 ----
  		BIGINT			{ $$ = make_str("bigint");}
  		| BIT			{ $$ = make_str("bit"); }
  /* CHAR must be excluded from ECPGColLabel because of conflict with UNSIGNED
! 		| CHAR_P		{ $$ = make_str("char"); }
   */
  		| CHARACTER		{ $$ = make_str("character"); }
  		| COALESCE		{ $$ = make_str("coalesce"); }
***************
*** 5052,5058 ****
  		| DECIMAL		{ $$ = make_str("decimal"); }
  		| EXISTS		{ $$ = make_str("exists"); }
  		| EXTRACT		{ $$ = make_str("extract"); }
! 		| FLOAT			{ $$ = make_str("float"); }
  /* INT must be excluded from ECPGColLabel because of conflict 
  		| INT			{ $$ = make_str("int"); }
   */
--- 5052,5058 ----
  		| DECIMAL		{ $$ = make_str("decimal"); }
  		| EXISTS		{ $$ = make_str("exists"); }
  		| EXTRACT		{ $$ = make_str("extract"); }
! 		| FLOAT_P		{ $$ = make_str("float"); }
  /* INT must be excluded from ECPGColLabel because of conflict 
  		| INT			{ $$ = make_str("int"); }
   */
***************
*** 5091,5097 ****
  		| FREEZE						{ $$ = make_str("freeze"); }
  		| FULL							{ $$ = make_str("full"); }
  		| ILIKE							{ $$ = make_str("ilike"); }
! 		| IN							{ $$ = make_str("in"); }
  		| INNER_P						{ $$ = make_str("inner"); }
  		| IS							{ $$ = make_str("is"); }
  		| ISNULL						{ $$ = make_str("isnull"); }
--- 5091,5097 ----
  		| FREEZE						{ $$ = make_str("freeze"); }
  		| FULL							{ $$ = make_str("full"); }
  		| ILIKE							{ $$ = make_str("ilike"); }
! 		| IN_P							{ $$ = make_str("in"); }
  		| INNER_P						{ $$ = make_str("inner"); }
  		| IS							{ $$ = make_str("is"); }
  		| ISNULL						{ $$ = make_str("isnull"); }
***************
*** 5145,5151 ****
  		| FOREIGN						{ $$ = make_str("foreign"); }
  		| FROM							{ $$ = make_str("from"); }
  		| GRANT							{ $$ = make_str("grant"); }
! 		| GROUP							{ $$ = make_str("group"); }
  		| HAVING						{ $$ = make_str("having"); }
  		| INITIALLY						{ $$ = make_str("initially"); }
  		| INTERSECT						{ $$ = make_str("intersect"); }
--- 5145,5151 ----
  		| FOREIGN						{ $$ = make_str("foreign"); }
  		| FROM							{ $$ = make_str("from"); }
  		| GRANT							{ $$ = make_str("grant"); }
! 		| GROUP_P						{ $$ = make_str("group"); }
  		| HAVING						{ $$ = make_str("having"); }
  		| INITIALLY						{ $$ = make_str("initially"); }
  		| INTERSECT						{ $$ = make_str("intersect"); }
***************
*** 5305,5313 ****
  		| SQL_SIGNED				{ $$ = make_str("signed"); }
  		| SQL_STRUCT				{ $$ = make_str("struct"); }
  		| SQL_UNSIGNED				{ $$ = make_str("unsigned"); }
! 		| CHAR						{ $$ = make_str("char"); }
  		| DOUBLE					{ $$ = make_str("double"); }
! 		| FLOAT						{ $$ = make_str("float"); }
  		| UNION						{ $$ = make_str("union"); }
  		| VARCHAR					{ $$ = make_str("varchar"); }
  		| '['						{ $$ = make_str("["); }
--- 5305,5313 ----
  		| SQL_SIGNED				{ $$ = make_str("signed"); }
  		| SQL_STRUCT				{ $$ = make_str("struct"); }
  		| SQL_UNSIGNED				{ $$ = make_str("unsigned"); }
! 		| CHAR_P					{ $$ = make_str("char"); }
  		| DOUBLE					{ $$ = make_str("double"); }
! 		| FLOAT_P					{ $$ = make_str("float"); }
  		| UNION						{ $$ = make_str("union"); }
  		| VARCHAR					{ $$ = make_str("varchar"); }
  		| '['						{ $$ = make_str("["); }
Index: src/interfaces/libpq/fe-auth.c
===================================================================
RCS file: /projects/cvsroot/pgsql/src/interfaces/libpq/fe-auth.c,v
retrieving revision 1.65
diff -c -r1.65 fe-auth.c
*** src/interfaces/libpq/fe-auth.c	2002/04/24 23:00:40	1.65
--- src/interfaces/libpq/fe-auth.c	2002/06/10 17:44:33
***************
*** 714,720 ****
  		char		username[128];
  		DWORD		namesize = sizeof(username) - 1;
  
! 		if (GetUserName(username, &namesize))
  			name = username;
  #else
  		struct passwd *pw = getpwuid(geteuid());
--- 714,720 ----
  		char		username[128];
  		DWORD		namesize = sizeof(username) - 1;
  
! 		if (GetUserNameFromId(username, &namesize))
  			name = username;
  #else
  		struct passwd *pw = getpwuid(geteuid());