Fix pg_get_ruledef() so that negative numeric constants are parenthesized.

tglsfdc · tglsfdc · commit c1943dbaefb9 · 2008-06-06T17:59:29.000Z
This is needed because :: casting binds more tightly than minus, so for
example -1::integer is not the same as (-1)::integer, and there are cases
where the difference is important.  In particular this caused a failure
in SELECT DISTINCT ... ORDER BY ... where expressions that should have
matched were seen as different by the parser; but I suspect that there
could be other cases where failure to parenthesize leads to subtler
semantic differences in reloaded rules.  Per report from Alexandr Popov.
diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c
@@ -9,7 +9,7 @@
  *
  *
  * IDENTIFICATION
- *	  $PostgreSQL: pgsql/src/backend/utils/adt/ruleutils.c,v 1.274 2008/05/12 00:00:51 alvherre Exp $
+ *	  $PostgreSQL: pgsql/src/backend/utils/adt/ruleutils.c,v 1.275 2008/06/06 17:59:29 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -4479,10 +4479,19 @@ get_const_expr(Const *constval, deparse_context *context, int showtype)
 				 *
 				 * In reality we only need to defend against infinity and NaN,
 				 * so we need not get too crazy about pattern matching here.
+				 *
+				 * There is a special-case gotcha: if the constant is signed,
+				 * we need to parenthesize it, else the parser might see a
+				 * leading plus/minus as binding less tightly than adjacent
+				 * operators --- particularly, the cast that we might attach
+				 * below.
 				 */
 				if (strspn(extval, "0123456789+-eE.") == strlen(extval))
 				{
-					appendStringInfoString(buf, extval);
+					if (extval[0] == '+' || extval[0] == '-')
+						appendStringInfo(buf, "(%s)", extval);
+					else
+						appendStringInfoString(buf, extval);
 					if (strcspn(extval, "eE.") != strlen(extval))
 						isfloat = true; /* it looks like a float */
 				}

Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@`
`9`	`9`	`*`
`10`	`10`	`*`
`11`	`11`	`* IDENTIFICATION`
`12`		`- * $PostgreSQL: pgsql/src/backend/utils/adt/ruleutils.c,v 1.274 2008/05/12 00:00:51 alvherre Exp $`
	`12`	`+ * $PostgreSQL: pgsql/src/backend/utils/adt/ruleutils.c,v 1.275 2008/06/06 17:59:29 tgl Exp $`
`13`	`13`	`*`
`14`	`14`	`*-------------------------------------------------------------------------`
`15`	`15`	`*/`
`@@ -4479,10 +4479,19 @@ get_const_expr(Const constval, deparse_context context, int showtype)`
`4479`	`4479`	`*`
`4480`	`4480`	`* In reality we only need to defend against infinity and NaN,`
`4481`	`4481`	`* so we need not get too crazy about pattern matching here.`
	`4482`	`+ *`
	`4483`	`+ * There is a special-case gotcha: if the constant is signed,`
	`4484`	`+ * we need to parenthesize it, else the parser might see a`
	`4485`	`+ * leading plus/minus as binding less tightly than adjacent`
	`4486`	`+ * operators --- particularly, the cast that we might attach`
	`4487`	`+ * below.`
`4482`	`4488`	`*/`
`4483`	`4489`	`if (strspn(extval, "0123456789+-eE.") == strlen(extval))`
`4484`	`4490`	`{`
`4485`		`- appendStringInfoString(buf, extval);`
	`4491`	`+ if (extval[0] == '+' \|\| extval[0] == '-')`
	`4492`	`+ appendStringInfo(buf, "(%s)", extval);`
	`4493`	`+ else`
	`4494`	`+ appendStringInfoString(buf, extval);`
`4486`	`4495`	`if (strcspn(extval, "eE.") != strlen(extval))`
`4487`	`4496`	`isfloat = true; /* it looks like a float */`
`4488`	`4497`	`}`