On Fri, Jun 28, 2013 at 01:28:35PM -0400, Peter Eisentraut wrote:
> On 6/28/13 11:30 AM, Robert Haas wrote:
> > On Fri, Jun 28, 2013 at 10:31 AM, Tom Lane <t...@sss.pgh.pa.us> wrote:
> >> David Fetter <da...@fetter.org> writes:
> >>> Please find attached the latest patch.
> >>
> >> I remain of the opinion that this is simply a bad idea.  It is unlike
> >> our habits for constructing other types of nodes, and makes it harder
> >> not easier to find all the places that need to be updated when adding
> >> another field to FuncCall.
> > 
> > I think it's a nice code cleanup.  I don't understand your objection.
> 
> Yeah, I was reading the patch thinking, yes, finally someone cleans that up.

Please find enclosed a patch reflecting the changes that de-reserved
OVER as a keyword.

Cheers,
David.
-- 
David Fetter <da...@fetter.org> http://fetter.org/
Phone: +1 415 235 3778  AIM: dfetter666  Yahoo!: dfetter
Skype: davidfetter      XMPP: david.fet...@gmail.com
iCal: webcal://www.tripit.com/feed/ical/people/david74/tripit.ics

Remember to vote!
Consider donating to Postgres: http://www.postgresql.org/about/donate
diff --git a/src/backend/nodes/makefuncs.c b/src/backend/nodes/makefuncs.c
index c487db9..245aef2 100644
--- a/src/backend/nodes/makefuncs.c
+++ b/src/backend/nodes/makefuncs.c
@@ -508,3 +508,28 @@ makeDefElemExtended(char *nameSpace, char *name, Node *arg,
 
        return res;
 }
