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 7bf301d02e1c28ae6c973c8e6a07c5bd0a5099e7..aa38052d4b4fa5204140f8f7eb65c59fff9ef6ef 100644 (file)
--- a/src/backend/nodes/copyfuncs.c
+++ b/src/backend/nodes/copyfuncs.c
@@ -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 6bd5c2c209176358a2707ce47ba69f45f94395dd..dc855949de193f759a4c811017c57335208bb9c3 100644 (file)
--- a/src/backend/nodes/equalfuncs.c
+++ b/src/backend/nodes/equalfuncs.c
@@ -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 f1cd4215bf6d329cfbee80672e3fc17049aa6a65..d06f03585f85844a9a675063e42950c7b11825f4 100644 (file)
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -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 fe06f3a8e5d90ed52e9aa6d6c2dfb4e911807874..6ca09b8406bc34d5ae5d035e4a5f8f85b66864dc 100644 (file)
--- a/src/backend/parser/gram.y
+++ b/src/backend/parser/gram.y
@@ -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 ac2afa0d9278feafd3878ca8707701a7440eb0c1..0d8d5e64d0327e0129b1f56215196d4a0a799a8d 100644 (file)
--- a/src/backend/parser/parse_expr.c
+++ b/src/backend/parser/parse_expr.c
@@ -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 247eb420ed24312fd084c6158783f6473978abd7..70e30df4dc711118e36c08c287d28692ef1eecc4 100644 (file)
--- a/src/backend/parser/parse_target.c
+++ b/src/backend/parser/parse_target.c
@@ -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 8ddcdbd8c4d7c3a31809b655017c18d473ffa5c2..a1b59cc36d6de1592b9c77cef99564a9e0caf7e4 100644 (file)
--- a/src/backend/parser/parse_type.c
+++ b/src/backend/parser/parse_type.c
@@ -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 66cc0b5e90fe411f56015062843e0b27788311e3..db1bcd89497c1c44e01231ecb9463b1eddea5342 100644 (file)
--- a/src/backend/parser/parse_utilcmd.c
+++ b/src/backend/parser/parse_utilcmd.c
@@ -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 25277439039bd1fbaeeb972a0d02ec1ee1c26b0b..6a0c59e8a14cce888472e434e7e5ff7cabce489f 100644 (file)
--- a/src/backend/utils/misc/guc.c
+++ b/src/backend/utils/misc/guc.c
@@ -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 145150326e33019943d85a66dc1f62efa9b0b910..e787c52632edb60b31f6b5aa335c440f2c3fa016 100644 (file)
--- a/src/include/catalog/catversion.h
+++ b/src/include/catalog/catversion.h
@@ -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 04f805d6edfec1cf1f6f41bced2a2e68ffb52a41..54dfe7cec1e360f51ec53fe93fdac2a3a1bf53d7 100644 (file)
--- a/src/include/nodes/parsenodes.h
+++ b/src/include/nodes/parsenodes.h
@@ -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
 {