Fix a thinko in my patch of a couple months ago for bug #3116: it did the

wrong thing when inlining polymorphic SQL functions, because it was using the
function's declared return type where it should have used the actual result
type of the current call.  In 8.1 and 8.2 this causes obvious failures even if
you don't have assertions turned on; in 8.0 and 7.4 it would only be a problem
if the inlined expression were used as an input to a function that did
run-time type determination on its inputs.  Add a regression test, since this
is evidently an under-tested area.

diff --git a/src/backend/optimizer/util/clauses.c b/src/backend/optimizer/util/clauses.c
index 2dd5928a9af031f29d2b32ed9c51783fc9525070..bca819ccaa0c8334a551eb560957cbcb660354c1 100644 (file)
--- a/src/backend/optimizer/util/clauses.c
+++ b/src/backend/optimizer/util/clauses.c
@@ -2354,11 +2354,11 @@ inline_function(Oid funcid, Oid result_type, List *args,
         * compatible with the original expression result type.  To avoid
         * confusing matters, insert a RelabelType in such cases.
         */
-       if (exprType(newexpr) != funcform->prorettype)
+       if (exprType(newexpr) != result_type)
        {
-               Assert(IsBinaryCoercible(exprType(newexpr), funcform->prorettype));
+               Assert(IsBinaryCoercible(exprType(newexpr), result_type));
                newexpr = (Node *) makeRelabelType((Expr *) newexpr,
-                                                                                  funcform->prorettype,
+                                                                                  result_type,
                                                                                   -1,
                                                                                   COERCE_IMPLICIT_CAST);
        }

diff --git a/src/test/regress/expected/polymorphism.out b/src/test/regress/expected/polymorphism.out
index 23ee8b839e7157fed2c83c21e562a64e3fc5ded5..ce1d5db8fe851e2a76fe06a28d7cce198ffbe14e 100644 (file)
--- a/src/test/regress/expected/polymorphism.out
+++ b/src/test/regress/expected/polymorphism.out
@@ -349,184 +349,219 @@ insert into t values(3,array[3],'b');
 select f3, myaggp01a(*) from t group by f3;
  f3 | myaggp01a 
 ----+-----------
+ b  | {}
  c  | {}
  a  | {}
- b  | {}
 (3 rows)
 
 select f3, myaggp03a(*) from t group by f3;
  f3 | myaggp03a 
 ----+-----------
+ b  | {}
  c  | {}
  a  | {}
- b  | {}
 (3 rows)
 
 select f3, myaggp03b(*) from t group by f3;
  f3 | myaggp03b 
 ----+-----------
+ b  | {}
  c  | {}
  a  | {}
- b  | {}
 (3 rows)
 
 select f3, myaggp05a(f1) from t group by f3;
  f3 | myaggp05a 
 ----+-----------
+ b  | {1,2,3}
  c  | {1,2}
  a  | {1,2,3}
- b  | {1,2,3}
 (3 rows)
 
 select f3, myaggp06a(f1) from t group by f3;
  f3 | myaggp06a 
 ----+-----------
+ b  | {}
  c  | {}
  a  | {}
- b  | {}
 (3 rows)
 
 select f3, myaggp08a(f1) from t group by f3;
  f3 | myaggp08a 
 ----+-----------
+ b  | {}
  c  | {}
  a  | {}
- b  | {}
 (3 rows)
 
 select f3, myaggp09a(f1) from t group by f3;
  f3 | myaggp09a 
 ----+-----------
+ b  | {}
  c  | {}
  a  | {}
- b  | {}
 (3 rows)
 
 select f3, myaggp09b(f1) from t group by f3;
  f3 | myaggp09b 
 ----+-----------
+ b  | {}
  c  | {}
  a  | {}
- b  | {}
 (3 rows)
 
 select f3, myaggp10a(f1) from t group by f3;
  f3 | myaggp10a 
 ----+-----------
+ b  | {1,2,3}
  c  | {1,2}
  a  | {1,2,3}
- b  | {1,2,3}
 (3 rows)
 
 select f3, myaggp10b(f1) from t group by f3;
  f3 | myaggp10b 
 ----+-----------
+ b  | {1,2,3}
  c  | {1,2}
  a  | {1,2,3}
- b  | {1,2,3}
 (3 rows)
 
 select f3, myaggp20a(f1) from t group by f3;
  f3 | myaggp20a 
 ----+-----------
+ b  | {1,2,3}
  c  | {1,2}
  a  | {1,2,3}
- b  | {1,2,3}
 (3 rows)
 
 select f3, myaggp20b(f1) from t group by f3;
  f3 | myaggp20b 
 ----+-----------
+ b  | {1,2,3}
  c  | {1,2}
  a  | {1,2,3}
- b  | {1,2,3}
 (3 rows)
 
 select f3, myaggn01a(*) from t group by f3;
  f3 | myaggn01a 
 ----+-----------
+ b  | {}
  c  | {}
  a  | {}
- b  | {}
 (3 rows)
 
 select f3, myaggn01b(*) from t group by f3;
  f3 | myaggn01b 
 ----+-----------
+ b  | {}
  c  | {}
  a  | {}
- b  | {}
 (3 rows)
 
 select f3, myaggn03a(*) from t group by f3;
  f3 | myaggn03a 
 ----+-----------
+ b  | {}
  c  | {}
  a  | {}
- b  | {}
 (3 rows)
 
 select f3, myaggn05a(f1) from t group by f3;
  f3 | myaggn05a 
 ----+-----------
+ b  | {1,2,3}
  c  | {1,2}
  a  | {1,2,3}
- b  | {1,2,3}
 (3 rows)
 
 select f3, myaggn05b(f1) from t group by f3;
  f3 | myaggn05b 
 ----+-----------
+ b  | {1,2,3}
  c  | {1,2}
  a  | {1,2,3}
- b  | {1,2,3}
 (3 rows)
 
 select f3, myaggn06a(f1) from t group by f3;
  f3 | myaggn06a 
 ----+-----------
+ b  | {}
  c  | {}
  a  | {}
- b  | {}
 (3 rows)
 
 select f3, myaggn06b(f1) from t group by f3;
  f3 | myaggn06b 
 ----+-----------
+ b  | {}
  c  | {}
  a  | {}
- b  | {}
 (3 rows)
 
 select f3, myaggn08a(f1) from t group by f3;
  f3 | myaggn08a 
 ----+-----------
+ b  | {}
  c  | {}
  a  | {}
- b  | {}
 (3 rows)
 
 select f3, myaggn08b(f1) from t group by f3;
  f3 | myaggn08b 
 ----+-----------
+ b  | {}
  c  | {}
  a  | {}
- b  | {}
 (3 rows)
 
 select f3, myaggn09a(f1) from t group by f3;
  f3 | myaggn09a 
 ----+-----------
+ b  | {}
  c  | {}
  a  | {}
- b  | {}
 (3 rows)
 
 select f3, myaggn10a(f1) from t group by f3;
  f3 | myaggn10a 
 ----+-----------
+ b  | {1,2,3}
  c  | {1,2}
  a  | {1,2,3}
- b  | {1,2,3}
 (3 rows)
 
+-- test inlining of polymorphic SQL functions
+create function bleat(int) returns int as $$
+begin
+  raise notice 'bleat %', $1;
+  return $1;
+end$$ language plpgsql;
+create function sql_if(bool, anyelement, anyelement) returns anyelement as $$
+select case when $1 then $2 else $3 end $$ language sql;
+-- Note this would fail with integer overflow, never mind wrong bleat() output,
+-- if the CASE expression were not successfully inlined
+select f1, sql_if(f1 > 0, bleat(f1), bleat(f1 + 1)) from int4_tbl;
+NOTICE:  bleat 1
+NOTICE:  bleat 123456
+NOTICE:  bleat -123455
+NOTICE:  bleat 2147483647
+NOTICE:  bleat -2147483646
+     f1      |   sql_if    
+-------------+-------------
+           0 |           1
+      123456 |      123456
+     -123456 |     -123455
+  2147483647 |  2147483647
+ -2147483647 | -2147483646
+(5 rows)
+
+select q2, sql_if(q2 > 0, q2, q2 + 1) from int8_tbl;
+        q2         |      sql_if       
+-------------------+-------------------
+               456 |               456
+  4567890123456789 |  4567890123456789
+               123 |               123
+  4567890123456789 |  4567890123456789
+ -4567890123456789 | -4567890123456788
+(5 rows)
+

diff --git a/src/test/regress/sql/polymorphism.sql b/src/test/regress/sql/polymorphism.sql
index 5175f9f93d1c1f7a99c8b637f5a593dce41209b5..2ba0ca0d44610537b2c0b866b79c95d42eb230d8 100644 (file)
--- a/src/test/regress/sql/polymorphism.sql
+++ b/src/test/regress/sql/polymorphism.sql
@@ -365,3 +365,19 @@ select f3, myaggn08a(f1) from t group by f3;
 select f3, myaggn08b(f1) from t group by f3;
 select f3, myaggn09a(f1) from t group by f3;
 select f3, myaggn10a(f1) from t group by f3;
+
+-- test inlining of polymorphic SQL functions
+create function bleat(int) returns int as $$
+begin
+  raise notice 'bleat %', $1;
+  return $1;
+end$$ language plpgsql;
+
+create function sql_if(bool, anyelement, anyelement) returns anyelement as $$
+select case when $1 then $2 else $3 end $$ language sql;
+
+-- Note this would fail with integer overflow, never mind wrong bleat() output,
+-- if the CASE expression were not successfully inlined
+select f1, sql_if(f1 > 0, bleat(f1), bleat(f1 + 1)) from int4_tbl;
+
+select q2, sql_if(q2 > 0, q2, q2 + 1) from int8_tbl;