+
+/*
+ * makeFuncCall -
+ *
+ * Initialize a FuncCall struct with the information every caller must
+ * supply.  Any non-default parameters have to be handled by the
+ * caller.
+ *
+ */
+
+FuncCall *
+makeFuncCall(List *name, List *args, int location)
+{
+       FuncCall *n = makeNode(FuncCall);
+       n->funcname = name;
+       n->args = args;
+       n->location = location;
+       n->agg_order = NIL;
+       n->agg_star = FALSE;
+       n->agg_distinct = FALSE;
+       n->func_variadic = FALSE;
+       n->over = NULL;
+       return n;
+}
+
diff --git a/src/backend/parser/gram.y b/src/backend/parser/gram.y
index 0fc5b13..f67ef0c 100644
--- a/src/backend/parser/gram.y
+++ b/src/backend/parser/gram.y
@@ -10503,16 +10503,9 @@ a_expr:                c_expr                          
                                        { $$ = $1; }
                                }
                        | a_expr AT TIME ZONE a_expr                    %prec AT
                                {
-                                       FuncCall *n = makeNode(FuncCall);
-                                       n->funcname = 
SystemFuncName("timezone");
-                                       n->args = list_make2($5, $1);
-                                       n->agg_order = NIL;
-                                       n->agg_star = FALSE;
-                                       n->agg_distinct = FALSE;
-                                       n->func_variadic = FALSE;
-                                       n->over = NULL;
-                                       n->location = @2;
-                                       $$ = (Node *) n;
+                                       $$ = (Node *) 
makeFuncCall(SystemFuncName("timezone"),
+                                                                               
           list_make2($5, $1),
+                                                                               
           @2);
                                }
                /*
                 * These operators must be called out explicitly in order to 
make use
@@ -10564,113 +10557,65 @@ a_expr:              c_expr                          
                                        { $$ = $1; }
                                { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, 
"~~", $1, $3, @2); }
                        | a_expr LIKE a_expr ESCAPE a_expr
                                {
-                                       FuncCall *n = makeNode(FuncCall);
-                                       n->funcname = 
SystemFuncName("like_escape");
-                                       n->args = list_make2($3, $5);
-                                       n->agg_order = NIL;
-                                       n->agg_star = FALSE;
-                                       n->agg_distinct = FALSE;
-                                       n->func_variadic = FALSE;
-                                       n->over = NULL;
-                                       n->location = @2;
+                                       FuncCall *n = 
makeFuncCall(SystemFuncName("like_escape"),
+                                                                               
           list_make2($3, $5),
+                                                                               
           @2);
                                        $$ = (Node *) 
makeSimpleA_Expr(AEXPR_OP, "~~", $1, (Node *) n, @2);
                                }
                        | a_expr NOT LIKE a_expr
                                { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, 
"!~~", $1, $4, @2); }
                        | a_expr NOT LIKE a_expr ESCAPE a_expr
                                {
-                                       FuncCall *n = makeNode(FuncCall);
-                                       n->funcname = 
SystemFuncName("like_escape");
-                                       n->args = list_make2($4, $6);
-                                       n->agg_order = NIL;
-                                       n->agg_star = FALSE;
-                                       n->agg_distinct = FALSE;
-                                       n->func_variadic = FALSE;
-                                       n->over = NULL;
-                                       n->location = @2;
+                                       FuncCall *n = 
makeFuncCall(SystemFuncName("like_escape"),
+                                                                               
           list_make2($4, $6),
+                                                                               
           @2);
                                        $$ = (Node *) 
makeSimpleA_Expr(AEXPR_OP, "!~~", $1, (Node *) n, @2);
                                }
                        | a_expr ILIKE a_expr
                                { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, 
"~~*", $1, $3, @2); }
                        | a_expr ILIKE a_expr ESCAPE a_expr
                                {
-                                       FuncCall *n = makeNode(FuncCall);
-                                       n->funcname = 
SystemFuncName("like_escape");
-                                       n->args = list_make2($3, $5);
-                                       n->agg_order = NIL;
-                                       n->agg_star = FALSE;
-                                       n->agg_distinct = FALSE;
-                                       n->func_variadic = FALSE;
-                                       n->over = NULL;
-                                       n->location = @2;
+                                       FuncCall *n = 
makeFuncCall(SystemFuncName("like_escape"),
+                                                                               
           list_make2($3, $5),
+                                                                               
           @2);
                                        $$ = (Node *) 
makeSimpleA_Expr(AEXPR_OP, "~~*", $1, (Node *) n, @2);
                                }
                        | a_expr NOT ILIKE a_expr
                                { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, 
"!~~*", $1, $4, @2); }
                        | a_expr NOT ILIKE a_expr ESCAPE a_expr
                                {
-                                       FuncCall *n = makeNode(FuncCall);
-                                       n->funcname = 
SystemFuncName("like_escape");
-                                       n->args = list_make2($4, $6);
-                                       n->agg_order = NIL;
-                                       n->agg_star = FALSE;
-                                       n->agg_distinct = FALSE;
-                                       n->func_variadic = FALSE;
-                                       n->over = NULL;
-                                       n->location = @2;
+                                       FuncCall *n = 
makeFuncCall(SystemFuncName("like_escape"),
+                                                                               
           list_make2($4, $6),
+                                                                               
           @2);
                                        $$ = (Node *) 
makeSimpleA_Expr(AEXPR_OP, "!~~*", $1, (Node *) n, @2);
                                }
 
                        | a_expr SIMILAR TO a_expr                              
%prec SIMILAR
                                {
-                                       FuncCall *n = makeNode(FuncCall);
-                                       n->funcname = 
SystemFuncName("similar_escape");
-                                       n->args = list_make2($4, 
makeNullAConst(-1));
-                                       n->agg_order = NIL;
-                                       n->agg_star = FALSE;
-                                       n->agg_distinct = FALSE;
-                                       n->func_variadic = FALSE;
-                                       n->over = NULL;
-                                       n->location = @2;
+                                       FuncCall *n = 
makeFuncCall(SystemFuncName("similar_escape"),
+                                                                               
           list_make2($4, makeNullAConst(-1)),
+                                                                               
           @2);
                                        $$ = (Node *) 
makeSimpleA_Expr(AEXPR_OP, "~", $1, (Node *) n, @2);
                                }
                        | a_expr SIMILAR TO a_expr ESCAPE a_expr
                                {
-                                       FuncCall *n = makeNode(FuncCall);
-                                       n->funcname = 
SystemFuncName("similar_escape");
-                                       n->args = list_make2($4, $6);
-                                       n->agg_order = NIL;
-                                       n->agg_star = FALSE;
-                                       n->agg_distinct = FALSE;
-                                       n->func_variadic = FALSE;
-                                       n->over = NULL;
-                                       n->location = @2;
+                                       FuncCall *n = 
makeFuncCall(SystemFuncName("similar_escape"),
+                                                                               
           list_make2($4, $6),
+                                                                               
           @2);
                                        $$ = (Node *) 
makeSimpleA_Expr(AEXPR_OP, "~", $1, (Node *) n, @2);
                                }
                        | a_expr NOT SIMILAR TO a_expr                  %prec 
SIMILAR
                                {
-                                       FuncCall *n = makeNode(FuncCall);
-                                       n->funcname = 
SystemFuncName("similar_escape");
-                                       n->args = list_make2($5, 
makeNullAConst(-1));
-                                       n->agg_order = NIL;
-                                       n->agg_star = FALSE;
-                                       n->agg_distinct = FALSE;
-                                       n->func_variadic = FALSE;
-                                       n->over = NULL;
-                                       n->location = @2;
+                                       FuncCall *n = 
makeFuncCall(SystemFuncName("similar_escape"),
+                                                                               
           list_make2($5, makeNullAConst(-1)),
+                                                                               
           @2);
                                        $$ = (Node *) 
makeSimpleA_Expr(AEXPR_OP, "!~", $1, (Node *) n, @2);
                                }
                        | a_expr NOT SIMILAR TO a_expr ESCAPE a_expr
                                {
-                                       FuncCall *n = makeNode(FuncCall);
-                                       n->funcname = 
SystemFuncName("similar_escape");
-                                       n->args = list_make2($5, $7);
-                                       n->agg_order = NIL;
-                                       n->agg_star = FALSE;
-                                       n->agg_distinct = FALSE;
-                                       n->func_variadic = FALSE;
-                                       n->over = NULL;
-                                       n->location = @2;
+                                       FuncCall *n = 
makeFuncCall(SystemFuncName("similar_escape"),
+                                                                               
           list_make2($5, $7),
+                                                                               
           @2);
                                        $$ = (Node *) 
makeSimpleA_Expr(AEXPR_OP, "!~", $1, (Node *) n, @2);
                                }
 
@@ -11097,97 +11042,45 @@ c_expr:               columnref                       
                                        { $$ = $1; }
 
 func_application: func_name '(' ')'
                                {
-                                       FuncCall *n = makeNode(FuncCall);
-                                       n->funcname = $1;
-                                       n->args = NIL;
-                                       n->agg_order = NIL;
-                                       n->agg_star = FALSE;
-                                       n->agg_distinct = FALSE;
-                                       n->func_variadic = FALSE;
-                                       n->over = NULL;
-                                       n->location = @1;
-                                       $$ = (Node *)n;
+                                       $$ = (Node *) makeFuncCall($1, NIL, @1);
                                }
                        | func_name '(' func_arg_list ')'
                                {
-                                       FuncCall *n = makeNode(FuncCall);
-                                       n->funcname = $1;
-                                       n->args = $3;
-                                       n->agg_order = NIL;
-                                       n->agg_star = FALSE;
-                                       n->agg_distinct = FALSE;
-                                       n->func_variadic = FALSE;
-                                       n->over = NULL;
-                                       n->location = @1;
-                                       $$ = (Node *)n;
+                                       $$ = (Node *) makeFuncCall($1, $3, @1);
                                }
                        | func_name '(' VARIADIC func_arg_expr ')'
                                {
-                                       FuncCall *n = makeNode(FuncCall);
-                                       n->funcname = $1;
-                                       n->args = list_make1($4);
-                                       n->agg_order = NIL;
-                                       n->agg_star = FALSE;
-                                       n->agg_distinct = FALSE;
+                                       FuncCall *n = makeFuncCall($1, 
list_make1($4), @1);
                                        n->func_variadic = TRUE;
-                                       n->over = NULL;
-                                       n->location = @1;
                                        $$ = (Node *)n;
                                }
                        | func_name '(' func_arg_list ',' VARIADIC 
func_arg_expr ')'
                                {
-                                       FuncCall *n = makeNode(FuncCall);
-                                       n->funcname = $1;
-                                       n->args = lappend($3, $6);
-                                       n->agg_order = NIL;
-                                       n->agg_star = FALSE;
-                                       n->agg_distinct = FALSE;
+                                       FuncCall *n = makeFuncCall($1, 
lappend($3, $6), @1);
                                        n->func_variadic = TRUE;
-                                       n->over = NULL;
-                                       n->location = @1;
                                        $$ = (Node *)n;
                                }
                        | func_name '(' func_arg_list sort_clause ')'
                                {
-                                       FuncCall *n = makeNode(FuncCall);
-                                       n->funcname = $1;
-                                       n->args = $3;
+                                       FuncCall *n = makeFuncCall($1, $3, @1);
                                        n->agg_order = $4;
-                                       n->agg_star = FALSE;
-                                       n->agg_distinct = FALSE;
-                                       n->func_variadic = FALSE;
-                                       n->over = NULL;
-                                       n->location = @1;
                                        $$ = (Node *)n;
                                }
                        | func_name '(' ALL func_arg_list opt_sort_clause ')'
                                {
-                                       FuncCall *n = makeNode(FuncCall);
-                                       n->funcname = $1;
-                                       n->args = $4;
+                                       FuncCall *n = makeFuncCall($1, $4, @1);
                                        n->agg_order = $5;
-                                       n->agg_star = FALSE;
-                                       n->agg_distinct = FALSE;
                                        /* Ideally we'd mark the FuncCall node 
to indicate
                                         * "must be an aggregate", but there's 
no provision
                                         * for that in FuncCall at the moment.
                                         */
