Get rid of last few vestiges of parsetree dependency on grammar token

codes, per discussion from last March.  parse.h should now be included
*only* by gram.y, scan.l, keywords.c, parser.c.  This prevents surprising
misbehavior after seemingly-trivial grammar adjustments.

diff --git a/src/backend/nodes/copyfuncs.c b/src/backend/nodes/copyfuncs.c
index 4be727d2abad5d9fd465b5f943b47fa09cdfbe65..aa7a7efcc8b8e92d3b1808f2343f954a9e8e633a 100644 (file)
--- a/src/backend/nodes/copyfuncs.c
+++ b/src/backend/nodes/copyfuncs.c
@@ -15,7 +15,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *       $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.242 2003/02/09 06:56:27 tgl Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.243 2003/02/10 04:44:44 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -1198,7 +1198,7 @@ _copyAExpr(A_Expr *from)
 {
        A_Expr     *newnode = makeNode(A_Expr);
 
-       COPY_SCALAR_FIELD(oper);
+       COPY_SCALAR_FIELD(kind);
        COPY_NODE_FIELD(name);
        COPY_NODE_FIELD(lexpr);
        COPY_NODE_FIELD(rexpr);
@@ -1669,7 +1669,7 @@ _copyDefineStmt(DefineStmt *from)
 {
        DefineStmt *newnode = makeNode(DefineStmt);
 
-       COPY_SCALAR_FIELD(defType);
+       COPY_SCALAR_FIELD(kind);
        COPY_NODE_FIELD(defnames);
        COPY_NODE_FIELD(definition);
 
@@ -1869,7 +1869,7 @@ _copyTransactionStmt(TransactionStmt *from)
 {
        TransactionStmt *newnode = makeNode(TransactionStmt);
 
-       COPY_SCALAR_FIELD(command);
+       COPY_SCALAR_FIELD(kind);
        COPY_NODE_FIELD(options);
 
        return newnode;
@@ -2215,7 +2215,7 @@ _copyReindexStmt(ReindexStmt *from)
 {
        ReindexStmt *newnode = makeNode(ReindexStmt);
 
-       COPY_SCALAR_FIELD(reindexType);
+       COPY_SCALAR_FIELD(kind);
        COPY_NODE_FIELD(relation);
        COPY_STRING_FIELD(name);
        COPY_SCALAR_FIELD(force);

diff --git a/src/backend/nodes/equalfuncs.c b/src/backend/nodes/equalfuncs.c
index d33c4f52732cbe2110fac011728f31d3c9a78473..c0bd77756a4929717e0c0f8388f2d7ccec625367 100644 (file)
--- a/src/backend/nodes/equalfuncs.c
+++ b/src/backend/nodes/equalfuncs.c
@@ -18,7 +18,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *       $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.185 2003/02/09 06:56:27 tgl Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.186 2003/02/10 04:44:45 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -730,7 +730,7 @@ _equalCreateStmt(CreateStmt *a, CreateStmt *b)
 static bool
 _equalDefineStmt(DefineStmt *a, DefineStmt *b)
 {
-       COMPARE_SCALAR_FIELD(defType);
+       COMPARE_SCALAR_FIELD(kind);
        COMPARE_NODE_FIELD(defnames);
        COMPARE_NODE_FIELD(definition);
 
@@ -898,7 +898,7 @@ _equalUnlistenStmt(UnlistenStmt *a, UnlistenStmt *b)
 static bool
 _equalTransactionStmt(TransactionStmt *a, TransactionStmt *b)
 {
-       COMPARE_SCALAR_FIELD(command);
+       COMPARE_SCALAR_FIELD(kind);
        COMPARE_NODE_FIELD(options);
 
        return true;
@@ -1187,7 +1187,7 @@ _equalDropGroupStmt(DropGroupStmt *a, DropGroupStmt *b)
 static bool
 _equalReindexStmt(ReindexStmt *a, ReindexStmt *b)
 {
-       COMPARE_SCALAR_FIELD(reindexType);
+       COMPARE_SCALAR_FIELD(kind);
        COMPARE_NODE_FIELD(relation);
        COMPARE_STRING_FIELD(name);
        COMPARE_SCALAR_FIELD(force);
@@ -1276,7 +1276,7 @@ _equalDeallocateStmt(DeallocateStmt *a, DeallocateStmt *b)
 static bool
 _equalAExpr(A_Expr *a, A_Expr *b)
 {
-       COMPARE_SCALAR_FIELD(oper);
+       COMPARE_SCALAR_FIELD(kind);
        COMPARE_NODE_FIELD(name);
        COMPARE_NODE_FIELD(lexpr);
        COMPARE_NODE_FIELD(rexpr);

diff --git a/src/backend/nodes/makefuncs.c b/src/backend/nodes/makefuncs.c
index de13e943d5e22f2b5023e9d8d506f25111365123..e9f10720cbb2b0bb29bc07ac8e96b7a337751e39 100644 (file)
--- a/src/backend/nodes/makefuncs.c
+++ b/src/backend/nodes/makefuncs.c
@@ -9,7 +9,7 @@
  *
  *
  * IDENTIFICATION
- *       $Header: /cvsroot/pgsql/src/backend/nodes/makefuncs.c,v 1.37 2002/12/12 15:49:28 tgl Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/nodes/makefuncs.c,v 1.38 2003/02/10 04:44:45 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -24,11 +24,11 @@
  *             makes an A_Expr node
  */
 A_Expr *
-makeA_Expr(int oper, List *name, Node *lexpr, Node *rexpr)
+makeA_Expr(A_Expr_Kind kind, List *name, Node *lexpr, Node *rexpr)
 {
        A_Expr     *a = makeNode(A_Expr);
 
-       a->oper = oper;
+       a->kind = kind;
        a->name = name;
        a->lexpr = lexpr;
        a->rexpr = rexpr;
@@ -40,12 +40,12 @@ makeA_Expr(int oper, List *name, Node *lexpr, Node *rexpr)
  *             As above, given a simple (unqualified) operator name
  */
 A_Expr *
-makeSimpleA_Expr(int oper, const char *name,
+makeSimpleA_Expr(A_Expr_Kind kind, const char *name,
                                 Node *lexpr, Node *rexpr)
 {
        A_Expr     *a = makeNode(A_Expr);
 
-       a->oper = oper;
+       a->kind = kind;
        a->name = makeList1(makeString((char *) name));
        a->lexpr = lexpr;
        a->rexpr = rexpr;

diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index c42f2639df1e17e681cf3de692a9659627d81f15..134ee4328e77536ff1391f0dfe79ef4e1071f708 100644 (file)
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *       $Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.198 2003/02/09 06:56:27 tgl Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.199 2003/02/10 04:44:45 tgl Exp $
  *
  * NOTES
  *       Every node type that can appear in stored rules' parsetrees *must*
@@ -27,7 +27,6 @@
 #include "nodes/parsenodes.h"
 #include "nodes/plannodes.h"
 #include "nodes/relation.h"
-#include "parser/parse.h"
 #include "utils/datum.h"
 
 
@@ -1259,19 +1258,27 @@ _outAExpr(StringInfo str, A_Expr *node)
 {
        WRITE_NODE_TYPE("AEXPR");
 
-       switch (node->oper)
+       switch (node->kind)
        {
-               case AND:
+               case AEXPR_OP:
+                       appendStringInfo(str, " ");
+                       WRITE_NODE_FIELD(name);
+                       break;
+               case AEXPR_AND:
                        appendStringInfo(str, " AND");
                        break;
-               case OR:
+               case AEXPR_OR:
                        appendStringInfo(str, " OR");
                        break;
-               case NOT:
+               case AEXPR_NOT:
                        appendStringInfo(str, " NOT");
                        break;
-               case OP:
-                       appendStringInfo(str, " ");
+               case AEXPR_DISTINCT:
+                       appendStringInfo(str, " DISTINCT ");
+                       WRITE_NODE_FIELD(name);
+                       break;
+               case AEXPR_OF:
+                       appendStringInfo(str, " OF ");
                        WRITE_NODE_FIELD(name);
                        break;
                default:

diff --git a/src/backend/parser/Makefile b/src/backend/parser/Makefile
index d2401ec75e78556863f8776013b45f907aecbf74..5720452f8186d0c5310460983f4bc72e683b9ef0 100644 (file)
--- a/src/backend/parser/Makefile
+++ b/src/backend/parser/Makefile
@@ -2,7 +2,7 @@
 #
 # Makefile for parser
 #
-# $Header: /cvsroot/pgsql/src/backend/parser/Makefile,v 1.39 2003/01/31 20:58:00 tgl Exp $
+# $Header: /cvsroot/pgsql/src/backend/parser/Makefile,v 1.40 2003/02/10 04:44:45 tgl Exp $
 #
 #-------------------------------------------------------------------------
 
@@ -64,7 +64,7 @@ endif
 
 # Force these dependencies to be known even without dependency info built:
 
-keywords.o parse_clause.o parse_expr.o parser.o gram.o: $(srcdir)/parse.h
+gram.o keywords.o parser.o: $(srcdir)/parse.h
 
 
 # gram.c, parse.h, and scan.c are in the distribution tarball, so they

diff --git a/src/backend/parser/gram.y b/src/backend/parser/gram.y
index 2c5eb2ef5bd511cffb3e3165e28be8f1a737545d..ba153497826f383005aa31091218d9d296d13a57 100644 (file)
--- a/src/backend/parser/gram.y
+++ b/src/backend/parser/gram.y
@@ -11,7 +11,7 @@
  *
  *
  * IDENTIFICATION
- *       $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 2.400 2003/02/09 06:56:28 tgl Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 2.401 2003/02/10 04:44:45 tgl Exp $
  *
  * HISTORY
  *       AUTHOR                        DATE                    MAJOR EVENT
@@ -324,11 +324,11 @@ static void doNegateFloat(Value *v);
  */
 
 /* ordinary key words in alphabetical order */
-%token <keyword> ABORT_TRANS ABSOLUTE ACCESS ACTION ADD AFTER
+%token <keyword> ABORT_P ABSOLUTE ACCESS ACTION ADD AFTER
        AGGREGATE ALL ALTER ANALYSE ANALYZE AND ANY AS ASC
        ASSERTION ASSIGNMENT AT AUTHORIZATION
 
-       BACKWARD BEFORE BEGIN_TRANS BETWEEN BIGINT BINARY BIT
+       BACKWARD BEFORE BEGIN_P BETWEEN BIGINT BINARY BIT
        BOOLEAN BOTH BY
 
        CACHE CALLED CASCADE CASE CAST CHAIN CHAR_P
@@ -342,13 +342,13 @@ static void doNegateFloat(Value *v);
        DEFERRABLE DEFERRED DEFINER DELETE_P DELIMITER DELIMITERS
     DESC DISTINCT DO DOMAIN_P DOUBLE DROP
 
-       EACH ELSE ENCODING ENCRYPTED END_TRANS ESCAPE EXCEPT
+       EACH ELSE ENCODING ENCRYPTED END_P ESCAPE EXCEPT
        EXCLUSIVE EXECUTE EXISTS EXPLAIN EXTERNAL EXTRACT
 
        FALSE_P FETCH FLOAT_P FOR FORCE FOREIGN FORWARD
        FREEZE FROM FULL FUNCTION
 
-       GET GLOBAL GRANT GROUP_P
+       GLOBAL GRANT GROUP_P
 
        HANDLER HAVING HOUR_P
 
@@ -414,9 +414,6 @@ static void doNegateFloat(Value *v);
 %token <str>   IDENT FCONST SCONST NCONST BCONST XCONST Op
 %token <ival>  ICONST PARAM
 
-/* these are not real. they are here so that they get generated as #define's*/
-%token                 OP
-
 /* precedence: lowest to highest */
 %left          UNION EXCEPT
 %left          INTERSECT
@@ -2234,7 +2231,7 @@ DefineStmt:
                        CREATE AGGREGATE func_name definition
                                {
                                        DefineStmt *n = makeNode(DefineStmt);
-                                       n->defType = AGGREGATE;
+                                       n->kind = DEFINE_STMT_AGGREGATE;
                                        n->defnames = $3;
                                        n->definition = $4;
                                        $$ = (Node *)n;
@@ -2242,7 +2239,7 @@ DefineStmt:
                        | CREATE OPERATOR any_operator definition
                                {
                                        DefineStmt *n = makeNode(DefineStmt);
-                                       n->defType = OPERATOR;
+                                       n->kind = DEFINE_STMT_OPERATOR;
                                        n->defnames = $3;
                                        n->definition = $4;
                                        $$ = (Node *)n;
@@ -2250,7 +2247,7 @@ DefineStmt:
                        | CREATE TYPE_P any_name definition
                                {
                                        DefineStmt *n = makeNode(DefineStmt);
-                                       n->defType = TYPE_P;
+                                       n->kind = DEFINE_STMT_TYPE;
                                        n->defnames = $3;
                                        n->definition = $4;
                                        $$ = (Node *)n;
@@ -2288,14 +2285,6 @@ DefineStmt:
                                        n->coldeflist = $6;
                                        $$ = (Node *)n;
                                }
-                       | CREATE CHARACTER SET opt_as any_name GET definition opt_collate
-                               {
-                                       DefineStmt *n = makeNode(DefineStmt);
-                                       n->defType = CHARACTER;
-                                       n->defnames = $5;
-                                       n->definition = $7;
-                                       $$ = (Node *)n;
-                               }
                ;
 
 definition: '(' def_list ')'                                           { $$ = $2; }
@@ -2586,7 +2575,7 @@ FetchStmt:        FETCH direction fetch_how_many from_in name
                                        if ($3 < 0)
                                        {
                                                $3 = -$3;
-                                               $2 = (($2 == FORWARD) ? BACKWARD : FORWARD);
+                                               $2 = (($2 == FETCH_FORWARD) ? FETCH_BACKWARD : FETCH_FORWARD);
                                        }
                                        n->direction = $2;
                                        n->howMany = $3;
@@ -2600,11 +2589,11 @@ FetchStmt:      FETCH direction fetch_how_many from_in name
                                        if ($2 < 0)
                                        {
                                                n->howMany = -$2;
-                                               n->direction = BACKWARD;
+                                               n->direction = FETCH_BACKWARD;
                                        }
                                        else
                                        {
-                                               n->direction = FORWARD;
+                                               n->direction = FETCH_FORWARD;
                                                n->howMany = $2;
                                        }
                                        n->portalname = $4;
@@ -2623,7 +2612,7 @@ FetchStmt:        FETCH direction fetch_how_many from_in name
                        | FETCH from_in name
                                {
                                        FetchStmt *n = makeNode(FetchStmt);
-                                       n->direction = FORWARD;
+                                       n->direction = FETCH_FORWARD;
                                        n->howMany = 1;
                                        n->portalname = $3;
                                        n->ismove = FALSE;
@@ -2632,7 +2621,7 @@ FetchStmt:        FETCH direction fetch_how_many from_in name
                        | FETCH name
                                {
                                        FetchStmt *n = makeNode(FetchStmt);
-                                       n->direction = FORWARD;
+                                       n->direction = FETCH_FORWARD;
                                        n->howMany = 1;
                                        n->portalname = $2;
                                        n->ismove = FALSE;
@@ -2644,7 +2633,7 @@ FetchStmt:        FETCH direction fetch_how_many from_in name
                                        if ($3 < 0)
                                        {
                                                $3 = -$3;
-                                               $2 = (($2 == FORWARD) ? BACKWARD : FORWARD);
+                                               $2 = (($2 == FETCH_FORWARD) ? FETCH_BACKWARD : FETCH_FORWARD);
                                        }
                                        n->direction = $2;
                                        n->howMany = $3;
@@ -2658,11 +2647,11 @@ FetchStmt:      FETCH direction fetch_how_many from_in name
                                        if ($2 < 0)
                                        {
                                                n->howMany = -$2;
-                                               n->direction = BACKWARD;
+                                               n->direction = FETCH_BACKWARD;
                                        }
                                        else
                                        {
-                                               n->direction = FORWARD;
+                                               n->direction = FETCH_FORWARD;
                                                n->howMany = $2;
                                        }
                                        n->portalname = $4;
@@ -2681,7 +2670,7 @@ FetchStmt:        FETCH direction fetch_how_many from_in name
                        | MOVE from_in name
                                {
                                        FetchStmt *n = makeNode(FetchStmt);
-                                       n->direction = FORWARD;
+                                       n->direction = FETCH_FORWARD;
                                        n->howMany = 1;
                                        n->portalname = $3;
                                        n->ismove = TRUE;
@@ -2690,7 +2679,7 @@ FetchStmt:        FETCH direction fetch_how_many from_in name
                        | MOVE name
                                {
                                        FetchStmt *n = makeNode(FetchStmt);
-                                       n->direction = FORWARD;
+                                       n->direction = FETCH_FORWARD;
                                        n->howMany = 1;
                                        n->portalname = $2;
                                        n->ismove = TRUE;
@@ -2698,14 +2687,14 @@ FetchStmt:      FETCH direction fetch_how_many from_in name
                                }
                ;
 
-direction:     FORWARD                                                                 { $$ = FORWARD; }
-                       | BACKWARD                                                              { $$ = BACKWARD; }
-                       | RELATIVE                                                              { $$ = FORWARD; }
+direction:     FORWARD                                                                 { $$ = FETCH_FORWARD; }
+                       | BACKWARD                                                              { $$ = FETCH_BACKWARD; }
+                       | RELATIVE                                                              { $$ = FETCH_FORWARD; }
                        | ABSOLUTE
                                {
                                        elog(NOTICE,
                                        "FETCH / ABSOLUTE not supported, using RELATIVE");
-                                       $$ = FORWARD;
+                                       $$ = FETCH_FORWARD;
                                }
                ;
 
@@ -3281,7 +3270,7 @@ ReindexStmt:
                        REINDEX reindex_type qualified_name opt_force
                                {
                                        ReindexStmt *n = makeNode(ReindexStmt);
-                                       n->reindexType = $2;
+                                       n->kind = $2;
                                        n->relation = $3;
                                        n->name = NULL;
                                        n->force = $4;
@@ -3290,7 +3279,7 @@ ReindexStmt:
                        | REINDEX DATABASE name opt_force
                                {
                                        ReindexStmt *n = makeNode(ReindexStmt);
-                                       n->reindexType = DATABASE;
+                                       n->kind = REINDEX_DATABASE;
                                        n->name = $3;
                                        n->relation = NULL;
                                        n->force = $4;
@@ -3299,8 +3288,8 @@ ReindexStmt:
                ;
 
 reindex_type:
-                       INDEX                                                                   { $$ = INDEX; }
-                       | TABLE                                                                 { $$ = TABLE; }
+                       INDEX                                                                   { $$ = REINDEX_INDEX; }
+                       | TABLE                                                                 { $$ = REINDEX_TABLE; }
                ;
 
 opt_force:     FORCE                                                                   {  $$ = TRUE; }
@@ -3485,45 +3474,45 @@ UnlistenStmt:
  *****************************************************************************/
 
 TransactionStmt:
-                       ABORT_TRANS opt_transaction
+                       ABORT_P opt_transaction
                                {
                                        TransactionStmt *n = makeNode(TransactionStmt);
-                                       n->command = ROLLBACK;
+                                       n->kind = TRANS_STMT_ROLLBACK;
                                        n->options = NIL;
                                        $$ = (Node *)n;
                                }
-                       | BEGIN_TRANS opt_transaction
+                       | BEGIN_P opt_transaction
                                {
                                        TransactionStmt *n = makeNode(TransactionStmt);
-                                       n->command = BEGIN_TRANS;
+                                       n->kind = TRANS_STMT_BEGIN;
                                        n->options = NIL;
                                        $$ = (Node *)n;
                                }
                        | START TRANSACTION transaction_mode_list_or_empty
                                {
                                        TransactionStmt *n = makeNode(TransactionStmt);
-                                       n->command = START;
+                                       n->kind = TRANS_STMT_START;
                                        n->options = $3;
                                        $$ = (Node *)n;
                                }
                        | COMMIT opt_transaction
                                {
                                        TransactionStmt *n = makeNode(TransactionStmt);
-                                       n->command = COMMIT;
+                                       n->kind = TRANS_STMT_COMMIT;
                                        n->options = NIL;
                                        $$ = (Node *)n;
                                }
-                       | END_TRANS opt_transaction
+                       | END_P opt_transaction
                                {
                                        TransactionStmt *n = makeNode(TransactionStmt);
-                                       n->command = COMMIT;
+                                       n->kind = TRANS_STMT_COMMIT;
                                        n->options = NIL;
                                        $$ = (Node *)n;
                                }
                        | ROLLBACK opt_transaction
                                {
                                        TransactionStmt *n = makeNode(TransactionStmt);
-                                       n->command = ROLLBACK;
+                                       n->kind = TRANS_STMT_ROLLBACK;
                                        n->options = NIL;
                                        $$ = (Node *)n;
                                }
@@ -5467,7 +5456,7 @@ r_expr:  row IN_P select_with_parens
                                        n->operName = makeList1(makeString("="));
                                        n->subselect = $4;
                                        /* Stick a NOT on top */
-                                       $$ = (Node *) makeA_Expr(NOT, NIL, NULL, (Node *) n);
+                                       $$ = (Node *) makeA_Expr(AEXPR_NOT, NIL, NULL, (Node *) n);
                                }
                        | row qual_all_Op sub_type select_with_parens
                        %prec Op
@@ -5629,52 +5618,52 @@ a_expr:         c_expr                                                                  { $$ = $1; }
                 * also to b_expr and to the MathOp list above.
                 */
                        | '+' a_expr                                    %prec UMINUS
-                               { $$ = (Node *) makeSimpleA_Expr(OP, "+", NULL, $2); }
+                               { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "+", NULL, $2); }
                        | '-' a_expr                                    %prec UMINUS
                                { $$ = doNegate($2); }
                        | '%' a_expr
-                               { $$ = (Node *) makeSimpleA_Expr(OP, "%", NULL, $2); }
+                               { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "%", NULL, $2); }
                        | '^' a_expr
-                               { $$ = (Node *) makeSimpleA_Expr(OP, "^", NULL, $2); }
+                               { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "^", NULL, $2); }
                        | a_expr '%'
-                               { $$ = (Node *) makeSimpleA_Expr(OP, "%", $1, NULL); }
+                               { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "%", $1, NULL); }
                        | a_expr '^'
-                               { $$ = (Node *) makeSimpleA_Expr(OP, "^", $1, NULL); }
+                               { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "^", $1, NULL); }
                        | a_expr '+' a_expr
-                               { $$ = (Node *) makeSimpleA_Expr(OP, "+", $1, $3); }
+                               { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "+", $1, $3); }
                        | a_expr '-' a_expr
-                               { $$ = (Node *) makeSimpleA_Expr(OP, "-", $1, $3); }
+                               { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "-", $1, $3); }
                        | a_expr '*' a_expr
-                               { $$ = (Node *) makeSimpleA_Expr(OP, "*", $1, $3); }
+                               { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "*", $1, $3); }
                        | a_expr '/' a_expr
-                               { $$ = (Node *) makeSimpleA_Expr(OP, "/", $1, $3); }
+                               { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "/", $1, $3); }
                        | a_expr '%' a_expr
-                               { $$ = (Node *) makeSimpleA_Expr(OP, "%", $1, $3); }
+                               { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "%", $1, $3); }
                        | a_expr '^' a_expr
-                               { $$ = (Node *) makeSimpleA_Expr(OP, "^", $1, $3); }
+                               { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "^", $1, $3); }
                        | a_expr '<' a_expr
-                               { $$ = (Node *) makeSimpleA_Expr(OP, "<", $1, $3); }
+                               { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "<", $1, $3); }
                        | a_expr '>' a_expr
-                               { $$ = (Node *) makeSimpleA_Expr(OP, ">", $1, $3); }
+                               { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, ">", $1, $3); }
                        | a_expr '=' a_expr
-                               { $$ = (Node *) makeSimpleA_Expr(OP, "=", $1, $3); }
+                               { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "=", $1, $3); }
 
                        | a_expr qual_Op a_expr                         %prec Op
-                               { $$ = (Node *) makeA_Expr(OP, $2, $1, $3); }
+                               { $$ = (Node *) makeA_Expr(AEXPR_OP, $2, $1, $3); }
                        | qual_Op a_expr                                        %prec Op
-                               { $$ = (Node *) makeA_Expr(OP, $1, NULL, $2); }
+                               { $$ = (Node *) makeA_Expr(AEXPR_OP, $1, NULL, $2); }
                        | a_expr qual_Op                                        %prec POSTFIXOP
-                               { $$ = (Node *) makeA_Expr(OP, $2, $1, NULL); }
+                               { $$ = (Node *) makeA_Expr(AEXPR_OP, $2, $1, NULL); }
 
                        | a_expr AND a_expr
-                               { $$ = (Node *) makeA_Expr(AND, NIL, $1, $3); }
+                               { $$ = (Node *) makeA_Expr(AEXPR_AND, NIL, $1, $3); }
                        | a_expr OR a_expr
-                               { $$ = (Node *) makeA_Expr(OR, NIL, $1, $3); }
+                               { $$ = (Node *) makeA_Expr(AEXPR_OR, NIL, $1, $3); }
                        | NOT a_expr
-                               { $$ = (Node *) makeA_Expr(NOT, NIL, NULL, $2); }
+                               { $$ = (Node *) makeA_Expr(AEXPR_NOT, NIL, NULL, $2); }
 
                        | a_expr LIKE a_expr
-                               { $$ = (Node *) makeSimpleA_Expr(OP, "~~", $1, $3); }
+                               { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "~~", $1, $3); }
                        | a_expr LIKE a_expr ESCAPE a_expr
                                {
                                        FuncCall *n = makeNode(FuncCall);
@@ -5682,10 +5671,10 @@ a_expr:         c_expr                                                                  { $$ = $1; }
                                        n->args = makeList2($3, $5);
                                        n->agg_star = FALSE;
                                        n->agg_distinct = FALSE;
-                                       $$ = (Node *) makeSimpleA_Expr(OP, "~~", $1, (Node *) n);
+                                       $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "~~", $1, (Node *) n);
                                }
                        | a_expr NOT LIKE a_expr
-                               { $$ = (Node *) makeSimpleA_Expr(OP, "!~~", $1, $4); }
+                               { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "!~~", $1, $4); }
                        | a_expr NOT LIKE a_expr ESCAPE a_expr
                                {
                                        FuncCall *n = makeNode(FuncCall);
@@ -5693,10 +5682,10 @@ a_expr:         c_expr                                                                  { $$ = $1; }
                                        n->args = makeList2($4, $6);
                                        n->agg_star = FALSE;
                                        n->agg_distinct = FALSE;
-                                       $$ = (Node *) makeSimpleA_Expr(OP, "!~~", $1, (Node *) n);
+                                       $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "!~~", $1, (Node *) n);
                                }
                        | a_expr ILIKE a_expr
-                               { $$ = (Node *) makeSimpleA_Expr(OP, "~~*", $1, $3); }
+                               { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "~~*", $1, $3); }
                        | a_expr ILIKE a_expr ESCAPE a_expr
                                {
                                        FuncCall *n = makeNode(FuncCall);
@@ -5704,10 +5693,10 @@ a_expr:         c_expr                                                                  { $$ = $1; }
                                        n->args = makeList2($3, $5);
                                        n->agg_star = FALSE;
                                        n->agg_distinct = FALSE;
-                                       $$ = (Node *) makeSimpleA_Expr(OP, "~~*", $1, (Node *) n);
+                                       $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "~~*", $1, (Node *) n);
                                }
                        | a_expr NOT ILIKE a_expr
