Remove typename from A_Const.

Brendan Jurd, minor editorialization by me.

diff --git a/src/backend/nodes/copyfuncs.c b/src/backend/nodes/copyfuncs.c
index 87a04bcd64c99a7cb14f13dba7c291cddd5b71ae..67dcf9a2182c1f5dd24a09cba8f8e40f3a5c1ecf 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
- *   $PostgreSQL: pgsql/src/backend/nodes/copyfuncs.c,v 1.392 2008/04/14 17:05:33 tgl Exp $
+ *   $PostgreSQL: pgsql/src/backend/nodes/copyfuncs.c,v 1.393 2008/04/29 14:59:16 alvherre Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -1639,8 +1639,6 @@ _copyAConst(A_Const *from)
            break;
    }
 
-   COPY_NODE_FIELD(typename);
-
    return newnode;
 }
 

diff --git a/src/backend/nodes/equalfuncs.c b/src/backend/nodes/equalfuncs.c
index 161e8f06dcf01c9f4a35d61d8063e1ea7b09e8be..0c444901322073f84dfc5de1543a63d37f148a4c 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
- *   $PostgreSQL: pgsql/src/backend/nodes/equalfuncs.c,v 1.321 2008/04/14 17:05:33 tgl Exp $
+ *   $PostgreSQL: pgsql/src/backend/nodes/equalfuncs.c,v 1.322 2008/04/29 14:59:16 alvherre Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -1693,7 +1693,6 @@ _equalAConst(A_Const *a, A_Const *b)
 {
    if (!equal(&a->val, &b->val))       /* hack for in-line Value field */
        return false;
-   COMPARE_NODE_FIELD(typename);
 
    return true;
 }

diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index 8e5302452012bf9eeae06143d98cf43f965d4a3d..51b46a83edfb6ab3603562f4164a5598e87b85b9 100644 (file)
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *   $PostgreSQL: pgsql/src/backend/nodes/outfuncs.c,v 1.325 2008/04/13 20:51:20 tgl Exp $
+ *   $PostgreSQL: pgsql/src/backend/nodes/outfuncs.c,v 1.326 2008/04/29 14:59:16 alvherre Exp $
  *
  * NOTES
  *   Every node type that can appear in stored rules' parsetrees *must*
@@ -1945,7 +1945,6 @@ _outAConst(StringInfo str, A_Const *node)
 
    appendStringInfo(str, " :val ");
    _outValue(str, &(node->val));
-   WRITE_NODE_FIELD(typename);
 }
 
 static void

diff --git a/src/backend/parser/gram.y b/src/backend/parser/gram.y
index e17842231d9e18c8b80e92778ec5a80c0f1344e4..7908b44711265e8f83b5732a5f0000726a378366 100644 (file)
--- a/src/backend/parser/gram.y
+++ b/src/backend/parser/gram.y
@@ -11,7 +11,7 @@
  *
  *
  * IDENTIFICATION
- *   $PostgreSQL: pgsql/src/backend/parser/gram.y,v 2.612 2008/04/14 17:05:33 tgl Exp $
+ *   $PostgreSQL: pgsql/src/backend/parser/gram.y,v 2.613 2008/04/29 14:59:16 alvherre Exp $
  *
  * HISTORY
  *   AUTHOR            DATE            MAJOR EVENT
@@ -91,11 +91,12 @@ static bool QueryIsRule = FALSE;
 
 static Node *makeColumnRef(char *relname, List *indirection, int location);
 static Node *makeTypeCast(Node *arg, TypeName *typename);
-static Node *makeStringConst(char *str, TypeName *typename);
+static Node *makeStringConst(char *str);
+static Node *makeStringConstCast(char *str, TypeName *typename);
 static Node *makeIntConst(int val);
 static Node *makeFloatConst(char *str);
 static Node *makeAConst(Value *v);
-static A_Const *makeBoolAConst(bool state);
+static Node *makeBoolAConst(bool state);
 static FuncCall *makeOverlaps(List *largs, List *rargs, int location);
 static void check_qualified_name(List *names);
 static List *check_func_name(List *names);
