Avoid inserting Result nodes that only compute identity projections.

The planner sometimes inserts Result nodes to perform column projections
(ie, arbitrary scalar calculations) above plan nodes that lack projection
logic of their own.  However, we did that even if the lower plan node was
in fact producing the required column set already; which is a pretty common
case given the popularity of "SELECT * FROM ...".  Measurements show that
the useless plan node adds non-negligible overhead, especially when there
are many columns in the result.  So add a check to avoid inserting a Result
node unless there's something useful for it to do.

There are a couple of remaining places where unnecessary Result nodes
could get inserted, but they are (a) much less performance-critical,
and (b) coded in such a way that it's hard to avoid inserting a Result,
because the desired tlist is changed on-the-fly in subsequent logic.
We'll leave those alone for now.

Kyotaro Horiguchi; reviewed and further hacked on by Amit Kapila and
Tom Lane.

3 files changed, 107 insertions, 119 deletions

diff --git a/src/test/regress/expected/alter_table.out b/src/test/regress/expected/alter_table.out
index 8392c27b368..18daf95c668 100644
--- a/src/test/regress/expected/alter_table.out
+++ b/src/test/regress/expected/alter_table.out
@@ -385,61 +385,57 @@ create table nv_child_2011 () inherits (nv_parent);
 alter table nv_child_2010 add check (d between '2010-01-01'::date and '2010-12-31'::date) not valid;
 alter table nv_child_2011 add check (d between '2011-01-01'::date and '2011-12-31'::date) not valid;
 explain (costs off) select * from nv_parent where d between '2011-08-01' and '2011-08-31';
-                                   QUERY PLAN                                    
----------------------------------------------------------------------------------
- Result
-   ->  Append
-         ->  Seq Scan on nv_parent
-               Filter: ((d >= '08-01-2011'::date) AND (d <= '08-31-2011'::date))
-         ->  Seq Scan on nv_child_2010
-               Filter: ((d >= '08-01-2011'::date) AND (d <= '08-31-2011'::date))
-         ->  Seq Scan on nv_child_2011
-               Filter: ((d >= '08-01-2011'::date) AND (d <= '08-31-2011'::date))
-(8 rows)
+                                QUERY PLAN                                 
+---------------------------------------------------------------------------
+ Append
+   ->  Seq Scan on nv_parent
+         Filter: ((d >= '08-01-2011'::date) AND (d <= '08-31-2011'::date))
+   ->  Seq Scan on nv_child_2010
+         Filter: ((d >= '08-01-2011'::date) AND (d <= '08-31-2011'::date))
+   ->  Seq Scan on nv_child_2011
+         Filter: ((d >= '08-01-2011'::date) AND (d <= '08-31-2011'::date))
+(7 rows)
 
 create table nv_child_2009 (check (d between '2009-01-01'::date and '2009-12-31'::date)) inherits (nv_parent);
 explain (costs off) select * from nv_parent where d between '2011-08-01'::date and '2011-08-31'::date;
-                                   QUERY PLAN                                    
----------------------------------------------------------------------------------
- Result
-   ->  Append
-         ->  Seq Scan on nv_parent
-               Filter: ((d >= '08-01-2011'::date) AND (d <= '08-31-2011'::date))
-         ->  Seq Scan on nv_child_2010
-               Filter: ((d >= '08-01-2011'::date) AND (d <= '08-31-2011'::date))
-         ->  Seq Scan on nv_child_2011
-               Filter: ((d >= '08-01-2011'::date) AND (d <= '08-31-2011'::date))
-(8 rows)
+                                QUERY PLAN                                 
+---------------------------------------------------------------------------
+ Append
+   ->  Seq Scan on nv_parent
+         Filter: ((d >= '08-01-2011'::date) AND (d <= '08-31-2011'::date))
+   ->  Seq Scan on nv_child_2010
+         Filter: ((d >= '08-01-2011'::date) AND (d <= '08-31-2011'::date))
+   ->  Seq Scan on nv_child_2011
+         Filter: ((d >= '08-01-2011'::date) AND (d <= '08-31-2011'::date))
+(7 rows)
 
 explain (costs off) select * from nv_parent where d between '2009-08-01'::date and '2009-08-31'::date;
-                                   QUERY PLAN                                    
----------------------------------------------------------------------------------
- Result
-   ->  Append
-         ->  Seq Scan on nv_parent
-               Filter: ((d >= '08-01-2009'::date) AND (d <= '08-31-2009'::date))
-         ->  Seq Scan on nv_child_2010
-               Filter: ((d >= '08-01-2009'::date) AND (d <= '08-31-2009'::date))
-         ->  Seq Scan on nv_child_2011
-               Filter: ((d >= '08-01-2009'::date) AND (d <= '08-31-2009'::date))
-         ->  Seq Scan on nv_child_2009
-               Filter: ((d >= '08-01-2009'::date) AND (d <= '08-31-2009'::date))
-(10 rows)
+                                QUERY PLAN                                 
+---------------------------------------------------------------------------
+ Append
+   ->  Seq Scan on nv_parent
+         Filter: ((d >= '08-01-2009'::date) AND (d <= '08-31-2009'::date))
+   ->  Seq Scan on nv_child_2010
+         Filter: ((d >= '08-01-2009'::date) AND (d <= '08-31-2009'::date))
+   ->  Seq Scan on nv_child_2011
+         Filter: ((d >= '08-01-2009'::date) AND (d <= '08-31-2009'::date))
+   ->  Seq Scan on nv_child_2009
+         Filter: ((d >= '08-01-2009'::date) AND (d <= '08-31-2009'::date))
+(9 rows)
 
 -- after validation, the constraint should be used
 alter table nv_child_2011 VALIDATE CONSTRAINT nv_child_2011_d_check;
 explain (costs off) select * from nv_parent where d between '2009-08-01'::date and '2009-08-31'::date;