-                               { $$ = (Node *) makeSimpleA_Expr(OP, "!~~*", $1, $4); }
+                               { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "!~~*", $1, $4); }
                        | a_expr NOT ILIKE a_expr ESCAPE a_expr
                                {
                                        FuncCall *n = makeNode(FuncCall);
@@ -5715,7 +5704,7 @@ a_expr:           c_expr                                                                  { $$ = $1; }
                                        n->args = makeList2($4, $6);
                                        n->agg_star = FALSE;
                                        n->agg_distinct = FALSE;
-                                       $$ = (Node *) makeSimpleA_Expr(OP, "!~~*", $1, (Node *) n);
+                                       $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "!~~*", $1, (Node *) n);
                                }
 
                        | a_expr SIMILAR TO a_expr                              %prec SIMILAR
@@ -5727,7 +5716,7 @@ a_expr:           c_expr                                                                  { $$ = $1; }
                                        n->args = makeList2($4, (Node *) c);
                                        n->agg_star = FALSE;
                                        n->agg_distinct = FALSE;
-                                       $$ = (Node *) makeSimpleA_Expr(OP, "~", $1, (Node *) n);
+                                       $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "~", $1, (Node *) n);
                                }
                        | a_expr SIMILAR TO a_expr ESCAPE a_expr
                                {
@@ -5736,7 +5725,7 @@ a_expr:           c_expr                                                                  { $$ = $1; }
                                        n->args = makeList2($4, $6);
                                        n->agg_star = FALSE;
                                        n->agg_distinct = FALSE;
-                                       $$ = (Node *) makeSimpleA_Expr(OP, "~", $1, (Node *) n);
+                                       $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "~", $1, (Node *) n);
                                }
                        | a_expr NOT SIMILAR TO a_expr                  %prec SIMILAR
                                {
@@ -5747,7 +5736,7 @@ a_expr:           c_expr                                                                  { $$ = $1; }
                                        n->args = makeList2($5, (Node *) c);
                                        n->agg_star = FALSE;
                                        n->agg_distinct = FALSE;
-                                       $$ = (Node *) makeSimpleA_Expr(OP, "!~", $1, (Node *) n);
+                                       $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "!~", $1, (Node *) n);
                                }
                        | a_expr NOT SIMILAR TO a_expr ESCAPE a_expr
                                {
@@ -5756,7 +5745,7 @@ a_expr:           c_expr                                                                  { $$ = $1; }
                                        n->args = makeList2($5, $7);
                                        n->agg_star = FALSE;
                                        n->agg_distinct = FALSE;
-                                       $$ = (Node *) makeSimpleA_Expr(OP, "!~", $1, (Node *) n);
+                                       $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "!~", $1, (Node *) n);
                                }
 
                        /* NullTest clause
@@ -5839,26 +5828,26 @@ a_expr:         c_expr                                                                  { $$ = $1; }
                                        $$ = (Node *)b;
                                }
                        | a_expr IS DISTINCT FROM a_expr                        %prec IS
-                               { $$ = (Node *) makeSimpleA_Expr(DISTINCT, "=", $1, $5); }
+                               { $$ = (Node *) makeSimpleA_Expr(AEXPR_DISTINCT, "=", $1, $5); }
                        | a_expr IS OF '(' type_list ')'                        %prec IS
                                {
-                                       $$ = (Node *) makeSimpleA_Expr(OF, "=", $1, (Node *) $5);
+                                       $$ = (Node *) makeSimpleA_Expr(AEXPR_OF, "=", $1, (Node *) $5);
                                }
                        | a_expr IS NOT OF '(' type_list ')'            %prec IS
                                {
-                                       $$ = (Node *) makeSimpleA_Expr(OF, "!=", $1, (Node *) $6);
+                                       $$ = (Node *) makeSimpleA_Expr(AEXPR_OF, "!=", $1, (Node *) $6);
                                }
                        | a_expr BETWEEN b_expr AND b_expr                      %prec BETWEEN
                                {
-                                       $$ = (Node *) makeA_Expr(AND, NIL,
-                                               (Node *) makeSimpleA_Expr(OP, ">=", $1, $3),
-                                               (Node *) makeSimpleA_Expr(OP, "<=", $1, $5));
+                                       $$ = (Node *) makeA_Expr(AEXPR_AND, NIL,
+                                               (Node *) makeSimpleA_Expr(AEXPR_OP, ">=", $1, $3),
+                                               (Node *) makeSimpleA_Expr(AEXPR_OP, "<=", $1, $5));
                                }
                        | a_expr NOT BETWEEN b_expr AND b_expr          %prec BETWEEN
                                {
-                                       $$ = (Node *) makeA_Expr(OR, NIL,
-                                               (Node *) makeSimpleA_Expr(OP, "<", $1, $4),
-                                               (Node *) makeSimpleA_Expr(OP, ">", $1, $6));
+                                       $$ = (Node *) makeA_Expr(AEXPR_OR, NIL,
+                                               (Node *) makeSimpleA_Expr(AEXPR_OP, "<", $1, $4),
+                                               (Node *) makeSimpleA_Expr(AEXPR_OP, ">", $1, $6));
                                }
                        | a_expr IN_P in_expr
                                {
@@ -5878,11 +5867,11 @@ a_expr:         c_expr                                                                  { $$ = $1; }
                                                foreach(l, (List *) $3)
                                                {
                                                        Node *cmp;
-                                                       cmp = (Node *) makeSimpleA_Expr(OP, "=", $1, lfirst(l));
+                                                       cmp = (Node *) makeSimpleA_Expr(AEXPR_OP, "=", $1, lfirst(l));
                                                        if (n == NULL)
                                                                n = cmp;
                                                        else
-                                                               n = (Node *) makeA_Expr(OR, NIL, n, cmp);
+                                                               n = (Node *) makeA_Expr(AEXPR_OR, NIL, n, cmp);
                                                }
                                                $$ = n;
                                        }
@@ -5898,7 +5887,7 @@ a_expr:           c_expr                                                                  { $$ = $1; }
                                                n->lefthand = makeList1($1);
                                                n->operName = makeList1(makeString("="));
                                                /* Stick a NOT on top */