@@ -1112,7 +1113,7 @@ set_rest: /* Generic SET syntaxes: */
                    n->kind = VAR_SET_VALUE;
                    n->name = "client_encoding";
                    if ($2 != NULL)
-                       n->args = list_make1(makeStringConst($2, NULL));
+                       n->args = list_make1(makeStringConst($2));
                    else
                        n->kind = VAR_SET_DEFAULT;
                    $$ = n;
@@ -1122,7 +1123,7 @@ set_rest: /* Generic SET syntaxes: */
                    VariableSetStmt *n = makeNode(VariableSetStmt);
                    n->kind = VAR_SET_VALUE;
                    n->name = "role";
-                   n->args = list_make1(makeStringConst($2, NULL));
+                   n->args = list_make1(makeStringConst($2));
                    $$ = n;
                }
            | SESSION AUTHORIZATION ColId_or_Sconst
@@ -1130,7 +1131,7 @@ set_rest: /* Generic SET syntaxes: */
                    VariableSetStmt *n = makeNode(VariableSetStmt);
                    n->kind = VAR_SET_VALUE;
                    n->name = "session_authorization";
-                   n->args = list_make1(makeStringConst($3, NULL));
+                   n->args = list_make1(makeStringConst($3));
                    $$ = n;
                }
            | SESSION AUTHORIZATION DEFAULT
@@ -1145,7 +1146,7 @@ set_rest: /* Generic SET syntaxes: */
                    VariableSetStmt *n = makeNode(VariableSetStmt);
                    n->kind = VAR_SET_VALUE;
                    n->name = "xmloption";
-                   n->args = list_make1(makeStringConst($3 == XMLOPTION_DOCUMENT ? "DOCUMENT" : "CONTENT", NULL));
+                   n->args = list_make1(makeStringConst($3 == XMLOPTION_DOCUMENT ? "DOCUMENT" : "CONTENT"));
                    $$ = n;
                }
        ;
@@ -1163,9 +1164,9 @@ var_list: var_value                               { $$ = list_make1($1); }
        ;
 
 var_value: opt_boolean
-               { $$ = makeStringConst($1, NULL); }
+               { $$ = makeStringConst($1); }
            | ColId_or_Sconst
-               { $$ = makeStringConst($1, NULL); }
+               { $$ = makeStringConst($1); }
            | NumericOnly
                { $$ = makeAConst($1); }
        ;
@@ -1194,36 +1195,36 @@ opt_boolean:
 zone_value:
            Sconst
                {
-                   $$ = makeStringConst($1, NULL);
+                   $$ = makeStringConst($1);
                }
            | IDENT
                {
-                   $$ = makeStringConst($1, NULL);
+                   $$ = makeStringConst($1);
                }
            | ConstInterval Sconst opt_interval
                {
-                   A_Const *n = (A_Const *) makeStringConst($2, $1);
+                   TypeName *t = $1;
                    if ($3 != INTERVAL_FULL_RANGE)
                    {
                        if (($3 & ~(INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE))) != 0)
                            ereport(ERROR,
                                    (errcode(ERRCODE_SYNTAX_ERROR),
                                     errmsg("time zone interval must be HOUR or HOUR TO MINUTE")));
-                       n->typename->typmods = list_make1(makeIntConst($3));
+                       t->typmods = list_make1(makeIntConst($3));
                    }
-                   $$ = (Node *)n;
+                   $$ = makeStringConstCast($2, t);
                }
            | ConstInterval '(' Iconst ')' Sconst opt_interval
                {
-                   A_Const *n = (A_Const *) makeStringConst($5, $1);
+                   TypeName *t = $1;
                    if (($6 != INTERVAL_FULL_RANGE)
                        && (($6 & ~(INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE))) != 0))
                        ereport(ERROR,
                                (errcode(ERRCODE_SYNTAX_ERROR),
                                 errmsg("time zone interval must be HOUR or HOUR TO MINUTE")));
-                   n->typename->typmods = list_make2(makeIntConst($6),
-                                                     makeIntConst($3));
-                   $$ = (Node *)n;
+                   t->typmods = list_make2(makeIntConst($6), 
+                                           makeIntConst($3));
+                   $$ = makeStringConstCast($5, t);
                }
            | NumericOnly                           { $$ = makeAConst($1); }
            | DEFAULT                               { $$ = NULL; }