-                                   QUERY PLAN                                    
----------------------------------------------------------------------------------
- Result
-   ->  Append
-         ->  Seq Scan on nv_parent
-               Filter: ((d >= '08-01-2009'::date) AND (d <= '08-31-2009'::date))
-         ->  Seq Scan on nv_child_2010
-               Filter: ((d >= '08-01-2009'::date) AND (d <= '08-31-2009'::date))
-         ->  Seq Scan on nv_child_2009
-               Filter: ((d >= '08-01-2009'::date) AND (d <= '08-31-2009'::date))
-(8 rows)
+                                QUERY PLAN                                 
+---------------------------------------------------------------------------
+ Append
+   ->  Seq Scan on nv_parent
+         Filter: ((d >= '08-01-2009'::date) AND (d <= '08-31-2009'::date))
+   ->  Seq Scan on nv_child_2010
+         Filter: ((d >= '08-01-2009'::date) AND (d <= '08-31-2009'::date))
+   ->  Seq Scan on nv_child_2009
+         Filter: ((d >= '08-01-2009'::date) AND (d <= '08-31-2009'::date))
+(7 rows)
 
 -- Foreign key adding test with mixed types
 -- Note: these tables are TEMP to avoid name conflicts when this test
diff --git a/src/test/regress/expected/inherit.out b/src/test/regress/expected/inherit.out
index 906a928b0c0..cc3670bd914 100644
--- a/src/test/regress/expected/inherit.out
+++ b/src/test/regress/expected/inherit.out
@@ -1210,24 +1210,22 @@ select * from matest0 order by 1-id;
 reset enable_indexscan;
 set enable_seqscan = off;  -- plan with fewest seqscans should be merge
 explain (verbose, costs off) select * from matest0 order by 1-id;
-                               QUERY PLAN                               
-------------------------------------------------------------------------
- Result
-   Output: matest0.id, matest0.name, ((1 - matest0.id))
-   ->  Merge Append
-         Sort Key: ((1 - matest0.id))
-         ->  Index Scan using matest0i on public.matest0
-               Output: matest0.id, matest0.name, (1 - matest0.id)
-         ->  Index Scan using matest1i on public.matest1
-               Output: matest1.id, matest1.name, (1 - matest1.id)
-         ->  Sort
-               Output: matest2.id, matest2.name, ((1 - matest2.id))
-               Sort Key: ((1 - matest2.id))
-               ->  Seq Scan on public.matest2
-                     Output: matest2.id, matest2.name, (1 - matest2.id)
-         ->  Index Scan using matest3i on public.matest3
-               Output: matest3.id, matest3.name, (1 - matest3.id)
-(15 rows)
+                            QUERY PLAN                            
+------------------------------------------------------------------
+ Merge Append
+   Sort Key: ((1 - matest0.id))
+   ->  Index Scan using matest0i on public.matest0
+         Output: matest0.id, matest0.name, (1 - matest0.id)
+   ->  Index Scan using matest1i on public.matest1
+         Output: matest1.id, matest1.name, (1 - matest1.id)
+   ->  Sort
+         Output: matest2.id, matest2.name, ((1 - matest2.id))
+         Sort Key: ((1 - matest2.id))
+         ->  Seq Scan on public.matest2
+               Output: matest2.id, matest2.name, (1 - matest2.id)
+   ->  Index Scan using matest3i on public.matest3
+         Output: matest3.id, matest3.name, (1 - matest3.id)
+(13 rows)
 
 select * from matest0 order by 1-id;
  id |  name  
@@ -1258,48 +1256,45 @@ SELECT thousand, tenthous FROM tenk1
 UNION ALL
 SELECT thousand, thousand FROM tenk1
 ORDER BY thousand, tenthous;
-                                  QUERY PLAN                                   
--------------------------------------------------------------------------------
- Result
-   ->  Merge Append
-         Sort Key: tenk1.thousand, tenk1.tenthous
-         ->  Index Only Scan using tenk1_thous_tenthous on tenk1
-         ->  Sort
-               Sort Key: tenk1_1.thousand, tenk1_1.thousand
-               ->  Index Only Scan using tenk1_thous_tenthous on tenk1 tenk1_1
-(7 rows)
+                               QUERY PLAN                                
+-------------------------------------------------------------------------
+ Merge Append
+   Sort Key: tenk1.thousand, tenk1.tenthous
+   ->  Index Only Scan using tenk1_thous_tenthous on tenk1
+   ->  Sort
+         Sort Key: tenk1_1.thousand, tenk1_1.thousand
+         ->  Index Only Scan using tenk1_thous_tenthous on tenk1 tenk1_1
+(6 rows)
 
 explain (costs off)
 SELECT thousand, tenthous, thousand+tenthous AS x FROM tenk1
 UNION ALL
 SELECT 42, 42, hundred FROM tenk1
 ORDER BY thousand, tenthous;