-                                               $$ = (Node *) makeA_Expr(NOT, NIL, NULL, (Node *) n);
+                                               $$ = (Node *) makeA_Expr(AEXPR_NOT, NIL, NULL, (Node *) n);
                                        }
                                        else
                                        {
@@ -5907,11 +5896,11 @@ a_expr:         c_expr                                                                  { $$ = $1; }
                                                foreach(l, (List *) $4)
                                                {
                                                        Node *cmp;
-                                                       cmp = (Node *) makeSimpleA_Expr(OP, "<>", $1, lfirst(l));
+                                                       cmp = (Node *) makeSimpleA_Expr(AEXPR_OP, "<>", $1, lfirst(l));
                                                        if (n == NULL)
                                                                n = cmp;
                                                        else
-                                                               n = (Node *) makeA_Expr(AND, NIL, n, cmp);
+                                                               n = (Node *) makeA_Expr(AEXPR_AND, NIL, n, cmp);
                                                }
                                                $$ = n;
                                        }
@@ -5956,50 +5945,50 @@ b_expr:         c_expr
                        | b_expr TYPECAST Typename
                                { $$ = makeTypeCast($1, $3); }
                        | '+' b_expr                                    %prec UMINUS
-                               { $$ = (Node *) makeSimpleA_Expr(OP, "+", NULL, $2); }
+                               { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "+", NULL, $2); }
                        | '-' b_expr                                    %prec UMINUS
                                { $$ = doNegate($2); }
                        | '%' b_expr
