From dd378dd1e5b3ee0abf3b3a9b9ec889624cdf8b0f Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Tue, 18 Feb 2014 12:44:36 -0500 Subject: [PATCH] Remove broken code that tried to handle OVERLAPS with a single argument. The SQL standard says that OVERLAPS should have a two-element row constructor on each side. The original coding of OVERLAPS support in our grammar attempted to extend that by allowing a single-element row constructor, which it internally duplicated ... or tried to, anyway. But that code has certainly not worked since our List infrastructure was rewritten in 2004, and I'm none too sure it worked before that. As it stands, it ends up building a List that includes itself, leading to assorted undesirable behaviors later in the parser. Even if it worked as intended, it'd be a bit evil because of the possibility of duplicate evaluation of a volatile function that the user had written only once. Given the lack of documentation, test cases, or complaints, let's just get rid of the idea and only support the standard syntax. While we're at it, improve the error cursor positioning for the wrong-number-of-arguments errors, and inline the makeOverlaps() function since it's only called in one place anyway. Per bug #9227 from Joshua Yanovski. Initial patch by Joshua Yanovski, extended a bit by me. --- src/backend/parser/gram.y | 53 ++++++++++++++------------------------- 1 file changed, 19 insertions(+), 34 deletions(-) diff --git a/src/backend/parser/gram.y b/src/backend/parser/gram.y index 74c50bf6b0..c05a19ba5a 100644 --- a/src/backend/parser/gram.y +++ b/src/backend/parser/gram.y @@ -119,7 +119,6 @@ static Node *makeBitStringConst(char *str, int location); static Node *makeNullAConst(int location); static Node *makeAConst(Value *v, int location); static Node *makeBoolAConst(bool state, int location); -static FuncCall *makeOverlaps(List *largs, List *rargs, int location); static void check_qualified_name(List *names); static List *check_func_name(List *names); static List *check_indirection(List *indirection); @@ -8393,7 +8392,25 @@ a_expr: c_expr { $$ = $1; } } | row OVERLAPS row { - $$ = (Node *)makeOverlaps($1, $3, @2); + FuncCall *n = makeNode(FuncCall); + n->funcname = SystemFuncName("overlaps"); + if (list_length($1) != 2) + ereport(ERROR, + (errcode(ERRCODE_SYNTAX_ERROR), + errmsg("wrong number of parameters on left side of OVERLAPS expression"), + scanner_errposition(@1))); + if (list_length($3) != 2) + ereport(ERROR, + (errcode(ERRCODE_SYNTAX_ERROR), + errmsg("wrong number of parameters on right side of OVERLAPS expression"), + scanner_errposition(@3))); + n->args = list_concat($1, $3); + n->agg_star = FALSE; + n->agg_distinct = FALSE; + n->func_variadic = FALSE; + n->over = NULL; + n->location = @2; + $$ = (Node *)n; } | a_expr IS TRUE_P { @@ -10762,38 +10779,6 @@ makeBoolAConst(bool state, int location) return makeTypeCast((Node *)n, SystemTypeName("bool"), -1); } -/* makeOverlaps() - * Create and populate a FuncCall node to support the OVERLAPS operator. - */ -static FuncCall * -makeOverlaps(List *largs, List *rargs, int location) -{ - FuncCall *n = makeNode(FuncCall); - - n->funcname = SystemFuncName("overlaps"); - if (list_length(largs) == 1) - largs = lappend(largs, largs); - else if (list_length(largs) != 2) - ereport(ERROR, - (errcode(ERRCODE_SYNTAX_ERROR), - errmsg("wrong number of parameters on left side of OVERLAPS expression"), - scanner_errposition(location))); - if (list_length(rargs) == 1) - rargs = lappend(rargs, rargs); - else if (list_length(rargs) != 2) - ereport(ERROR, - (errcode(ERRCODE_SYNTAX_ERROR), - errmsg("wrong number of parameters on right side of OVERLAPS expression"), - scanner_errposition(location))); - n->args = list_concat(largs, rargs); - n->agg_star = FALSE; - n->agg_distinct = FALSE; - n->func_variadic = FALSE; - n->over = NULL; - n->location = location; - return n; -} - /* check_qualified_name --- check the result of qualified_name production * * It's easiest to let the grammar production for qualified_name allow -- 2.50.0