@@ -5207,7 +5208,7 @@ opt_transaction:  WORK                            {}
 transaction_mode_item:
            ISOLATION LEVEL iso_level
                    { $$ = makeDefElem("transaction_isolation",
-                                      makeStringConst($3, NULL)); }
+                                      makeStringConst($3)); }
            | READ ONLY
                    { $$ = makeDefElem("transaction_read_only",
                                       makeIntConst(TRUE)); }
@@ -7912,16 +7913,9 @@ func_expr:   func_name '(' ')'
                     * that is actually possible, but not clear that we want
                     * to rely on it.)
                     */
-                   A_Const *s = makeNode(A_Const);
-                   TypeName *d;
-
-                   s->val.type = T_String;
-                   s->val.val.str = "now";
-                   s->typename = SystemTypeName("text");
-
-                   d = SystemTypeName("date");
-
-                   $$ = (Node *)makeTypeCast((Node *)s, d);
+                   Node *n;
+                   n = makeStringConstCast("now", SystemTypeName("text"));
+                   $$ = makeTypeCast(n, SystemTypeName("date"));
                }
            | CURRENT_TIME
                {
@@ -7929,16 +7923,9 @@ func_expr:   func_name '(' ')'
                     * Translate as "'now'::text::timetz".
                     * See comments for CURRENT_DATE.
                     */
-                   A_Const *s = makeNode(A_Const);
-                   TypeName *d;
-
-                   s->val.type = T_String;
-                   s->val.val.str = "now";
-                   s->typename = SystemTypeName("text");
-
-                   d = SystemTypeName("timetz");
-
-                   $$ = (Node *)makeTypeCast((Node *)s, d);
+                   Node *n;
+                   n = makeStringConstCast("now", SystemTypeName("text"));
+                   $$ = makeTypeCast(n, SystemTypeName("timetz"));
                }
            | CURRENT_TIME '(' Iconst ')'
                {
@@ -7946,16 +7933,12 @@ func_expr:  func_name '(' ')'
                     * Translate as "'now'::text::timetz(n)".
                     * See comments for CURRENT_DATE.
                     */
-                   A_Const *s = makeNode(A_Const);
+                   Node *n;
                    TypeName *d;
-
-                   s->val.type = T_String;
-                   s->val.val.str = "now";
-                   s->typename = SystemTypeName("text");
+                   n = makeStringConstCast("now", SystemTypeName("text"));
                    d = SystemTypeName("timetz");
                    d->typmods = list_make1(makeIntConst($3));
-
-                   $$ = (Node *)makeTypeCast((Node *)s, d);
+                   $$ = makeTypeCast(n, d);
                }
            | CURRENT_TIMESTAMP
                {
@@ -7977,17 +7960,12 @@ func_expr:  func_name '(' ')'
                     * Translate as "'now'::text::timestamptz(n)".
                     * See comments for CURRENT_DATE.
                     */
-                   A_Const *s = makeNode(A_Const);
+                   Node *n;
                    TypeName *d;
-
-                   s->val.type = T_String;
-                   s->val.val.str = "now";
-                   s->typename = SystemTypeName("text");
-
+                   n = makeStringConstCast("now", SystemTypeName("text"));
                    d = SystemTypeName("timestamptz");
                    d->typmods = list_make1(makeIntConst($3));
-
-                   $$ = (Node *)makeTypeCast((Node *)s, d);
+                   $$ = makeTypeCast(n, d);
                }
            | LOCALTIME
                {
@@ -7995,16 +7973,9 @@ func_expr:   func_name '(' ')'
                     * Translate as "'now'::text::time".
                     * See comments for CURRENT_DATE.
                     */
-                   A_Const *s = makeNode(A_Const);
-                   TypeName *d;
-
-                   s->val.type = T_String;
-                   s->val.val.str = "now";
-                   s->typename = SystemTypeName("text");
-
-                   d = SystemTypeName("time");
-
-                   $$ = (Node *)makeTypeCast((Node *)s, d);
+                   Node *n;
+                   n = makeStringConstCast("now", SystemTypeName("text"));
+                   $$ = makeTypeCast((Node *)n, SystemTypeName("time"));
                }
            | LOCALTIME '(' Iconst ')'
                {
@@ -8012,16 +7983,12 @@ func_expr:  func_name '(' ')'
                     * Translate as "'now'::text::time(n)".
                     * See comments for CURRENT_DATE.
                     */
-                   A_Const *s = makeNode(A_Const);
+                   Node *n;
                    TypeName *d;
-
-                   s->val.type = T_String;
-                   s->val.val.str = "now";
-                   s->typename = SystemTypeName("text");
+                   n = makeStringConstCast("now", SystemTypeName("text"));
                    d = SystemTypeName("time");
                    d->typmods = list_make1(makeIntConst($3));
-
-                   $$ = (Node *)makeTypeCast((Node *)s, d);
+                   $$ = makeTypeCast((Node *)n, d);
                }
            | LOCALTIMESTAMP
                {
@@ -8029,16 +7996,9 @@ func_expr:   func_name '(' ')'
                     * Translate as "'now'::text::timestamp".
                     * See comments for CURRENT_DATE.
                     */
-                   A_Const *s = makeNode(A_Const);
-                   TypeName *d;
-
-                   s->val.type = T_String;
-                   s->val.val.str = "now";
-                   s->typename = SystemTypeName("text");
-
-                   d = SystemTypeName("timestamp");
-
-                   $$ = (Node *)makeTypeCast((Node *)s, d);
+                   Node *n;
+                   n = makeStringConstCast("now", SystemTypeName("text"));
+                   $$ = makeTypeCast(n, SystemTypeName("timestamp"));
                }
            | LOCALTIMESTAMP '(' Iconst ')'
                {
@@ -8046,17 +8006,12 @@ func_expr:  func_name '(' ')'
                     * Translate as "'now'::text::timestamp(n)".
                     * See comments for CURRENT_DATE.
                     */
-                   A_Const *s = makeNode(A_Const);
+                   Node *n;
                    TypeName *d;
-
-                   s->val.type = T_String;
-                   s->val.val.str = "now";
-                   s->typename = SystemTypeName("text");
-
+                   n = makeStringConstCast("now", SystemTypeName("text"));
                    d = SystemTypeName("timestamp");
                    d->typmods = list_make1(makeIntConst($3));
-
-                   $$ = (Node *)makeTypeCast((Node *)s, d);
+                   $$ = makeTypeCast(n, d);
                }
            | CURRENT_ROLE
                {
@@ -8304,13 +8259,13 @@ xml_root_version: VERSION_P a_expr
        ;
 
 opt_xml_root_standalone: ',' STANDALONE_P YES_P
-               { $$ = (Node *) makeIntConst(XML_STANDALONE_YES); }
+               { $$ = makeIntConst(XML_STANDALONE_YES); }
            | ',' STANDALONE_P NO
-               { $$ = (Node *) makeIntConst(XML_STANDALONE_NO); }
+               { $$ = makeIntConst(XML_STANDALONE_NO); }
            | ',' STANDALONE_P NO VALUE_P
-               { $$ = (Node *) makeIntConst(XML_STANDALONE_NO_VALUE); }
+               { $$ = makeIntConst(XML_STANDALONE_NO_VALUE); }
            | /*EMPTY*/
-               { $$ = (Node *) makeIntConst(XML_STANDALONE_OMITTED); }
+               { $$ = makeIntConst(XML_STANDALONE_OMITTED); }
        ;
 
 xml_attributes: XMLATTRIBUTES '(' xml_attribute_list ')'   { $$ = $3; }
@@ -8897,60 +8852,44 @@ AexprConst: Iconst
            | func_name Sconst
                {
                    /* generic type 'literal' syntax */
-                   A_Const *n = makeNode(A_Const);
-                   n->typename = makeTypeNameFromNameList($1);
-                   n->typename->location = @1;
-                   n->val.type = T_String;
-                   n->val.val.str = $2;
-                   $$ = (Node *)n;
+                   TypeName *t = makeTypeNameFromNameList($1);
+                   t->location = @1;
+                   $$ = makeStringConstCast($2, t);
                }
            | func_name '(' expr_list ')' Sconst
                {
                    /* generic syntax with a type modifier */
-                   A_Const *n = makeNode(A_Const);
-                   n->typename = makeTypeNameFromNameList($1);
-                   n->typename->typmods = $3;
-                   n->typename->location = @1;
-                   n->val.type = T_String;
-                   n->val.val.str = $5;
-                   $$ = (Node *)n;
+                   TypeName *t = makeTypeNameFromNameList($1);
+                   t->typmods = $3;
+                   t->location = @1;
+                   $$ = makeStringConstCast($5, t);
                }
            | ConstTypename Sconst
                {
-                   A_Const *n = makeNode(A_Const);
-                   n->typename = $1;
-                   n->val.type = T_String;
-                   n->val.val.str = $2;
-                   $$ = (Node *)n;
+                   $$ = makeStringConstCast($2, $1);
                }
            | ConstInterval Sconst opt_interval
                {
-                   A_Const *n = makeNode(A_Const);
-                   n->typename = $1;
-                   n->val.type = T_String;
-                   n->val.val.str = $2;
+                   TypeName *t = $1;
                    /* precision is not specified, but fields may be... */
                    if ($3 != INTERVAL_FULL_RANGE)
-                       n->typename->typmods = list_make1(makeIntConst($3));
-                   $$ = (Node *)n;
+                       t->typmods = list_make1(makeIntConst($3));
+                   $$ = makeStringConstCast($2, t);
                }
            | ConstInterval '(' Iconst ')' Sconst opt_interval
                {
-                   A_Const *n = makeNode(A_Const);
-                   n->typename = $1;
-                   n->val.type = T_String;
-                   n->val.val.str = $5;
-                   n->typename->typmods = list_make2(makeIntConst($6),
-                                                     makeIntConst($3));
-                   $$ = (Node *)n;
+                   TypeName *t = $1;
+                   t->typmods = list_make2(makeIntConst($6),
+                                           makeIntConst($3));
+                   $$ = makeStringConstCast($5, t);
                }
            | TRUE_P
                {
-                   $$ = (Node *)makeBoolAConst(TRUE);
+                   $$ = makeBoolAConst(TRUE);
                }
            | FALSE_P
                {
-                   $$ = (Node *)makeBoolAConst(FALSE);
+                   $$ = makeBoolAConst(FALSE);
                }
            | NULL_P
                {
@@ -9506,24 +9445,31 @@ makeTypeCast(Node *arg, TypeName *typename)
 }
 
 static Node *
-makeStringConst(char *str, TypeName *typename)
+makeStringConst(char *str)
 {
    A_Const *n = makeNode(A_Const);
 
    n->val.type = T_String;
    n->val.val.str = str;
-   n->typename = typename;
 
    return (Node *)n;
 }
 
+static Node *
+makeStringConstCast(char *str, TypeName *typename)
+{
+   Node *s = makeStringConst(str);
+
+   return makeTypeCast(s, typename);
+}
+
 static Node *
 makeIntConst(int val)
 {
    A_Const *n = makeNode(A_Const);
+
    n->val.type = T_Integer;
    n->val.val.ival = val;
-   n->typename = SystemTypeName("int4");
 
    return (Node *)n;
 }
@@ -9535,9 +9481,8 @@ makeFloatConst(char *str)
 
    n->val.type = T_Float;
    n->val.val.str = str;
-   n->typename = SystemTypeName("float8");
 
-   return (Node *)n;
+   return makeTypeCast((Node *)n, SystemTypeName("float8"));
 }
 
 static Node *
