open-dsi
/
postgres
mirror of https://github.com/postgres/postgres
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Remove typename from A_Const.

Browse Source 
Brendan Jurd, minor editorialization by me.
REL8_5_ALPHA1_BRANCH
Alvaro Herrera 18 years ago
parent 339570fd8e
commit 6fff5c3b82
11 changed files with 150 additions and 192 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 4
      src/backend/nodes/copyfuncs.c
  2. 3
      src/backend/nodes/equalfuncs.c
  3. 3
      src/backend/nodes/outfuncs.c
  4. 218
      src/backend/parser/gram.y
  5. 8
      src/backend/parser/parse_expr.c
  6. 9
      src/backend/parser/parse_target.c
  7. 31
      src/backend/parser/parse_type.c
  8. 9
      src/backend/parser/parse_utilcmd.c
  9. 44
      src/backend/utils/misc/guc.c
  10. 4
      src/include/catalog/catversion.h
  11. 9
      src/include/nodes/parsenodes.h

4
src/backend/nodes/copyfuncs.c
Unescape View File

@ -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;
}

3
src/backend/nodes/equalfuncs.c
Unescape View File

@ -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;
}

3
src/backend/nodes/outfuncs.c
Unescape View File

@ -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

218
src/backend/parser/gram.y
Unescape View File

@ -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()

8
src/backend/parser/parse_expr.c
Unescape View File

@ -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;

9
src/backend/parser/parse_target.c
Unescape View File

@ -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);

31
src/backend/parser/parse_type.c
Unescape View File

@ -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))

9
src/backend/parser/parse_utilcmd.c
Unescape View File

@ -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;

44
src/backend/utils/misc/guc.c
Unescape View File

@ -10,7 +10,7 @@
* Written by Peter Eisentraut <peter_e@gmx.net>.
*
* 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;
}
}

4
src/include/catalog/catversion.h
Unescape View File

@ -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

9
src/include/nodes/parsenodes.h
Unescape View File

@ -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
{

Write Preview
Loading…
Cancel
Save