-                               { $$ = (Node *) makeSimpleA_Expr(OP, "%", NULL, $2); }
+                               { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "%", NULL, $2); }
                        | '^' b_expr
-                               { $$ = (Node *) makeSimpleA_Expr(OP, "^", NULL, $2); }
+                               { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "^", NULL, $2); }
                        | b_expr '%'
-                               { $$ = (Node *) makeSimpleA_Expr(OP, "%", $1, NULL); }
+                               { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "%", $1, NULL); }
                        | b_expr '^'
-                               { $$ = (Node *) makeSimpleA_Expr(OP, "^", $1, NULL); }
+                               { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "^", $1, NULL); }
                        | b_expr '+' b_expr
-                               { $$ = (Node *) makeSimpleA_Expr(OP, "+", $1, $3); }
+                               { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "+", $1, $3); }
                        | b_expr '-' b_expr
-                               { $$ = (Node *) makeSimpleA_Expr(OP, "-", $1, $3); }
+                               { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "-", $1, $3); }
                        | b_expr '*' b_expr
-                               { $$ = (Node *) makeSimpleA_Expr(OP, "*", $1, $3); }
+                               { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "*", $1, $3); }
                        | b_expr '/' b_expr
-                               { $$ = (Node *) makeSimpleA_Expr(OP, "/", $1, $3); }
+                               { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "/", $1, $3); }
                        | b_expr '%' b_expr
