Some minor further cleanup around A_Const. Don't attach a typecast in

makeFloatConst, and avoid "manual" construction of A_Const nodes in grammar
productions, in favor of using makeXXXConst subroutines.

diff --git a/src/backend/parser/gram.y b/src/backend/parser/gram.y
index 6ca09b8406bc34d5ae5d035e4a5f8f85b66864dc..8ea88ddedd66dcf6b23c141458366df99dd0ac54 100644 (file)
--- a/src/backend/parser/gram.y
+++ b/src/backend/parser/gram.y
@@ -95,6 +95,8 @@ static Node *makeStringConst(char *str);
 static Node *makeStringConstCast(char *str, TypeName *typename);
 static Node *makeIntConst(int val);
 static Node *makeFloatConst(char *str);
+static Node *makeBitStringConst(char *str);
+static Node *makeNullAConst(void);
 static Node *makeAConst(Value *v);
 static Node *makeBoolAConst(bool state);
 static FuncCall *makeOverlaps(List *largs, List *rargs, int location);
@@ -6395,9 +6397,7 @@ select_limit_value:
                        | ALL
                                {
                                        /* LIMIT ALL is represented as a NULL constant */
-                                       A_Const *n = makeNode(A_Const);
-                                       n->val.type = T_Null;
-                                       $$ = (Node *)n;
+                                       $$ = makeNullAConst();
                                }
                ;
 
@@ -7409,11 +7409,9 @@ a_expr:          c_expr                                                                  { $$ = $1; }
 
                        | a_expr SIMILAR TO a_expr                              %prec SIMILAR
                                {
-                                       A_Const *c = makeNode(A_Const);
                                        FuncCall *n = makeNode(FuncCall);
-                                       c->val.type = T_Null;
                                        n->funcname = SystemFuncName("similar_escape");
-                                       n->args = list_make2($4, (Node *) c);
+                                       n->args = list_make2($4, makeNullAConst());
                                        n->agg_star = FALSE;
                                        n->agg_distinct = FALSE;
                                        n->location = @2;
@@ -7431,11 +7429,9 @@ a_expr:          c_expr                                                                  { $$ = $1; }
                                }
                        | a_expr NOT SIMILAR TO a_expr                  %prec SIMILAR
                                {
-                                       A_Const *c = makeNode(A_Const);
                                        FuncCall *n = makeNode(FuncCall);
-                                       c->val.type = T_Null;
                                        n->funcname = SystemFuncName("similar_escape");
-                                       n->args = list_make2($5, (Node *) c);
+                                       n->args = list_make2($5, makeNullAConst());
                                        n->agg_star = FALSE;
                                        n->agg_distinct = FALSE;
                                        n->location = @5;
@@ -8251,11 +8247,7 @@ func_expr:       func_name '(' ')'
 xml_root_version: VERSION_P a_expr
                                { $$ = $2; }
                        | VERSION_P NO VALUE_P
-                               {
-                                       A_Const *val = makeNode(A_Const);
-                                       val->val.type = T_Null;
-                                       $$ = (Node *) val;
-                               }
+                               { $$ = makeNullAConst(); }
                ;
 
 opt_xml_root_standalone: ',' STANDALONE_P YES_P
@@ -8409,10 +8401,7 @@ array_expr_list: array_expr                                                      { $$ = list_make1($1); }
 extract_list:
                        extract_arg FROM a_expr
                                {
-                                       A_Const *n = makeNode(A_Const);
-                                       n->val.type = T_String;
-                                       n->val.val.str = $1;
-                                       $$ = list_make2((Node *) n, $3);
+                                       $$ = list_make2(makeStringConst($1), $3);
                                }
                        | /*EMPTY*/                                                             { $$ = NIL; }
                ;
@@ -8496,10 +8485,7 @@ substr_list:
                                         * which it is likely to do if the second argument
                                         * is unknown or doesn't have an implicit cast to int4.
                                         */
-                                       A_Const *n = makeNode(A_Const);
-                                       n->val.type = T_Integer;
-                                       n->val.val.ival = 1;
-                                       $$ = list_make3($1, (Node *) n,
+                                       $$ = list_make3($1, makeIntConst(1),
                                                                        makeTypeCast($2, SystemTypeName("int4")));
                                }
                        | expr_list
@@ -8811,31 +8797,19 @@ func_name:      type_function_name
  */
 AexprConst: Iconst
                                {
-                                       A_Const *n = makeNode(A_Const);
-                                       n->val.type = T_Integer;
-                                       n->val.val.ival = $1;
-                                       $$ = (Node *)n;
+                                       $$ = makeIntConst($1);
                                }
                        | FCONST
                                {
-                                       A_Const *n = makeNode(A_Const);
-                                       n->val.type = T_Float;
-                                       n->val.val.str = $1;
-                                       $$ = (Node *)n;
+                                       $$ = makeFloatConst($1);
                                }
                        | Sconst
                                {
-                                       A_Const *n = makeNode(A_Const);
-                                       n->val.type = T_String;
-                                       n->val.val.str = $1;
-                                       $$ = (Node *)n;
+                                       $$ = makeStringConst($1);
                                }
                        | BCONST
                                {
-                                       A_Const *n = makeNode(A_Const);
-                                       n->val.type = T_BitString;
-                                       n->val.val.str = $1;
-                                       $$ = (Node *)n;
+                                       $$ = makeBitStringConst($1);
                                }
                        | XCONST
                                {
@@ -8844,10 +8818,7 @@ AexprConst: Iconst
                                         * a <general literal> shall not be a
                                         * <bit string literal> or a <hex string literal>.
                                         */
-                                       A_Const *n = makeNode(A_Const);
-                                       n->val.type = T_BitString;
-                                       n->val.val.str = $1;
-                                       $$ = (Node *)n;
+                                       $$ = makeBitStringConst($1);
                                }
                        | func_name Sconst
                                {
@@ -8893,9 +8864,7 @@ AexprConst: Iconst
                                }
                        | NULL_P
                                {
-                                       A_Const *n = makeNode(A_Const);
-                                       n->val.type = T_Null;
-                                       $$ = (Node *)n;
+                                       $$ = makeNullAConst();
                                }
                ;
 
@@ -9482,7 +9451,28 @@ makeFloatConst(char *str)
        n->val.type = T_Float;
        n->val.val.str = str;
 
-       return makeTypeCast((Node *)n, SystemTypeName("float8"));
+       return (Node *)n;
+}
+
+static Node *
+makeBitStringConst(char *str)
+{
+       A_Const *n = makeNode(A_Const);
+
+       n->val.type = T_BitString;
+       n->val.val.str = str;
+
+       return (Node *)n;
+}
+
+static Node *
+makeNullAConst(void)
+{
+       A_Const *n = makeNode(A_Const);
+
+       n->val.type = T_Null;
+
+       return (Node *)n;
 }
 
 static Node *