@@ -9557,7 +9502,7 @@ makeAConst(Value *v)
 
        case T_String:
        default:
-           n = makeStringConst(v->val.str, NULL);
+           n = makeStringConst(v->val.str);
            break;
    }
 
@@ -9565,16 +9510,17 @@ makeAConst(Value *v)
 }
 
 /* makeBoolAConst()
- * Create an A_Const node and initialize to a boolean constant.
+ * Create an A_Const string node and put it inside a boolean cast.
  */
-static A_Const *
+static Node *
 makeBoolAConst(bool state)
 {
    A_Const *n = makeNode(A_Const);
+
    n->val.type = T_String;
    n->val.val.str = (state ? "t" : "f");
-   n->typename = SystemTypeName("bool");
-   return n;
+
+   return makeTypeCast((Node *)n, SystemTypeName("bool"));
 }
 
 /* makeOverlaps()

diff --git a/src/backend/parser/parse_expr.c b/src/backend/parser/parse_expr.c
index 29c058aa40b3315ffd4261b2e61f843a8d7ff846..362108ba3fa054188c55e7ea2e1069b72095e468 100644 (file)
--- a/src/backend/parser/parse_expr.c
+++ b/src/backend/parser/parse_expr.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *   $PostgreSQL: pgsql/src/backend/parser/parse_expr.c,v 1.227 2008/03/20 21:42:48 tgl Exp $
+ *   $PostgreSQL: pgsql/src/backend/parser/parse_expr.c,v 1.228 2008/04/29 14:59:16 alvherre Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -127,9 +127,6 @@ transformExpr(ParseState *pstate, Node *expr)
                Value      *val = &con->val;
 
                result = (Node *) make_const(val);
-               if (con->typename != NULL)
-                   result = typecast_expression(pstate, result,
-                                                con->typename);
                break;
            }
 
@@ -649,8 +646,7 @@ exprIsNullConstant(Node *arg)
    {
        A_Const    *con = (A_Const *) arg;
 
-       if (con->val.type == T_Null &&
-           con->typename == NULL)
+       if (con->val.type == T_Null)
            return true;
    }
    return false;

diff --git a/src/backend/parser/parse_target.c b/src/backend/parser/parse_target.c
index e1d69fec42121ca92a6d3da021df0e578698daf9..f6cfacd12aa0d14ebf5a45261ddb1cb80421cfd5 100644 (file)
--- a/src/backend/parser/parse_target.c
+++ b/src/backend/parser/parse_target.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *   $PostgreSQL: pgsql/src/backend/parser/parse_target.c,v 1.159 2008/03/20 21:42:48 tgl Exp $
+ *   $PostgreSQL: pgsql/src/backend/parser/parse_target.c,v 1.160 2008/04/29 14:59:17 alvherre Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -1266,13 +1266,6 @@ FigureColnameInternal(Node *node, char **name)
                return 2;
            }
            break;
-       case T_A_Const:
-           if (((A_Const *) node)->typename != NULL)
-           {
-               *name = strVal(llast(((A_Const *) node)->typename->names));
-               return 1;
-           }
-           break;
        case T_TypeCast:
            strength = FigureColnameInternal(((TypeCast *) node)->arg,
                                             name);

diff --git a/src/backend/parser/parse_type.c b/src/backend/parser/parse_type.c
index e07879b184d6c92f00a234d15305704bfcaa8b2c..9e3e0f2e75b208656dd716a84b8b8ce4d25f48a4 100644 (file)
--- a/src/backend/parser/parse_type.c
+++ b/src/backend/parser/parse_type.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *   $PostgreSQL: pgsql/src/backend/parser/parse_type.c,v 1.95 2008/04/11 22:54:23 tgl Exp $
+ *   $PostgreSQL: pgsql/src/backend/parser/parse_type.c,v 1.96 2008/04/29 14:59:17 alvherre Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -289,20 +289,33 @@ typenameTypeMod(ParseState *pstate, const TypeName *typename, Type typ)
        {
            A_Const    *ac = (A_Const *) tm;
 
-           /*
-            * The grammar hands back some integers with ::int4 attached, so
-            * allow a cast decoration if it's an Integer value, but not
-            * otherwise.
-            */
            if (IsA(&ac->val, Integer))
            {
                cstr = (char *) palloc(32);
                snprintf(cstr, 32, "%ld", (long) ac->val.val.ival);
            }