-                               { $$ = (Node *) makeSimpleA_Expr(OP, "%", $1, $3); }
+                               { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "%", $1, $3); }
                        | b_expr '^' b_expr
-                               { $$ = (Node *) makeSimpleA_Expr(OP, "^", $1, $3); }
+                               { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "^", $1, $3); }
                        | b_expr '<' b_expr
-                               { $$ = (Node *) makeSimpleA_Expr(OP, "<", $1, $3); }
+                               { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "<", $1, $3); }
                        | b_expr '>' b_expr
-                               { $$ = (Node *) makeSimpleA_Expr(OP, ">", $1, $3); }
+                               { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, ">", $1, $3); }
                        | b_expr '=' b_expr
-                               { $$ = (Node *) makeSimpleA_Expr(OP, "=", $1, $3); }
+                               { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "=", $1, $3); }
                        | b_expr qual_Op b_expr                         %prec Op
-                               { $$ = (Node *) makeA_Expr(OP, $2, $1, $3); }
+                               { $$ = (Node *) makeA_Expr(AEXPR_OP, $2, $1, $3); }
                        | qual_Op b_expr                                        %prec Op
-                               { $$ = (Node *) makeA_Expr(OP, $1, NULL, $2); }
+                               { $$ = (Node *) makeA_Expr(AEXPR_OP, $1, NULL, $2); }
                        | b_expr qual_Op                                        %prec POSTFIXOP
-                               { $$ = (Node *) makeA_Expr(OP, $2, $1, NULL); }
+                               { $$ = (Node *) makeA_Expr(AEXPR_OP, $2, $1, NULL); }
                        | b_expr IS DISTINCT FROM b_expr        %prec IS
-                               { $$ = (Node *) makeSimpleA_Expr(DISTINCT, "=", $1, $5); }
+                               { $$ = (Node *) makeSimpleA_Expr(AEXPR_DISTINCT, "=", $1, $5); }
                        | b_expr IS OF '(' type_list ')'        %prec IS
                                {
-                                       $$ = (Node *) makeSimpleA_Expr(OF, "=", $1, (Node *) $5);
+                                       $$ = (Node *) makeSimpleA_Expr(AEXPR_OF, "=", $1, (Node *) $5);
                                }
                        | b_expr IS NOT OF '(' type_list ')'    %prec IS
                                {
-                                       $$ = (Node *) makeSimpleA_Expr(OF, "!=", $1, (Node *) $6);
+                                       $$ = (Node *) makeSimpleA_Expr(AEXPR_OF, "!=", $1, (Node *) $6);
                                }
                ;
 
@@ -6646,7 +6635,7 @@ in_expr:  select_with_parens
  * same as CASE WHEN a IS NOT NULL THEN a WHEN b IS NOT NULL THEN b ... END
  * - thomas 1998-11-09
  */