-                                       n->func_variadic = FALSE;
-                                       n->over = NULL;
-                                       n->location = @1;
                                        $$ = (Node *)n;
                                }
                        | func_name '(' DISTINCT func_arg_list opt_sort_clause 
')'
                                {
-                                       FuncCall *n = makeNode(FuncCall);
-                                       n->funcname = $1;
-                                       n->args = $4;
+                                       FuncCall *n = makeFuncCall($1, $4, @1);
                                        n->agg_order = $5;
-                                       n->agg_star = FALSE;
                                        n->agg_distinct = TRUE;
-                                       n->func_variadic = FALSE;
-                                       n->over = NULL;
-                                       n->location = @1;
                                        $$ = (Node *)n;
                                }
                        | func_name '(' '*' ')'
@@ -11202,15 +11095,8 @@ func_application: func_name '(' ')'
                                         * so that later processing can detect 
what the argument
                                         * really was.
                                         */
-                                       FuncCall *n = makeNode(FuncCall);
-                                       n->funcname = $1;
-                                       n->args = NIL;
-                                       n->agg_order = NIL;
+                                       FuncCall *n = makeFuncCall($1, NIL, @1);
                                        n->agg_star = TRUE;
-                                       n->agg_distinct = FALSE;
-                                       n->func_variadic = FALSE;
-                                       n->over = NULL;
-                                       n->location = @1;
                                        $$ = (Node *)n;
                                }
         ;