-           else if (ac->typename == NULL)      /* no casts allowed */
-           {
-               /* otherwise we can just use the str field directly. */
+           else
+               /* we can just use the str field directly. */
                cstr = ac->val.val.str;
+       }
+       else if (IsA(tm, TypeCast))
+       {
+           /*
+            * The grammar hands back some integers with ::int4 attached, so
+            * allow a cast decoration if it's an Integer value, but not
+            * otherwise.
+            */
+           TypeCast *tc = (TypeCast *) tm;
+
+           if (IsA(tc->arg, A_Const))
+           {
+               A_Const    *ac = (A_Const *) tc->arg;
+
+               if (IsA(&ac->val, Integer))
+               {
+                   cstr = (char *) palloc(32);
+                   snprintf(cstr, 32, "%ld", (long) ac->val.val.ival);
+               }
            }
        }
        else if (IsA(tm, ColumnRef))

diff --git a/src/backend/parser/parse_utilcmd.c b/src/backend/parser/parse_utilcmd.c
index a6ec85350f18ee84c011dedb2d9075037a6e53bd..33f5b8015f6040f5fc5238a51d14bcc667e58d64 100644 (file)
--- a/src/backend/parser/parse_utilcmd.c
+++ b/src/backend/parser/parse_utilcmd.c
@@ -19,7 +19,7 @@
  * Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $PostgreSQL: pgsql/src/backend/parser/parse_utilcmd.c,v 2.12 2008/04/24 20:46:49 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/parser/parse_utilcmd.c,v 2.13 2008/04/29 14:59:17 alvherre Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -308,6 +308,7 @@ transformColumnDefinition(ParseState *pstate, CreateStmtContext *cxt,
        char       *sname;
        char       *qstring;
        A_Const    *snamenode;
+       TypeCast   *castnode;
        FuncCall   *funccallnode;
        CreateSeqStmt *seqstmt;
        AlterSeqStmt *altseqstmt;
@@ -379,10 +380,12 @@ transformColumnDefinition(ParseState *pstate, CreateStmtContext *cxt,
        snamenode = makeNode(A_Const);
        snamenode->val.type = T_String;
        snamenode->val.val.str = qstring;
-       snamenode->typename = SystemTypeName("regclass");
+       castnode = makeNode(TypeCast);
+       castnode->typename = SystemTypeName("regclass");
+       castnode->arg = (Node *) snamenode;
        funccallnode = makeNode(FuncCall);
        funccallnode->funcname = SystemFuncName("nextval");
-       funccallnode->args = list_make1(snamenode);
+       funccallnode->args = list_make1(castnode);
        funccallnode->agg_star = false;
        funccallnode->agg_distinct = false;
        funccallnode->location = -1;

diff --git a/src/backend/utils/misc/guc.c b/src/backend/utils/misc/guc.c
index a2faea97825be7010fd643023a97323e259044f6..df3186b77cffff37b7fd69d536fe14820b8aa7c0 100644 (file)
--- a/src/backend/utils/misc/guc.c
+++ b/src/backend/utils/misc/guc.c
@@ -10,7 +10,7 @@
  * Written by Peter Eisentraut .
  *
  * IDENTIFICATION
- *   $PostgreSQL: pgsql/src/backend/utils/misc/guc.c,v 1.447 2008/04/18 01:42:17 tgl Exp $
+ *   $PostgreSQL: pgsql/src/backend/utils/misc/guc.c,v 1.448 2008/04/29 14:59:17 alvherre Exp $
  *
  *--------------------------------------------------------------------
  */
@@ -5207,29 +5207,48 @@ flatten_set_variable_args(const char *name, List *args)
 
    initStringInfo(&buf);
 
+   /*
+    * Each list member may be a plain A_Const node, or an A_Const within a
+    * TypeCast, as produced by makeFloatConst() et al in gram.y.
+    */
    foreach(l, args)
    {
-       A_Const    *arg = (A_Const *) lfirst(l);
+       Node       *arg = (Node *) lfirst(l);
        char       *val;
+       TypeName   *typename = NULL;
+       A_Const    *con;
 
        if (l != list_head(args))
            appendStringInfo(&buf, ", ");
 
+       if (IsA(arg, TypeCast))
+       {
+           TypeCast *tc = (TypeCast *) arg;
+
+           arg = tc->arg;
+           typename = tc->typename;
+       }
+
        if (!IsA(arg, A_Const))
            elog(ERROR, "unrecognized node type: %d", (int) nodeTag(arg));
 
-       switch (nodeTag(&arg->val))
+       con = (A_Const *) arg;
+       switch (nodeTag(&con->val))
        {
            case T_Integer:
-               appendStringInfo(&buf, "%ld", intVal(&arg->val));
+               appendStringInfo(&buf, "%ld", intVal(&con->val));
                break;
            case T_Float:
                /* represented as a string, so just copy it */
-               appendStringInfoString(&buf, strVal(&arg->val));
+               appendStringInfoString(&buf, strVal(&con->val));
                break;
            case T_String:
-               val = strVal(&arg->val);
-               if (arg->typename != NULL)
+               /*
+                * Plain string literal or identifier.  For quote mode,
+                * quote it if it's not a vanilla identifier.
+                */
+               val = strVal(&con->val);
+               if (typename != NULL)
                {
                    /*
                     * Must be a ConstInterval argument for TIME ZONE. Coerce
@@ -5241,7 +5260,7 @@ flatten_set_variable_args(const char *name, List *args)
                    Datum       interval;
                    char       *intervalout;
 
-                   typoid = typenameTypeId(NULL, arg->typename, &typmod);
+                   typoid = typenameTypeId(NULL, typename, &typmod);
                    Assert(typoid == INTERVALOID);
 
                    interval =
@@ -5254,13 +5273,12 @@ flatten_set_variable_args(const char *name, List *args)
                        DatumGetCString(DirectFunctionCall1(interval_out,
                                                            interval));
                    appendStringInfo(&buf, "INTERVAL '%s'", intervalout);
+
+                   /* don't leave this set */
+                   typename = NULL;
                }
                else
                {
-                   /*
-                    * Plain string literal or identifier.  For quote mode,
-                    * quote it if it's not a vanilla identifier.
-                    */
                    if (flags & GUC_LIST_QUOTE)
                        appendStringInfoString(&buf, quote_identifier(val));
                    else
@@ -5269,7 +5287,7 @@ flatten_set_variable_args(const char *name, List *args)
                break;
            default:
                elog(ERROR, "unrecognized node type: %d",
-                    (int) nodeTag(&arg->val));
+                    (int) nodeTag(&con->val));
                break;
        }
    }

diff --git a/src/include/catalog/catversion.h b/src/include/catalog/catversion.h
index 1eeac0ce0c1ee4eb822d98e1ee7d3e7a7bd152cc..67b71f09f0878ce0879fc00a894dcac35c90d688 100644 (file)
--- a/src/include/catalog/catversion.h
+++ b/src/include/catalog/catversion.h
@@ -37,7 +37,7 @@
  * Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $PostgreSQL: pgsql/src/include/catalog/catversion.h,v 1.452 2008/04/29 13:00:22 alvherre Exp $
+ * $PostgreSQL: pgsql/src/include/catalog/catversion.h,v 1.453 2008/04/29 14:59:17 alvherre Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -53,6 +53,6 @@
  */
 
 /*                         yyyymmddN */
-#define CATALOG_VERSION_NO 200804291
+#define CATALOG_VERSION_NO 200804292
 
 #endif

diff --git a/src/include/nodes/parsenodes.h b/src/include/nodes/parsenodes.h
index 2463125626954f63887c0a239af6fa5e571045e3..fe1410531a6142cd14f7a03769a52976f11d0084 100644 (file)
--- a/src/include/nodes/parsenodes.h
+++ b/src/include/nodes/parsenodes.h
@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $PostgreSQL: pgsql/src/include/nodes/parsenodes.h,v 1.362 2008/04/14 17:05:34 tgl Exp $
+ * $PostgreSQL: pgsql/src/include/nodes/parsenodes.h,v 1.363 2008/04/29 14:59:17 alvherre Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -234,17 +234,10 @@ typedef struct A_Const
 {
    NodeTag     type;
    Value       val;            /* the value (with the tag) */
-   TypeName   *typename;       /* typecast, or NULL if none */
 } A_Const;
 
 /*
  * TypeCast - a CAST expression
- *
- * NOTE: for mostly historical reasons, A_Const parsenodes contain
- * room for a TypeName, allowing a constant to be marked as being of a given
- * type without a separate TypeCast node.  Either representation will work,
- * but the combined representation saves a bit of code in many
- * productions in gram.y.
  */
 typedef struct TypeCast
 {