-case_expr:     CASE case_arg when_clause_list case_default END_TRANS
+case_expr:     CASE case_arg when_clause_list case_default END_P
                                {
                                        CaseExpr *c = makeNode(CaseExpr);
                                        c->arg = (Expr *) $2;
@@ -6659,7 +6648,7 @@ case_expr:        CASE case_arg when_clause_list case_default END_TRANS
                                        CaseExpr *c = makeNode(CaseExpr);
                                        CaseWhen *w = makeNode(CaseWhen);
 
-                                       w->expr = (Expr *) makeSimpleA_Expr(OP, "=", $3, $5);
+                                       w->expr = (Expr *) makeSimpleA_Expr(AEXPR_OP, "=", $3, $5);
                                        /* w->result is left NULL */
                                        c->args = makeList1(w);
                                        c->defresult = (Expr *) $3;
@@ -7055,7 +7044,7 @@ ColLabel: IDENT                                                                   { $$ = $1; }
 /* "Unreserved" keywords --- available for use as any kind of name.
  */
 unreserved_keyword:
-                         ABORT_TRANS
+                         ABORT_P
                        | ABSOLUTE
                        | ACCESS
                        | ACTION
@@ -7068,7 +7057,7 @@ unreserved_keyword:
                        | AT
                        | BACKWARD
                        | BEFORE
-                       | BEGIN_TRANS
+                       | BEGIN_P
                        | BY
                        | CACHE
                        | CALLED
@@ -7113,7 +7102,6 @@ unreserved_keyword:
                        | FORCE
                        | FORWARD
                        | FUNCTION
-                       | GET
                        | GLOBAL
                        | HANDLER
                        | HOUR_P
@@ -7345,7 +7333,7 @@ reserved_keyword:
                        | DISTINCT
                        | DO
                        | ELSE
-                       | END_TRANS
+                       | END_P
                        | EXCEPT
                        | FALSE_P
                        | FOR
@@ -7541,19 +7529,19 @@ makeRowExpr(List *opr, List *largs, List *rargs)
                (strcmp(oprname, ">=") == 0))
        {
                if (expr == NULL)
-                       expr = (Node *) makeA_Expr(OP, opr, larg, rarg);
+                       expr = (Node *) makeA_Expr(AEXPR_OP, opr, larg, rarg);
                else
-                       expr = (Node *) makeA_Expr(AND, NIL, expr,
-                                                                          (Node *) makeA_Expr(OP, opr,
+                       expr = (Node *) makeA_Expr(AEXPR_AND, NIL, expr,
+                                                                          (Node *) makeA_Expr(AEXPR_OP, opr,
                                                                                                                   larg, rarg));
        }
        else if (strcmp(oprname, "<>") == 0)
        {
                if (expr == NULL)
-                       expr = (Node *) makeA_Expr(OP, opr, larg, rarg);
+                       expr = (Node *) makeA_Expr(AEXPR_OP, opr, larg, rarg);
                else
-                       expr = (Node *) makeA_Expr(OR, NIL, expr,
-                                                                          (Node *) makeA_Expr(OP, opr,
+                       expr = (Node *) makeA_Expr(AEXPR_OR, NIL, expr,
+                                                                          (Node *) makeA_Expr(AEXPR_OP, opr,
                                                                                                                   larg, rarg));
        }
        else
@@ -7585,10 +7573,10 @@ makeDistinctExpr(List *largs, List *rargs)
        rarg = lfirst(rargs);
 
        if (expr == NULL)
-               expr = (Node *) makeSimpleA_Expr(DISTINCT, "=", larg, rarg);
+               expr = (Node *) makeSimpleA_Expr(AEXPR_DISTINCT, "=", larg, rarg);
        else
-               expr = (Node *) makeA_Expr(OR, NIL, expr,
-                                                                  (Node *) makeSimpleA_Expr(DISTINCT, "=",
+               expr = (Node *) makeA_Expr(AEXPR_OR, NIL, expr,
+                                                                  (Node *) makeSimpleA_Expr(AEXPR_DISTINCT, "=",
                                                                                                                         larg, rarg));
 
        return expr;
@@ -7613,9 +7601,9 @@ makeRowNullTest(NullTestType test, List *args)
        if (expr == NULL)
                expr = (Node *) n;
        else if (test == IS_NOT_NULL)
-               expr = (Node *) makeA_Expr(OR, NIL, expr, (Node *)n);
+               expr = (Node *) makeA_Expr(AEXPR_OR, NIL, expr, (Node *)n);
        else
-               expr = (Node *) makeA_Expr(AND, NIL, expr, (Node *)n);
+               expr = (Node *) makeA_Expr(AEXPR_AND, NIL, expr, (Node *)n);
 
        return expr;
 }
@@ -7790,7 +7778,7 @@ doNegate(Node *n)
                }
        }
 
-       return (Node *) makeSimpleA_Expr(OP, "-", NULL, n);
+       return (Node *) makeSimpleA_Expr(AEXPR_OP, "-", NULL, n);
 }
 
 static void

diff --git a/src/backend/parser/keywords.c b/src/backend/parser/keywords.c
index 4166825df86df212bf2b34379f513e09202bfccc..727cff3eaf4bfeb37ca7ffa24823db3105048d70 100644 (file)
--- a/src/backend/parser/keywords.c
+++ b/src/backend/parser/keywords.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *       $Header: /cvsroot/pgsql/src/backend/parser/keywords.c,v 1.133 2003/02/03 14:04:24 momjian Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/parser/keywords.c,v 1.134 2003/02/10 04:44:46 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -30,7 +30,7 @@
  */
 static const ScanKeyword ScanKeywords[] = {
        /* name, value */
-       {"abort", ABORT_TRANS},
+       {"abort", ABORT_P},
        {"absolute", ABSOLUTE},
        {"access", ACCESS},
        {"action", ACTION},
@@ -51,7 +51,7 @@ static const ScanKeyword ScanKeywords[] = {
        {"authorization", AUTHORIZATION},
        {"backward", BACKWARD},
        {"before", BEFORE},
-       {"begin", BEGIN_TRANS},
+       {"begin", BEGIN_P},
        {"between", BETWEEN},
        {"bigint", BIGINT},
        {"binary", BINARY},
@@ -117,7 +117,7 @@ static const ScanKeyword ScanKeywords[] = {
        {"else", ELSE},
        {"encoding", ENCODING},
        {"encrypted", ENCRYPTED},
-       {"end", END_TRANS},
+       {"end", END_P},
        {"escape", ESCAPE},
        {"except", EXCEPT},
        {"exclusive", EXCLUSIVE},
@@ -137,7 +137,6 @@ static const ScanKeyword ScanKeywords[] = {
        {"from", FROM},
        {"full", FULL},
        {"function", FUNCTION},
-       {"get", GET},
        {"global", GLOBAL},
        {"grant", GRANT},
        {"group", GROUP_P},

diff --git a/src/backend/parser/parse_clause.c b/src/backend/parser/parse_clause.c
index ea9b95c68ae8cdd451531fa0a7b82ee303b548d6..ec468516ccadba53c232cf7c509d3e22a8809c62 100644 (file)
--- a/src/backend/parser/parse_clause.c
+++ b/src/backend/parser/parse_clause.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *       $Header: /cvsroot/pgsql/src/backend/parser/parse_clause.c,v 1.105 2003/02/09 06:56:28 tgl Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/parser/parse_clause.c,v 1.106 2003/02/10 04:44:46 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -22,7 +22,6 @@
 #include "optimizer/tlist.h"
 #include "optimizer/var.h"
 #include "parser/analyze.h"
-#include "parser/parse.h"
 #include "parser/parsetree.h"
 #include "parser/parse_clause.h"
 #include "parser/parse_coerce.h"
@@ -263,7 +262,7 @@ transformJoinUsingClause(ParseState *pstate, List *leftVars, List *rightVars)
                Node       *rvar = (Node *) lfirst(rvars);
                A_Expr     *e;
 
-               e = makeSimpleA_Expr(OP, "=", copyObject(lvar), copyObject(rvar));
+               e = makeSimpleA_Expr(AEXPR_OP, "=", copyObject(lvar), copyObject(rvar));
 
                if (result == NULL)
                        result = (Node *) e;
@@ -271,7 +270,7 @@ transformJoinUsingClause(ParseState *pstate, List *leftVars, List *rightVars)
                {
                        A_Expr     *a;
 
-                       a = makeA_Expr(AND, NIL, result, (Node *) e);
+                       a = makeA_Expr(AEXPR_AND, NIL, result, (Node *) e);
                        result = (Node *) a;
                }
 

diff --git a/src/backend/parser/parse_expr.c b/src/backend/parser/parse_expr.c
index e807dfe3f462284ac3abbb41c152c7d7ac5bb245..ec95870ec9e5f3a75c777419752393cfdffd5b8d 100644 (file)
--- a/src/backend/parser/parse_expr.c
+++ b/src/backend/parser/parse_expr.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *       $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.143 2003/02/09 06:56:28 tgl Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.144 2003/02/10 04:44:46 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -23,7 +23,6 @@
 #include "nodes/plannodes.h"
 #include "parser/analyze.h"
 #include "parser/gramparse.h"
-#include "parser/parse.h"
 #include "parser/parse_coerce.h"
 #include "parser/parse_expr.h"
 #include "parser/parse_func.h"
@@ -178,9 +177,9 @@ transformExpr(ParseState *pstate, Node *expr)
                        {
                                A_Expr     *a = (A_Expr *) expr;
 
-                               switch (a->oper)
+                               switch (a->kind)
                                {
-                                       case OP:
+                                       case AEXPR_OP:
                                                {
                                                        /*
                                                         * Special-case "foo = NULL" and "NULL = foo"
@@ -219,7 +218,7 @@ transformExpr(ParseState *pstate, Node *expr)
                                                        }
                                                }
                                                break;
-                                       case AND:
+                                       case AEXPR_AND:
                                                {
                                                        Node       *lexpr = transformExpr(pstate,
                                                                                                                          a->lexpr);
@@ -234,7 +233,7 @@ transformExpr(ParseState *pstate, Node *expr)
                                                                                                                                         rexpr));
                                                }
                                                break;
-                                       case OR:
+                                       case AEXPR_OR:
                                                {
                                                        Node       *lexpr = transformExpr(pstate,
                                                                                                                          a->lexpr);
@@ -249,7 +248,7 @@ transformExpr(ParseState *pstate, Node *expr)
                                                                                                                                         rexpr));
                                                }
                                                break;
-                                       case NOT:
+                                       case AEXPR_NOT:
                                                {
                                                        Node       *rexpr = transformExpr(pstate,
                                                                                                                          a->rexpr);
@@ -260,7 +259,7 @@ transformExpr(ParseState *pstate, Node *expr)
                                                                                                                   makeList1(rexpr));
                                                }
                                                break;
-                                       case DISTINCT:
+                                       case AEXPR_DISTINCT:
                                                {
                                                        Node       *lexpr = transformExpr(pstate,
                                                                                                                          a->lexpr);
@@ -278,18 +277,17 @@ transformExpr(ParseState *pstate, Node *expr)
                                                        NodeSetTag(result, T_DistinctExpr);
                                                }
                                                break;
-                                       case OF:
+                                       case AEXPR_OF:
                                                {
+                                                       /*
+                                                        * Checking an expression for match to type.
+                                                        * Will result in a boolean constant node.
+                                                        */
                                                        List       *telem;
                                                        A_Const    *n;
                                                        Oid                     ltype,
                                                                                rtype;
                                                        bool            matched = FALSE;
-
-                                                       /*
-                                                        * Checking an expression for match to type.
-                                                        * Will result in a boolean constant node.
-                                                        */
                                                        Node       *lexpr = transformExpr(pstate,
                                                                                                                          a->lexpr);
 
@@ -530,7 +528,7 @@ transformExpr(ParseState *pstate, Node *expr)
                                        if (c->arg != NULL)
                                        {
                                                /* shorthand form was specified, so expand... */
-                                               warg = (Node *) makeSimpleA_Expr(OP, "=",
+                                               warg = (Node *) makeSimpleA_Expr(AEXPR_OP, "=",
                                                                                                                 (Node *) c->arg,
                                                                                                                 warg);
                                        }

diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c
index 44f163215bc7b44bc42262781888bccf7b8de9ee..d6366a1104d46b1ba0fbd20241039382dd893454 100644 (file)
--- a/src/backend/tcop/postgres.c
+++ b/src/backend/tcop/postgres.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *       $Header: /cvsroot/pgsql/src/backend/tcop/postgres.c,v 1.314 2003/01/01 21:57:05 tgl Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/tcop/postgres.c,v 1.315 2003/02/10 04:44:46 tgl Exp $
  *
  * NOTES
  *       this is the "main" module of the postgres backend and
@@ -44,7 +44,6 @@
 #include "optimizer/cost.h"
 #include "optimizer/planner.h"
 #include "parser/analyze.h"
-#include "parser/parse.h"
 #include "parser/parser.h"
 #include "rewrite/rewriteHandler.h"
 #include "storage/ipc.h"
@@ -666,7 +665,8 @@ pg_exec_query_string(StringInfo query_string,       /* string to execute */
                        {
                                TransactionStmt *stmt = (TransactionStmt *) parsetree;
 
-                               if (stmt->command == COMMIT || stmt->command == ROLLBACK)
+                               if (stmt->kind == TRANS_STMT_COMMIT ||
+                                       stmt->kind == TRANS_STMT_ROLLBACK)
                                        allowit = true;
                        }
 
@@ -1781,7 +1781,7 @@ PostgresMain(int argc, char *argv[], const char *username)
        if (!IsUnderPostmaster)
        {
                puts("\nPOSTGRES backend interactive interface ");
-               puts("$Revision: 1.314 $ $Date: 2003/01/01 21:57:05 $\n");
+               puts("$Revision: 1.315 $ $Date: 2003/02/10 04:44:46 $\n");
        }
 
        /*
@@ -2212,21 +2212,21 @@ CreateCommandTag(Node *parsetree)
                        {
                                TransactionStmt *stmt = (TransactionStmt *) parsetree;
 
-                               switch (stmt->command)
+                               switch (stmt->kind)
                                {
-                                       case BEGIN_TRANS:
+                                       case TRANS_STMT_BEGIN:
                                                tag = "BEGIN";
                                                break;
 
-                                       case START:
+                                       case TRANS_STMT_START:
                                                tag = "START TRANSACTION";
                                                break;
 
-                                       case COMMIT:
+                                       case TRANS_STMT_COMMIT:
                                                tag = "COMMIT";
                                                break;
 
-                                       case ROLLBACK:
+                                       case TRANS_STMT_ROLLBACK:
                                                tag = "ROLLBACK";
                                                break;
 
@@ -2329,15 +2329,15 @@ CreateCommandTag(Node *parsetree)
                        break;
 
                case T_DefineStmt:
-                       switch (((DefineStmt *) parsetree)->defType)
+                       switch (((DefineStmt *) parsetree)->kind)
                        {
-                               case AGGREGATE:
+                               case DEFINE_STMT_AGGREGATE:
                                        tag = "CREATE AGGREGATE";
                                        break;
-                               case OPERATOR:
+                               case DEFINE_STMT_OPERATOR:
                                        tag = "CREATE OPERATOR";
                                        break;
-                               case TYPE_P:
+                               case DEFINE_STMT_TYPE:
                                        tag = "CREATE TYPE";
                                        break;
                                default:

diff --git a/src/backend/tcop/utility.c b/src/backend/tcop/utility.c
index 16ca619445c707b79e19e11a82adf8cb6ced6958..18a474f34b6863140acf7715c355d876cc176611 100644 (file)
--- a/src/backend/tcop/utility.c
+++ b/src/backend/tcop/utility.c
@@ -10,7 +10,7 @@
  *
  *
  * IDENTIFICATION
- *       $Header: /cvsroot/pgsql/src/backend/tcop/utility.c,v 1.190 2003/01/27 00:48:28 tgl Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/tcop/utility.c,v 1.191 2003/02/10 04:44:46 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -42,7 +42,6 @@
 #include "commands/view.h"
 #include "miscadmin.h"
 #include "nodes/makefuncs.h"
-#include "parser/parse.h"
 #include "parser/parse_clause.h"
 #include "parser/parse_expr.h"
 #include "parser/parse_type.h"
@@ -261,9 +260,9 @@ ProcessUtility(Node *parsetree,
                        {
                                TransactionStmt *stmt = (TransactionStmt *) parsetree;
 
-                               switch (stmt->command)
+                               switch (stmt->kind)
                                {
-                                       case BEGIN_TRANS:
+                                       case TRANS_STMT_BEGIN:
                                                BeginTransactionBlock();
                                                break;
 
@@ -272,7 +271,7 @@ ProcessUtility(Node *parsetree,
                                                 * Identical to BEGIN, except that it takes a few
                                                 * additional options.
                                                 */
-                                       case START:
+                                       case TRANS_STMT_START:
                                                {
                                                        BeginTransactionBlock();
 
@@ -295,11 +294,11 @@ ProcessUtility(Node *parsetree,
                                                }
                                                break;
 
-                                       case COMMIT:
+                                       case TRANS_STMT_COMMIT:
                                                EndTransactionBlock();
                                                break;
 
-                                       case ROLLBACK:
+                                       case TRANS_STMT_ROLLBACK:
                                                UserAbortTransactionBlock();
                                                break;
                                }
@@ -320,17 +319,10 @@ ProcessUtility(Node *parsetree,
                case T_FetchStmt:
                        {
                                FetchStmt  *stmt = (FetchStmt *) parsetree;
-                               char       *portalName = stmt->portalname;
-                               bool            forward;
-                               long            count;
 
-                               forward = (bool) (stmt->direction == FORWARD);
-
-                               /*
-                                * parser ensures that count is >= 0
-                                */
-                               count = stmt->howMany;
-                               PerformPortalFetch(portalName, forward, count,
+                               PerformPortalFetch(stmt->portalname,
+                                                                  stmt->direction == FETCH_FORWARD,
+                                                                  stmt->howMany,
                                                                   (stmt->ismove) ? None : dest,
                                                                   completionTag);
                        }
@@ -693,17 +685,17 @@ ProcessUtility(Node *parsetree,
                        {
                                DefineStmt *stmt = (DefineStmt *) parsetree;
 
-                               switch (stmt->defType)
+                               switch (stmt->kind)
                                {
-                                       case OPERATOR:
+                                       case DEFINE_STMT_AGGREGATE:
+                                               DefineAggregate(stmt->defnames, stmt->definition);
+                                               break;
+                                       case DEFINE_STMT_OPERATOR:
                                                DefineOperator(stmt->defnames, stmt->definition);
                                                break;
-                                       case TYPE_P:
+                                       case DEFINE_STMT_TYPE:
                                                DefineType(stmt->defnames, stmt->definition);
                                                break;
-                                       case AGGREGATE:
-                                               DefineAggregate(stmt->defnames, stmt->definition);
-                                               break;
                                }
                        }
                        break;
@@ -981,17 +973,17 @@ ProcessUtility(Node *parsetree,
                        {
                                ReindexStmt *stmt = (ReindexStmt *) parsetree;
 
-                               switch (stmt->reindexType)
+                               switch (stmt->kind)
                                {
-                                       case INDEX:
+                                       case REINDEX_INDEX:
                                                CheckOwnership(stmt->relation, false);
                                                ReindexIndex(stmt->relation, stmt->force);
                                                break;
-                                       case TABLE:
+                                       case REINDEX_TABLE:
                                                CheckOwnership(stmt->relation, false);
                                                ReindexTable(stmt->relation, stmt->force);
                                                break;
-                                       case DATABASE:
+                                       case REINDEX_DATABASE:
                                                ReindexDatabase(stmt->name, stmt->force, false);
                                                break;
                                }

diff --git a/src/include/nodes/makefuncs.h b/src/include/nodes/makefuncs.h
index d1f4ebfc4002c8404e99ffd5ff8b2c285133d50b..a66e9fc09be9948c099ccc1223b3130ba29ac8d5 100644 (file)
--- a/src/include/nodes/makefuncs.h
+++ b/src/include/nodes/makefuncs.h
@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: makefuncs.h,v 1.43 2002/12/12 15:49:40 tgl Exp $
+ * $Id: makefuncs.h,v 1.44 2003/02/10 04:44:46 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -17,10 +17,11 @@
 #include "nodes/parsenodes.h"
 
 
-extern A_Expr *makeA_Expr(int oper, List *name, Node *lexpr, Node *rexpr);
+extern A_Expr *makeA_Expr(A_Expr_Kind kind, List *name,
+                                                 Node *lexpr, Node *rexpr);
 
-extern A_Expr *makeSimpleA_Expr(int oper, const char *name,
-                                Node *lexpr, Node *rexpr);
+extern A_Expr *makeSimpleA_Expr(A_Expr_Kind kind, const char *name,
+                                                               Node *lexpr, Node *rexpr);
 
 extern Var *makeVar(Index varno,
                AttrNumber varattno,

diff --git a/src/include/nodes/parsenodes.h b/src/include/nodes/parsenodes.h
index 53b0a3db7fcdbbba2a544f61b5d89def963c728f..5f8f4794f936ef3bcf092844bed262dfee91bc4a 100644 (file)
--- a/src/include/nodes/parsenodes.h
+++ b/src/include/nodes/parsenodes.h
@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: parsenodes.h,v 1.228 2003/02/09 06:56:28 tgl Exp $
+ * $Id: parsenodes.h,v 1.229 2003/02/10 04:44:47 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -165,15 +165,25 @@ typedef struct ParamRef
 } ParamRef;
 
 /*
- * A_Expr - binary expressions
+ * A_Expr - infix, prefix, and postfix expressions
  */
+typedef enum A_Expr_Kind
+{
+       AEXPR_OP,                                       /* normal operator */
+       AEXPR_AND,                                      /* booleans - name field is unused */
+       AEXPR_OR,
+       AEXPR_NOT,
+       AEXPR_DISTINCT,                         /* IS DISTINCT FROM - name must be "=" */
+       AEXPR_OF                                        /* IS (not) OF - name must be "=" or "!=" */
+} A_Expr_Kind;
+
 typedef struct A_Expr
 {
        NodeTag         type;
-       int                     oper;                   /* type of operation (OP,OR,AND,NOT) */
+       A_Expr_Kind     kind;                   /* see above */
        List       *name;                       /* possibly-qualified name of operator */
-       Node       *lexpr;                      /* left argument */
-       Node       *rexpr;                      /* right argument */
+       Node       *lexpr;                      /* left argument, or NULL if none */
+       Node       *rexpr;                      /* right argument, or NULL if none */
 } A_Expr;
 
 /*
@@ -1058,13 +1068,20 @@ typedef struct CreateSeqStmt
 } CreateSeqStmt;
 
 /* ----------------------
- *             Create {Operator|Type|Aggregate} Statement
+ *             Create {Aggregate|Operator|Type} Statement
  * ----------------------
  */
+typedef enum DefineStmtKind
+{
+       DEFINE_STMT_AGGREGATE,
+       DEFINE_STMT_OPERATOR,
+       DEFINE_STMT_TYPE
+} DefineStmtKind;
+
 typedef struct DefineStmt
 {
        NodeTag         type;
-       int                     defType;                /* OPERATOR|TYPE_P|AGGREGATE */
+       DefineStmtKind kind;            /* see above */
        List       *defnames;           /* qualified name (list of Value strings) */
        List       *definition;         /* a list of DefElem */
 } DefineStmt;
@@ -1196,11 +1213,18 @@ typedef struct CommentStmt
  *             Fetch Statement
  * ----------------------
  */
+typedef enum FetchDirection
+{
+       FETCH_FORWARD,
+       FETCH_BACKWARD
+       /* ABSOLUTE someday? */
+} FetchDirection;
+
 typedef struct FetchStmt
 {
        NodeTag         type;
-       int                     direction;              /* FORWARD or BACKWARD */
-       long            howMany;                /* amount to fetch */
+       FetchDirection direction;       /* see above */
+       long            howMany;                /* number of rows */
        char       *portalname;         /* name of portal (cursor) */
        bool            ismove;                 /* TRUE if MOVE */
 } FetchStmt;
@@ -1357,11 +1381,19 @@ typedef struct UnlistenStmt
  *             {Begin|Commit|Rollback} Transaction Statement
  * ----------------------
  */
+typedef enum TransactionStmtKind
+{
+       TRANS_STMT_BEGIN,
+       TRANS_STMT_START,                       /* semantically identical to BEGIN */
+       TRANS_STMT_COMMIT,
+       TRANS_STMT_ROLLBACK
+} TransactionStmtKind;
+
 typedef struct TransactionStmt
 {
        NodeTag         type;
-       int                     command;                /* BEGIN_TRANS|START|COMMIT|ROLLBACK */
-       List       *options;
+       TransactionStmtKind kind;       /* see above */
+       List       *options;            /* for BEGIN/START only */
 } TransactionStmt;
 
 /* ----------------------
@@ -1544,10 +1576,17 @@ typedef struct ConstraintsSetStmt
  *             REINDEX Statement
  * ----------------------
  */
+typedef enum ReindexStmtKind
+{
+       REINDEX_INDEX,
+       REINDEX_TABLE,
+       REINDEX_DATABASE
+} ReindexStmtKind;
+
 typedef struct ReindexStmt
 {
        NodeTag         type;
-       int                     reindexType;    /* INDEX|TABLE|DATABASE */
+       ReindexStmtKind kind;           /* see above */
        RangeVar   *relation;           /* Table or index to reindex */
        const char *name;                       /* name of database to reindex */
        bool            force;