-                               QUERY PLAN                               
-------------------------------------------------------------------------
- Result
-   ->  Merge Append
-         Sort Key: tenk1.thousand, tenk1.tenthous
-         ->  Index Only Scan using tenk1_thous_tenthous on tenk1
-         ->  Sort
-               Sort Key: (42), (42)
-               ->  Index Only Scan using tenk1_hundred on tenk1 tenk1_1
-(7 rows)
+                            QUERY PLAN                            
+------------------------------------------------------------------
+ Merge Append
+   Sort Key: tenk1.thousand, tenk1.tenthous
+   ->  Index Only Scan using tenk1_thous_tenthous on tenk1
+   ->  Sort
+         Sort Key: (42), (42)
+         ->  Index Only Scan using tenk1_hundred on tenk1 tenk1_1
+(6 rows)
 
 explain (costs off)
 SELECT thousand, tenthous FROM tenk1
 UNION ALL
 SELECT thousand, random()::integer FROM tenk1
 ORDER BY thousand, tenthous;
-                                  QUERY PLAN                                   
--------------------------------------------------------------------------------
- Result
-   ->  Merge Append
-         Sort Key: tenk1.thousand, tenk1.tenthous
-         ->  Index Only Scan using tenk1_thous_tenthous on tenk1
-         ->  Sort
-               Sort Key: tenk1_1.thousand, ((random())::integer)
-               ->  Index Only Scan using tenk1_thous_tenthous on tenk1 tenk1_1
-(7 rows)
+                               QUERY PLAN                                
+-------------------------------------------------------------------------
+ Merge Append
+   Sort Key: tenk1.thousand, tenk1.tenthous
+   ->  Index Only Scan using tenk1_thous_tenthous on tenk1
+   ->  Sort
+         Sort Key: tenk1_1.thousand, ((random())::integer)
+         ->  Index Only Scan using tenk1_thous_tenthous on tenk1 tenk1_1
+(6 rows)
 
 -- Check min/max aggregate optimization
 explain (costs off)
@@ -1345,16 +1340,15 @@ SELECT x, y FROM
    UNION ALL
    SELECT unique2 AS x, unique2 AS y FROM tenk1 b) s
 ORDER BY x, y;
-                            QUERY PLAN                             
--------------------------------------------------------------------
- Result
-   ->  Merge Append
-         Sort Key: a.thousand, a.tenthous
-         ->  Index Only Scan using tenk1_thous_tenthous on tenk1 a
-         ->  Sort
-               Sort Key: b.unique2, b.unique2
-               ->  Index Only Scan using tenk1_unique2 on tenk1 b
-(7 rows)
+                         QUERY PLAN                          
+-------------------------------------------------------------
+ Merge Append
+   Sort Key: a.thousand, a.tenthous
+   ->  Index Only Scan using tenk1_thous_tenthous on tenk1 a
+   ->  Sort
+         Sort Key: b.unique2, b.unique2
+         ->  Index Only Scan using tenk1_unique2 on tenk1 b
+(6 rows)
 
 reset enable_seqscan;
 reset enable_indexscan;
diff --git a/src/test/regress/expected/union.out b/src/test/regress/expected/union.out
index f78218822f5..031be5389eb 100644
--- a/src/test/regress/expected/union.out
+++ b/src/test/regress/expected/union.out
@@ -474,15 +474,14 @@ explain (costs off)
   UNION ALL
   SELECT * FROM t2) t
  WHERE ab = 'ab';
-                    QUERY PLAN                     
----------------------------------------------------
- Result
-   ->  Append
-         ->  Index Scan using t1_ab_idx on t1
-               Index Cond: ((a || b) = 'ab'::text)
-         ->  Index Only Scan using t2_pkey on t2
-               Index Cond: (ab = 'ab'::text)
-(6 rows)
+                 QUERY PLAN                  
+---------------------------------------------
+ Append
+   ->  Index Scan using t1_ab_idx on t1
+         Index Cond: ((a || b) = 'ab'::text)
+   ->  Index Only Scan using t2_pkey on t2
+         Index Cond: (ab = 'ab'::text)
+(5 rows)
 
 explain (costs off)
  SELECT * FROM
@@ -510,10 +509,9 @@ explain (costs off)
    UNION ALL
    SELECT 2 AS t, * FROM tenk1 b) c
  WHERE t = 2;
-           QUERY PLAN            
----------------------------------
- Result
-   ->  Append
-         ->  Seq Scan on tenk1 b
-(3 rows)
+        QUERY PLAN         
+---------------------------
+ Append
+   ->  Seq Scan on tenk1 b
+(2 rows)