diff --git a/src/backend/parser/parse_type.c b/src/backend/parser/parse_type.c
index a1b59cc36d6de1592b9c77cef99564a9e0caf7e4..076536133da107e7bb52618498ead4f5eb3c0f46 100644 (file)
--- a/src/backend/parser/parse_type.c
+++ b/src/backend/parser/parse_type.c
@@ -294,28 +294,11 @@ typenameTypeMod(ParseState *pstate, const TypeName *typename, Type typ)
                                cstr = (char *) palloc(32);
                                snprintf(cstr, 32, "%ld", (long) ac->val.val.ival);
                        }
-                       else
+                       else if (IsA(&ac->val, Float) ||
+                                        IsA(&ac->val, String))
+                       {
                                /* 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/utils/misc/guc.c b/src/backend/utils/misc/guc.c
index 6a0c59e8a14cce888472e434e7e5ff7cabce489f..241fbbb401f49bb21adf534da992272dd49d39d9 100644 (file)
--- a/src/backend/utils/misc/guc.c
+++ b/src/backend/utils/misc/guc.c
@@ -5209,7 +5209,8 @@ flatten_set_variable_args(const char *name, List *args)
 
        /*
         * 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.
+        * TypeCast; the latter case is supported only for ConstInterval
+        * arguments (for SET TIME ZONE).
         */
        foreach(l, args)
        {
@@ -5231,8 +5232,8 @@ flatten_set_variable_args(const char *name, List *args)
 
                if (!IsA(arg, A_Const))
                        elog(ERROR, "unrecognized node type: %d", (int) nodeTag(arg));
-
                con = (A_Const *) arg;
+
                switch (nodeTag(&con->val))
                {
                        case T_Integer:
@@ -5243,10 +5244,6 @@ flatten_set_variable_args(const char *name, List *args)
                                appendStringInfoString(&buf, strVal(&con->val));
                                break;
                        case T_String:
-                               /*
-                                * Plain string literal or identifier.  For quote mode,
-                                * quote it if it's not a vanilla identifier.
-                                */
                                val = strVal(&con->val);
                                if (typename != NULL)
                                {
@@ -5273,12 +5270,13 @@ 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

diff --git a/src/include/nodes/parsenodes.h b/src/include/nodes/parsenodes.h
index 54dfe7cec1e360f51ec53fe93fdac2a3a1bf53d7..871383aba99b84f3dcced53ed7789a735aa3688e 100644 (file)
--- a/src/include/nodes/parsenodes.h
+++ b/src/include/nodes/parsenodes.h
@@ -228,12 +228,12 @@ typedef struct A_Expr
 } A_Expr;
 
 /*
- * A_Const - a constant expression
+ * A_Const - a literal constant
  */
 typedef struct A_Const
 {
        NodeTag         type;
-       Value           val;                    /* the value (with the tag) */
+       Value           val;                    /* value (includes type info, see value.h) */
 } A_Const;
 
 /*