@@ -11252,16 +11138,9 @@ func_expr_windowless:
 func_expr_common_subexpr:      
                        COLLATION FOR '(' a_expr ')'
                                {
-                                       FuncCall *n = makeNode(FuncCall);
-                                       n->funcname = 
SystemFuncName("pg_collation_for");
-                                       n->args = list_make1($4);
-                                       n->agg_order = NIL;
-                                       n->agg_star = FALSE;
-                                       n->agg_distinct = FALSE;
-                                       n->func_variadic = FALSE;
-                                       n->over = NULL;
-                                       n->location = @1;
-                                       $$ = (Node *)n;
+                                       $$ = (Node *) 
makeFuncCall(SystemFuncName("pg_collation_for"),
+                                                                               
           list_make1($4),
+                                                                               
           @1);
                                }
                        | CURRENT_DATE
                                {
@@ -11313,16 +11192,7 @@ func_expr_common_subexpr:
                                         * Translate as "now()", since we have 
a function that
                                         * does exactly what is needed.
                                         */
-                                       FuncCall *n = makeNode(FuncCall);
-                                       n->funcname = SystemFuncName("now");
-                                       n->args = NIL;
-                                       n->agg_order = NIL;
-                                       n->agg_star = FALSE;
-                                       n->agg_distinct = FALSE;
-                                       n->func_variadic = FALSE;
-                                       n->over = NULL;
-                                       n->location = @1;
-                                       $$ = (Node *)n;
+                                       $$ = (Node *) 
makeFuncCall(SystemFuncName("now"), NIL, @1);
                                }
                        | CURRENT_TIMESTAMP '(' Iconst ')'
                                {
@@ -11385,96 +11255,33 @@ func_expr_common_subexpr:
                                }
                        | CURRENT_ROLE
                                {
-                                       FuncCall *n = makeNode(FuncCall);
-                                       n->funcname = 
SystemFuncName("current_user");
-                                       n->args = NIL;
-                                       n->agg_order = NIL;
-                                       n->agg_star = FALSE;
-                                       n->agg_distinct = FALSE;
-                                       n->func_variadic = FALSE;
-                                       n->over = NULL;
-                                       n->location = @1;
-                                       $$ = (Node *)n;
+                                       $$ = (Node *) 
makeFuncCall(SystemFuncName("current_user"), NIL, @1);
                                }
                        | CURRENT_USER
                                {
-                                       FuncCall *n = makeNode(FuncCall);
-                                       n->funcname = 
SystemFuncName("current_user");
-                                       n->args = NIL;
-                                       n->agg_order = NIL;
-                                       n->agg_star = FALSE;
-                                       n->agg_distinct = FALSE;
-                                       n->func_variadic = FALSE;
-                                       n->over = NULL;
-                                       n->location = @1;
-                                       $$ = (Node *)n;
+                                       $$ = (Node *) 
makeFuncCall(SystemFuncName("current_user"), NIL, @1);
                                }
                        | SESSION_USER
                                {
-                                       FuncCall *n = makeNode(FuncCall);
-                                       n->funcname = 
SystemFuncName("session_user");
-                                       n->args = NIL;
-                                       n->agg_order = NIL;
-                                       n->agg_star = FALSE;
-                                       n->agg_distinct = FALSE;
-                                       n->func_variadic = FALSE;
-                                       n->over = NULL;
-                                       n->location = @1;
-                                       $$ = (Node *)n;
+                                       $$ = (Node *) 
makeFuncCall(SystemFuncName("session_user"), NIL, @1);
                                }
                        | USER
                                {
-                                       FuncCall *n = makeNode(FuncCall);
-                                       n->funcname = 
SystemFuncName("current_user");
-                                       n->args = NIL;
-                                       n->agg_order = NIL;
-                                       n->agg_star = FALSE;
-                                       n->agg_distinct = FALSE;
-                                       n->func_variadic = FALSE;
-                                       n->over = NULL;
-                                       n->location = @1;
-                                       $$ = (Node *)n;
+                                       $$ = (Node *) 
makeFuncCall(SystemFuncName("current_user"), NIL, @1);
                                }
                        | CURRENT_CATALOG
                                {
-                                       FuncCall *n = makeNode(FuncCall);
-                                       n->funcname = 
SystemFuncName("current_database");
-                                       n->args = NIL;
-                                       n->agg_order = NIL;
-                                       n->agg_star = FALSE;
-                                       n->agg_distinct = FALSE;
-                                       n->func_variadic = FALSE;
-                                       n->over = NULL;
-                                       n->location = @1;
-                                       $$ = (Node *)n;
+                                       $$ = (Node *) 
makeFuncCall(SystemFuncName("current_database"), NIL, @1);
                                }
                        | CURRENT_SCHEMA
                                {
-                                       FuncCall *n = makeNode(FuncCall);
-                                       n->funcname = 
SystemFuncName("current_schema");
-                                       n->args = NIL;
-                                       n->agg_order = NIL;
-                                       n->agg_star = FALSE;
-                                       n->agg_distinct = FALSE;
-                                       n->func_variadic = FALSE;
-                                       n->over = NULL;
-                                       n->location = @1;
-                                       $$ = (Node *)n;
+                                       $$ = (Node *) 
makeFuncCall(SystemFuncName("current_schema"), NIL, @1);
                                }
                        | CAST '(' a_expr AS Typename ')'
                                { $$ = makeTypeCast($3, $5, @1); }
                        | EXTRACT '(' extract_list ')'
                                {
-                                       FuncCall *n = makeNode(FuncCall);
-                                       n->funcname = 
SystemFuncName("date_part");
-                                       n->args = $3;
-                                       n->agg_order = NIL;
-                                       n->agg_star = FALSE;
-                                       n->agg_distinct = FALSE;
-                                       n->func_variadic = FALSE;
-                                       n->over = NULL;
-                                       n->location = @1;
-                                       $$ = (Node *)n;
+                                       $$ = (Node *) 
makeFuncCall(SystemFuncName("date_part"), $3, @1);
                                }
                        | OVERLAY '(' overlay_list ')'
                                {
@@ -11483,46 +11290,19 @@ func_expr_common_subexpr:
                                         * overlay(A PLACING B FROM C) is 
converted to
                                         * overlay(A, B, C)
                                         */
-                                       FuncCall *n = makeNode(FuncCall);
-                                       n->funcname = SystemFuncName("overlay");
-                                       n->args = $3;
-                                       n->agg_order = NIL;
-                                       n->agg_star = FALSE;
-                                       n->agg_distinct = FALSE;
-                                       n->func_variadic = FALSE;
-                                       n->over = NULL;
-                                       n->location = @1;
-                                       $$ = (Node *)n;
+                                       $$ = (Node *) 
makeFuncCall(SystemFuncName("overlay"), $3, @1);
                                }
                        | POSITION '(' position_list ')'
                                {
                                        /* position(A in B) is converted to 
position(B, A) */
-                                       FuncCall *n = makeNode(FuncCall);
-                                       n->funcname = 
SystemFuncName("position");
-                                       n->args = $3;
-                                       n->agg_order = NIL;
-                                       n->agg_star = FALSE;
-                                       n->agg_distinct = FALSE;
-                                       n->func_variadic = FALSE;
-                                       n->over = NULL;
-                                       n->location = @1;
-                                       $$ = (Node *)n;
+                                       $$ = (Node *) 
makeFuncCall(SystemFuncName("position"), $3, @1);
                                }
                        | SUBSTRING '(' substr_list ')'
                                {
                                        /* substring(A from B for C) is 
converted to
                                         * substring(A, B, C) - thomas 
2000-11-28
                                         */
-                                       FuncCall *n = makeNode(FuncCall);
-                                       n->funcname = 
SystemFuncName("substring");
-                                       n->args = $3;
-                                       n->agg_order = NIL;
-                                       n->agg_star = FALSE;
-                                       n->agg_distinct = FALSE;
-                                       n->func_variadic = FALSE;
-                                       n->over = NULL;
-                                       n->location = @1;
-                                       $$ = (Node *)n;
+                                       $$ = (Node *) 
makeFuncCall(SystemFuncName("substring"), $3, @1);
                                }
                        | TREAT '(' a_expr AS Typename ')'
                                {
@@ -11531,75 +11311,32 @@ func_expr_common_subexpr:
                                         * In SQL99, this is intended for use 
with structured UDTs,
                                         * but let's make this a generally 
useful form allowing stronger
                                         * coercions than are handled by 
implicit casting.
-                                        */
-                                       FuncCall *n = makeNode(FuncCall);
-                                       /* Convert SystemTypeName() to 
SystemFuncName() even though
+                                        *
+                                        * Convert SystemTypeName() to 
SystemFuncName() even though
                                         * at the moment they result in the 
same thing.
                                         */
-                                       n->funcname = SystemFuncName(((Value 
*)llast($5->names))->val.str);
-                                       n->args = list_make1($3);
-                                       n->agg_order = NIL;
-                                       n->agg_star = FALSE;
-                                       n->agg_distinct = FALSE;
-                                       n->func_variadic = FALSE;
-                                       n->over = NULL;
-                                       n->location = @1;
-                                       $$ = (Node *)n;
+                                       $$ = (Node *) 
makeFuncCall(SystemFuncName(((Value *)llast($5->names))->val.str),
+                                                                               
            list_make1($3),
+                                                                               
            @1);
                                }
                        | TRIM '(' BOTH trim_list ')'
                                {
                                        /* various trim expressions are defined 
in SQL
                                         * - thomas 1997-07-19
                                         */
-                                       FuncCall *n = makeNode(FuncCall);
-                                       n->funcname = SystemFuncName("btrim");
-                                       n->args = $4;
-                                       n->agg_order = NIL;
-                                       n->agg_star = FALSE;
-                                       n->agg_distinct = FALSE;
-                                       n->func_variadic = FALSE;
-                                       n->over = NULL;
-                                       n->location = @1;
-                                       $$ = (Node *)n;
+                                       $$ = (Node *) 
makeFuncCall(SystemFuncName("btrim"), $4, @1);
                                }
                        | TRIM '(' LEADING trim_list ')'
                                {
-                                       FuncCall *n = makeNode(FuncCall);
-                                       n->funcname = SystemFuncName("ltrim");
-                                       n->args = $4;
-                                       n->agg_order = NIL;
-                                       n->agg_star = FALSE;
-                                       n->agg_distinct = FALSE;
-                                       n->func_variadic = FALSE;
-                                       n->over = NULL;
-                                       n->location = @1;
-                                       $$ = (Node *)n;
+                                       $$ = (Node *) 
makeFuncCall(SystemFuncName("ltrim"), $4, @1);
                                }
                        | TRIM '(' TRAILING trim_list ')'
                                {
-                                       FuncCall *n = makeNode(FuncCall);
-                                       n->funcname = SystemFuncName("rtrim");
-                                       n->args = $4;
-                                       n->agg_order = NIL;
-                                       n->agg_star = FALSE;
-                                       n->agg_distinct = FALSE;
-                                       n->func_variadic = FALSE;
-                                       n->over = NULL;
-                                       n->location = @1;
-                                       $$ = (Node *)n;
+                                       $$ = (Node *) 
makeFuncCall(SystemFuncName("rtrim"), $4, @1);
                                }
                        | TRIM '(' trim_list ')'
                                {
-                                       FuncCall *n = makeNode(FuncCall);
-                                       n->funcname = SystemFuncName("btrim");
-                                       n->args = $3;
-                                       n->agg_order = NIL;
-                                       n->agg_star = FALSE;
-                                       n->agg_distinct = FALSE;
-                                       n->func_variadic = FALSE;
-                                       n->over = NULL;
-                                       n->location = @1;
-                                       $$ = (Node *)n;
+                                       $$ = (Node *) 
makeFuncCall(SystemFuncName("btrim"), $3, @1);
                                }
                        | NULLIF '(' a_expr ',' a_expr ')'
                                {
@@ -11652,16 +11389,7 @@ func_expr_common_subexpr:
                                {
                                        /* xmlexists(A PASSING [BY REF] B [BY 
REF]) is
                                         * converted to xmlexists(A, B)*/
-                                       FuncCall *n = makeNode(FuncCall);
-                                       n->funcname = 
SystemFuncName("xmlexists");
-                                       n->args = list_make2($3, $4);
-                                       n->agg_order = NIL;
-                                       n->agg_star = FALSE;
-                                       n->agg_distinct = FALSE;
-                                       n->func_variadic = FALSE;
-                                       n->over = NULL;
-                                       n->location = @1;
-                                       $$ = (Node *)n;
+                                       $$ = (Node *) 
makeFuncCall(SystemFuncName("xmlexists"), list_make2($3, $4), @1);
                                }
                        | XMLFOREST '(' xml_attribute_list ')'
                                {
@@ -13317,9 +13045,7 @@ makeBoolAConst(bool state, int location)
 static FuncCall *
 makeOverlaps(List *largs, List *rargs, int location, core_yyscan_t yyscanner)
 {
-       FuncCall *n = makeNode(FuncCall);
-
-       n->funcname = SystemFuncName("overlaps");
+       FuncCall *n;
        if (list_length(largs) == 1)
                largs = lappend(largs, largs);
        else if (list_length(largs) != 2)
@@ -13334,13 +13060,7 @@ makeOverlaps(List *largs, List *rargs, int location, 
core_yyscan_t yyscanner)
                                (errcode(ERRCODE_SYNTAX_ERROR),
                                 errmsg("wrong number of parameters on right 
side of OVERLAPS expression"),
                                 parser_errposition(location)));
-       n->args = list_concat(largs, rargs);
-       n->agg_order = NIL;
-       n->agg_star = FALSE;
-       n->agg_distinct = FALSE;
-       n->func_variadic = FALSE;
-       n->over = NULL;
-       n->location = location;
+       n = makeFuncCall(SystemFuncName("overlaps"), list_concat(largs, rargs), 
location);
        return n;
 }
 
diff --git a/src/backend/parser/parse_utilcmd.c 
b/src/backend/parser/parse_utilcmd.c
index b426a45..40e3717 100644
--- a/src/backend/parser/parse_utilcmd.c
+++ b/src/backend/parser/parse_utilcmd.c
@@ -448,16 +448,9 @@ transformColumnDefinition(CreateStmtContext *cxt, 
ColumnDef *column)
                castnode->typeName = SystemTypeName("regclass");
                castnode->arg = (Node *) snamenode;
                castnode->location = -1;
-               funccallnode = makeNode(FuncCall);
-               funccallnode->funcname = SystemFuncName("nextval");
-               funccallnode->args = list_make1(castnode);
-               funccallnode->agg_order = NIL;
-               funccallnode->agg_star = false;
-               funccallnode->agg_distinct = false;
-               funccallnode->func_variadic = false;
-               funccallnode->over = NULL;
-               funccallnode->location = -1;
-
+               funccallnode = makeFuncCall(SystemFuncName("nextval"),
+                                                                       
list_make1(castnode),
+                                                                       -1);
                constraint = makeNode(Constraint);
                constraint->contype = CONSTR_DEFAULT;
                constraint->location = -1;
diff --git a/src/include/nodes/makefuncs.h b/src/include/nodes/makefuncs.h
index ee0c365..3b71b5b 100644
--- a/src/include/nodes/makefuncs.h
+++ b/src/include/nodes/makefuncs.h
@@ -75,6 +75,8 @@ extern TypeName *makeTypeNameFromOid(Oid typeOid, int32 
typmod);
 extern FuncExpr *makeFuncExpr(Oid funcid, Oid rettype, List *args,
                         Oid funccollid, Oid inputcollid, CoercionForm fformat);
 
+extern FuncCall *makeFuncCall(List *name, List *args, int location);
+
 extern DefElem *makeDefElem(char *name, Node *arg);
 extern DefElem *makeDefElemExtended(char *nameSpace, char *name, Node *arg,
                                        DefElemAction defaction);
diff --git a/src/include/nodes/parsenodes.h b/src/include/nodes/parsenodes.h
index 9453e1d..de22dff 100644
--- a/src/include/nodes/parsenodes.h
+++ b/src/include/nodes/parsenodes.h
@@ -285,6 +285,11 @@ typedef struct CollateClause
  * construct *must* be an aggregate call.  Otherwise, it might be either an
  * aggregate or some other kind of function.  However, if OVER is present
  * it had better be an aggregate or window function.
+ *
+ * Normally, you'd initialize this via makeFuncCall() and then only
+ * change the parts of the struct its defaults don't match afterwards
+ * if needed.
+ *
  */
 typedef struct FuncCall
 {
-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers

Reply via email to