Modify expected files.

At 10 beta2, planner seems to get some changes to affect plans used in
regression test. Tentatively modify it just to pass the regression.
Probably it is no problem but should be checked later.

diff --git a/expected/pg_hint_plan.out b/expected/pg_hint_plan.out
index e95f0af..8fb1c7a 100644 (file)
--- a/expected/pg_hint_plan.out
+++ b/expected/pg_hint_plan.out
@@ -1283,16 +1283,15 @@ error hint:
 (3 rows)
 
 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
-                  QUERY PLAN                   
------------------------------------------------
+               QUERY PLAN                
+-----------------------------------------
  Nested Loop
    Join Filter: (t1.id = t2.id)
    ->  Tid Scan on t1
          TID Cond: (ctid = '(1,1)'::tid)
-   ->  Materialize
-         ->  Tid Scan on t2
-               TID Cond: (ctid = '(1,1)'::tid)
-(7 rows)
+   ->  Tid Scan on t2
+         TID Cond: (ctid = '(1,1)'::tid)
+(6 rows)
 
 /*+SeqScan(t1)*/
 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
@@ -1307,10 +1306,10 @@ error hint:
 -----------------------------------------
  Nested Loop
    Join Filter: (t1.id = t2.id)
-   ->  Tid Scan on t2
-         TID Cond: (ctid = '(1,1)'::tid)
    ->  Seq Scan on t1
          Filter: (ctid = '(1,1)'::tid)
+   ->  Tid Scan on t2
+         TID Cond: (ctid = '(1,1)'::tid)
 (6 rows)
 
 /*+SeqScan(t2)*/
@@ -1428,10 +1427,10 @@ error hint:
 -----------------------------------------
  Nested Loop
    Join Filter: (t1.id = t2.id)
-   ->  Tid Scan on t2
-         TID Cond: (ctid = '(1,1)'::tid)
    ->  Seq Scan on t1
          Filter: (ctid = '(1,1)'::tid)
+   ->  Tid Scan on t2
+         TID Cond: (ctid = '(1,1)'::tid)
 (6 rows)
 
 /*+SeqScan(t1) NoIndexScan(t2)*/
@@ -1448,10 +1447,10 @@ error hint:
 -----------------------------------------
  Nested Loop
    Join Filter: (t1.id = t2.id)
-   ->  Tid Scan on t2
-         TID Cond: (ctid = '(1,1)'::tid)
    ->  Seq Scan on t1
          Filter: (ctid = '(1,1)'::tid)
+   ->  Tid Scan on t2
+         TID Cond: (ctid = '(1,1)'::tid)
 (6 rows)
 
 /*+SeqScan(t1) NoBitmapScan(t2)*/
@@ -1468,10 +1467,10 @@ error hint:
 -----------------------------------------
  Nested Loop
    Join Filter: (t1.id = t2.id)
-   ->  Tid Scan on t2
-         TID Cond: (ctid = '(1,1)'::tid)
    ->  Seq Scan on t1
          Filter: (ctid = '(1,1)'::tid)
+   ->  Tid Scan on t2
+         TID Cond: (ctid = '(1,1)'::tid)
 (6 rows)
 
 /*+SeqScan(t1) NoTidScan(t2)*/
@@ -1488,10 +1487,10 @@ error hint:
 ---------------------------------------
  Nested Loop
    Join Filter: (t1.id = t2.id)
-   ->  Seq Scan on t2
-         Filter: (ctid = '(1,1)'::tid)
    ->  Seq Scan on t1
          Filter: (ctid = '(1,1)'::tid)
+   ->  Seq Scan on t2
+         Filter: (ctid = '(1,1)'::tid)
 (6 rows)
 
 /*+IndexScan(t1)*/
@@ -1946,10 +1945,10 @@ error hint:
 -----------------------------------------
  Nested Loop
    Join Filter: (t1.id = t2.id)
-   ->  Tid Scan on t2
-         TID Cond: (ctid = '(1,1)'::tid)
    ->  Tid Scan on t1
          TID Cond: (ctid = '(1,1)'::tid)
+   ->  Tid Scan on t2
+         TID Cond: (ctid = '(1,1)'::tid)
 (6 rows)
 
 /*+TidScan(t2)*/
@@ -2067,10 +2066,10 @@ error hint:
 -----------------------------------------
  Nested Loop
    Join Filter: (t1.id = t2.id)
-   ->  Tid Scan on t2
-         TID Cond: (ctid = '(1,1)'::tid)
    ->  Tid Scan on t1
          TID Cond: (ctid = '(1,1)'::tid)
+   ->  Tid Scan on t2
+         TID Cond: (ctid = '(1,1)'::tid)
 (6 rows)
 
 /*+TidScan(t1) NoIndexScan(t2)*/
@@ -2087,10 +2086,10 @@ error hint:
 -----------------------------------------
  Nested Loop
    Join Filter: (t1.id = t2.id)
-   ->  Tid Scan on t2
-         TID Cond: (ctid = '(1,1)'::tid)
    ->  Tid Scan on t1
          TID Cond: (ctid = '(1,1)'::tid)
+   ->  Tid Scan on t2
+         TID Cond: (ctid = '(1,1)'::tid)
 (6 rows)
 
 /*+TidScan(t1) NoBitmapScan(t2)*/
@@ -2107,10 +2106,10 @@ error hint:
 -----------------------------------------
  Nested Loop
    Join Filter: (t1.id = t2.id)
-   ->  Tid Scan on t2
-         TID Cond: (ctid = '(1,1)'::tid)
    ->  Tid Scan on t1
          TID Cond: (ctid = '(1,1)'::tid)
+   ->  Tid Scan on t2
+         TID Cond: (ctid = '(1,1)'::tid)
 (6 rows)
 
 /*+TidScan(t1) NoTidScan(t2)*/
@@ -2142,16 +2141,15 @@ not used hint:
 duplication hint:
 error hint:
 
-                  QUERY PLAN                   
------------------------------------------------
+               QUERY PLAN                
+-----------------------------------------
  Nested Loop
    Join Filter: (t1.id = t2.id)
    ->  Tid Scan on t1
          TID Cond: (ctid = '(1,1)'::tid)
-   ->  Materialize
-         ->  Tid Scan on t2
-               TID Cond: (ctid = '(1,1)'::tid)
-(7 rows)
+   ->  Tid Scan on t2
+         TID Cond: (ctid = '(1,1)'::tid)
+(6 rows)
 
 /*+NoSeqScan(t2)*/
 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
@@ -2162,16 +2160,15 @@ not used hint:
 duplication hint:
 error hint:
 
-                  QUERY PLAN                   
------------------------------------------------
+               QUERY PLAN                
+-----------------------------------------
  Nested Loop
    Join Filter: (t1.id = t2.id)
    ->  Tid Scan on t1
          TID Cond: (ctid = '(1,1)'::tid)
-   ->  Materialize
-         ->  Tid Scan on t2
-               TID Cond: (ctid = '(1,1)'::tid)
-(7 rows)
+   ->  Tid Scan on t2
+         TID Cond: (ctid = '(1,1)'::tid)
+(6 rows)
 
 /*+NoSeqScan(t1) SeqScan(t2)*/
 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
@@ -2265,16 +2262,15 @@ not used hint:
 duplication hint:
 error hint:
 
-                  QUERY PLAN                   
------------------------------------------------
+               QUERY PLAN                
+-----------------------------------------
  Nested Loop
    Join Filter: (t1.id = t2.id)
    ->  Tid Scan on t1
          TID Cond: (ctid = '(1,1)'::tid)
-   ->  Materialize
-         ->  Tid Scan on t2
-               TID Cond: (ctid = '(1,1)'::tid)
-(7 rows)
+   ->  Tid Scan on t2
+         TID Cond: (ctid = '(1,1)'::tid)
+(6 rows)
 
 /*+NoSeqScan(t1) NoIndexScan(t2)*/
 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
@@ -2286,16 +2282,15 @@ not used hint:
 duplication hint:
 error hint:
 
-                  QUERY PLAN                   
------------------------------------------------
+               QUERY PLAN                
+-----------------------------------------
  Nested Loop
    Join Filter: (t1.id = t2.id)
    ->  Tid Scan on t1
          TID Cond: (ctid = '(1,1)'::tid)
-   ->  Materialize
-         ->  Tid Scan on t2
-               TID Cond: (ctid = '(1,1)'::tid)
-(7 rows)
+   ->  Tid Scan on t2
+         TID Cond: (ctid = '(1,1)'::tid)
+(6 rows)
 
 /*+NoSeqScan(t1) NoBitmapScan(t2)*/
 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
@@ -2307,16 +2302,15 @@ not used hint:
 duplication hint:
 error hint:
 
-                  QUERY PLAN                   
------------------------------------------------
+               QUERY PLAN                
+-----------------------------------------
  Nested Loop
    Join Filter: (t1.id = t2.id)
    ->  Tid Scan on t1
          TID Cond: (ctid = '(1,1)'::tid)
-   ->  Materialize
-         ->  Tid Scan on t2
-               TID Cond: (ctid = '(1,1)'::tid)
-(7 rows)
+   ->  Tid Scan on t2
+         TID Cond: (ctid = '(1,1)'::tid)
+(6 rows)
 
 /*+NoSeqScan(t1) NoTidScan(t2)*/
 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
@@ -2347,16 +2341,15 @@ not used hint:
 duplication hint:
 error hint:
 
-                  QUERY PLAN                   
------------------------------------------------
+               QUERY PLAN                
+-----------------------------------------
  Nested Loop
    Join Filter: (t1.id = t2.id)
    ->  Tid Scan on t1
          TID Cond: (ctid = '(1,1)'::tid)
-   ->  Materialize
-         ->  Tid Scan on t2
-               TID Cond: (ctid = '(1,1)'::tid)
-(7 rows)
+   ->  Tid Scan on t2
+         TID Cond: (ctid = '(1,1)'::tid)
+(6 rows)
 
 /*+NoIndexScan(t2)*/
 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
@@ -2367,16 +2360,15 @@ not used hint:
 duplication hint:
 error hint:
 
-                  QUERY PLAN                   
------------------------------------------------
+               QUERY PLAN                
+-----------------------------------------
  Nested Loop
    Join Filter: (t1.id = t2.id)
    ->  Tid Scan on t1
          TID Cond: (ctid = '(1,1)'::tid)
-   ->  Materialize
-         ->  Tid Scan on t2
-               TID Cond: (ctid = '(1,1)'::tid)
-(7 rows)
+   ->  Tid Scan on t2
+         TID Cond: (ctid = '(1,1)'::tid)
+(6 rows)
 
 /*+NoIndexScan(t1) SeqScan(t2)*/
 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
@@ -2470,16 +2462,15 @@ not used hint:
 duplication hint:
 error hint:
 
-                  QUERY PLAN                   
------------------------------------------------
+               QUERY PLAN                
+-----------------------------------------
  Nested Loop
    Join Filter: (t1.id = t2.id)
    ->  Tid Scan on t1
          TID Cond: (ctid = '(1,1)'::tid)
-   ->  Materialize
-         ->  Tid Scan on t2
-               TID Cond: (ctid = '(1,1)'::tid)
-(7 rows)
+   ->  Tid Scan on t2
+         TID Cond: (ctid = '(1,1)'::tid)
+(6 rows)
 
 /*+NoIndexScan(t1) NoIndexScan(t2)*/
 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
@@ -2491,16 +2482,15 @@ not used hint:
 duplication hint:
 error hint:
 
-                  QUERY PLAN                   
------------------------------------------------
+               QUERY PLAN                
+-----------------------------------------
  Nested Loop
    Join Filter: (t1.id = t2.id)
    ->  Tid Scan on t1
          TID Cond: (ctid = '(1,1)'::tid)
-   ->  Materialize
-         ->  Tid Scan on t2
-               TID Cond: (ctid = '(1,1)'::tid)
-(7 rows)
+   ->  Tid Scan on t2
+         TID Cond: (ctid = '(1,1)'::tid)
+(6 rows)
 
 /*+NoIndexScan(t1) NoBitmapScan(t2)*/
 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
@@ -2512,16 +2502,15 @@ not used hint:
 duplication hint:
 error hint:
 
-                  QUERY PLAN                   
------------------------------------------------
+               QUERY PLAN                
+-----------------------------------------
  Nested Loop
    Join Filter: (t1.id = t2.id)
    ->  Tid Scan on t1
          TID Cond: (ctid = '(1,1)'::tid)
-   ->  Materialize
-         ->  Tid Scan on t2
-               TID Cond: (ctid = '(1,1)'::tid)
-(7 rows)
+   ->  Tid Scan on t2
+         TID Cond: (ctid = '(1,1)'::tid)
+(6 rows)
 
 /*+NoIndexScan(t1) NoTidScan(t2)*/
 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
@@ -2552,16 +2541,15 @@ not used hint:
 duplication hint:
 error hint:
 
-                  QUERY PLAN                   
------------------------------------------------
+               QUERY PLAN                
+-----------------------------------------
  Nested Loop
    Join Filter: (t1.id = t2.id)
    ->  Tid Scan on t1
          TID Cond: (ctid = '(1,1)'::tid)
-   ->  Materialize
-         ->  Tid Scan on t2
-               TID Cond: (ctid = '(1,1)'::tid)
-(7 rows)
+   ->  Tid Scan on t2
+         TID Cond: (ctid = '(1,1)'::tid)
+(6 rows)
 
 /*+NoBitmapScan(t2)*/
 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
@@ -2572,16 +2560,15 @@ not used hint:
 duplication hint:
 error hint:
 
-                  QUERY PLAN                   
------------------------------------------------
+               QUERY PLAN                
+-----------------------------------------
  Nested Loop
    Join Filter: (t1.id = t2.id)
    ->  Tid Scan on t1
          TID Cond: (ctid = '(1,1)'::tid)
-   ->  Materialize
-         ->  Tid Scan on t2
-               TID Cond: (ctid = '(1,1)'::tid)
-(7 rows)
+   ->  Tid Scan on t2
+         TID Cond: (ctid = '(1,1)'::tid)
+(6 rows)
 
 /*+NoBitmapScan(t1) SeqScan(t2)*/
 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
@@ -2675,16 +2662,15 @@ not used hint:
 duplication hint:
 error hint:
 
-                  QUERY PLAN                   
------------------------------------------------
+               QUERY PLAN                
+-----------------------------------------
  Nested Loop
    Join Filter: (t1.id = t2.id)
    ->  Tid Scan on t1
          TID Cond: (ctid = '(1,1)'::tid)
-   ->  Materialize
-         ->  Tid Scan on t2
-               TID Cond: (ctid = '(1,1)'::tid)
-(7 rows)
+   ->  Tid Scan on t2
+         TID Cond: (ctid = '(1,1)'::tid)
+(6 rows)
 
 /*+NoBitmapScan(t1) NoIndexScan(t2)*/
 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
@@ -2696,16 +2682,15 @@ not used hint:
 duplication hint:
 error hint:
 
-                  QUERY PLAN                   
------------------------------------------------
+               QUERY PLAN                
+-----------------------------------------
  Nested Loop
    Join Filter: (t1.id = t2.id)
    ->  Tid Scan on t1
          TID Cond: (ctid = '(1,1)'::tid)
-   ->  Materialize
-         ->  Tid Scan on t2
-               TID Cond: (ctid = '(1,1)'::tid)
-(7 rows)
+   ->  Tid Scan on t2
+         TID Cond: (ctid = '(1,1)'::tid)
+(6 rows)
 
 /*+NoBitmapScan(t1) NoBitmapScan(t2)*/
 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
@@ -2717,16 +2702,15 @@ not used hint:
 duplication hint:
 error hint:
 
-                  QUERY PLAN                   
------------------------------------------------
+               QUERY PLAN                
+-----------------------------------------
  Nested Loop
    Join Filter: (t1.id = t2.id)
    ->  Tid Scan on t1
          TID Cond: (ctid = '(1,1)'::tid)
-   ->  Materialize
-         ->  Tid Scan on t2
-               TID Cond: (ctid = '(1,1)'::tid)
-(7 rows)
+   ->  Tid Scan on t2
+         TID Cond: (ctid = '(1,1)'::tid)
+(6 rows)
 
 /*+NoBitmapScan(t1) NoTidScan(t2)*/
 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
@@ -2950,18 +2934,17 @@ error hint:
 
 -- additional test
 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)' AND t1.id < 10 AND t2.id < 10;
-                  QUERY PLAN                   
------------------------------------------------
+               QUERY PLAN                
+-----------------------------------------
  Nested Loop
    Join Filter: (t1.id = t2.id)
    ->  Tid Scan on t1
          TID Cond: (ctid = '(1,1)'::tid)
          Filter: (id < 10)
-   ->  Materialize
-         ->  Tid Scan on t2
-               TID Cond: (ctid = '(1,1)'::tid)
-               Filter: (id < 10)
-(9 rows)
+   ->  Tid Scan on t2
+         TID Cond: (ctid = '(1,1)'::tid)
+         Filter: (id < 10)
+(8 rows)
 
 /*+BitmapScan(t1) BitmapScan(t2)*/
 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)' AND t1.id < 10 AND t2.id < 10;
@@ -3616,32 +3599,32 @@ not used hint:
 duplication hint:
 error hint:
 
-                                    QUERY PLAN                                     
------------------------------------------------------------------------------------
+                                 QUERY PLAN                                  
+-----------------------------------------------------------------------------
  Nested Loop
    Join Filter: (p1.id = t1.id)
-   ->  Index Scan using t1_pkey on t1
-         Index Cond: (id < 10)
+   ->  Append
+         ->  Seq Scan on p1
+               Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+         ->  Seq Scan on p1_c1
+               Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+         ->  Seq Scan on p1_c2
+               Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+         ->  Seq Scan on p1_c3
+               Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+         ->  Seq Scan on p1_c4
+               Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+         ->  Seq Scan on p1_c1_c1
+               Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+         ->  Seq Scan on p1_c1_c2
+               Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+         ->  Seq Scan on p1_c3_c1
+               Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+         ->  Seq Scan on p1_c3_c2
+               Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
    ->  Materialize
-         ->  Append
-               ->  Seq Scan on p1
-                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-               ->  Seq Scan on p1_c1
-                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-               ->  Seq Scan on p1_c2
-                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-               ->  Seq Scan on p1_c3
-                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-               ->  Seq Scan on p1_c4
-                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-               ->  Seq Scan on p1_c1_c1
-                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-               ->  Seq Scan on p1_c1_c2
-                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-               ->  Seq Scan on p1_c3_c1
-                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-               ->  Seq Scan on p1_c3_c2
-                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+         ->  Index Scan using t1_pkey on t1
+               Index Cond: (id < 10)
 (24 rows)
 
 /*+MergeJoin(p1 t1)*/
@@ -4028,10 +4011,10 @@ error hint:
 -----------------------------------------------------------------------
  Nested Loop
    Join Filter: (p1.id = t1.id)
-   ->  Index Scan using t1_pkey on t1
-         Index Cond: (id < 10)
    ->  Seq Scan on p1
          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+   ->  Index Scan using t1_pkey on t1
+         Index Cond: (id < 10)
 (6 rows)
 
 /*+MergeJoin(p1 t1)*/
@@ -4154,10 +4137,10 @@ error hint:
 -----------------------------------------------------------------------
  Nested Loop
    Join Filter: (p1.id = t1.id)
-   ->  Index Scan using t1_pkey on t1
-         Index Cond: (id < 10)
    ->  Seq Scan on p1
          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+   ->  Index Scan using t1_pkey on t1
+         Index Cond: (id < 10)
 (6 rows)
 
 /*+MergeJoin(p1 t1)*/
@@ -4207,10 +4190,10 @@ EXPLAIN (COSTS false) SELECT * FROM ONLY p1, t1 WHERE p1.id >= 50 AND p1.id <= 5
 -----------------------------------------------------------------------
  Nested Loop
    Join Filter: (p1.id = t1.id)
-   ->  Index Scan using t1_pkey on t1
-         Index Cond: (id < 10)
    ->  Seq Scan on p1
          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+   ->  Index Scan using t1_pkey on t1
+         Index Cond: (id < 10)
 (6 rows)
 
 SET constraint_exclusion TO on;
@@ -4219,10 +4202,10 @@ EXPLAIN (COSTS false) SELECT * FROM ONLY p1, t1 WHERE p1.id >= 50 AND p1.id <= 5
 -----------------------------------------------------------------------
  Nested Loop
    Join Filter: (p1.id = t1.id)
-   ->  Index Scan using t1_pkey on t1
-         Index Cond: (id < 10)
    ->  Seq Scan on p1
          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+   ->  Index Scan using t1_pkey on t1
+         Index Cond: (id < 10)
 (6 rows)
 
 SET constraint_exclusion TO off;
@@ -4239,10 +4222,10 @@ error hint:
 -----------------------------------------------------------------------
  Nested Loop
    Join Filter: (p1.id = t1.id)
-   ->  Index Scan using t1_pkey on t1
-         Index Cond: (id < 10)
    ->  Seq Scan on p1
          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+   ->  Index Scan using t1_pkey on t1
+         Index Cond: (id < 10)
 (6 rows)
 
 /*+IndexScan(p1)*/
@@ -4274,19 +4257,18 @@ not used hint:
 duplication hint:
 error hint:
 
-                         QUERY PLAN                          
--------------------------------------------------------------
+                      QUERY PLAN                       
+-------------------------------------------------------
  Nested Loop
    Join Filter: (p1.id = t1.id)
+   ->  Bitmap Heap Scan on p1
+         Recheck Cond: ((id >= 50) AND (id <= 51))
+         Filter: (ctid = '(1,1)'::tid)
+         ->  Bitmap Index Scan on p1_pkey
+               Index Cond: ((id >= 50) AND (id <= 51))
    ->  Index Scan using t1_pkey on t1
          Index Cond: (id < 10)
-   ->  Materialize
-         ->  Bitmap Heap Scan on p1
-               Recheck Cond: ((id >= 50) AND (id <= 51))
-               Filter: (ctid = '(1,1)'::tid)
-               ->  Bitmap Index Scan on p1_pkey
-                     Index Cond: ((id >= 50) AND (id <= 51))
-(10 rows)
+(9 rows)
 
 /*+TidScan(p1)*/
 EXPLAIN (COSTS false) SELECT * FROM ONLY p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
@@ -4297,17 +4279,16 @@ not used hint:
 duplication hint:
 error hint:
 
-                    QUERY PLAN                     
----------------------------------------------------
+                 QUERY PLAN                  
+---------------------------------------------
  Nested Loop
    Join Filter: (p1.id = t1.id)
+   ->  Tid Scan on p1
+         TID Cond: (ctid = '(1,1)'::tid)
+         Filter: ((id >= 50) AND (id <= 51))
    ->  Index Scan using t1_pkey on t1
          Index Cond: (id < 10)
-   ->  Materialize
-         ->  Tid Scan on p1
-               TID Cond: (ctid = '(1,1)'::tid)
-               Filter: ((id >= 50) AND (id <= 51))
-(8 rows)
+(7 rows)
 
 SET constraint_exclusion TO on;
 /*+SeqScan(p1)*/
@@ -4323,10 +4304,10 @@ error hint:
 -----------------------------------------------------------------------
  Nested Loop
    Join Filter: (p1.id = t1.id)
-   ->  Index Scan using t1_pkey on t1
-         Index Cond: (id < 10)
    ->  Seq Scan on p1
          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+   ->  Index Scan using t1_pkey on t1
+         Index Cond: (id < 10)
 (6 rows)
 
 /*+IndexScan(p1)*/
@@ -4358,19 +4339,18 @@ not used hint:
 duplication hint:
 error hint:
 
-                         QUERY PLAN                          
--------------------------------------------------------------
+                      QUERY PLAN                       
+-------------------------------------------------------
  Nested Loop
    Join Filter: (p1.id = t1.id)
+   ->  Bitmap Heap Scan on p1
+         Recheck Cond: ((id >= 50) AND (id <= 51))
+         Filter: (ctid = '(1,1)'::tid)
+         ->  Bitmap Index Scan on p1_pkey
+               Index Cond: ((id >= 50) AND (id <= 51))
    ->  Index Scan using t1_pkey on t1
          Index Cond: (id < 10)
-   ->  Materialize
-         ->  Bitmap Heap Scan on p1
-               Recheck Cond: ((id >= 50) AND (id <= 51))
-               Filter: (ctid = '(1,1)'::tid)
-               ->  Bitmap Index Scan on p1_pkey
-                     Index Cond: ((id >= 50) AND (id <= 51))
-(10 rows)
+(9 rows)
 
 /*+TidScan(p1)*/
 EXPLAIN (COSTS false) SELECT * FROM ONLY p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
@@ -4381,17 +4361,16 @@ not used hint:
 duplication hint:
 error hint:
 
-                    QUERY PLAN                     
----------------------------------------------------
+                 QUERY PLAN                  
+---------------------------------------------
  Nested Loop
    Join Filter: (p1.id = t1.id)
+   ->  Tid Scan on p1
+         TID Cond: (ctid = '(1,1)'::tid)
+         Filter: ((id >= 50) AND (id <= 51))
    ->  Index Scan using t1_pkey on t1
          Index Cond: (id < 10)
-   ->  Materialize
-         ->  Tid Scan on p1
-               TID Cond: (ctid = '(1,1)'::tid)
-               Filter: ((id >= 50) AND (id <= 51))
-(8 rows)
+(7 rows)
 
 -- quote test
 /*+SeqScan("""t1 )     ")IndexScan("t  2 """)HashJoin("""t1 )  "T3"t   2 """)Leading("""t1 )   "T3"t   2 """)Set(application_name"a    a       a""     a       A")*/
@@ -6086,6 +6065,7 @@ error hint:
                     QUERY PLAN                    
 --------------------------------------------------
  Nested Loop
+   Join Filter: (t3.id = t4.id)
    ->  Nested Loop
          Join Filter: (t1.val = t3.val)
          ->  Hash Join
@@ -6095,8 +6075,7 @@ error hint:
                ->  Hash
                      ->  Seq Scan on t2
          ->  Seq Scan on t3
-   ->  Index Scan using t4_pkey on t4
-         Index Cond: (id = t3.id)
+   ->  Seq Scan on t4
 (12 rows)
 
 /*+Leading(((t1 t2) t3)) MergeJoin(t1 t2 t3 t4)*/

diff --git a/expected/ut-G.out b/expected/ut-G.out
index e66aebe..df36b84 100644 (file)
--- a/expected/ut-G.out
+++ b/expected/ut-G.out
@@ -13,22 +13,22 @@ EXPLAIN (COSTS false) UPDATE s1.r1 SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
  Aggregate
    ->  Nested Loop
          Join Filter: (t1.c1 = t4.c1)
-         ->  Tid Scan on t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (t1.c1 = t3.c1)
-               ->  Tid Scan on t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (t1.c1 = t2.c1)
-                     ->  Seq Scan on t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r1
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4
+               TID Cond: (ctid = '(1,1)'::tid)
 (19 rows)
 
 /*+
@@ -74,22 +74,22 @@ EXPLAIN (COSTS false) UPDATE s1.r1_ SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
  Aggregate
    ->  Nested Loop
          Join Filter: (b1t1.c1 = b1t4.c1)
-         ->  Tid Scan on t4 b1t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (b1t1.c1 = b1t3.c1)
-               ->  Tid Scan on t3 b1t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (b1t1.c1 = b1t2.c1)
-                     ->  Seq Scan on t2 b1t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r1_
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1 b1t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2 b1t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 b1t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 b1t4
+               TID Cond: (ctid = '(1,1)'::tid)
 (19 rows)
 
 /*+
@@ -136,42 +136,42 @@ EXPLAIN (COSTS false) UPDATE s1.r2 SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
  Aggregate
    ->  Nested Loop
          Join Filter: (t1.c1 = t4.c1)
-         ->  Tid Scan on t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (t1.c1 = t3.c1)
-               ->  Tid Scan on t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (t1.c1 = t2.c1)
-                     ->  Seq Scan on t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r2
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4
+               TID Cond: (ctid = '(1,1)'::tid)
  
  Aggregate
    ->  Nested Loop
          Join Filter: (t1.c1 = t4.c1)
-         ->  Tid Scan on t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (t1.c1 = t3.c1)
-               ->  Tid Scan on t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (t1.c1 = t2.c1)
-                     ->  Seq Scan on t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r2
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4
+               TID Cond: (ctid = '(1,1)'::tid)
 (39 rows)
 
 /*+
@@ -247,42 +247,42 @@ EXPLAIN (COSTS false) UPDATE s1.r2_ SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
  Aggregate
    ->  Nested Loop
          Join Filter: (b1t1.c1 = b1t4.c1)
-         ->  Tid Scan on t4 b1t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (b1t1.c1 = b1t3.c1)
-               ->  Tid Scan on t3 b1t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (b1t1.c1 = b1t2.c1)
-                     ->  Seq Scan on t2 b1t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r2_
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1 b1t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2 b1t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 b1t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 b1t4
+               TID Cond: (ctid = '(1,1)'::tid)
  
  Aggregate
    ->  Nested Loop
          Join Filter: (b2t1.c1 = b2t4.c1)
-         ->  Tid Scan on t4 b2t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (b2t1.c1 = b2t3.c1)
-               ->  Tid Scan on t3 b2t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (b2t1.c1 = b2t2.c1)
-                     ->  Seq Scan on t2 b2t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r2_
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1 b2t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2 b2t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 b2t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 b2t4
+               TID Cond: (ctid = '(1,1)'::tid)
 (39 rows)
 
 /*+
@@ -359,62 +359,62 @@ EXPLAIN (COSTS false) UPDATE s1.r3 SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
  Aggregate
    ->  Nested Loop
          Join Filter: (t1.c1 = t4.c1)
-         ->  Tid Scan on t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (t1.c1 = t3.c1)
-               ->  Tid Scan on t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (t1.c1 = t2.c1)
-                     ->  Seq Scan on t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r3
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4
+               TID Cond: (ctid = '(1,1)'::tid)
  
  Aggregate
    ->  Nested Loop
          Join Filter: (t1.c1 = t4.c1)
-         ->  Tid Scan on t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (t1.c1 = t3.c1)
-               ->  Tid Scan on t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (t1.c1 = t2.c1)
-                     ->  Seq Scan on t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r3
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4
+               TID Cond: (ctid = '(1,1)'::tid)
  
  Aggregate
    ->  Nested Loop
          Join Filter: (t1.c1 = t4.c1)
-         ->  Tid Scan on t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (t1.c1 = t3.c1)
-               ->  Tid Scan on t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (t1.c1 = t2.c1)
-                     ->  Seq Scan on t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r3
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4
+               TID Cond: (ctid = '(1,1)'::tid)
 (59 rows)
 
 /*+
@@ -520,62 +520,62 @@ EXPLAIN (COSTS false) UPDATE s1.r3_ SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
  Aggregate
    ->  Nested Loop
          Join Filter: (b1t1.c1 = b1t4.c1)
-         ->  Tid Scan on t4 b1t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (b1t1.c1 = b1t3.c1)
-               ->  Tid Scan on t3 b1t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (b1t1.c1 = b1t2.c1)
-                     ->  Seq Scan on t2 b1t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r3_
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1 b1t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2 b1t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 b1t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 b1t4
+               TID Cond: (ctid = '(1,1)'::tid)
  
  Aggregate
    ->  Nested Loop
          Join Filter: (b2t1.c1 = b2t4.c1)
-         ->  Tid Scan on t4 b2t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (b2t1.c1 = b2t3.c1)
-               ->  Tid Scan on t3 b2t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (b2t1.c1 = b2t2.c1)
-                     ->  Seq Scan on t2 b2t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r3_
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1 b2t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2 b2t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 b2t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 b2t4
+               TID Cond: (ctid = '(1,1)'::tid)
  
  Aggregate
    ->  Nested Loop
          Join Filter: (b3t1.c1 = b3t4.c1)
-         ->  Tid Scan on t4 b3t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (b3t1.c1 = b3t3.c1)
-               ->  Tid Scan on t3 b3t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (b3t1.c1 = b3t2.c1)
-                     ->  Seq Scan on t2 b3t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r3_
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1 b3t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2 b3t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 b3t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 b3t4
+               TID Cond: (ctid = '(1,1)'::tid)
 (59 rows)
 
 /*+

diff --git a/expected/ut-J.out b/expected/ut-J.out
index 46d28c2..fdb8246 100644 (file)
--- a/expected/ut-J.out
+++ b/expected/ut-J.out
@@ -874,59 +874,56 @@ SELECT max(b2t1.c1) FROM s1.t1 b2t1, s1.t2 b2t2, s1.t3 b2t3, s1.t4 b2t4 WHERE b2
 )
                     FROM s1.t1 bmt1, s1.t2 bmt2, s1.t3 bmt3, s1.t4 bmt4 WHERE bmt1.ctid = '(1,1)' AND bmt1.c1 = bmt2.c1 AND bmt2.ctid = '(1,1)' AND bmt1.c1 = bmt3.c1 AND bmt3.ctid = '(1,1)' AND bmt1.c1 = bmt4.c1 AND bmt4.ctid = '(1,1)'
 ;
-                              QUERY PLAN                               
------------------------------------------------------------------------
+                            QUERY PLAN                             
+-------------------------------------------------------------------
  Aggregate
    InitPlan 1 (returns $0)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b1t1.c1 = b1t4.c1)
-                 ->  Tid Scan on t4 b1t4
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b1t1.c1 = b1t3.c1)
-                       ->  Tid Scan on t3 b1t3
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b1t1.c1 = b1t2.c1)
                              ->  Tid Scan on t1 b1t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Seq Scan on t2 b1t2
-                                         Filter: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b1t2
+                                   Filter: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t3 b1t3
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t4 b1t4
+                       TID Cond: (ctid = '(1,1)'::tid)
    InitPlan 2 (returns $1)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b2t1.c1 = b2t4.c1)
-                 ->  Tid Scan on t4 b2t4
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b2t1.c1 = b2t3.c1)
-                       ->  Tid Scan on t3 b2t3
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b2t1.c1 = b2t2.c1)
                              ->  Tid Scan on t1 b2t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Seq Scan on t2 b2t2
-                                         Filter: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b2t2
+                                   Filter: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t3 b2t3
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t4 b2t4
+                       TID Cond: (ctid = '(1,1)'::tid)
    ->  Nested Loop
          Join Filter: (bmt1.c1 = bmt4.c1)
-         ->  Tid Scan on t4 bmt4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (bmt1.c1 = bmt3.c1)
-               ->  Tid Scan on t3 bmt3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (bmt1.c1 = bmt2.c1)
                      ->  Tid Scan on t1 bmt1
                            TID Cond: (ctid = '(1,1)'::tid)
-                     ->  Materialize
-                           ->  Seq Scan on t2 bmt2
-                                 Filter: (ctid = '(1,1)'::tid)
-(50 rows)
+                     ->  Seq Scan on t2 bmt2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 bmt3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 bmt4
+               TID Cond: (ctid = '(1,1)'::tid)
+(47 rows)
 
 /*+
 Leading(bmt1 bmt2 bmt3 bmt4)
@@ -969,8 +966,6 @@ error hint:
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b1t2.c1 = b1t1.c1)
-                 ->  Tid Scan on t1 b1t1
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Hash Join
                        Hash Cond: (b1t4.c1 = b1t2.c1)
                        ->  Tid Scan on t4 b1t4
@@ -986,12 +981,12 @@ error hint:
                                          Sort Key: b1t3.c1
                                          ->  Tid Scan on t3 b1t3
                                                TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t1 b1t1
+                       TID Cond: (ctid = '(1,1)'::tid)
    InitPlan 2 (returns $1)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b2t1.c1 = b2t2.c1)
-                 ->  Seq Scan on t2 b2t2
-                       Filter: (ctid = '(1,1)'::tid)
                  ->  Hash Join
                        Hash Cond: (b2t1.c1 = b2t3.c1)
                        ->  Tid Scan on t1 b2t1
@@ -1007,10 +1002,10 @@ error hint:
                                          Sort Key: b2t4.c1
                                          ->  Tid Scan on t4 b2t4
                                                TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Seq Scan on t2 b2t2
+                       Filter: (ctid = '(1,1)'::tid)
    ->  Nested Loop
          Join Filter: (bmt1.c1 = bmt4.c1)
-         ->  Tid Scan on t4 bmt4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Hash Join
                Hash Cond: (bmt3.c1 = bmt1.c1)
                ->  Tid Scan on t3 bmt3
@@ -1026,6 +1021,8 @@ error hint:
                                  Sort Key: bmt2.c1
                                  ->  Seq Scan on t2 bmt2
                                        Filter: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 bmt4
+               TID Cond: (ctid = '(1,1)'::tid)
 (62 rows)
 
 -- No. J-2-1-2
@@ -1039,76 +1036,72 @@ SELECT max(b3t1.c1) FROM s1.t1 b3t1, s1.t2 b3t2, s1.t3 b3t3, s1.t4 b3t4 WHERE b3
 )
                     FROM s1.t1 bmt1, s1.t2 bmt2, s1.t3 bmt3, s1.t4 bmt4 WHERE bmt1.ctid = '(1,1)' AND bmt1.c1 = bmt2.c1 AND bmt2.ctid = '(1,1)' AND bmt1.c1 = bmt3.c1 AND bmt3.ctid = '(1,1)' AND bmt1.c1 = bmt4.c1 AND bmt4.ctid = '(1,1)'
 ;
-                              QUERY PLAN                               
------------------------------------------------------------------------
+                            QUERY PLAN                             
+-------------------------------------------------------------------
  Aggregate
    InitPlan 1 (returns $0)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b1t1.c1 = b1t4.c1)
-                 ->  Tid Scan on t4 b1t4
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b1t1.c1 = b1t3.c1)
-                       ->  Tid Scan on t3 b1t3
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b1t1.c1 = b1t2.c1)
                              ->  Tid Scan on t1 b1t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Seq Scan on t2 b1t2
-                                         Filter: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b1t2
+                                   Filter: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t3 b1t3
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t4 b1t4
+                       TID Cond: (ctid = '(1,1)'::tid)
    InitPlan 2 (returns $1)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b2t1.c1 = b2t4.c1)
-                 ->  Tid Scan on t4 b2t4
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b2t1.c1 = b2t3.c1)
-                       ->  Tid Scan on t3 b2t3
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b2t1.c1 = b2t2.c1)
                              ->  Tid Scan on t1 b2t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Seq Scan on t2 b2t2
-                                         Filter: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b2t2
+                                   Filter: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t3 b2t3
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t4 b2t4
+                       TID Cond: (ctid = '(1,1)'::tid)
    InitPlan 3 (returns $2)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b3t1.c1 = b3t4.c1)
-                 ->  Tid Scan on t4 b3t4
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b3t1.c1 = b3t3.c1)
-                       ->  Tid Scan on t3 b3t3
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b3t1.c1 = b3t2.c1)
                              ->  Tid Scan on t1 b3t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Seq Scan on t2 b3t2
-                                         Filter: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b3t2
+                                   Filter: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t3 b3t3
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t4 b3t4
+                       TID Cond: (ctid = '(1,1)'::tid)
    ->  Nested Loop
          Join Filter: (bmt1.c1 = bmt4.c1)
-         ->  Tid Scan on t4 bmt4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (bmt1.c1 = bmt3.c1)
-               ->  Tid Scan on t3 bmt3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (bmt1.c1 = bmt2.c1)
                      ->  Tid Scan on t1 bmt1
                            TID Cond: (ctid = '(1,1)'::tid)
-                     ->  Materialize
-                           ->  Seq Scan on t2 bmt2
-                                 Filter: (ctid = '(1,1)'::tid)
-(67 rows)
+                     ->  Seq Scan on t2 bmt2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 bmt3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 bmt4
+               TID Cond: (ctid = '(1,1)'::tid)
+(63 rows)
 
 /*+
 Leading(bmt1 bmt2 bmt3 bmt4)
@@ -1159,8 +1152,6 @@ error hint:
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b1t2.c1 = b1t1.c1)
-                 ->  Tid Scan on t1 b1t1
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Hash Join
                        Hash Cond: (b1t4.c1 = b1t2.c1)
                        ->  Tid Scan on t4 b1t4
@@ -1176,12 +1167,12 @@ error hint:
                                          Sort Key: b1t3.c1
                                          ->  Tid Scan on t3 b1t3
                                                TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t1 b1t1
+                       TID Cond: (ctid = '(1,1)'::tid)
    InitPlan 2 (returns $1)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b2t1.c1 = b2t2.c1)
-                 ->  Seq Scan on t2 b2t2
-                       Filter: (ctid = '(1,1)'::tid)
                  ->  Hash Join
                        Hash Cond: (b2t1.c1 = b2t3.c1)
                        ->  Tid Scan on t1 b2t1
@@ -1197,12 +1188,12 @@ error hint:
                                          Sort Key: b2t4.c1
                                          ->  Tid Scan on t4 b2t4
                                                TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Seq Scan on t2 b2t2
+                       Filter: (ctid = '(1,1)'::tid)
    InitPlan 3 (returns $2)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b3t1.c1 = b3t3.c1)
-                 ->  Tid Scan on t3 b3t3
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Hash Join
                        Hash Cond: (b3t2.c1 = b3t1.c1)
                        ->  Seq Scan on t2 b3t2
@@ -1218,10 +1209,10 @@ error hint:
                                          Sort Key: b3t4.c1
                                          ->  Tid Scan on t4 b3t4
                                                TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t3 b3t3
+                       TID Cond: (ctid = '(1,1)'::tid)
    ->  Nested Loop
          Join Filter: (bmt1.c1 = bmt4.c1)
-         ->  Tid Scan on t4 bmt4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Hash Join
                Hash Cond: (bmt3.c1 = bmt1.c1)
                ->  Tid Scan on t3 bmt3
@@ -1237,29 +1228,30 @@ error hint:
                                  Sort Key: bmt2.c1
                                  ->  Seq Scan on t2 bmt2
                                        Filter: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 bmt4
+               TID Cond: (ctid = '(1,1)'::tid)
 (83 rows)
 
 -- No. J-2-1-3
 EXPLAIN (COSTS false) SELECT max(bmt1.c1) FROM s1.t1 bmt1, s1.t2 bmt2, (SELECT ctid, * FROM s1.t3 bmt3) sbmt3, (SELECT ctid, * FROM s1.t4 bmt4) sbmt4 WHERE bmt1.ctid = '(1,1)' AND bmt1.c1 = bmt2.c1 AND bmt2.ctid = '(1,1)' AND bmt1.c1 = sbmt3.c1 AND sbmt3.ctid = '(1,1)' AND bmt1.c1 = sbmt4.c1 AND sbmt4.ctid = '(1,1)';
-                          QUERY PLAN                           
----------------------------------------------------------------
+                        QUERY PLAN                         
+-----------------------------------------------------------
  Aggregate
    ->  Nested Loop
          Join Filter: (bmt1.c1 = bmt4.c1)
-         ->  Tid Scan on t4 bmt4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (bmt1.c1 = bmt3.c1)
-               ->  Tid Scan on t3 bmt3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (bmt1.c1 = bmt2.c1)
                      ->  Tid Scan on t1 bmt1
                            TID Cond: (ctid = '(1,1)'::tid)
-                     ->  Materialize
-                           ->  Seq Scan on t2 bmt2
-                                 Filter: (ctid = '(1,1)'::tid)
-(16 rows)
+                     ->  Seq Scan on t2 bmt2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 bmt3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 bmt4
+               TID Cond: (ctid = '(1,1)'::tid)
+(15 rows)
 
 /*+
 Leading(bmt4 bmt3 bmt2 bmt1)
@@ -1281,8 +1273,6 @@ error hint:
  Aggregate
    ->  Nested Loop
          Join Filter: (bmt2.c1 = bmt1.c1)
-         ->  Tid Scan on t1 bmt1
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Hash Join
                Hash Cond: (bmt2.c1 = bmt3.c1)
                ->  Seq Scan on t2 bmt2
@@ -1298,29 +1288,30 @@ error hint:
                                  Sort Key: bmt4.c1
                                  ->  Tid Scan on t4 bmt4
                                        TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t1 bmt1
+               TID Cond: (ctid = '(1,1)'::tid)
 (20 rows)
 
 -- No. J-2-1-4
 EXPLAIN (COSTS false) SELECT max(bmt1.c1) FROM s1.t1 bmt1, (SELECT ctid, * FROM s1.t2 bmt2) sbmt2, (SELECT ctid, * FROM s1.t3 bmt3) sbmt3, (SELECT ctid, * FROM s1.t4 bmt4) sbmt4 WHERE bmt1.ctid = '(1,1)' AND bmt1.c1 = sbmt2.c1 AND sbmt2.ctid = '(1,1)' AND bmt1.c1 = sbmt3.c1 AND sbmt3.ctid = '(1,1)' AND bmt1.c1 = sbmt4.c1 AND sbmt4.ctid = '(1,1)';
-                          QUERY PLAN                           
----------------------------------------------------------------
+                        QUERY PLAN                         
+-----------------------------------------------------------
  Aggregate
    ->  Nested Loop
          Join Filter: (bmt1.c1 = bmt4.c1)
-         ->  Tid Scan on t4 bmt4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (bmt1.c1 = bmt3.c1)
-               ->  Tid Scan on t3 bmt3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (bmt1.c1 = bmt2.c1)
                      ->  Tid Scan on t1 bmt1
                            TID Cond: (ctid = '(1,1)'::tid)
-                     ->  Materialize
-                           ->  Seq Scan on t2 bmt2
-                                 Filter: (ctid = '(1,1)'::tid)
-(16 rows)
+                     ->  Seq Scan on t2 bmt2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 bmt3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 bmt4
+               TID Cond: (ctid = '(1,1)'::tid)
+(15 rows)
 
 /*+
 Leading(bmt4 bmt3 bmt2 bmt1)
@@ -1342,8 +1333,6 @@ error hint:
  Aggregate
    ->  Nested Loop
          Join Filter: (bmt2.c1 = bmt1.c1)
-         ->  Tid Scan on t1 bmt1
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Hash Join
                Hash Cond: (bmt2.c1 = bmt3.c1)
                ->  Seq Scan on t2 bmt2
@@ -1359,6 +1348,8 @@ error hint:
                                  Sort Key: bmt4.c1
                                  ->  Tid Scan on t4 bmt4
                                        TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t1 bmt1
+               TID Cond: (ctid = '(1,1)'::tid)
 (20 rows)
 
 -- No. J-2-1-5
@@ -1370,60 +1361,57 @@ SELECT max(b1t1.c1) FROM s1.t1 b1t1, s1.t2 b1t2, s1.t3 b1t3, s1.t4 b1t4 WHERE b1
 SELECT max(b2t1.c1) FROM s1.t1 b2t1, s1.t2 b2t2, s1.t3 b2t3, s1.t4 b2t4 WHERE b2t1.ctid = '(1,1)' AND b2t1.c1 = b2t2.c1 AND b2t2.ctid = '(1,1)' AND b2t1.c1 = b2t3.c1 AND b2t3.ctid = '(1,1)' AND b2t1.c1 = b2t4.c1 AND b2t4.ctid = '(1,1)'
 )
 ;
-                              QUERY PLAN                               
------------------------------------------------------------------------
+                            QUERY PLAN                             
+-------------------------------------------------------------------
  Aggregate
    InitPlan 1 (returns $0)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b1t1.c1 = b1t4.c1)
-                 ->  Tid Scan on t4 b1t4
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b1t1.c1 = b1t3.c1)
-                       ->  Tid Scan on t3 b1t3
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b1t1.c1 = b1t2.c1)
                              ->  Tid Scan on t1 b1t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Seq Scan on t2 b1t2
-                                         Filter: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b1t2
+                                   Filter: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t3 b1t3
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t4 b1t4
+                       TID Cond: (ctid = '(1,1)'::tid)
    InitPlan 2 (returns $1)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b2t1.c1 = b2t4.c1)
-                 ->  Tid Scan on t4 b2t4
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b2t1.c1 = b2t3.c1)
-                       ->  Tid Scan on t3 b2t3
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b2t1.c1 = b2t2.c1)
                              ->  Tid Scan on t1 b2t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Seq Scan on t2 b2t2
-                                         Filter: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b2t2
+                                   Filter: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t3 b2t3
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t4 b2t4
+                       TID Cond: (ctid = '(1,1)'::tid)
    ->  Nested Loop
          Join Filter: (bmt1.c1 = bmt4.c1)
-         ->  Tid Scan on t4 bmt4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (bmt1.c1 = bmt3.c1)
-               ->  Tid Scan on t3 bmt3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (bmt1.c1 = bmt2.c1)
                      ->  Tid Scan on t1 bmt1
                            TID Cond: (ctid = '(1,1)'::tid)
                            Filter: ((c1 <> $0) AND (c1 <> $1))
-                     ->  Materialize
-                           ->  Seq Scan on t2 bmt2
-                                 Filter: (ctid = '(1,1)'::tid)
-(51 rows)
+                     ->  Seq Scan on t2 bmt2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 bmt3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 bmt4
+               TID Cond: (ctid = '(1,1)'::tid)
+(48 rows)
 
 /*+
 Leading(bmt1 bmt2 bmt3 bmt4)
@@ -1466,8 +1454,6 @@ error hint:
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b1t2.c1 = b1t1.c1)
-                 ->  Tid Scan on t1 b1t1
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Hash Join
                        Hash Cond: (b1t4.c1 = b1t2.c1)
                        ->  Tid Scan on t4 b1t4
@@ -1483,12 +1469,12 @@ error hint:
                                          Sort Key: b1t3.c1
                                          ->  Tid Scan on t3 b1t3
                                                TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t1 b1t1
+                       TID Cond: (ctid = '(1,1)'::tid)
    InitPlan 2 (returns $1)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b2t1.c1 = b2t2.c1)
-                 ->  Seq Scan on t2 b2t2
-                       Filter: (ctid = '(1,1)'::tid)
                  ->  Hash Join
                        Hash Cond: (b2t1.c1 = b2t3.c1)
                        ->  Tid Scan on t1 b2t1
@@ -1504,10 +1490,10 @@ error hint:
                                          Sort Key: b2t4.c1
                                          ->  Tid Scan on t4 b2t4
                                                TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Seq Scan on t2 b2t2
+                       Filter: (ctid = '(1,1)'::tid)
    ->  Nested Loop
          Join Filter: (bmt1.c1 = bmt4.c1)
-         ->  Tid Scan on t4 bmt4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Hash Join
                Hash Cond: (bmt3.c1 = bmt1.c1)
                ->  Tid Scan on t3 bmt3
@@ -1524,6 +1510,8 @@ error hint:
                                  Sort Key: bmt2.c1
                                  ->  Seq Scan on t2 bmt2
                                        Filter: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 bmt4
+               TID Cond: (ctid = '(1,1)'::tid)
 (63 rows)
 
 -- No. J-2-1-6
@@ -1544,70 +1532,66 @@ SELECT max(b3t1.c1) FROM s1.t1 b3t1, s1.t2 b3t2, s1.t3 b3t3, s1.t4 b3t4 WHERE b3
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b1t1.c1 = b1t4.c1)
-                 ->  Tid Scan on t4 b1t4
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b1t1.c1 = b1t3.c1)
-                       ->  Tid Scan on t3 b1t3
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b1t1.c1 = b1t2.c1)
                              ->  Tid Scan on t1 b1t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Seq Scan on t2 b1t2
-                                         Filter: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b1t2
+                                   Filter: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t3 b1t3
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t4 b1t4
+                       TID Cond: (ctid = '(1,1)'::tid)
    InitPlan 2 (returns $1)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b2t1.c1 = b2t4.c1)
-                 ->  Tid Scan on t4 b2t4
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b2t1.c1 = b2t3.c1)
-                       ->  Tid Scan on t3 b2t3
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b2t1.c1 = b2t2.c1)
                              ->  Tid Scan on t1 b2t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Seq Scan on t2 b2t2
-                                         Filter: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b2t2
+                                   Filter: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t3 b2t3
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t4 b2t4
+                       TID Cond: (ctid = '(1,1)'::tid)
    InitPlan 3 (returns $2)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b3t1.c1 = b3t4.c1)
-                 ->  Tid Scan on t4 b3t4
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b3t1.c1 = b3t3.c1)
-                       ->  Tid Scan on t3 b3t3
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b3t1.c1 = b3t2.c1)
                              ->  Tid Scan on t1 b3t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Seq Scan on t2 b3t2
-                                         Filter: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b3t2
+                                   Filter: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t3 b3t3
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t4 b3t4
+                       TID Cond: (ctid = '(1,1)'::tid)
    ->  Nested Loop
          Join Filter: (bmt1.c1 = bmt4.c1)
-         ->  Tid Scan on t4 bmt4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (bmt1.c1 = bmt3.c1)
-               ->  Tid Scan on t3 bmt3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (bmt1.c1 = bmt2.c1)
                      ->  Tid Scan on t1 bmt1
                            TID Cond: (ctid = '(1,1)'::tid)
                            Filter: ((c1 <> $0) AND (c1 <> $1) AND (c1 <> $2))
-                     ->  Materialize
-                           ->  Seq Scan on t2 bmt2
-                                 Filter: (ctid = '(1,1)'::tid)
-(68 rows)
+                     ->  Seq Scan on t2 bmt2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 bmt3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 bmt4
+               TID Cond: (ctid = '(1,1)'::tid)
+(64 rows)
 
 /*+
 Leading(bmt1 bmt2 bmt3 bmt4)
@@ -1658,8 +1642,6 @@ error hint:
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b1t2.c1 = b1t1.c1)
-                 ->  Tid Scan on t1 b1t1
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Hash Join
                        Hash Cond: (b1t4.c1 = b1t2.c1)
                        ->  Tid Scan on t4 b1t4
@@ -1675,12 +1657,12 @@ error hint:
                                          Sort Key: b1t3.c1
                                          ->  Tid Scan on t3 b1t3
                                                TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t1 b1t1
+                       TID Cond: (ctid = '(1,1)'::tid)
    InitPlan 2 (returns $1)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b2t1.c1 = b2t2.c1)
-                 ->  Seq Scan on t2 b2t2
-                       Filter: (ctid = '(1,1)'::tid)
                  ->  Hash Join
                        Hash Cond: (b2t1.c1 = b2t3.c1)
                        ->  Tid Scan on t1 b2t1
@@ -1696,12 +1678,12 @@ error hint:
                                          Sort Key: b2t4.c1
                                          ->  Tid Scan on t4 b2t4
                                                TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Seq Scan on t2 b2t2
+                       Filter: (ctid = '(1,1)'::tid)
    InitPlan 3 (returns $2)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b3t1.c1 = b3t3.c1)
-                 ->  Tid Scan on t3 b3t3
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Hash Join
                        Hash Cond: (b3t2.c1 = b3t1.c1)
                        ->  Seq Scan on t2 b3t2
@@ -1717,10 +1699,10 @@ error hint:
                                          Sort Key: b3t4.c1
                                          ->  Tid Scan on t4 b3t4
                                                TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t3 b3t3
+                       TID Cond: (ctid = '(1,1)'::tid)
    ->  Nested Loop
          Join Filter: (bmt1.c1 = bmt4.c1)
-         ->  Tid Scan on t4 bmt4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Hash Join
                Hash Cond: (bmt3.c1 = bmt1.c1)
                ->  Tid Scan on t3 bmt3
@@ -1737,6 +1719,8 @@ error hint:
                                  Sort Key: bmt2.c1
                                  ->  Seq Scan on t2 bmt2
                                        Filter: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 bmt4
+               TID Cond: (ctid = '(1,1)'::tid)
 (84 rows)
 
 -- No. J-2-1-7
@@ -1760,57 +1744,55 @@ AND bmt1.c1 = c2.c1
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b1t1.c1 = b1t4.c1)
-                 ->  Tid Scan on t4 b1t4
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b1t1.c1 = b1t3.c1)
-                       ->  Tid Scan on t3 b1t3
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b1t1.c1 = b1t2.c1)
                              ->  Tid Scan on t1 b1t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Seq Scan on t2 b1t2
-                                         Filter: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b1t2
+                                   Filter: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t3 b1t3
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t4 b1t4
+                       TID Cond: (ctid = '(1,1)'::tid)
    CTE c2
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b2t1.c1 = b2t4.c1)
-                 ->  Tid Scan on t4 b2t4
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b2t1.c1 = b2t3.c1)
-                       ->  Tid Scan on t3 b2t3
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b2t1.c1 = b2t2.c1)
                              ->  Tid Scan on t1 b2t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Seq Scan on t2 b2t2
-                                         Filter: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b2t2
+                                   Filter: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t3 b2t3
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t4 b2t4
+                       TID Cond: (ctid = '(1,1)'::tid)
    ->  Nested Loop
          Join Filter: (bmt1.c1 = c2.c1)
          ->  Nested Loop
-               Join Filter: (bmt1.c1 = bmt4.c1)
-               ->  Tid Scan on t4 bmt4
-                     TID Cond: (ctid = '(1,1)'::tid)
+               Join Filter: (bmt1.c1 = c1.c1)
                ->  Nested Loop
-                     Join Filter: (bmt1.c1 = bmt3.c1)
-                     ->  Tid Scan on t3 bmt3
-                           TID Cond: (ctid = '(1,1)'::tid)
+                     Join Filter: (bmt1.c1 = bmt4.c1)
                      ->  Nested Loop
-                           Join Filter: (bmt1.c1 = bmt2.c1)
-                           ->  Seq Scan on t2 bmt2
-                                 Filter: (ctid = '(1,1)'::tid)
+                           Join Filter: (bmt1.c1 = bmt3.c1)
                            ->  Nested Loop
-                                 Join Filter: (bmt1.c1 = c1.c1)
+                                 Join Filter: (bmt1.c1 = bmt2.c1)
                                  ->  Tid Scan on t1 bmt1
                                        TID Cond: (ctid = '(1,1)'::tid)
-                                 ->  CTE Scan on c1
+                                 ->  Seq Scan on t2 bmt2
+                                       Filter: (ctid = '(1,1)'::tid)
+                           ->  Tid Scan on t3 bmt3
+                                 TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Tid Scan on t4 bmt4
+                           TID Cond: (ctid = '(1,1)'::tid)
+               ->  CTE Scan on c1
          ->  CTE Scan on c2
-(55 rows)
+(53 rows)
 
 /*+
 Leading(c2 c1 bmt1 bmt2 bmt3 bmt4)
@@ -1860,8 +1842,6 @@ error hint:
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b1t2.c1 = b1t1.c1)
-                 ->  Tid Scan on t1 b1t1
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Hash Join
                        Hash Cond: (b1t4.c1 = b1t2.c1)
                        ->  Tid Scan on t4 b1t4
@@ -1877,12 +1857,12 @@ error hint:
                                          Sort Key: b1t3.c1
                                          ->  Tid Scan on t3 b1t3
                                                TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t1 b1t1
+                       TID Cond: (ctid = '(1,1)'::tid)
    CTE c2
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b2t1.c1 = b2t2.c1)
-                 ->  Seq Scan on t2 b2t2
-                       Filter: (ctid = '(1,1)'::tid)
                  ->  Hash Join
                        Hash Cond: (b2t1.c1 = b2t3.c1)
                        ->  Tid Scan on t1 b2t1
@@ -1898,6 +1878,8 @@ error hint:
                                          Sort Key: b2t4.c1
                                          ->  Tid Scan on t4 b2t4
                                                TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Seq Scan on t2 b2t2
+                       Filter: (ctid = '(1,1)'::tid)
    ->  Hash Join
          Hash Cond: (bmt4.c1 = bmt1.c1)
          ->  Tid Scan on t4 bmt4
@@ -1909,8 +1891,6 @@ error hint:
                            Sort Key: bmt1.c1
                            ->  Nested Loop
                                  Join Filter: (bmt1.c1 = bmt2.c1)
-                                 ->  Seq Scan on t2 bmt2
-                                       Filter: (ctid = '(1,1)'::tid)
                                  ->  Hash Join
                                        Hash Cond: (bmt1.c1 = c1.c1)
                                        ->  Tid Scan on t1 bmt1
@@ -1924,6 +1904,8 @@ error hint:
                                                    ->  Sort
                                                          Sort Key: c2.c1
                                                          ->  CTE Scan on c2
+                                 ->  Seq Scan on t2 bmt2
+                                       Filter: (ctid = '(1,1)'::tid)
                      ->  Sort
                            Sort Key: bmt3.c1
                            ->  Tid Scan on t3 bmt3
@@ -1955,77 +1937,74 @@ AND bmt1.c1 = c3.c1
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b1t1.c1 = b1t4.c1)
-                 ->  Tid Scan on t4 b1t4
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b1t1.c1 = b1t3.c1)
-                       ->  Tid Scan on t3 b1t3
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b1t1.c1 = b1t2.c1)
                              ->  Tid Scan on t1 b1t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Seq Scan on t2 b1t2
-                                         Filter: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b1t2
+                                   Filter: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t3 b1t3
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t4 b1t4
+                       TID Cond: (ctid = '(1,1)'::tid)
    CTE c2
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b2t1.c1 = b2t4.c1)
-                 ->  Tid Scan on t4 b2t4
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b2t1.c1 = b2t3.c1)
-                       ->  Tid Scan on t3 b2t3
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b2t1.c1 = b2t2.c1)
                              ->  Tid Scan on t1 b2t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Seq Scan on t2 b2t2
-                                         Filter: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b2t2
+                                   Filter: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t3 b2t3
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t4 b2t4
+                       TID Cond: (ctid = '(1,1)'::tid)
    CTE c3
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b3t1.c1 = b3t4.c1)
-                 ->  Tid Scan on t4 b3t4
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b3t1.c1 = b3t3.c1)
-                       ->  Tid Scan on t3 b3t3
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b3t1.c1 = b3t2.c1)
                              ->  Tid Scan on t1 b3t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Seq Scan on t2 b3t2
-                                         Filter: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b3t2
+                                   Filter: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t3 b3t3
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t4 b3t4
+                       TID Cond: (ctid = '(1,1)'::tid)
    ->  Nested Loop
          Join Filter: (bmt1.c1 = c3.c1)
          ->  Nested Loop
                Join Filter: (bmt1.c1 = c2.c1)
                ->  Nested Loop
-                     Join Filter: (bmt1.c1 = bmt4.c1)
-                     ->  Tid Scan on t4 bmt4
-                           TID Cond: (ctid = '(1,1)'::tid)
+                     Join Filter: (bmt1.c1 = c1.c1)
                      ->  Nested Loop
-                           Join Filter: (bmt1.c1 = bmt3.c1)
-                           ->  Tid Scan on t3 bmt3
-                                 TID Cond: (ctid = '(1,1)'::tid)
+                           Join Filter: (bmt1.c1 = bmt4.c1)
                            ->  Nested Loop
-                                 Join Filter: (bmt1.c1 = bmt2.c1)
-                                 ->  Seq Scan on t2 bmt2
-                                       Filter: (ctid = '(1,1)'::tid)
+                                 Join Filter: (bmt1.c1 = bmt3.c1)
                                  ->  Nested Loop
-                                       Join Filter: (bmt1.c1 = c1.c1)
+                                       Join Filter: (bmt1.c1 = bmt2.c1)
                                        ->  Tid Scan on t1 bmt1
                                              TID Cond: (ctid = '(1,1)'::tid)
-                                       ->  CTE Scan on c1
+                                       ->  Seq Scan on t2 bmt2
+                                             Filter: (ctid = '(1,1)'::tid)
+                                 ->  Tid Scan on t3 bmt3
+                                       TID Cond: (ctid = '(1,1)'::tid)
+                           ->  Tid Scan on t4 bmt4
+                                 TID Cond: (ctid = '(1,1)'::tid)
+                     ->  CTE Scan on c1
                ->  CTE Scan on c2
          ->  CTE Scan on c3
-(75 rows)
+(72 rows)
 
 /*+
 Leading(c3 c2 c1 bmt1 bmt2 bmt3 bmt4)
@@ -2086,8 +2065,6 @@ error hint:
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b1t2.c1 = b1t1.c1)
-                 ->  Tid Scan on t1 b1t1
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Hash Join
                        Hash Cond: (b1t4.c1 = b1t2.c1)
                        ->  Tid Scan on t4 b1t4
@@ -2103,12 +2080,12 @@ error hint:
                                          Sort Key: b1t3.c1
                                          ->  Tid Scan on t3 b1t3
                                                TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t1 b1t1
+                       TID Cond: (ctid = '(1,1)'::tid)
    CTE c2
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b2t1.c1 = b2t2.c1)
-                 ->  Seq Scan on t2 b2t2
-                       Filter: (ctid = '(1,1)'::tid)
                  ->  Hash Join
                        Hash Cond: (b2t1.c1 = b2t3.c1)
                        ->  Tid Scan on t1 b2t1
@@ -2124,12 +2101,12 @@ error hint:
                                          Sort Key: b2t4.c1
                                          ->  Tid Scan on t4 b2t4
                                                TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Seq Scan on t2 b2t2
+                       Filter: (ctid = '(1,1)'::tid)
    CTE c3
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b3t1.c1 = b3t3.c1)
-                 ->  Tid Scan on t3 b3t3
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Hash Join
                        Hash Cond: (b3t2.c1 = b3t1.c1)
                        ->  Seq Scan on t2 b3t2
@@ -2145,10 +2122,10 @@ error hint:
                                          Sort Key: b3t4.c1
                                          ->  Tid Scan on t4 b3t4
                                                TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t3 b3t3
+                       TID Cond: (ctid = '(1,1)'::tid)
    ->  Nested Loop
          Join Filter: (bmt1.c1 = bmt4.c1)
-         ->  Tid Scan on t4 bmt4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Hash Join
                Hash Cond: (bmt3.c1 = bmt1.c1)
                ->  Tid Scan on t3 bmt3
@@ -2160,8 +2137,6 @@ error hint:
                                  Sort Key: bmt1.c1
                                  ->  Nested Loop
                                        Join Filter: (c1.c1 = bmt1.c1)
-                                       ->  Tid Scan on t1 bmt1
-                                             TID Cond: (ctid = '(1,1)'::tid)
                                        ->  Hash Join
                                              Hash Cond: (c2.c1 = c1.c1)
                                              ->  Merge Join
@@ -2174,10 +2149,14 @@ error hint:
                                                          ->  CTE Scan on c3
                                              ->  Hash
                                                    ->  CTE Scan on c1
+                                       ->  Tid Scan on t1 bmt1
+                                             TID Cond: (ctid = '(1,1)'::tid)
                            ->  Sort
                                  Sort Key: bmt2.c1
                                  ->  Seq Scan on t2 bmt2
                                        Filter: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 bmt4
+               TID Cond: (ctid = '(1,1)'::tid)
 (97 rows)
 
 ----
@@ -2306,8 +2285,8 @@ AND bmt1.c1 <> (
 SELECT max(b3t1.c1) FROM s1.t1 b3t1, s1.t2 b3t2 WHERE b3t1.ctid = '(1,1)' AND b3t1.c1 = b3t2.c1 AND b3t2.ctid = '(1,1)'
 )
 ;
-                        QUERY PLAN                         
------------------------------------------------------------
+                      QUERY PLAN                       
+-------------------------------------------------------
  Aggregate
    CTE c1
      ->  Aggregate
@@ -2315,38 +2294,35 @@ SELECT max(b3t1.c1) FROM s1.t1 b3t1, s1.t2 b3t2 WHERE b3t1.ctid = '(1,1)' AND b3
                  Join Filter: (b1t1.c1 = b1t2.c1)
                  ->  Tid Scan on t1 b1t1
                        TID Cond: (ctid = '(1,1)'::tid)
-                 ->  Materialize
-                       ->  Seq Scan on t2 b1t2
-                             Filter: (ctid = '(1,1)'::tid)
+                 ->  Seq Scan on t2 b1t2
+                       Filter: (ctid = '(1,1)'::tid)
    InitPlan 2 (returns $1)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b2t1.c1 = b2t2.c1)
                  ->  Tid Scan on t1 b2t1
                        TID Cond: (ctid = '(1,1)'::tid)
-                 ->  Materialize
-                       ->  Seq Scan on t2 b2t2
-                             Filter: (ctid = '(1,1)'::tid)
+                 ->  Seq Scan on t2 b2t2
+                       Filter: (ctid = '(1,1)'::tid)
    InitPlan 3 (returns $2)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b3t1.c1 = b3t2.c1)
                  ->  Tid Scan on t1 b3t1
                        TID Cond: (ctid = '(1,1)'::tid)
-                 ->  Materialize
-                       ->  Seq Scan on t2 b3t2
-                             Filter: (ctid = '(1,1)'::tid)
+                 ->  Seq Scan on t2 b3t2
+                       Filter: (ctid = '(1,1)'::tid)
    ->  Nested Loop
-         Join Filter: (bmt1.c1 = bmt2.c1)
-         ->  Seq Scan on t2 bmt2
-               Filter: (ctid = '(1,1)'::tid)
+         Join Filter: (bmt1.c1 = c1.c1)
          ->  Nested Loop
-               Join Filter: (bmt1.c1 = c1.c1)
+               Join Filter: (bmt1.c1 = bmt2.c1)
                ->  Tid Scan on t1 bmt1
                      TID Cond: (ctid = '(1,1)'::tid)
                      Filter: (c1 <> $2)
-               ->  CTE Scan on c1
-(38 rows)
+               ->  Seq Scan on t2 bmt2
+                     Filter: (ctid = '(1,1)'::tid)
+         ->  CTE Scan on c1
+(35 rows)
 
 /*+
 Leading(c1 bmt2 bmt1)
@@ -2456,79 +2432,76 @@ AND bmt1.c1 <> (
 SELECT max(b3t1.c1) FROM s1.t1 b3t1, s1.t2 b3t2, s1.t3 b3t3, s1.t4 b3t4 WHERE b3t1.ctid = '(1,1)' AND b3t1.c1 = b3t2.c1 AND b3t2.ctid = '(1,1)' AND b3t1.c1 = b3t3.c1 AND b3t3.ctid = '(1,1)' AND b3t1.c1 = b3t4.c1 AND b3t4.ctid = '(1,1)'
 )
 ;
-                              QUERY PLAN                               
------------------------------------------------------------------------
+                            QUERY PLAN                             
+-------------------------------------------------------------------
  Aggregate
    CTE c1
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b1t1.c1 = b1t4.c1)
-                 ->  Tid Scan on t4 b1t4
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b1t1.c1 = b1t3.c1)
-                       ->  Tid Scan on t3 b1t3
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b1t1.c1 = b1t2.c1)
                              ->  Tid Scan on t1 b1t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Seq Scan on t2 b1t2
-                                         Filter: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b1t2
+                                   Filter: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t3 b1t3
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t4 b1t4
+                       TID Cond: (ctid = '(1,1)'::tid)
    InitPlan 2 (returns $1)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b2t1.c1 = b2t4.c1)
-                 ->  Tid Scan on t4 b2t4
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b2t1.c1 = b2t3.c1)
-                       ->  Tid Scan on t3 b2t3
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b2t1.c1 = b2t2.c1)
                              ->  Tid Scan on t1 b2t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Seq Scan on t2 b2t2
-                                         Filter: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b2t2
+                                   Filter: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t3 b2t3
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t4 b2t4
+                       TID Cond: (ctid = '(1,1)'::tid)
    InitPlan 3 (returns $2)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b3t1.c1 = b3t4.c1)
-                 ->  Tid Scan on t4 b3t4
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b3t1.c1 = b3t3.c1)
-                       ->  Tid Scan on t3 b3t3
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b3t1.c1 = b3t2.c1)
                              ->  Tid Scan on t1 b3t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Seq Scan on t2 b3t2
-                                         Filter: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b3t2
+                                   Filter: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t3 b3t3
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t4 b3t4
+                       TID Cond: (ctid = '(1,1)'::tid)
    ->  Nested Loop
-         Join Filter: (bmt1.c1 = bmt4.c1)
-         ->  Tid Scan on t4 bmt4
-               TID Cond: (ctid = '(1,1)'::tid)
+         Join Filter: (bmt1.c1 = c1.c1)
          ->  Nested Loop
-               Join Filter: (bmt1.c1 = bmt3.c1)
-               ->  Tid Scan on t3 bmt3
-                     TID Cond: (ctid = '(1,1)'::tid)
+               Join Filter: (bmt1.c1 = bmt4.c1)
                ->  Nested Loop
-                     Join Filter: (bmt1.c1 = bmt2.c1)
-                     ->  Seq Scan on t2 bmt2
-                           Filter: (ctid = '(1,1)'::tid)
+                     Join Filter: (bmt1.c1 = bmt3.c1)
                      ->  Nested Loop
-                           Join Filter: (bmt1.c1 = c1.c1)
+                           Join Filter: (bmt1.c1 = bmt2.c1)
                            ->  Tid Scan on t1 bmt1
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 <> $2)
-                           ->  CTE Scan on c1
-(70 rows)
+                           ->  Seq Scan on t2 bmt2
+                                 Filter: (ctid = '(1,1)'::tid)
+                     ->  Tid Scan on t3 bmt3
+                           TID Cond: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t4 bmt4
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  CTE Scan on c1
+(67 rows)
 
 /*+
 Leading(c1 bmt4 bmt3 bmt2 bmt1)
@@ -2595,8 +2568,6 @@ error hint:
                        Sort Key: b1t2.c1
                        ->  Nested Loop
                              Join Filter: (b1t3.c1 = b1t2.c1)
-                             ->  Seq Scan on t2 b1t2
-                                   Filter: (ctid = '(1,1)'::tid)
                              ->  Hash Join
                                    Hash Cond: (b1t3.c1 = b1t4.c1)
                                    ->  Tid Scan on t3 b1t3
@@ -2604,6 +2575,8 @@ error hint:
                                    ->  Hash
                                          ->  Tid Scan on t4 b1t4
                                                TID Cond: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b1t2
+                                   Filter: (ctid = '(1,1)'::tid)
                  ->  Sort
                        Sort Key: b1t1.c1
                        ->  Tid Scan on t1 b1t1
@@ -2616,8 +2589,6 @@ error hint:
                        Sort Key: b2t2.c1
                        ->  Nested Loop
                              Join Filter: (b2t3.c1 = b2t2.c1)
-                             ->  Seq Scan on t2 b2t2
-                                   Filter: (ctid = '(1,1)'::tid)
                              ->  Hash Join
                                    Hash Cond: (b2t3.c1 = b2t4.c1)
                                    ->  Tid Scan on t3 b2t3
@@ -2625,6 +2596,8 @@ error hint:
                                    ->  Hash
                                          ->  Tid Scan on t4 b2t4
                                                TID Cond: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b2t2
+                                   Filter: (ctid = '(1,1)'::tid)
                  ->  Sort
                        Sort Key: b2t1.c1
                        ->  Tid Scan on t1 b2t1
@@ -2637,8 +2610,6 @@ error hint:
                        Sort Key: b3t2.c1
                        ->  Nested Loop
                              Join Filter: (b3t3.c1 = b3t2.c1)
-                             ->  Seq Scan on t2 b3t2
-                                   Filter: (ctid = '(1,1)'::tid)
                              ->  Hash Join
                                    Hash Cond: (b3t3.c1 = b3t4.c1)
                                    ->  Tid Scan on t3 b3t3
@@ -2646,6 +2617,8 @@ error hint:
                                    ->  Hash
                                          ->  Tid Scan on t4 b3t4
                                                TID Cond: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b3t2
+                                   Filter: (ctid = '(1,1)'::tid)
                  ->  Sort
                        Sort Key: b3t1.c1
                        ->  Tid Scan on t1 b3t1
@@ -2656,8 +2629,6 @@ error hint:
                Sort Key: bmt2.c1
                ->  Nested Loop
                      Join Filter: (bmt3.c1 = bmt2.c1)
-                     ->  Seq Scan on t2 bmt2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Hash Join
                            Hash Cond: (bmt3.c1 = bmt4.c1)
                            ->  Tid Scan on t3 bmt3
@@ -2672,6 +2643,8 @@ error hint:
                                        ->  Sort
                                              Sort Key: c1.c1
                                              ->  CTE Scan on c1
+                     ->  Seq Scan on t2 bmt2
+                           Filter: (ctid = '(1,1)'::tid)
          ->  Sort
                Sort Key: bmt1.c1
                ->  Tid Scan on t1 bmt1
@@ -2692,26 +2665,25 @@ AND bmt1.c1 <> (
 SELECT max(b3t1.c1) FROM s1.t1 b3t1 WHERE b3t1.ctid = '(1,1)'
 )
 ;
-                              QUERY PLAN                               
------------------------------------------------------------------------
+                            QUERY PLAN                             
+-------------------------------------------------------------------
  Aggregate
    CTE c1
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b1t1.c1 = b1t4.c1)
-                 ->  Tid Scan on t4 b1t4
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b1t1.c1 = b1t3.c1)
-                       ->  Tid Scan on t3 b1t3
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b1t1.c1 = b1t2.c1)
                              ->  Tid Scan on t1 b1t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Seq Scan on t2 b1t2
-                                         Filter: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b1t2
+                                   Filter: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t3 b1t3
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t4 b1t4
+                       TID Cond: (ctid = '(1,1)'::tid)
    InitPlan 3 (returns $2)
      ->  Result
            InitPlan 2 (returns $1)
@@ -2724,24 +2696,24 @@ SELECT max(b3t1.c1) FROM s1.t1 b3t1 WHERE b3t1.ctid = '(1,1)'
            ->  Tid Scan on t1 b3t1
                  TID Cond: (ctid = '(1,1)'::tid)
    ->  Nested Loop
-         Join Filter: (bmt1.c1 = bmt4.c1)
-         ->  Tid Scan on t4 bmt4
-               TID Cond: (ctid = '(1,1)'::tid)
+         Join Filter: (bmt1.c1 = c1.c1)
          ->  Nested Loop
-               Join Filter: (bmt1.c1 = bmt3.c1)
-               ->  Tid Scan on t3 bmt3
-                     TID Cond: (ctid = '(1,1)'::tid)
+               Join Filter: (bmt1.c1 = bmt4.c1)
                ->  Nested Loop
-                     Join Filter: (bmt1.c1 = bmt2.c1)
-                     ->  Seq Scan on t2 bmt2
-                           Filter: (ctid = '(1,1)'::tid)
+                     Join Filter: (bmt1.c1 = bmt3.c1)
                      ->  Nested Loop
-                           Join Filter: (bmt1.c1 = c1.c1)
+                           Join Filter: (bmt1.c1 = bmt2.c1)
                            ->  Tid Scan on t1 bmt1
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 <> $4)
-                           ->  CTE Scan on c1
-(47 rows)
+                           ->  Seq Scan on t2 bmt2
+                                 Filter: (ctid = '(1,1)'::tid)
+                     ->  Tid Scan on t3 bmt3
+                           TID Cond: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t4 bmt4
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  CTE Scan on c1
+(46 rows)
 
 /*+
 Leading(c1 bmt4 bmt3 bmt2 bmt1)
@@ -2788,8 +2760,6 @@ error hint:
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b1t2.c1 = b1t1.c1)
-                 ->  Tid Scan on t1 b1t1
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Hash Join
                        Hash Cond: (b1t2.c1 = b1t3.c1)
                        ->  Seq Scan on t2 b1t2
@@ -2805,6 +2775,8 @@ error hint:
                                          Sort Key: b1t4.c1
                                          ->  Tid Scan on t4 b1t4
                                                TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t1 b1t1
+                       TID Cond: (ctid = '(1,1)'::tid)
    InitPlan 3 (returns $2)
      ->  Result
            InitPlan 2 (returns $1)
@@ -2822,8 +2794,6 @@ error hint:
                Sort Key: bmt2.c1
                ->  Nested Loop
                      Join Filter: (bmt3.c1 = bmt2.c1)
-                     ->  Seq Scan on t2 bmt2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Hash Join
                            Hash Cond: (bmt3.c1 = bmt4.c1)
                            ->  Tid Scan on t3 bmt3
@@ -2838,6 +2808,8 @@ error hint:
                                        ->  Sort
                                              Sort Key: c1.c1
                                              ->  CTE Scan on c1
+                     ->  Seq Scan on t2 bmt2
+                           Filter: (ctid = '(1,1)'::tid)
          ->  Sort
                Sort Key: bmt1.c1
                ->  Tid Scan on t1 bmt1
@@ -2855,22 +2827,22 @@ EXPLAIN (COSTS false) UPDATE s1.r1 SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
  Aggregate
    ->  Nested Loop
          Join Filter: (t1.c1 = t4.c1)
-         ->  Tid Scan on t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (t1.c1 = t3.c1)
-               ->  Tid Scan on t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (t1.c1 = t2.c1)
-                     ->  Seq Scan on t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r1
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4
+               TID Cond: (ctid = '(1,1)'::tid)
 (19 rows)
 
 /*+
@@ -2913,13 +2885,12 @@ error hint:
                                        Sort Key: t4.c1
                                        ->  Tid Scan on t4
                                              TID Cond: (ctid = '(1,1)'::tid)
-                           ->  Materialize
-                                 ->  Seq Scan on t2
-                                       Filter: (ctid = '(1,1)'::tid)
+                           ->  Seq Scan on t2
+                                 Filter: (ctid = '(1,1)'::tid)
          ->  Tid Scan on r1
                TID Cond: (ctid = '(1,1)'::tid)
                Filter: (c1 = 1)
-(25 rows)
+(24 rows)
 
 EXPLAIN (COSTS false) UPDATE s1.r1_ SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
                            QUERY PLAN                            
@@ -2927,22 +2898,22 @@ EXPLAIN (COSTS false) UPDATE s1.r1_ SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
  Aggregate
    ->  Nested Loop
          Join Filter: (b1t1.c1 = b1t4.c1)
-         ->  Tid Scan on t4 b1t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (b1t1.c1 = b1t3.c1)
-               ->  Tid Scan on t3 b1t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (b1t1.c1 = b1t2.c1)
-                     ->  Seq Scan on t2 b1t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r1_
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1 b1t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2 b1t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 b1t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 b1t4
+               TID Cond: (ctid = '(1,1)'::tid)
 (19 rows)
 
 /*+
@@ -2985,13 +2956,12 @@ error hint:
                                        Sort Key: b1t4.c1
                                        ->  Tid Scan on t4 b1t4
                                              TID Cond: (ctid = '(1,1)'::tid)
-                           ->  Materialize
-                                 ->  Seq Scan on t2 b1t2
-                                       Filter: (ctid = '(1,1)'::tid)
+                           ->  Seq Scan on t2 b1t2
+                                 Filter: (ctid = '(1,1)'::tid)
          ->  Tid Scan on r1_
                TID Cond: (ctid = '(1,1)'::tid)
                Filter: (c1 = 1)
-(25 rows)
+(24 rows)
 
 -- No. J-2-3-2
 EXPLAIN (COSTS false) UPDATE s1.r2 SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
@@ -3000,42 +2970,42 @@ EXPLAIN (COSTS false) UPDATE s1.r2 SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
  Aggregate
    ->  Nested Loop
          Join Filter: (t1.c1 = t4.c1)
-         ->  Tid Scan on t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (t1.c1 = t3.c1)
-               ->  Tid Scan on t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (t1.c1 = t2.c1)
-                     ->  Seq Scan on t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r2
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4
+               TID Cond: (ctid = '(1,1)'::tid)
  
  Aggregate
    ->  Nested Loop
          Join Filter: (t1.c1 = t4.c1)
-         ->  Tid Scan on t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (t1.c1 = t3.c1)
-               ->  Tid Scan on t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (t1.c1 = t2.c1)
-                     ->  Seq Scan on t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r2
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4
+               TID Cond: (ctid = '(1,1)'::tid)
 (39 rows)
 
 /*+
@@ -3089,9 +3059,8 @@ error hint:
                                        Sort Key: t4.c1
                                        ->  Tid Scan on t4
                                              TID Cond: (ctid = '(1,1)'::tid)
-                           ->  Materialize
-                                 ->  Seq Scan on t2
-                                       Filter: (ctid = '(1,1)'::tid)
+                           ->  Seq Scan on t2
+                                 Filter: (ctid = '(1,1)'::tid)
          ->  Tid Scan on r2
                TID Cond: (ctid = '(1,1)'::tid)
                Filter: (c1 = 1)
@@ -3115,13 +3084,12 @@ error hint:
                                        Sort Key: t4.c1
                                        ->  Tid Scan on t4
                                              TID Cond: (ctid = '(1,1)'::tid)
-                           ->  Materialize
-                                 ->  Seq Scan on t2
-                                       Filter: (ctid = '(1,1)'::tid)
+                           ->  Seq Scan on t2
+                                 Filter: (ctid = '(1,1)'::tid)
          ->  Tid Scan on r2
                TID Cond: (ctid = '(1,1)'::tid)
                Filter: (c1 = 1)
-(51 rows)
+(49 rows)
 
 EXPLAIN (COSTS false) UPDATE s1.r2_ SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
                            QUERY PLAN                            
@@ -3129,42 +3097,42 @@ EXPLAIN (COSTS false) UPDATE s1.r2_ SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
  Aggregate
    ->  Nested Loop
          Join Filter: (b1t1.c1 = b1t4.c1)
-         ->  Tid Scan on t4 b1t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (b1t1.c1 = b1t3.c1)
-               ->  Tid Scan on t3 b1t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (b1t1.c1 = b1t2.c1)
-                     ->  Seq Scan on t2 b1t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r2_
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1 b1t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2 b1t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 b1t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 b1t4
+               TID Cond: (ctid = '(1,1)'::tid)
  
  Aggregate
    ->  Nested Loop
          Join Filter: (b2t1.c1 = b2t4.c1)
-         ->  Tid Scan on t4 b2t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (b2t1.c1 = b2t3.c1)
-               ->  Tid Scan on t3 b2t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (b2t1.c1 = b2t2.c1)
-                     ->  Seq Scan on t2 b2t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r2_
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1 b2t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2 b2t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 b2t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 b2t4
+               TID Cond: (ctid = '(1,1)'::tid)
 (39 rows)
 
 /*+
@@ -3218,8 +3186,6 @@ error hint:
    ->  Nested Loop
          ->  Nested Loop
                Join Filter: (b1t1.c1 = b1t4.c1)
-               ->  Tid Scan on t4 b1t4
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Hash Join
                      Hash Cond: (b1t3.c1 = b1t1.c1)
                      ->  Tid Scan on t3 b1t3
@@ -3235,6 +3201,8 @@ error hint:
                                        Sort Key: b1t2.c1
                                        ->  Seq Scan on t2 b1t2
                                              Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t4 b1t4
+                     TID Cond: (ctid = '(1,1)'::tid)
          ->  Tid Scan on r2_
                TID Cond: (ctid = '(1,1)'::tid)
                Filter: (c1 = 1)
@@ -3243,8 +3211,6 @@ error hint:
    ->  Nested Loop
          ->  Nested Loop
                Join Filter: (b2t1.c1 = b2t4.c1)
-               ->  Tid Scan on t4 b2t4
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Hash Join
                      Hash Cond: (b2t3.c1 = b2t1.c1)
                      ->  Tid Scan on t3 b2t3
@@ -3260,6 +3226,8 @@ error hint:
                                        Sort Key: b2t2.c1
                                        ->  Seq Scan on t2 b2t2
                                              Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t4 b2t4
+                     TID Cond: (ctid = '(1,1)'::tid)
          ->  Tid Scan on r2_
                TID Cond: (ctid = '(1,1)'::tid)
                Filter: (c1 = 1)
@@ -3272,62 +3240,62 @@ EXPLAIN (COSTS false) UPDATE s1.r3 SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
  Aggregate
    ->  Nested Loop
          Join Filter: (t1.c1 = t4.c1)
-         ->  Tid Scan on t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (t1.c1 = t3.c1)
-               ->  Tid Scan on t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (t1.c1 = t2.c1)
-                     ->  Seq Scan on t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r3
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4
+               TID Cond: (ctid = '(1,1)'::tid)
  
  Aggregate
    ->  Nested Loop
          Join Filter: (t1.c1 = t4.c1)
-         ->  Tid Scan on t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (t1.c1 = t3.c1)
-               ->  Tid Scan on t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (t1.c1 = t2.c1)
-                     ->  Seq Scan on t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r3
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4
+               TID Cond: (ctid = '(1,1)'::tid)
  
  Aggregate
    ->  Nested Loop
          Join Filter: (t1.c1 = t4.c1)
-         ->  Tid Scan on t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (t1.c1 = t3.c1)
-               ->  Tid Scan on t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (t1.c1 = t2.c1)
-                     ->  Seq Scan on t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r3
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4
+               TID Cond: (ctid = '(1,1)'::tid)
 (59 rows)
 
 /*+
@@ -3392,9 +3360,8 @@ error hint:
                                        Sort Key: t4.c1
                                        ->  Tid Scan on t4
                                              TID Cond: (ctid = '(1,1)'::tid)
-                           ->  Materialize
-                                 ->  Seq Scan on t2
-                                       Filter: (ctid = '(1,1)'::tid)
+                           ->  Seq Scan on t2
+                                 Filter: (ctid = '(1,1)'::tid)
          ->  Tid Scan on r3
                TID Cond: (ctid = '(1,1)'::tid)
                Filter: (c1 = 1)
@@ -3418,9 +3385,8 @@ error hint:
                                        Sort Key: t4.c1
                                        ->  Tid Scan on t4
                                              TID Cond: (ctid = '(1,1)'::tid)
-                           ->  Materialize
-                                 ->  Seq Scan on t2
-                                       Filter: (ctid = '(1,1)'::tid)
+                           ->  Seq Scan on t2
+                                 Filter: (ctid = '(1,1)'::tid)
          ->  Tid Scan on r3
                TID Cond: (ctid = '(1,1)'::tid)
                Filter: (c1 = 1)
@@ -3444,13 +3410,12 @@ error hint:
                                        Sort Key: t4.c1
                                        ->  Tid Scan on t4
                                              TID Cond: (ctid = '(1,1)'::tid)
-                           ->  Materialize
-                                 ->  Seq Scan on t2
-                                       Filter: (ctid = '(1,1)'::tid)
+                           ->  Seq Scan on t2
+                                 Filter: (ctid = '(1,1)'::tid)
          ->  Tid Scan on r3
                TID Cond: (ctid = '(1,1)'::tid)
                Filter: (c1 = 1)
-(77 rows)
+(74 rows)
 
 EXPLAIN (COSTS false) UPDATE s1.r3_ SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
                            QUERY PLAN                            
@@ -3458,62 +3423,62 @@ EXPLAIN (COSTS false) UPDATE s1.r3_ SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
  Aggregate
    ->  Nested Loop
          Join Filter: (b1t1.c1 = b1t4.c1)
-         ->  Tid Scan on t4 b1t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (b1t1.c1 = b1t3.c1)
-               ->  Tid Scan on t3 b1t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (b1t1.c1 = b1t2.c1)
-                     ->  Seq Scan on t2 b1t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r3_
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1 b1t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2 b1t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 b1t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 b1t4
+               TID Cond: (ctid = '(1,1)'::tid)
  
  Aggregate
    ->  Nested Loop
          Join Filter: (b2t1.c1 = b2t4.c1)
-         ->  Tid Scan on t4 b2t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (b2t1.c1 = b2t3.c1)
-               ->  Tid Scan on t3 b2t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (b2t1.c1 = b2t2.c1)
-                     ->  Seq Scan on t2 b2t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r3_
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1 b2t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2 b2t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 b2t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 b2t4
+               TID Cond: (ctid = '(1,1)'::tid)
  
  Aggregate
    ->  Nested Loop
          Join Filter: (b3t1.c1 = b3t4.c1)
-         ->  Tid Scan on t4 b3t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (b3t1.c1 = b3t3.c1)
-               ->  Tid Scan on t3 b3t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (b3t1.c1 = b3t2.c1)
-                     ->  Seq Scan on t2 b3t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r3_
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1 b3t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2 b3t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 b3t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 b3t4
+               TID Cond: (ctid = '(1,1)'::tid)
 (59 rows)
 
 /*+
@@ -3603,8 +3568,6 @@ error hint:
    ->  Nested Loop
          ->  Nested Loop
                Join Filter: (b1t1.c1 = b1t4.c1)
-               ->  Tid Scan on t4 b1t4
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Hash Join
                      Hash Cond: (b1t3.c1 = b1t1.c1)
                      ->  Tid Scan on t3 b1t3
@@ -3620,6 +3583,8 @@ error hint:
                                        Sort Key: b1t2.c1
                                        ->  Seq Scan on t2 b1t2
                                              Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t4 b1t4
+                     TID Cond: (ctid = '(1,1)'::tid)
          ->  Tid Scan on r3_
                TID Cond: (ctid = '(1,1)'::tid)
                Filter: (c1 = 1)
@@ -3628,8 +3593,6 @@ error hint:
    ->  Nested Loop
          ->  Nested Loop
                Join Filter: (b2t1.c1 = b2t4.c1)
-               ->  Tid Scan on t4 b2t4
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Hash Join
                      Hash Cond: (b2t3.c1 = b2t1.c1)
                      ->  Tid Scan on t3 b2t3
@@ -3645,6 +3608,8 @@ error hint:
                                        Sort Key: b2t2.c1
                                        ->  Seq Scan on t2 b2t2
                                              Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t4 b2t4
+                     TID Cond: (ctid = '(1,1)'::tid)
          ->  Tid Scan on r3_
                TID Cond: (ctid = '(1,1)'::tid)
                Filter: (c1 = 1)
@@ -3653,8 +3618,6 @@ error hint:
    ->  Nested Loop
          ->  Nested Loop
                Join Filter: (b3t1.c1 = b3t4.c1)
-               ->  Tid Scan on t4 b3t4
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Hash Join
                      Hash Cond: (b3t3.c1 = b3t1.c1)
                      ->  Tid Scan on t3 b3t3
@@ -3670,6 +3633,8 @@ error hint:
                                        Sort Key: b3t2.c1
                                        ->  Seq Scan on t2 b3t2
                                              Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t4 b3t4
+                     TID Cond: (ctid = '(1,1)'::tid)
          ->  Tid Scan on r3_
                TID Cond: (ctid = '(1,1)'::tid)
                Filter: (c1 = 1)
@@ -4002,15 +3967,14 @@ error hint:
 
 SET enable_mergejoin TO on;
 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1 AND t1.ctid = '(1,1)';;
-                  QUERY PLAN                   
------------------------------------------------
+               QUERY PLAN                
+-----------------------------------------
  Nested Loop
    Join Filter: (t1.c1 = t2.c1)
+   ->  Tid Scan on t1
+         TID Cond: (ctid = '(1,1)'::tid)
    ->  Seq Scan on t2
-   ->  Materialize
-         ->  Tid Scan on t1
-               TID Cond: (ctid = '(1,1)'::tid)
-(6 rows)
+(5 rows)
 
 /*+NoNestLoop(t1 t2)*/
 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1 AND t1.ctid = '(1,1)';;

diff --git a/expected/ut-L.out b/expected/ut-L.out
index bdf67d4..2e3389d 100644 (file)
--- a/expected/ut-L.out
+++ b/expected/ut-L.out
@@ -1219,59 +1219,56 @@ SELECT max(b2t1.c1) FROM s1.t1 b2t1, s1.t2 b2t2, s1.t3 b2t3, s1.t4 b2t4 WHERE b2
 )
                     FROM s1.t1 bmt1, s1.t2 bmt2, s1.t3 bmt3, s1.t4 bmt4 WHERE bmt1.ctid = '(1,1)' AND bmt1.c1 = bmt2.c1 AND bmt2.ctid = '(1,1)' AND bmt1.c1 = bmt3.c1 AND bmt3.ctid = '(1,1)' AND bmt1.c1 = bmt4.c1 AND bmt4.ctid = '(1,1)'
 ;
-                              QUERY PLAN                               
------------------------------------------------------------------------
+                            QUERY PLAN                             
+-------------------------------------------------------------------
  Aggregate
    InitPlan 1 (returns $0)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b1t1.c1 = b1t4.c1)
-                 ->  Tid Scan on t4 b1t4
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b1t1.c1 = b1t3.c1)
-                       ->  Tid Scan on t3 b1t3
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b1t1.c1 = b1t2.c1)
                              ->  Tid Scan on t1 b1t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Seq Scan on t2 b1t2
-                                         Filter: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b1t2
+                                   Filter: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t3 b1t3
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t4 b1t4
+                       TID Cond: (ctid = '(1,1)'::tid)
    InitPlan 2 (returns $1)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b2t1.c1 = b2t4.c1)
-                 ->  Tid Scan on t4 b2t4
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b2t1.c1 = b2t3.c1)
-                       ->  Tid Scan on t3 b2t3
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b2t1.c1 = b2t2.c1)
                              ->  Tid Scan on t1 b2t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Seq Scan on t2 b2t2
-                                         Filter: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b2t2
+                                   Filter: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t3 b2t3
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t4 b2t4
+                       TID Cond: (ctid = '(1,1)'::tid)
    ->  Nested Loop
          Join Filter: (bmt1.c1 = bmt4.c1)
-         ->  Tid Scan on t4 bmt4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (bmt1.c1 = bmt3.c1)
-               ->  Tid Scan on t3 bmt3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (bmt1.c1 = bmt2.c1)
                      ->  Tid Scan on t1 bmt1
                            TID Cond: (ctid = '(1,1)'::tid)
-                     ->  Materialize
-                           ->  Seq Scan on t2 bmt2
-                                 Filter: (ctid = '(1,1)'::tid)
-(50 rows)
+                     ->  Seq Scan on t2 bmt2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 bmt3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 bmt4
+               TID Cond: (ctid = '(1,1)'::tid)
+(47 rows)
 
 /*+
 Leading(bmt1 bmt2 bmt3 bmt4)
@@ -1295,59 +1292,56 @@ not used hint:
 duplication hint:
 error hint:
 
-                               QUERY PLAN                                
--------------------------------------------------------------------------
+                            QUERY PLAN                             
+-------------------------------------------------------------------
  Aggregate
    InitPlan 1 (returns $0)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b1t2.c1 = b1t1.c1)
-                 ->  Tid Scan on t1 b1t1
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b1t2.c1 = b1t4.c1)
-                       ->  Tid Scan on t4 b1t4
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b1t2.c1 = b1t3.c1)
                              ->  Seq Scan on t2 b1t2
                                    Filter: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Tid Scan on t3 b1t3
-                                         TID Cond: (ctid = '(1,1)'::tid)
+                             ->  Tid Scan on t3 b1t3
+                                   TID Cond: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t4 b1t4
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t1 b1t1
+                       TID Cond: (ctid = '(1,1)'::tid)
    InitPlan 2 (returns $1)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b2t1.c1 = b2t2.c1)
-                 ->  Seq Scan on t2 b2t2
-                       Filter: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b2t3.c1 = b2t1.c1)
-                       ->  Tid Scan on t1 b2t1
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b2t3.c1 = b2t4.c1)
                              ->  Tid Scan on t3 b2t3
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Tid Scan on t4 b2t4
-                                         TID Cond: (ctid = '(1,1)'::tid)
+                             ->  Tid Scan on t4 b2t4
+                                   TID Cond: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t1 b2t1
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Seq Scan on t2 b2t2
+                       Filter: (ctid = '(1,1)'::tid)
    ->  Nested Loop
          Join Filter: (bmt1.c1 = bmt4.c1)
-         ->  Tid Scan on t4 bmt4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (bmt1.c1 = bmt3.c1)
-               ->  Tid Scan on t3 bmt3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (bmt1.c1 = bmt2.c1)
                      ->  Tid Scan on t1 bmt1
                            TID Cond: (ctid = '(1,1)'::tid)
-                     ->  Materialize
-                           ->  Seq Scan on t2 bmt2
-                                 Filter: (ctid = '(1,1)'::tid)
-(50 rows)
+                     ->  Seq Scan on t2 bmt2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 bmt3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 bmt4
+               TID Cond: (ctid = '(1,1)'::tid)
+(47 rows)
 
 -- No. L-2-1-2
 EXPLAIN (COSTS false)
@@ -1360,76 +1354,72 @@ SELECT max(b3t1.c1) FROM s1.t1 b3t1, s1.t2 b3t2, s1.t3 b3t3, s1.t4 b3t4 WHERE b3
 )
                     FROM s1.t1 bmt1, s1.t2 bmt2, s1.t3 bmt3, s1.t4 bmt4 WHERE bmt1.ctid = '(1,1)' AND bmt1.c1 = bmt2.c1 AND bmt2.ctid = '(1,1)' AND bmt1.c1 = bmt3.c1 AND bmt3.ctid = '(1,1)' AND bmt1.c1 = bmt4.c1 AND bmt4.ctid = '(1,1)'
 ;
-                              QUERY PLAN                               
------------------------------------------------------------------------
+                            QUERY PLAN                             
+-------------------------------------------------------------------
  Aggregate
    InitPlan 1 (returns $0)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b1t1.c1 = b1t4.c1)
-                 ->  Tid Scan on t4 b1t4
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b1t1.c1 = b1t3.c1)
-                       ->  Tid Scan on t3 b1t3
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b1t1.c1 = b1t2.c1)
                              ->  Tid Scan on t1 b1t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Seq Scan on t2 b1t2
-                                         Filter: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b1t2
+                                   Filter: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t3 b1t3
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t4 b1t4
+                       TID Cond: (ctid = '(1,1)'::tid)
    InitPlan 2 (returns $1)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b2t1.c1 = b2t4.c1)
-                 ->  Tid Scan on t4 b2t4
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b2t1.c1 = b2t3.c1)
-                       ->  Tid Scan on t3 b2t3
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b2t1.c1 = b2t2.c1)
                              ->  Tid Scan on t1 b2t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Seq Scan on t2 b2t2
-                                         Filter: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b2t2
+                                   Filter: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t3 b2t3
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t4 b2t4
+                       TID Cond: (ctid = '(1,1)'::tid)
    InitPlan 3 (returns $2)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b3t1.c1 = b3t4.c1)
-                 ->  Tid Scan on t4 b3t4
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b3t1.c1 = b3t3.c1)
-                       ->  Tid Scan on t3 b3t3
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b3t1.c1 = b3t2.c1)
                              ->  Tid Scan on t1 b3t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Seq Scan on t2 b3t2
-                                         Filter: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b3t2
+                                   Filter: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t3 b3t3
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t4 b3t4
+                       TID Cond: (ctid = '(1,1)'::tid)
    ->  Nested Loop
          Join Filter: (bmt1.c1 = bmt4.c1)
-         ->  Tid Scan on t4 bmt4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (bmt1.c1 = bmt3.c1)
-               ->  Tid Scan on t3 bmt3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (bmt1.c1 = bmt2.c1)
                      ->  Tid Scan on t1 bmt1
                            TID Cond: (ctid = '(1,1)'::tid)
-                     ->  Materialize
-                           ->  Seq Scan on t2 bmt2
-                                 Filter: (ctid = '(1,1)'::tid)
-(67 rows)
+                     ->  Seq Scan on t2 bmt2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 bmt3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 bmt4
+               TID Cond: (ctid = '(1,1)'::tid)
+(63 rows)
 
 /*+
 Leading(bmt1 bmt2 bmt3 bmt4)
@@ -1457,98 +1447,93 @@ not used hint:
 duplication hint:
 error hint:
 
-                               QUERY PLAN                                
--------------------------------------------------------------------------
+                            QUERY PLAN                             
+-------------------------------------------------------------------
  Aggregate
    InitPlan 1 (returns $0)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b1t2.c1 = b1t1.c1)
-                 ->  Tid Scan on t1 b1t1
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b1t2.c1 = b1t4.c1)
-                       ->  Tid Scan on t4 b1t4
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b1t2.c1 = b1t3.c1)
                              ->  Seq Scan on t2 b1t2
                                    Filter: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Tid Scan on t3 b1t3
-                                         TID Cond: (ctid = '(1,1)'::tid)
+                             ->  Tid Scan on t3 b1t3
+                                   TID Cond: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t4 b1t4
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t1 b1t1
+                       TID Cond: (ctid = '(1,1)'::tid)
    InitPlan 2 (returns $1)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b2t1.c1 = b2t2.c1)
-                 ->  Seq Scan on t2 b2t2
-                       Filter: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b2t3.c1 = b2t1.c1)
-                       ->  Tid Scan on t1 b2t1
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b2t3.c1 = b2t4.c1)
                              ->  Tid Scan on t3 b2t3
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Tid Scan on t4 b2t4
-                                         TID Cond: (ctid = '(1,1)'::tid)
+                             ->  Tid Scan on t4 b2t4
+                                   TID Cond: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t1 b2t1
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Seq Scan on t2 b2t2
+                       Filter: (ctid = '(1,1)'::tid)
    InitPlan 3 (returns $2)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b3t1.c1 = b3t3.c1)
-                 ->  Tid Scan on t3 b3t3
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b3t1.c1 = b3t2.c1)
-                       ->  Seq Scan on t2 b3t2
-                             Filter: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b3t1.c1 = b3t4.c1)
                              ->  Tid Scan on t1 b3t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Tid Scan on t4 b3t4
-                                         TID Cond: (ctid = '(1,1)'::tid)
+                             ->  Tid Scan on t4 b3t4
+                                   TID Cond: (ctid = '(1,1)'::tid)
+                       ->  Seq Scan on t2 b3t2
+                             Filter: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t3 b3t3
+                       TID Cond: (ctid = '(1,1)'::tid)
    ->  Nested Loop
          Join Filter: (bmt1.c1 = bmt4.c1)
-         ->  Tid Scan on t4 bmt4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (bmt1.c1 = bmt3.c1)
-               ->  Tid Scan on t3 bmt3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (bmt1.c1 = bmt2.c1)
                      ->  Tid Scan on t1 bmt1
                            TID Cond: (ctid = '(1,1)'::tid)
-                     ->  Materialize
-                           ->  Seq Scan on t2 bmt2
-                                 Filter: (ctid = '(1,1)'::tid)
-(67 rows)
+                     ->  Seq Scan on t2 bmt2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 bmt3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 bmt4
+               TID Cond: (ctid = '(1,1)'::tid)
+(63 rows)
 
 -- No. L-2-1-3
 EXPLAIN (COSTS false) SELECT max(bmt1.c1) FROM s1.t1 bmt1, s1.t2 bmt2, (SELECT ctid, * FROM s1.t3 bmt3) sbmt3, (SELECT ctid, * FROM s1.t4 bmt4) sbmt4 WHERE bmt1.ctid = '(1,1)' AND bmt1.c1 = bmt2.c1 AND bmt2.ctid = '(1,1)' AND bmt1.c1 = sbmt3.c1 AND sbmt3.ctid = '(1,1)' AND bmt1.c1 = sbmt4.c1 AND sbmt4.ctid = '(1,1)';
-                          QUERY PLAN                           
----------------------------------------------------------------
+                        QUERY PLAN                         
+-----------------------------------------------------------
  Aggregate
    ->  Nested Loop
          Join Filter: (bmt1.c1 = bmt4.c1)
-         ->  Tid Scan on t4 bmt4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (bmt1.c1 = bmt3.c1)
-               ->  Tid Scan on t3 bmt3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (bmt1.c1 = bmt2.c1)
                      ->  Tid Scan on t1 bmt1
                            TID Cond: (ctid = '(1,1)'::tid)
-                     ->  Materialize
-                           ->  Seq Scan on t2 bmt2
-                                 Filter: (ctid = '(1,1)'::tid)
-(16 rows)
+                     ->  Seq Scan on t2 bmt2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 bmt3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 bmt4
+               TID Cond: (ctid = '(1,1)'::tid)
+(15 rows)
 
 /*+
 Leading(bmt4 bmt3 bmt2 bmt1)
@@ -1561,47 +1546,45 @@ not used hint:
 duplication hint:
 error hint:
 
-                           QUERY PLAN                            
------------------------------------------------------------------
+                        QUERY PLAN                         
+-----------------------------------------------------------
  Aggregate
    ->  Nested Loop
          Join Filter: (bmt2.c1 = bmt1.c1)
-         ->  Tid Scan on t1 bmt1
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (bmt3.c1 = bmt2.c1)
-               ->  Seq Scan on t2 bmt2
-                     Filter: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (bmt3.c1 = bmt4.c1)
                      ->  Tid Scan on t3 bmt3
                            TID Cond: (ctid = '(1,1)'::tid)
-                     ->  Materialize
-                           ->  Tid Scan on t4 bmt4
-                                 TID Cond: (ctid = '(1,1)'::tid)
-(16 rows)
+                     ->  Tid Scan on t4 bmt4
+                           TID Cond: (ctid = '(1,1)'::tid)
+               ->  Seq Scan on t2 bmt2
+                     Filter: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t1 bmt1
+               TID Cond: (ctid = '(1,1)'::tid)
+(15 rows)
 
 -- No. L-2-1-4
 EXPLAIN (COSTS false) SELECT max(bmt1.c1) FROM s1.t1 bmt1, (SELECT ctid, * FROM s1.t2 bmt2) sbmt2, (SELECT ctid, * FROM s1.t3 bmt3) sbmt3, (SELECT ctid, * FROM s1.t4 bmt4) sbmt4 WHERE bmt1.ctid = '(1,1)' AND bmt1.c1 = sbmt2.c1 AND sbmt2.ctid = '(1,1)' AND bmt1.c1 = sbmt3.c1 AND sbmt3.ctid = '(1,1)' AND bmt1.c1 = sbmt4.c1 AND sbmt4.ctid = '(1,1)';
-                          QUERY PLAN                           
----------------------------------------------------------------
+                        QUERY PLAN                         
+-----------------------------------------------------------
  Aggregate
    ->  Nested Loop
          Join Filter: (bmt1.c1 = bmt4.c1)
-         ->  Tid Scan on t4 bmt4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (bmt1.c1 = bmt3.c1)
-               ->  Tid Scan on t3 bmt3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (bmt1.c1 = bmt2.c1)
                      ->  Tid Scan on t1 bmt1
                            TID Cond: (ctid = '(1,1)'::tid)
-                     ->  Materialize
-                           ->  Seq Scan on t2 bmt2
-                                 Filter: (ctid = '(1,1)'::tid)
-(16 rows)
+                     ->  Seq Scan on t2 bmt2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 bmt3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 bmt4
+               TID Cond: (ctid = '(1,1)'::tid)
+(15 rows)
 
 /*+
 Leading(bmt4 bmt3 bmt2 bmt1)
@@ -1614,25 +1597,24 @@ not used hint:
 duplication hint:
 error hint:
 
-                           QUERY PLAN                            
------------------------------------------------------------------
+                        QUERY PLAN                         
+-----------------------------------------------------------
  Aggregate
    ->  Nested Loop
          Join Filter: (bmt2.c1 = bmt1.c1)
-         ->  Tid Scan on t1 bmt1
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (bmt3.c1 = bmt2.c1)
-               ->  Seq Scan on t2 bmt2
-                     Filter: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (bmt3.c1 = bmt4.c1)
                      ->  Tid Scan on t3 bmt3
                            TID Cond: (ctid = '(1,1)'::tid)
-                     ->  Materialize
-                           ->  Tid Scan on t4 bmt4
-                                 TID Cond: (ctid = '(1,1)'::tid)
-(16 rows)
+                     ->  Tid Scan on t4 bmt4
+                           TID Cond: (ctid = '(1,1)'::tid)
+               ->  Seq Scan on t2 bmt2
+                     Filter: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t1 bmt1
+               TID Cond: (ctid = '(1,1)'::tid)
+(15 rows)
 
 -- No. L-2-1-5
 EXPLAIN (COSTS false)
@@ -1643,60 +1625,57 @@ SELECT max(b1t1.c1) FROM s1.t1 b1t1, s1.t2 b1t2, s1.t3 b1t3, s1.t4 b1t4 WHERE b1
 SELECT max(b2t1.c1) FROM s1.t1 b2t1, s1.t2 b2t2, s1.t3 b2t3, s1.t4 b2t4 WHERE b2t1.ctid = '(1,1)' AND b2t1.c1 = b2t2.c1 AND b2t2.ctid = '(1,1)' AND b2t1.c1 = b2t3.c1 AND b2t3.ctid = '(1,1)' AND b2t1.c1 = b2t4.c1 AND b2t4.ctid = '(1,1)'
 )
 ;
-                              QUERY PLAN                               
------------------------------------------------------------------------
+                            QUERY PLAN                             
+-------------------------------------------------------------------
  Aggregate
    InitPlan 1 (returns $0)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b1t1.c1 = b1t4.c1)
-                 ->  Tid Scan on t4 b1t4
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b1t1.c1 = b1t3.c1)
-                       ->  Tid Scan on t3 b1t3
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b1t1.c1 = b1t2.c1)
                              ->  Tid Scan on t1 b1t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Seq Scan on t2 b1t2
-                                         Filter: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b1t2
+                                   Filter: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t3 b1t3
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t4 b1t4
+                       TID Cond: (ctid = '(1,1)'::tid)
    InitPlan 2 (returns $1)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b2t1.c1 = b2t4.c1)
-                 ->  Tid Scan on t4 b2t4
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b2t1.c1 = b2t3.c1)
-                       ->  Tid Scan on t3 b2t3
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b2t1.c1 = b2t2.c1)
                              ->  Tid Scan on t1 b2t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Seq Scan on t2 b2t2
-                                         Filter: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b2t2
+                                   Filter: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t3 b2t3
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t4 b2t4
+                       TID Cond: (ctid = '(1,1)'::tid)
    ->  Nested Loop
          Join Filter: (bmt1.c1 = bmt4.c1)
-         ->  Tid Scan on t4 bmt4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (bmt1.c1 = bmt3.c1)
-               ->  Tid Scan on t3 bmt3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (bmt1.c1 = bmt2.c1)
                      ->  Tid Scan on t1 bmt1
                            TID Cond: (ctid = '(1,1)'::tid)
                            Filter: ((c1 <> $0) AND (c1 <> $1))
-                     ->  Materialize
-                           ->  Seq Scan on t2 bmt2
-                                 Filter: (ctid = '(1,1)'::tid)
-(51 rows)
+                     ->  Seq Scan on t2 bmt2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 bmt3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 bmt4
+               TID Cond: (ctid = '(1,1)'::tid)
+(48 rows)
 
 /*+
 Leading(bmt1 bmt2 bmt3 bmt4)
@@ -1720,60 +1699,57 @@ not used hint:
 duplication hint:
 error hint:
 
-                               QUERY PLAN                                
--------------------------------------------------------------------------
+                            QUERY PLAN                             
+-------------------------------------------------------------------
  Aggregate
    InitPlan 1 (returns $0)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b1t2.c1 = b1t1.c1)
-                 ->  Tid Scan on t1 b1t1
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b1t2.c1 = b1t4.c1)
-                       ->  Tid Scan on t4 b1t4
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b1t2.c1 = b1t3.c1)
                              ->  Seq Scan on t2 b1t2
                                    Filter: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Tid Scan on t3 b1t3
-                                         TID Cond: (ctid = '(1,1)'::tid)
+                             ->  Tid Scan on t3 b1t3
+                                   TID Cond: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t4 b1t4
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t1 b1t1
+                       TID Cond: (ctid = '(1,1)'::tid)
    InitPlan 2 (returns $1)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b2t1.c1 = b2t2.c1)
-                 ->  Seq Scan on t2 b2t2
-                       Filter: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b2t3.c1 = b2t1.c1)
-                       ->  Tid Scan on t1 b2t1
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b2t3.c1 = b2t4.c1)
                              ->  Tid Scan on t3 b2t3
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Tid Scan on t4 b2t4
-                                         TID Cond: (ctid = '(1,1)'::tid)
+                             ->  Tid Scan on t4 b2t4
+                                   TID Cond: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t1 b2t1
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Seq Scan on t2 b2t2
+                       Filter: (ctid = '(1,1)'::tid)
    ->  Nested Loop
          Join Filter: (bmt1.c1 = bmt4.c1)
-         ->  Tid Scan on t4 bmt4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (bmt1.c1 = bmt3.c1)
-               ->  Tid Scan on t3 bmt3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (bmt1.c1 = bmt2.c1)
                      ->  Tid Scan on t1 bmt1
                            TID Cond: (ctid = '(1,1)'::tid)
                            Filter: ((c1 <> $0) AND (c1 <> $1))
-                     ->  Materialize
-                           ->  Seq Scan on t2 bmt2
-                                 Filter: (ctid = '(1,1)'::tid)
-(51 rows)
+                     ->  Seq Scan on t2 bmt2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 bmt3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 bmt4
+               TID Cond: (ctid = '(1,1)'::tid)
+(48 rows)
 
 -- No. L-2-1-6
 EXPLAIN (COSTS false)
@@ -1793,70 +1769,66 @@ SELECT max(b3t1.c1) FROM s1.t1 b3t1, s1.t2 b3t2, s1.t3 b3t3, s1.t4 b3t4 WHERE b3
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b1t1.c1 = b1t4.c1)
-                 ->  Tid Scan on t4 b1t4
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b1t1.c1 = b1t3.c1)
-                       ->  Tid Scan on t3 b1t3
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b1t1.c1 = b1t2.c1)
                              ->  Tid Scan on t1 b1t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Seq Scan on t2 b1t2
-                                         Filter: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b1t2
+                                   Filter: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t3 b1t3
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t4 b1t4
+                       TID Cond: (ctid = '(1,1)'::tid)
    InitPlan 2 (returns $1)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b2t1.c1 = b2t4.c1)
-                 ->  Tid Scan on t4 b2t4
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b2t1.c1 = b2t3.c1)
-                       ->  Tid Scan on t3 b2t3
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b2t1.c1 = b2t2.c1)
                              ->  Tid Scan on t1 b2t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Seq Scan on t2 b2t2
-                                         Filter: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b2t2
+                                   Filter: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t3 b2t3
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t4 b2t4
+                       TID Cond: (ctid = '(1,1)'::tid)
    InitPlan 3 (returns $2)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b3t1.c1 = b3t4.c1)
-                 ->  Tid Scan on t4 b3t4
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b3t1.c1 = b3t3.c1)
-                       ->  Tid Scan on t3 b3t3
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b3t1.c1 = b3t2.c1)
                              ->  Tid Scan on t1 b3t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Seq Scan on t2 b3t2
-                                         Filter: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b3t2
+                                   Filter: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t3 b3t3
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t4 b3t4
+                       TID Cond: (ctid = '(1,1)'::tid)
    ->  Nested Loop
          Join Filter: (bmt1.c1 = bmt4.c1)
-         ->  Tid Scan on t4 bmt4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (bmt1.c1 = bmt3.c1)
-               ->  Tid Scan on t3 bmt3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (bmt1.c1 = bmt2.c1)
                      ->  Tid Scan on t1 bmt1
                            TID Cond: (ctid = '(1,1)'::tid)
                            Filter: ((c1 <> $0) AND (c1 <> $1) AND (c1 <> $2))
-                     ->  Materialize
-                           ->  Seq Scan on t2 bmt2
-                                 Filter: (ctid = '(1,1)'::tid)
-(68 rows)
+                     ->  Seq Scan on t2 bmt2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 bmt3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 bmt4
+               TID Cond: (ctid = '(1,1)'::tid)
+(64 rows)
 
 /*+
 Leading(bmt1 bmt2 bmt3 bmt4)
@@ -1891,70 +1863,66 @@ error hint:
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b1t2.c1 = b1t1.c1)
-                 ->  Tid Scan on t1 b1t1
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b1t2.c1 = b1t4.c1)
-                       ->  Tid Scan on t4 b1t4
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b1t2.c1 = b1t3.c1)
                              ->  Seq Scan on t2 b1t2
                                    Filter: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Tid Scan on t3 b1t3
-                                         TID Cond: (ctid = '(1,1)'::tid)
+                             ->  Tid Scan on t3 b1t3
+                                   TID Cond: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t4 b1t4
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t1 b1t1
+                       TID Cond: (ctid = '(1,1)'::tid)
    InitPlan 2 (returns $1)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b2t1.c1 = b2t2.c1)
-                 ->  Seq Scan on t2 b2t2
-                       Filter: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b2t3.c1 = b2t1.c1)
-                       ->  Tid Scan on t1 b2t1
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b2t3.c1 = b2t4.c1)
                              ->  Tid Scan on t3 b2t3
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Tid Scan on t4 b2t4
-                                         TID Cond: (ctid = '(1,1)'::tid)
+                             ->  Tid Scan on t4 b2t4
+                                   TID Cond: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t1 b2t1
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Seq Scan on t2 b2t2
+                       Filter: (ctid = '(1,1)'::tid)
    InitPlan 3 (returns $2)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b3t1.c1 = b3t3.c1)
-                 ->  Tid Scan on t3 b3t3
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b3t1.c1 = b3t2.c1)
-                       ->  Seq Scan on t2 b3t2
-                             Filter: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b3t1.c1 = b3t4.c1)
                              ->  Tid Scan on t1 b3t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Tid Scan on t4 b3t4
-                                         TID Cond: (ctid = '(1,1)'::tid)
+                             ->  Tid Scan on t4 b3t4
+                                   TID Cond: (ctid = '(1,1)'::tid)
+                       ->  Seq Scan on t2 b3t2
+                             Filter: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t3 b3t3
+                       TID Cond: (ctid = '(1,1)'::tid)
    ->  Nested Loop
          Join Filter: (bmt1.c1 = bmt4.c1)
-         ->  Tid Scan on t4 bmt4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (bmt1.c1 = bmt3.c1)
-               ->  Tid Scan on t3 bmt3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (bmt1.c1 = bmt2.c1)
                      ->  Tid Scan on t1 bmt1
                            TID Cond: (ctid = '(1,1)'::tid)
                            Filter: ((c1 <> $0) AND (c1 <> $1) AND (c1 <> $2))
-                     ->  Materialize
-                           ->  Seq Scan on t2 bmt2
-                                 Filter: (ctid = '(1,1)'::tid)
-(68 rows)
+                     ->  Seq Scan on t2 bmt2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 bmt3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 bmt4
+               TID Cond: (ctid = '(1,1)'::tid)
+(64 rows)
 
 -- No. L-2-1-7
 EXPLAIN (COSTS false)
@@ -1977,57 +1945,55 @@ AND bmt1.c1 = c2.c1
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b1t1.c1 = b1t4.c1)
-                 ->  Tid Scan on t4 b1t4
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b1t1.c1 = b1t3.c1)
-                       ->  Tid Scan on t3 b1t3
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b1t1.c1 = b1t2.c1)
                              ->  Tid Scan on t1 b1t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Seq Scan on t2 b1t2
-                                         Filter: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b1t2
+                                   Filter: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t3 b1t3
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t4 b1t4
+                       TID Cond: (ctid = '(1,1)'::tid)
    CTE c2
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b2t1.c1 = b2t4.c1)
-                 ->  Tid Scan on t4 b2t4
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b2t1.c1 = b2t3.c1)
-                       ->  Tid Scan on t3 b2t3
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b2t1.c1 = b2t2.c1)
                              ->  Tid Scan on t1 b2t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Seq Scan on t2 b2t2
-                                         Filter: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b2t2
+                                   Filter: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t3 b2t3
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t4 b2t4
+                       TID Cond: (ctid = '(1,1)'::tid)
    ->  Nested Loop
          Join Filter: (bmt1.c1 = c2.c1)
          ->  Nested Loop
-               Join Filter: (bmt1.c1 = bmt4.c1)
-               ->  Tid Scan on t4 bmt4
-                     TID Cond: (ctid = '(1,1)'::tid)
+               Join Filter: (bmt1.c1 = c1.c1)
                ->  Nested Loop
-                     Join Filter: (bmt1.c1 = bmt3.c1)
-                     ->  Tid Scan on t3 bmt3
-                           TID Cond: (ctid = '(1,1)'::tid)
+                     Join Filter: (bmt1.c1 = bmt4.c1)
                      ->  Nested Loop
-                           Join Filter: (bmt1.c1 = bmt2.c1)
-                           ->  Seq Scan on t2 bmt2
-                                 Filter: (ctid = '(1,1)'::tid)
+                           Join Filter: (bmt1.c1 = bmt3.c1)
                            ->  Nested Loop
-                                 Join Filter: (bmt1.c1 = c1.c1)
+                                 Join Filter: (bmt1.c1 = bmt2.c1)
                                  ->  Tid Scan on t1 bmt1
                                        TID Cond: (ctid = '(1,1)'::tid)
-                                 ->  CTE Scan on c1
+                                 ->  Seq Scan on t2 bmt2
+                                       Filter: (ctid = '(1,1)'::tid)
+                           ->  Tid Scan on t3 bmt3
+                                 TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Tid Scan on t4 bmt4
+                           TID Cond: (ctid = '(1,1)'::tid)
+               ->  CTE Scan on c1
          ->  CTE Scan on c2
-(55 rows)
+(53 rows)
 
 /*+
 Leading(c2 c1 bmt1 bmt2 bmt3 bmt4)
@@ -2056,64 +2022,62 @@ not used hint:
 duplication hint:
 error hint:
 
-                               QUERY PLAN                                
--------------------------------------------------------------------------
+                            QUERY PLAN                             
+-------------------------------------------------------------------
  Aggregate
    CTE c1
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b1t2.c1 = b1t1.c1)
-                 ->  Tid Scan on t1 b1t1
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b1t2.c1 = b1t4.c1)
-                       ->  Tid Scan on t4 b1t4
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b1t2.c1 = b1t3.c1)
                              ->  Seq Scan on t2 b1t2
                                    Filter: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Tid Scan on t3 b1t3
-                                         TID Cond: (ctid = '(1,1)'::tid)
+                             ->  Tid Scan on t3 b1t3
+                                   TID Cond: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t4 b1t4
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t1 b1t1
+                       TID Cond: (ctid = '(1,1)'::tid)
    CTE c2
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b2t1.c1 = b2t2.c1)
-                 ->  Seq Scan on t2 b2t2
-                       Filter: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b2t3.c1 = b2t1.c1)
-                       ->  Tid Scan on t1 b2t1
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b2t3.c1 = b2t4.c1)
                              ->  Tid Scan on t3 b2t3
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Tid Scan on t4 b2t4
-                                         TID Cond: (ctid = '(1,1)'::tid)
+                             ->  Tid Scan on t4 b2t4
+                                   TID Cond: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t1 b2t1
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Seq Scan on t2 b2t2
+                       Filter: (ctid = '(1,1)'::tid)
    ->  Nested Loop
          Join Filter: (bmt1.c1 = bmt4.c1)
-         ->  Tid Scan on t4 bmt4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (bmt1.c1 = bmt3.c1)
-               ->  Tid Scan on t3 bmt3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (bmt1.c1 = bmt2.c1)
-                     ->  Seq Scan on t2 bmt2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            Join Filter: (c1.c1 = bmt1.c1)
-                           ->  Tid Scan on t1 bmt1
-                                 TID Cond: (ctid = '(1,1)'::tid)
                            ->  Nested Loop
                                  Join Filter: (c1.c1 = c2.c1)
                                  ->  CTE Scan on c1
                                  ->  CTE Scan on c2
-(55 rows)
+                           ->  Tid Scan on t1 bmt1
+                                 TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2 bmt2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 bmt3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 bmt4
+               TID Cond: (ctid = '(1,1)'::tid)
+(53 rows)
 
 -- No. L-2-1-8
 EXPLAIN (COSTS false)
@@ -2140,77 +2104,74 @@ AND bmt1.c1 = c3.c1
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b1t1.c1 = b1t4.c1)
-                 ->  Tid Scan on t4 b1t4
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b1t1.c1 = b1t3.c1)
-                       ->  Tid Scan on t3 b1t3
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b1t1.c1 = b1t2.c1)
                              ->  Tid Scan on t1 b1t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Seq Scan on t2 b1t2
-                                         Filter: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b1t2
+                                   Filter: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t3 b1t3
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t4 b1t4
+                       TID Cond: (ctid = '(1,1)'::tid)
    CTE c2
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b2t1.c1 = b2t4.c1)
-                 ->  Tid Scan on t4 b2t4
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b2t1.c1 = b2t3.c1)
-                       ->  Tid Scan on t3 b2t3
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b2t1.c1 = b2t2.c1)
                              ->  Tid Scan on t1 b2t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Seq Scan on t2 b2t2
-                                         Filter: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b2t2
+                                   Filter: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t3 b2t3
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t4 b2t4
+                       TID Cond: (ctid = '(1,1)'::tid)
    CTE c3
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b3t1.c1 = b3t4.c1)
-                 ->  Tid Scan on t4 b3t4
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b3t1.c1 = b3t3.c1)
-                       ->  Tid Scan on t3 b3t3
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b3t1.c1 = b3t2.c1)
                              ->  Tid Scan on t1 b3t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Seq Scan on t2 b3t2
-                                         Filter: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b3t2
+                                   Filter: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t3 b3t3
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t4 b3t4
+                       TID Cond: (ctid = '(1,1)'::tid)
    ->  Nested Loop
          Join Filter: (bmt1.c1 = c3.c1)
          ->  Nested Loop
                Join Filter: (bmt1.c1 = c2.c1)
                ->  Nested Loop
-                     Join Filter: (bmt1.c1 = bmt4.c1)
-                     ->  Tid Scan on t4 bmt4
-                           TID Cond: (ctid = '(1,1)'::tid)
+                     Join Filter: (bmt1.c1 = c1.c1)
                      ->  Nested Loop
-                           Join Filter: (bmt1.c1 = bmt3.c1)
-                           ->  Tid Scan on t3 bmt3
-                                 TID Cond: (ctid = '(1,1)'::tid)
+                           Join Filter: (bmt1.c1 = bmt4.c1)
                            ->  Nested Loop
-                                 Join Filter: (bmt1.c1 = bmt2.c1)
-                                 ->  Seq Scan on t2 bmt2
-                                       Filter: (ctid = '(1,1)'::tid)
+                                 Join Filter: (bmt1.c1 = bmt3.c1)
                                  ->  Nested Loop
-                                       Join Filter: (bmt1.c1 = c1.c1)
+                                       Join Filter: (bmt1.c1 = bmt2.c1)
                                        ->  Tid Scan on t1 bmt1
                                              TID Cond: (ctid = '(1,1)'::tid)
-                                       ->  CTE Scan on c1
+                                       ->  Seq Scan on t2 bmt2
+                                             Filter: (ctid = '(1,1)'::tid)
+                                 ->  Tid Scan on t3 bmt3
+                                       TID Cond: (ctid = '(1,1)'::tid)
+                           ->  Tid Scan on t4 bmt4
+                                 TID Cond: (ctid = '(1,1)'::tid)
+                     ->  CTE Scan on c1
                ->  CTE Scan on c2
          ->  CTE Scan on c3
-(75 rows)
+(72 rows)
 
 /*+
 Leading(c3 c2 c1 bmt1 bmt2 bmt3 bmt4)
@@ -2245,76 +2206,65 @@ not used hint:
 duplication hint:
 error hint:
 
-                               QUERY PLAN                                
--------------------------------------------------------------------------
+                             QUERY PLAN                             
+--------------------------------------------------------------------
  Aggregate
    CTE c1
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b1t2.c1 = b1t1.c1)
-                 ->  Tid Scan on t1 b1t1
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b1t2.c1 = b1t4.c1)
-                       ->  Tid Scan on t4 b1t4
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b1t2.c1 = b1t3.c1)
                              ->  Seq Scan on t2 b1t2
                                    Filter: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Tid Scan on t3 b1t3
-                                         TID Cond: (ctid = '(1,1)'::tid)
+                             ->  Tid Scan on t3 b1t3
+                                   TID Cond: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t4 b1t4
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t1 b1t1
+                       TID Cond: (ctid = '(1,1)'::tid)
    CTE c2
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b2t1.c1 = b2t2.c1)
-                 ->  Seq Scan on t2 b2t2
-                       Filter: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b2t3.c1 = b2t1.c1)
-                       ->  Tid Scan on t1 b2t1
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b2t3.c1 = b2t4.c1)
                              ->  Tid Scan on t3 b2t3
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Tid Scan on t4 b2t4
-                                         TID Cond: (ctid = '(1,1)'::tid)
+                             ->  Tid Scan on t4 b2t4
+                                   TID Cond: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t1 b2t1
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Seq Scan on t2 b2t2
+                       Filter: (ctid = '(1,1)'::tid)
    CTE c3
      ->  Aggregate
            ->  Nested Loop
-                 Join Filter: (b3t1.c1 = b3t3.c1)
-                 ->  Tid Scan on t3 b3t3
-                       TID Cond: (ctid = '(1,1)'::tid)
+                 Join Filter: (b3t1.c1 = b3t3.c1)
                  ->  Nested Loop
                        Join Filter: (b3t1.c1 = b3t2.c1)
-                       ->  Seq Scan on t2 b3t2
-                             Filter: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b3t1.c1 = b3t4.c1)
                              ->  Tid Scan on t1 b3t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Tid Scan on t4 b3t4
-                                         TID Cond: (ctid = '(1,1)'::tid)
+                             ->  Tid Scan on t4 b3t4
+                                   TID Cond: (ctid = '(1,1)'::tid)
+                       ->  Seq Scan on t2 b3t2
+                             Filter: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t3 b3t3
+                       TID Cond: (ctid = '(1,1)'::tid)
    ->  Nested Loop
          Join Filter: (bmt1.c1 = bmt4.c1)
-         ->  Tid Scan on t4 bmt4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (bmt1.c1 = bmt3.c1)
-               ->  Tid Scan on t3 bmt3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (bmt1.c1 = bmt2.c1)
-                     ->  Seq Scan on t2 bmt2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            Join Filter: (c1.c1 = bmt1.c1)
-                           ->  Tid Scan on t1 bmt1
-                                 TID Cond: (ctid = '(1,1)'::tid)
                            ->  Nested Loop
                                  Join Filter: (c2.c1 = c1.c1)
                                  ->  Nested Loop
@@ -2322,7 +2272,15 @@ error hint:
                                        ->  CTE Scan on c2
                                        ->  CTE Scan on c3
                                  ->  CTE Scan on c1
-(75 rows)
+                           ->  Tid Scan on t1 bmt1
+                                 TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2 bmt2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 bmt3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 bmt4
+               TID Cond: (ctid = '(1,1)'::tid)
+(72 rows)
 
 ----
 ---- No. L-2-2 the number of the tables per quiry block
@@ -2438,8 +2396,8 @@ AND bmt1.c1 <> (
 SELECT max(b3t1.c1) FROM s1.t1 b3t1, s1.t2 b3t2 WHERE b3t1.ctid = '(1,1)' AND b3t1.c1 = b3t2.c1 AND b3t2.ctid = '(1,1)'
 )
 ;
-                        QUERY PLAN                         
------------------------------------------------------------
+                      QUERY PLAN                       
+-------------------------------------------------------
  Aggregate
    CTE c1
      ->  Aggregate
@@ -2447,38 +2405,35 @@ SELECT max(b3t1.c1) FROM s1.t1 b3t1, s1.t2 b3t2 WHERE b3t1.ctid = '(1,1)' AND b3
                  Join Filter: (b1t1.c1 = b1t2.c1)
                  ->  Tid Scan on t1 b1t1
                        TID Cond: (ctid = '(1,1)'::tid)
-                 ->  Materialize
-                       ->  Seq Scan on t2 b1t2
-                             Filter: (ctid = '(1,1)'::tid)
+                 ->  Seq Scan on t2 b1t2
+                       Filter: (ctid = '(1,1)'::tid)
    InitPlan 2 (returns $1)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b2t1.c1 = b2t2.c1)
                  ->  Tid Scan on t1 b2t1
                        TID Cond: (ctid = '(1,1)'::tid)
-                 ->  Materialize
-                       ->  Seq Scan on t2 b2t2
-                             Filter: (ctid = '(1,1)'::tid)
+                 ->  Seq Scan on t2 b2t2
+                       Filter: (ctid = '(1,1)'::tid)
    InitPlan 3 (returns $2)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b3t1.c1 = b3t2.c1)
                  ->  Tid Scan on t1 b3t1
                        TID Cond: (ctid = '(1,1)'::tid)
-                 ->  Materialize
-                       ->  Seq Scan on t2 b3t2
-                             Filter: (ctid = '(1,1)'::tid)
+                 ->  Seq Scan on t2 b3t2
+                       Filter: (ctid = '(1,1)'::tid)
    ->  Nested Loop
-         Join Filter: (bmt1.c1 = bmt2.c1)
-         ->  Seq Scan on t2 bmt2
-               Filter: (ctid = '(1,1)'::tid)
+         Join Filter: (bmt1.c1 = c1.c1)
          ->  Nested Loop
-               Join Filter: (bmt1.c1 = c1.c1)
+               Join Filter: (bmt1.c1 = bmt2.c1)
                ->  Tid Scan on t1 bmt1
                      TID Cond: (ctid = '(1,1)'::tid)
                      Filter: (c1 <> $2)
-               ->  CTE Scan on c1
-(38 rows)
+               ->  Seq Scan on t2 bmt2
+                     Filter: (ctid = '(1,1)'::tid)
+         ->  CTE Scan on c1
+(35 rows)
 
 /*+
 Leading(c1 bmt2 bmt1)
@@ -2509,8 +2464,8 @@ not used hint:
 duplication hint:
 error hint:
 
-                        QUERY PLAN                         
------------------------------------------------------------
+                      QUERY PLAN                       
+-------------------------------------------------------
  Aggregate
    CTE c1
      ->  Aggregate
@@ -2518,38 +2473,35 @@ error hint:
                  Join Filter: (b1t1.c1 = b1t2.c1)
                  ->  Tid Scan on t1 b1t1
                        TID Cond: (ctid = '(1,1)'::tid)
-                 ->  Materialize
-                       ->  Seq Scan on t2 b1t2
-                             Filter: (ctid = '(1,1)'::tid)
+                 ->  Seq Scan on t2 b1t2
+                       Filter: (ctid = '(1,1)'::tid)
    InitPlan 2 (returns $1)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b2t1.c1 = b2t2.c1)
                  ->  Tid Scan on t1 b2t1
                        TID Cond: (ctid = '(1,1)'::tid)
-                 ->  Materialize
-                       ->  Seq Scan on t2 b2t2
-                             Filter: (ctid = '(1,1)'::tid)
+                 ->  Seq Scan on t2 b2t2
+                       Filter: (ctid = '(1,1)'::tid)
    InitPlan 3 (returns $2)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b3t1.c1 = b3t2.c1)
                  ->  Tid Scan on t1 b3t1
                        TID Cond: (ctid = '(1,1)'::tid)
-                 ->  Materialize
-                       ->  Seq Scan on t2 b3t2
-                             Filter: (ctid = '(1,1)'::tid)
+                 ->  Seq Scan on t2 b3t2
+                       Filter: (ctid = '(1,1)'::tid)
    ->  Nested Loop
          Join Filter: (bmt2.c1 = bmt1.c1)
-         ->  Tid Scan on t1 bmt1
-               TID Cond: (ctid = '(1,1)'::tid)
-               Filter: (c1 <> $2)
          ->  Nested Loop
                Join Filter: (bmt2.c1 = c1.c1)
                ->  Seq Scan on t2 bmt2
                      Filter: (ctid = '(1,1)'::tid)
                ->  CTE Scan on c1
-(38 rows)
+         ->  Tid Scan on t1 bmt1
+               TID Cond: (ctid = '(1,1)'::tid)
+               Filter: (c1 <> $2)
+(35 rows)
 
 -- No. L-2-2-3
 EXPLAIN (COSTS false)
@@ -2564,79 +2516,76 @@ AND bmt1.c1 <> (
 SELECT max(b3t1.c1) FROM s1.t1 b3t1, s1.t2 b3t2, s1.t3 b3t3, s1.t4 b3t4 WHERE b3t1.ctid = '(1,1)' AND b3t1.c1 = b3t2.c1 AND b3t2.ctid = '(1,1)' AND b3t1.c1 = b3t3.c1 AND b3t3.ctid = '(1,1)' AND b3t1.c1 = b3t4.c1 AND b3t4.ctid = '(1,1)'
 )
 ;
-                              QUERY PLAN                               
------------------------------------------------------------------------
+                            QUERY PLAN                             
+-------------------------------------------------------------------
  Aggregate
    CTE c1
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b1t1.c1 = b1t4.c1)
-                 ->  Tid Scan on t4 b1t4
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b1t1.c1 = b1t3.c1)
-                       ->  Tid Scan on t3 b1t3
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b1t1.c1 = b1t2.c1)
                              ->  Tid Scan on t1 b1t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Seq Scan on t2 b1t2
-                                         Filter: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b1t2
+                                   Filter: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t3 b1t3
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t4 b1t4
+                       TID Cond: (ctid = '(1,1)'::tid)
    InitPlan 2 (returns $1)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b2t1.c1 = b2t4.c1)
-                 ->  Tid Scan on t4 b2t4
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b2t1.c1 = b2t3.c1)
-                       ->  Tid Scan on t3 b2t3
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b2t1.c1 = b2t2.c1)
                              ->  Tid Scan on t1 b2t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Seq Scan on t2 b2t2
-                                         Filter: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b2t2
+                                   Filter: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t3 b2t3
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t4 b2t4
+                       TID Cond: (ctid = '(1,1)'::tid)
    InitPlan 3 (returns $2)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b3t1.c1 = b3t4.c1)
-                 ->  Tid Scan on t4 b3t4
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b3t1.c1 = b3t3.c1)
-                       ->  Tid Scan on t3 b3t3
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b3t1.c1 = b3t2.c1)
                              ->  Tid Scan on t1 b3t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Seq Scan on t2 b3t2
-                                         Filter: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b3t2
+                                   Filter: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t3 b3t3
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t4 b3t4
+                       TID Cond: (ctid = '(1,1)'::tid)
    ->  Nested Loop
-         Join Filter: (bmt1.c1 = bmt4.c1)
-         ->  Tid Scan on t4 bmt4
-               TID Cond: (ctid = '(1,1)'::tid)
+         Join Filter: (bmt1.c1 = c1.c1)
          ->  Nested Loop
-               Join Filter: (bmt1.c1 = bmt3.c1)
-               ->  Tid Scan on t3 bmt3
-                     TID Cond: (ctid = '(1,1)'::tid)
+               Join Filter: (bmt1.c1 = bmt4.c1)
                ->  Nested Loop
-                     Join Filter: (bmt1.c1 = bmt2.c1)
-                     ->  Seq Scan on t2 bmt2
-                           Filter: (ctid = '(1,1)'::tid)
+                     Join Filter: (bmt1.c1 = bmt3.c1)
                      ->  Nested Loop
-                           Join Filter: (bmt1.c1 = c1.c1)
+                           Join Filter: (bmt1.c1 = bmt2.c1)
                            ->  Tid Scan on t1 bmt1
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 <> $2)
-                           ->  CTE Scan on c1
-(70 rows)
+                           ->  Seq Scan on t2 bmt2
+                                 Filter: (ctid = '(1,1)'::tid)
+                     ->  Tid Scan on t3 bmt3
+                           TID Cond: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t4 bmt4
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  CTE Scan on c1
+(67 rows)
 
 /*+
 Leading(c1 bmt4 bmt3 bmt2 bmt1)
@@ -2666,79 +2615,76 @@ not used hint:
 duplication hint:
 error hint:
 
-                               QUERY PLAN                                
--------------------------------------------------------------------------
+                            QUERY PLAN                             
+-------------------------------------------------------------------
  Aggregate
    CTE c1
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b1t2.c1 = b1t1.c1)
-                 ->  Tid Scan on t1 b1t1
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b1t3.c1 = b1t2.c1)
-                       ->  Seq Scan on t2 b1t2
-                             Filter: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b1t3.c1 = b1t4.c1)
                              ->  Tid Scan on t3 b1t3
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Tid Scan on t4 b1t4
-                                         TID Cond: (ctid = '(1,1)'::tid)
+                             ->  Tid Scan on t4 b1t4
+                                   TID Cond: (ctid = '(1,1)'::tid)
+                       ->  Seq Scan on t2 b1t2
+                             Filter: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t1 b1t1
+                       TID Cond: (ctid = '(1,1)'::tid)
    InitPlan 2 (returns $1)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b2t2.c1 = b2t1.c1)
-                 ->  Tid Scan on t1 b2t1
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b2t3.c1 = b2t2.c1)
-                       ->  Seq Scan on t2 b2t2
-                             Filter: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b2t3.c1 = b2t4.c1)
                              ->  Tid Scan on t3 b2t3
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Tid Scan on t4 b2t4
-                                         TID Cond: (ctid = '(1,1)'::tid)
+                             ->  Tid Scan on t4 b2t4
+                                   TID Cond: (ctid = '(1,1)'::tid)
+                       ->  Seq Scan on t2 b2t2
+                             Filter: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t1 b2t1
+                       TID Cond: (ctid = '(1,1)'::tid)
    InitPlan 3 (returns $2)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b3t2.c1 = b3t1.c1)
-                 ->  Tid Scan on t1 b3t1
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b3t3.c1 = b3t2.c1)
-                       ->  Seq Scan on t2 b3t2
-                             Filter: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b3t3.c1 = b3t4.c1)
                              ->  Tid Scan on t3 b3t3
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Tid Scan on t4 b3t4
-                                         TID Cond: (ctid = '(1,1)'::tid)
+                             ->  Tid Scan on t4 b3t4
+                                   TID Cond: (ctid = '(1,1)'::tid)
+                       ->  Seq Scan on t2 b3t2
+                             Filter: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t1 b3t1
+                       TID Cond: (ctid = '(1,1)'::tid)
    ->  Nested Loop
          Join Filter: (bmt2.c1 = bmt1.c1)
-         ->  Tid Scan on t1 bmt1
-               TID Cond: (ctid = '(1,1)'::tid)
-               Filter: (c1 <> $2)
          ->  Nested Loop
                Join Filter: (bmt3.c1 = bmt2.c1)
-               ->  Seq Scan on t2 bmt2
-                     Filter: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (bmt4.c1 = bmt3.c1)
-                     ->  Tid Scan on t3 bmt3
-                           TID Cond: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            Join Filter: (bmt4.c1 = c1.c1)
                            ->  Tid Scan on t4 bmt4
                                  TID Cond: (ctid = '(1,1)'::tid)
                            ->  CTE Scan on c1
-(70 rows)
+                     ->  Tid Scan on t3 bmt3
+                           TID Cond: (ctid = '(1,1)'::tid)
+               ->  Seq Scan on t2 bmt2
+                     Filter: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t1 bmt1
+               TID Cond: (ctid = '(1,1)'::tid)
+               Filter: (c1 <> $2)
+(67 rows)
 
 -- No. L-2-2-4
 EXPLAIN (COSTS false)
@@ -2753,26 +2699,25 @@ AND bmt1.c1 <> (
 SELECT max(b3t1.c1) FROM s1.t1 b3t1 WHERE b3t1.ctid = '(1,1)'
 )
 ;
-                              QUERY PLAN                               
------------------------------------------------------------------------
+                            QUERY PLAN                             
+-------------------------------------------------------------------
  Aggregate
    CTE c1
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b1t1.c1 = b1t4.c1)
-                 ->  Tid Scan on t4 b1t4
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b1t1.c1 = b1t3.c1)
-                       ->  Tid Scan on t3 b1t3
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b1t1.c1 = b1t2.c1)
                              ->  Tid Scan on t1 b1t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Seq Scan on t2 b1t2
-                                         Filter: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b1t2
+                                   Filter: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t3 b1t3
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t4 b1t4
+                       TID Cond: (ctid = '(1,1)'::tid)
    InitPlan 3 (returns $2)
      ->  Result
            InitPlan 2 (returns $1)
@@ -2785,24 +2730,24 @@ SELECT max(b3t1.c1) FROM s1.t1 b3t1 WHERE b3t1.ctid = '(1,1)'
            ->  Tid Scan on t1 b3t1
                  TID Cond: (ctid = '(1,1)'::tid)
    ->  Nested Loop
-         Join Filter: (bmt1.c1 = bmt4.c1)
-         ->  Tid Scan on t4 bmt4
-               TID Cond: (ctid = '(1,1)'::tid)
+         Join Filter: (bmt1.c1 = c1.c1)
          ->  Nested Loop
-               Join Filter: (bmt1.c1 = bmt3.c1)
-               ->  Tid Scan on t3 bmt3
-                     TID Cond: (ctid = '(1,1)'::tid)
+               Join Filter: (bmt1.c1 = bmt4.c1)
                ->  Nested Loop
-                     Join Filter: (bmt1.c1 = bmt2.c1)
-                     ->  Seq Scan on t2 bmt2
-                           Filter: (ctid = '(1,1)'::tid)
+                     Join Filter: (bmt1.c1 = bmt3.c1)
                      ->  Nested Loop
-                           Join Filter: (bmt1.c1 = c1.c1)
+                           Join Filter: (bmt1.c1 = bmt2.c1)
                            ->  Tid Scan on t1 bmt1
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 <> $4)
-                           ->  CTE Scan on c1
-(47 rows)
+                           ->  Seq Scan on t2 bmt2
+                                 Filter: (ctid = '(1,1)'::tid)
+                     ->  Tid Scan on t3 bmt3
+                           TID Cond: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t4 bmt4
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  CTE Scan on c1
+(46 rows)
 
 /*+
 Leading(c1 bmt4 bmt3 bmt2 bmt1)
@@ -2828,26 +2773,25 @@ not used hint:
 duplication hint:
 error hint:
 
-                               QUERY PLAN                                
--------------------------------------------------------------------------
+                            QUERY PLAN                             
+-------------------------------------------------------------------
  Aggregate
    CTE c1
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b1t2.c1 = b1t1.c1)
-                 ->  Tid Scan on t1 b1t1
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b1t3.c1 = b1t2.c1)
-                       ->  Seq Scan on t2 b1t2
-                             Filter: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b1t3.c1 = b1t4.c1)
                              ->  Tid Scan on t3 b1t3
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Tid Scan on t4 b1t4
-                                         TID Cond: (ctid = '(1,1)'::tid)
+                             ->  Tid Scan on t4 b1t4
+                                   TID Cond: (ctid = '(1,1)'::tid)
+                       ->  Seq Scan on t2 b1t2
+                             Filter: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t1 b1t1
+                       TID Cond: (ctid = '(1,1)'::tid)
    InitPlan 3 (returns $2)
      ->  Result
            InitPlan 2 (returns $1)
@@ -2861,23 +2805,23 @@ error hint:
                  TID Cond: (ctid = '(1,1)'::tid)
    ->  Nested Loop
          Join Filter: (bmt2.c1 = bmt1.c1)
-         ->  Tid Scan on t1 bmt1
-               TID Cond: (ctid = '(1,1)'::tid)
-               Filter: (c1 <> $4)
          ->  Nested Loop
                Join Filter: (bmt3.c1 = bmt2.c1)
-               ->  Seq Scan on t2 bmt2
-                     Filter: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (bmt4.c1 = bmt3.c1)
-                     ->  Tid Scan on t3 bmt3
-                           TID Cond: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            Join Filter: (bmt4.c1 = c1.c1)
                            ->  Tid Scan on t4 bmt4
                                  TID Cond: (ctid = '(1,1)'::tid)
                            ->  CTE Scan on c1
-(47 rows)
+                     ->  Tid Scan on t3 bmt3
+                           TID Cond: (ctid = '(1,1)'::tid)
+               ->  Seq Scan on t2 bmt2
+                     Filter: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t1 bmt1
+               TID Cond: (ctid = '(1,1)'::tid)
+               Filter: (c1 <> $4)
+(46 rows)
 
 ----
 ---- No. L-2-3 RULE or VIEW
@@ -2889,22 +2833,22 @@ EXPLAIN (COSTS false) UPDATE s1.r1 SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
  Aggregate
    ->  Nested Loop
          Join Filter: (t1.c1 = t4.c1)
-         ->  Tid Scan on t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (t1.c1 = t3.c1)
-               ->  Tid Scan on t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (t1.c1 = t2.c1)
-                     ->  Seq Scan on t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r1
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4
+               TID Cond: (ctid = '(1,1)'::tid)
 (19 rows)
 
 /*+ Leading(t4 t3 t2 t1 r1) */
@@ -2916,29 +2860,28 @@ not used hint:
 duplication hint:
 error hint:
 
-                              QUERY PLAN                               
------------------------------------------------------------------------
+                           QUERY PLAN                            
+-----------------------------------------------------------------
  Aggregate
    ->  Nested Loop
          ->  Nested Loop
                Join Filter: (t2.c1 = t1.c1)
-               ->  Tid Scan on t1
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (t3.c1 = t2.c1)
-                     ->  Seq Scan on t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            Join Filter: (t3.c1 = t4.c1)
                            ->  Tid Scan on t3
                                  TID Cond: (ctid = '(1,1)'::tid)
-                           ->  Materialize
-                                 ->  Tid Scan on t4
-                                       TID Cond: (ctid = '(1,1)'::tid)
+                           ->  Tid Scan on t4
+                                 TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t1
+                     TID Cond: (ctid = '(1,1)'::tid)
          ->  Tid Scan on r1
                TID Cond: (ctid = '(1,1)'::tid)
                Filter: (c1 = 1)
-(20 rows)
+(19 rows)
 
 EXPLAIN (COSTS false) UPDATE s1.r1_ SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
                            QUERY PLAN                            
@@ -2946,22 +2889,22 @@ EXPLAIN (COSTS false) UPDATE s1.r1_ SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
  Aggregate
    ->  Nested Loop
          Join Filter: (b1t1.c1 = b1t4.c1)
-         ->  Tid Scan on t4 b1t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (b1t1.c1 = b1t3.c1)
-               ->  Tid Scan on t3 b1t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
-                     Join Filter: (b1t1.c1 = b1t2.c1)
-                     ->  Seq Scan on t2 b1t2
-                           Filter: (ctid = '(1,1)'::tid)
+                     Join Filter: (b1t1.c1 = b1t2.c1)
                      ->  Nested Loop
                            ->  Tid Scan on r1_
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1 b1t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2 b1t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 b1t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 b1t4
+               TID Cond: (ctid = '(1,1)'::tid)
 (19 rows)
 
 /*+ Leading(b1t1 b1t2 b1t3 b1t4 r1_) */
@@ -2973,29 +2916,28 @@ not used hint:
 duplication hint:
 error hint:
 
-                             QUERY PLAN                              
----------------------------------------------------------------------
+                           QUERY PLAN                            
+-----------------------------------------------------------------
  Aggregate
    ->  Nested Loop
          ->  Nested Loop
                Join Filter: (b1t1.c1 = b1t4.c1)
-               ->  Tid Scan on t4 b1t4
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (b1t1.c1 = b1t3.c1)
-                     ->  Tid Scan on t3 b1t3
-                           TID Cond: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            Join Filter: (b1t1.c1 = b1t2.c1)
                            ->  Tid Scan on t1 b1t1
                                  TID Cond: (ctid = '(1,1)'::tid)
-                           ->  Materialize
-                                 ->  Seq Scan on t2 b1t2
-                                       Filter: (ctid = '(1,1)'::tid)
+                           ->  Seq Scan on t2 b1t2
+                                 Filter: (ctid = '(1,1)'::tid)
+                     ->  Tid Scan on t3 b1t3
+                           TID Cond: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t4 b1t4
+                     TID Cond: (ctid = '(1,1)'::tid)
          ->  Tid Scan on r1_
                TID Cond: (ctid = '(1,1)'::tid)
                Filter: (c1 = 1)
-(20 rows)
+(19 rows)
 
 -- No. L-2-3-2
 EXPLAIN (COSTS false) UPDATE s1.r2 SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
@@ -3004,42 +2946,42 @@ EXPLAIN (COSTS false) UPDATE s1.r2 SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
  Aggregate
    ->  Nested Loop
          Join Filter: (t1.c1 = t4.c1)
-         ->  Tid Scan on t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (t1.c1 = t3.c1)
-               ->  Tid Scan on t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (t1.c1 = t2.c1)
-                     ->  Seq Scan on t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r2
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4
+               TID Cond: (ctid = '(1,1)'::tid)
  
  Aggregate
    ->  Nested Loop
          Join Filter: (t1.c1 = t4.c1)
-         ->  Tid Scan on t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (t1.c1 = t3.c1)
-               ->  Tid Scan on t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (t1.c1 = t2.c1)
-                     ->  Seq Scan on t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r2
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4
+               TID Cond: (ctid = '(1,1)'::tid)
 (39 rows)
 
 /*+ Leading(t4 t3 t2 t1 r2) */
@@ -3058,25 +3000,24 @@ not used hint:
 duplication hint:
 error hint:
 
-                              QUERY PLAN                               
------------------------------------------------------------------------
+                           QUERY PLAN                            
+-----------------------------------------------------------------
  Aggregate
    ->  Nested Loop
          ->  Nested Loop
                Join Filter: (t2.c1 = t1.c1)
-               ->  Tid Scan on t1
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (t3.c1 = t2.c1)
-                     ->  Seq Scan on t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            Join Filter: (t3.c1 = t4.c1)
                            ->  Tid Scan on t3
                                  TID Cond: (ctid = '(1,1)'::tid)
-                           ->  Materialize
-                                 ->  Tid Scan on t4
-                                       TID Cond: (ctid = '(1,1)'::tid)
+                           ->  Tid Scan on t4
+                                 TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t1
+                     TID Cond: (ctid = '(1,1)'::tid)
          ->  Tid Scan on r2
                TID Cond: (ctid = '(1,1)'::tid)
                Filter: (c1 = 1)
@@ -3085,23 +3026,22 @@ error hint:
    ->  Nested Loop
          ->  Nested Loop
                Join Filter: (t2.c1 = t1.c1)
-               ->  Tid Scan on t1
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (t3.c1 = t2.c1)
-                     ->  Seq Scan on t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            Join Filter: (t3.c1 = t4.c1)
                            ->  Tid Scan on t3
                                  TID Cond: (ctid = '(1,1)'::tid)
-                           ->  Materialize
-                                 ->  Tid Scan on t4
-                                       TID Cond: (ctid = '(1,1)'::tid)
+                           ->  Tid Scan on t4
+                                 TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t1
+                     TID Cond: (ctid = '(1,1)'::tid)
          ->  Tid Scan on r2
                TID Cond: (ctid = '(1,1)'::tid)
                Filter: (c1 = 1)
-(41 rows)
+(39 rows)
 
 EXPLAIN (COSTS false) UPDATE s1.r2_ SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
                            QUERY PLAN                            
@@ -3109,42 +3049,42 @@ EXPLAIN (COSTS false) UPDATE s1.r2_ SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
  Aggregate
    ->  Nested Loop
          Join Filter: (b1t1.c1 = b1t4.c1)
-         ->  Tid Scan on t4 b1t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (b1t1.c1 = b1t3.c1)
-               ->  Tid Scan on t3 b1t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (b1t1.c1 = b1t2.c1)
-                     ->  Seq Scan on t2 b1t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r2_
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1 b1t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2 b1t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 b1t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 b1t4
+               TID Cond: (ctid = '(1,1)'::tid)
  
  Aggregate
    ->  Nested Loop
          Join Filter: (b2t1.c1 = b2t4.c1)
-         ->  Tid Scan on t4 b2t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (b2t1.c1 = b2t3.c1)
-               ->  Tid Scan on t3 b2t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (b2t1.c1 = b2t2.c1)
-                     ->  Seq Scan on t2 b2t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r2_
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1 b2t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2 b2t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 b2t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 b2t4
+               TID Cond: (ctid = '(1,1)'::tid)
 (39 rows)
 
 /*+
@@ -3168,25 +3108,24 @@ Leading(b1t1 b1t2 b1t3 b1t4 r2_)
 duplication hint:
 error hint:
 
-                             QUERY PLAN                              
----------------------------------------------------------------------
+                           QUERY PLAN                            
+-----------------------------------------------------------------
  Aggregate
    ->  Nested Loop
          ->  Nested Loop
                Join Filter: (b1t1.c1 = b1t4.c1)
-               ->  Tid Scan on t4 b1t4
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (b1t1.c1 = b1t3.c1)
-                     ->  Tid Scan on t3 b1t3
-                           TID Cond: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            Join Filter: (b1t1.c1 = b1t2.c1)
                            ->  Tid Scan on t1 b1t1
                                  TID Cond: (ctid = '(1,1)'::tid)
-                           ->  Materialize
-                                 ->  Seq Scan on t2 b1t2
-                                       Filter: (ctid = '(1,1)'::tid)
+                           ->  Seq Scan on t2 b1t2
+                                 Filter: (ctid = '(1,1)'::tid)
+                     ->  Tid Scan on t3 b1t3
+                           TID Cond: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t4 b1t4
+                     TID Cond: (ctid = '(1,1)'::tid)
          ->  Tid Scan on r2_
                TID Cond: (ctid = '(1,1)'::tid)
                Filter: (c1 = 1)
@@ -3195,23 +3134,22 @@ error hint:
    ->  Nested Loop
          ->  Nested Loop
                Join Filter: (b2t1.c1 = b2t4.c1)
-               ->  Tid Scan on t4 b2t4
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (b2t1.c1 = b2t3.c1)
-                     ->  Tid Scan on t3 b2t3
-                           TID Cond: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            Join Filter: (b2t1.c1 = b2t2.c1)
                            ->  Tid Scan on t1 b2t1
                                  TID Cond: (ctid = '(1,1)'::tid)
-                           ->  Materialize
-                                 ->  Seq Scan on t2 b2t2
-                                       Filter: (ctid = '(1,1)'::tid)
+                           ->  Seq Scan on t2 b2t2
+                                 Filter: (ctid = '(1,1)'::tid)
+                     ->  Tid Scan on t3 b2t3
+                           TID Cond: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t4 b2t4
+                     TID Cond: (ctid = '(1,1)'::tid)
          ->  Tid Scan on r2_
                TID Cond: (ctid = '(1,1)'::tid)
                Filter: (c1 = 1)
-(41 rows)
+(39 rows)
 
 -- No. L-2-3-3
 EXPLAIN (COSTS false) UPDATE s1.r3 SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
@@ -3220,62 +3158,62 @@ EXPLAIN (COSTS false) UPDATE s1.r3 SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
  Aggregate
    ->  Nested Loop
          Join Filter: (t1.c1 = t4.c1)
-         ->  Tid Scan on t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (t1.c1 = t3.c1)
-               ->  Tid Scan on t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (t1.c1 = t2.c1)
-                     ->  Seq Scan on t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r3
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4
+               TID Cond: (ctid = '(1,1)'::tid)
  
  Aggregate
    ->  Nested Loop
          Join Filter: (t1.c1 = t4.c1)
-         ->  Tid Scan on t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (t1.c1 = t3.c1)
-               ->  Tid Scan on t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (t1.c1 = t2.c1)
-                     ->  Seq Scan on t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r3
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4
+               TID Cond: (ctid = '(1,1)'::tid)
  
  Aggregate
    ->  Nested Loop
          Join Filter: (t1.c1 = t4.c1)
-         ->  Tid Scan on t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (t1.c1 = t3.c1)
-               ->  Tid Scan on t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (t1.c1 = t2.c1)
-                     ->  Seq Scan on t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r3
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4
+               TID Cond: (ctid = '(1,1)'::tid)
 (59 rows)
 
 /*+ Leading(t4 t3 t2 t1 r3) */
@@ -3301,25 +3239,24 @@ not used hint:
 duplication hint:
 error hint:
 
-                              QUERY PLAN                               
------------------------------------------------------------------------
+                           QUERY PLAN                            
+-----------------------------------------------------------------
  Aggregate
    ->  Nested Loop
          ->  Nested Loop
                Join Filter: (t2.c1 = t1.c1)
-               ->  Tid Scan on t1
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (t3.c1 = t2.c1)
-                     ->  Seq Scan on t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            Join Filter: (t3.c1 = t4.c1)
                            ->  Tid Scan on t3
                                  TID Cond: (ctid = '(1,1)'::tid)
-                           ->  Materialize
-                                 ->  Tid Scan on t4
-                                       TID Cond: (ctid = '(1,1)'::tid)
+                           ->  Tid Scan on t4
+                                 TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t1
+                     TID Cond: (ctid = '(1,1)'::tid)
          ->  Tid Scan on r3
                TID Cond: (ctid = '(1,1)'::tid)
                Filter: (c1 = 1)
@@ -3328,19 +3265,18 @@ error hint:
    ->  Nested Loop
          ->  Nested Loop
                Join Filter: (t2.c1 = t1.c1)
-               ->  Tid Scan on t1
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (t3.c1 = t2.c1)
-                     ->  Seq Scan on t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            Join Filter: (t3.c1 = t4.c1)
                            ->  Tid Scan on t3
                                  TID Cond: (ctid = '(1,1)'::tid)
-                           ->  Materialize
-                                 ->  Tid Scan on t4
-                                       TID Cond: (ctid = '(1,1)'::tid)
+                           ->  Tid Scan on t4
+                                 TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t1
+                     TID Cond: (ctid = '(1,1)'::tid)
          ->  Tid Scan on r3
                TID Cond: (ctid = '(1,1)'::tid)
                Filter: (c1 = 1)
@@ -3349,23 +3285,22 @@ error hint:
    ->  Nested Loop
          ->  Nested Loop
                Join Filter: (t2.c1 = t1.c1)
-               ->  Tid Scan on t1
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (t3.c1 = t2.c1)
-                     ->  Seq Scan on t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            Join Filter: (t3.c1 = t4.c1)
                            ->  Tid Scan on t3
                                  TID Cond: (ctid = '(1,1)'::tid)
-                           ->  Materialize
-                                 ->  Tid Scan on t4
-                                       TID Cond: (ctid = '(1,1)'::tid)
+                           ->  Tid Scan on t4
+                                 TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t1
+                     TID Cond: (ctid = '(1,1)'::tid)
          ->  Tid Scan on r3
                TID Cond: (ctid = '(1,1)'::tid)
                Filter: (c1 = 1)
-(62 rows)
+(59 rows)
 
 EXPLAIN (COSTS false) UPDATE s1.r3_ SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
                            QUERY PLAN                            
@@ -3373,62 +3308,62 @@ EXPLAIN (COSTS false) UPDATE s1.r3_ SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
  Aggregate
    ->  Nested Loop
          Join Filter: (b1t1.c1 = b1t4.c1)
-         ->  Tid Scan on t4 b1t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (b1t1.c1 = b1t3.c1)
-               ->  Tid Scan on t3 b1t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (b1t1.c1 = b1t2.c1)
-                     ->  Seq Scan on t2 b1t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r3_
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1 b1t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2 b1t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 b1t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 b1t4
+               TID Cond: (ctid = '(1,1)'::tid)
  
  Aggregate
    ->  Nested Loop
          Join Filter: (b2t1.c1 = b2t4.c1)
-         ->  Tid Scan on t4 b2t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (b2t1.c1 = b2t3.c1)
-               ->  Tid Scan on t3 b2t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (b2t1.c1 = b2t2.c1)
-                     ->  Seq Scan on t2 b2t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r3_
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1 b2t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2 b2t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 b2t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 b2t4
+               TID Cond: (ctid = '(1,1)'::tid)
  
  Aggregate
    ->  Nested Loop
          Join Filter: (b3t1.c1 = b3t4.c1)
-         ->  Tid Scan on t4 b3t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (b3t1.c1 = b3t3.c1)
-               ->  Tid Scan on t3 b3t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (b3t1.c1 = b3t2.c1)
-                     ->  Seq Scan on t2 b3t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r3_
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1 b3t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2 b3t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 b3t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 b3t4
+               TID Cond: (ctid = '(1,1)'::tid)
 (59 rows)
 
 /*+
@@ -3464,25 +3399,24 @@ Leading(b2t1 b2t2 b2t3 b2t4 r3_)
 duplication hint:
 error hint:
 
-                             QUERY PLAN                              
----------------------------------------------------------------------
+                           QUERY PLAN                            
+-----------------------------------------------------------------
  Aggregate
    ->  Nested Loop
          ->  Nested Loop
                Join Filter: (b1t1.c1 = b1t4.c1)
-               ->  Tid Scan on t4 b1t4
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (b1t1.c1 = b1t3.c1)
-                     ->  Tid Scan on t3 b1t3
-                           TID Cond: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            Join Filter: (b1t1.c1 = b1t2.c1)
                            ->  Tid Scan on t1 b1t1
                                  TID Cond: (ctid = '(1,1)'::tid)
-                           ->  Materialize
-                                 ->  Seq Scan on t2 b1t2
-                                       Filter: (ctid = '(1,1)'::tid)
+                           ->  Seq Scan on t2 b1t2
+                                 Filter: (ctid = '(1,1)'::tid)
+                     ->  Tid Scan on t3 b1t3
+                           TID Cond: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t4 b1t4
+                     TID Cond: (ctid = '(1,1)'::tid)
          ->  Tid Scan on r3_
                TID Cond: (ctid = '(1,1)'::tid)
                Filter: (c1 = 1)
@@ -3491,19 +3425,18 @@ error hint:
    ->  Nested Loop
          ->  Nested Loop
                Join Filter: (b2t1.c1 = b2t4.c1)
-               ->  Tid Scan on t4 b2t4
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (b2t1.c1 = b2t3.c1)
-                     ->  Tid Scan on t3 b2t3
-                           TID Cond: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            Join Filter: (b2t1.c1 = b2t2.c1)
                            ->  Tid Scan on t1 b2t1
                                  TID Cond: (ctid = '(1,1)'::tid)
-                           ->  Materialize
-                                 ->  Seq Scan on t2 b2t2
-                                       Filter: (ctid = '(1,1)'::tid)
+                           ->  Seq Scan on t2 b2t2
+                                 Filter: (ctid = '(1,1)'::tid)
+                     ->  Tid Scan on t3 b2t3
+                           TID Cond: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t4 b2t4
+                     TID Cond: (ctid = '(1,1)'::tid)
          ->  Tid Scan on r3_
                TID Cond: (ctid = '(1,1)'::tid)
                Filter: (c1 = 1)
@@ -3512,23 +3445,22 @@ error hint:
    ->  Nested Loop
          ->  Nested Loop
                Join Filter: (b3t1.c1 = b3t4.c1)
-               ->  Tid Scan on t4 b3t4
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (b3t1.c1 = b3t3.c1)
-                     ->  Tid Scan on t3 b3t3
-                           TID Cond: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            Join Filter: (b3t1.c1 = b3t2.c1)
                            ->  Tid Scan on t1 b3t1
                                  TID Cond: (ctid = '(1,1)'::tid)
-                           ->  Materialize
-                                 ->  Seq Scan on t2 b3t2
-                                       Filter: (ctid = '(1,1)'::tid)
+                           ->  Seq Scan on t2 b3t2
+                                 Filter: (ctid = '(1,1)'::tid)
+                     ->  Tid Scan on t3 b3t3
+                           TID Cond: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t4 b3t4
+                     TID Cond: (ctid = '(1,1)'::tid)
          ->  Tid Scan on r3_
                TID Cond: (ctid = '(1,1)'::tid)
                Filter: (c1 = 1)
-(62 rows)
+(59 rows)
 
 -- No. L-2-3-4
 EXPLAIN (COSTS false) SELECT * FROM s1.v1 v1, s1.v1 v2 WHERE v1.c1 = v2.c1;

diff --git a/expected/ut-R.out b/expected/ut-R.out
index ef525ca..849a767 100644 (file)
--- a/expected/ut-R.out
+++ b/expected/ut-R.out
@@ -2363,6 +2363,7 @@ error hint:
                            ->  Sort  (cost=xxx rows=1 width=xxx)
                                  Sort Key: bmt1.c1
                                  ->  Nested Loop  (cost=xxx rows=1 width=xxx)
+                                       Join Filter: (c1.c1 = bmt1.c1)
                                        ->  Hash Join  (cost=xxx rows=1 width=xxx)
                                              Hash Cond: (c2.c1 = c1.c1)
                                              ->  Merge Join  (cost=xxx rows=1 width=xxx)
@@ -2376,13 +2377,13 @@ error hint:
                                              ->  Hash  (cost=xxx rows=1 width=xxx)
                                                    ->  CTE Scan on c1  (cost=xxx rows=1 width=xxx)
                                        ->  Index Only Scan using t1_i1 on t1 bmt1  (cost=xxx rows=1 width=xxx)
-                                             Index Cond: (c1 = c1.c1)
+                                             Index Cond: (c1 = c2.c1)
                            ->  Sort  (cost=xxx rows=100 width=xxx)
                                  Sort Key: bmt2.c1
                                  ->  Seq Scan on t2 bmt2  (cost=xxx rows=100 width=xxx)
          ->  Index Only Scan using t4_i1 on t4 bmt4  (cost=xxx rows=1 width=xxx)
                Index Cond: (c1 = bmt1.c1)
-(72 rows)
+(73 rows)
 
 \o results/ut-R.tmpout
 /*+
@@ -2512,6 +2513,7 @@ error hint:
                            ->  Sort  (cost=xxx rows=1 width=xxx)
                                  Sort Key: bmt1.c1
                                  ->  Nested Loop  (cost=xxx rows=1 width=xxx)
+                                       Join Filter: (c1.c1 = bmt1.c1)
                                        ->  Hash Join  (cost=xxx rows=1 width=xxx)
                                              Hash Cond: (c2.c1 = c1.c1)
                                              ->  Merge Join  (cost=xxx rows=1 width=xxx)
@@ -2525,13 +2527,13 @@ error hint:
                                              ->  Hash  (cost=xxx rows=1 width=xxx)
                                                    ->  CTE Scan on c1  (cost=xxx rows=1 width=xxx)
                                        ->  Index Only Scan using t1_i1 on t1 bmt1  (cost=xxx rows=1 width=xxx)
-                                             Index Cond: (c1 = c1.c1)
+                                             Index Cond: (c1 = c2.c1)
                            ->  Sort  (cost=xxx rows=100 width=xxx)
                                  Sort Key: bmt2.c1
                                  ->  Seq Scan on t2 bmt2  (cost=xxx rows=100 width=xxx)
          ->  Index Only Scan using t4_i1 on t4 bmt4  (cost=xxx rows=1 width=xxx)
                Index Cond: (c1 = bmt1.c1)
-(72 rows)
+(73 rows)
 
 ----
 ---- No. R-2-2 the number of the tables per quiry block
@@ -3272,8 +3274,6 @@ error hint:
  Aggregate  (cost=xxx rows=1 width=xxx)
    ->  Nested Loop  (cost=xxx rows=1 width=xxx)
          Join Filter: (t1.c1 = t4.c1)
-         ->  Tid Scan on t4  (cost=xxx rows=1 width=xxx)
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop  (cost=xxx rows=1 width=xxx)
                Join Filter: (t1.c1 = t3.c1)
                ->  Merge Join  (cost=xxx rows=1 width=xxx)
@@ -3287,10 +3287,11 @@ error hint:
                            Sort Key: t2.c1
                            ->  Seq Scan on t2  (cost=xxx rows=1 width=xxx)
                                  Filter: (ctid = '(1,1)'::tid)
-               ->  Materialize  (cost=xxx rows=1 width=xxx)
-                     ->  Tid Scan on t3  (cost=xxx rows=1 width=xxx)
-                           TID Cond: (ctid = '(1,1)'::tid)
-(21 rows)
+               ->  Tid Scan on t3  (cost=xxx rows=1 width=xxx)
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4  (cost=xxx rows=1 width=xxx)
+               TID Cond: (ctid = '(1,1)'::tid)
+(20 rows)
 
 \o results/ut-R.tmpout
 /*+
@@ -3355,8 +3356,6 @@ error hint:
  Aggregate  (cost=xxx rows=1 width=xxx)
    ->  Nested Loop  (cost=xxx rows=1 width=xxx)
          Join Filter: (b1t1.c1 = b1t4.c1)
-         ->  Tid Scan on t4 b1t4  (cost=xxx rows=1 width=xxx)
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop  (cost=xxx rows=1 width=xxx)
                Join Filter: (b1t1.c1 = b1t3.c1)
                ->  Merge Join  (cost=xxx rows=1 width=xxx)
@@ -3370,10 +3369,11 @@ error hint:
                            Sort Key: b1t2.c1
                            ->  Seq Scan on t2 b1t2  (cost=xxx rows=1 width=xxx)
                                  Filter: (ctid = '(1,1)'::tid)
-               ->  Materialize  (cost=xxx rows=1 width=xxx)
-                     ->  Tid Scan on t3 b1t3  (cost=xxx rows=1 width=xxx)
-                           TID Cond: (ctid = '(1,1)'::tid)
-(21 rows)
+               ->  Tid Scan on t3 b1t3  (cost=xxx rows=1 width=xxx)
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 b1t4  (cost=xxx rows=1 width=xxx)
+               TID Cond: (ctid = '(1,1)'::tid)
+(20 rows)
 
 \o results/ut-R.tmpout
 /*+
@@ -3446,8 +3446,6 @@ error hint:
  Aggregate  (cost=xxx rows=1 width=xxx)
    ->  Nested Loop  (cost=xxx rows=1 width=xxx)
          Join Filter: (t1.c1 = t4.c1)
-         ->  Tid Scan on t4  (cost=xxx rows=1 width=xxx)
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop  (cost=xxx rows=1 width=xxx)
                Join Filter: (t1.c1 = t3.c1)
                ->  Merge Join  (cost=xxx rows=1 width=xxx)
@@ -3461,15 +3459,14 @@ error hint:
                            Sort Key: t2.c1
                            ->  Seq Scan on t2  (cost=xxx rows=1 width=xxx)
                                  Filter: (ctid = '(1,1)'::tid)
-               ->  Materialize  (cost=xxx rows=1 width=xxx)
-                     ->  Tid Scan on t3  (cost=xxx rows=1 width=xxx)
-                           TID Cond: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3  (cost=xxx rows=1 width=xxx)
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4  (cost=xxx rows=1 width=xxx)
+               TID Cond: (ctid = '(1,1)'::tid)
  
  Aggregate  (cost=xxx rows=1 width=xxx)
    ->  Nested Loop  (cost=xxx rows=1 width=xxx)
          Join Filter: (t1.c1 = t4.c1)
-         ->  Tid Scan on t4  (cost=xxx rows=1 width=xxx)
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop  (cost=xxx rows=1 width=xxx)
                Join Filter: (t1.c1 = t3.c1)
                ->  Merge Join  (cost=xxx rows=1 width=xxx)
@@ -3483,10 +3480,11 @@ error hint:
                            Sort Key: t2.c1
                            ->  Seq Scan on t2  (cost=xxx rows=1 width=xxx)
                                  Filter: (ctid = '(1,1)'::tid)
-               ->  Materialize  (cost=xxx rows=1 width=xxx)
-                     ->  Tid Scan on t3  (cost=xxx rows=1 width=xxx)
-                           TID Cond: (ctid = '(1,1)'::tid)
-(43 rows)
+               ->  Tid Scan on t3  (cost=xxx rows=1 width=xxx)
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4  (cost=xxx rows=1 width=xxx)
+               TID Cond: (ctid = '(1,1)'::tid)
+(41 rows)
 
 \o results/ut-R.tmpout
 /*+
@@ -3591,8 +3589,6 @@ error hint:
  Aggregate  (cost=xxx rows=1 width=xxx)
    ->  Nested Loop  (cost=xxx rows=1 width=xxx)
          Join Filter: (b1t1.c1 = b1t4.c1)
-         ->  Tid Scan on t4 b1t4  (cost=xxx rows=1 width=xxx)
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop  (cost=xxx rows=1 width=xxx)
                Join Filter: (b1t1.c1 = b1t3.c1)
                ->  Merge Join  (cost=xxx rows=1 width=xxx)
@@ -3606,15 +3602,14 @@ error hint:
                            Sort Key: b1t2.c1
                            ->  Seq Scan on t2 b1t2  (cost=xxx rows=1 width=xxx)
                                  Filter: (ctid = '(1,1)'::tid)
-               ->  Materialize  (cost=xxx rows=1 width=xxx)
-                     ->  Tid Scan on t3 b1t3  (cost=xxx rows=1 width=xxx)
-                           TID Cond: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 b1t3  (cost=xxx rows=1 width=xxx)
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 b1t4  (cost=xxx rows=1 width=xxx)
+               TID Cond: (ctid = '(1,1)'::tid)
  
  Aggregate  (cost=xxx rows=1 width=xxx)
    ->  Nested Loop  (cost=xxx rows=1 width=xxx)
          Join Filter: (b2t1.c1 = b2t4.c1)
-         ->  Tid Scan on t4 b2t4  (cost=xxx rows=1 width=xxx)
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop  (cost=xxx rows=1 width=xxx)
                Join Filter: (b2t1.c1 = b2t3.c1)
                ->  Merge Join  (cost=xxx rows=1 width=xxx)
@@ -3628,10 +3623,11 @@ error hint:
                            Sort Key: b2t2.c1
                            ->  Seq Scan on t2 b2t2  (cost=xxx rows=1 width=xxx)
                                  Filter: (ctid = '(1,1)'::tid)
-               ->  Materialize  (cost=xxx rows=1 width=xxx)
-                     ->  Tid Scan on t3 b2t3  (cost=xxx rows=1 width=xxx)
-                           TID Cond: (ctid = '(1,1)'::tid)
-(43 rows)
+               ->  Tid Scan on t3 b2t3  (cost=xxx rows=1 width=xxx)
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 b2t4  (cost=xxx rows=1 width=xxx)
+               TID Cond: (ctid = '(1,1)'::tid)
+(41 rows)
 
 \o results/ut-R.tmpout
 /*+
@@ -3756,8 +3752,6 @@ error hint:
  Aggregate  (cost=xxx rows=1 width=xxx)
    ->  Nested Loop  (cost=xxx rows=1 width=xxx)
          Join Filter: (t1.c1 = t4.c1)
-         ->  Tid Scan on t4  (cost=xxx rows=1 width=xxx)
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop  (cost=xxx rows=1 width=xxx)
                Join Filter: (t1.c1 = t3.c1)
                ->  Merge Join  (cost=xxx rows=1 width=xxx)
@@ -3771,15 +3765,14 @@ error hint:
                            Sort Key: t2.c1
                            ->  Seq Scan on t2  (cost=xxx rows=1 width=xxx)
                                  Filter: (ctid = '(1,1)'::tid)
-               ->  Materialize  (cost=xxx rows=1 width=xxx)
-                     ->  Tid Scan on t3  (cost=xxx rows=1 width=xxx)
-                           TID Cond: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3  (cost=xxx rows=1 width=xxx)
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4  (cost=xxx rows=1 width=xxx)
+               TID Cond: (ctid = '(1,1)'::tid)
  
  Aggregate  (cost=xxx rows=1 width=xxx)
    ->  Nested Loop  (cost=xxx rows=1 width=xxx)
          Join Filter: (t1.c1 = t4.c1)
-         ->  Tid Scan on t4  (cost=xxx rows=1 width=xxx)
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop  (cost=xxx rows=1 width=xxx)
                Join Filter: (t1.c1 = t3.c1)
                ->  Merge Join  (cost=xxx rows=1 width=xxx)
@@ -3793,15 +3786,14 @@ error hint:
                            Sort Key: t2.c1
                            ->  Seq Scan on t2  (cost=xxx rows=1 width=xxx)
                                  Filter: (ctid = '(1,1)'::tid)
-               ->  Materialize  (cost=xxx rows=1 width=xxx)
-                     ->  Tid Scan on t3  (cost=xxx rows=1 width=xxx)
-                           TID Cond: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3  (cost=xxx rows=1 width=xxx)
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4  (cost=xxx rows=1 width=xxx)
+               TID Cond: (ctid = '(1,1)'::tid)
  
  Aggregate  (cost=xxx rows=1 width=xxx)
    ->  Nested Loop  (cost=xxx rows=1 width=xxx)
          Join Filter: (t1.c1 = t4.c1)
-         ->  Tid Scan on t4  (cost=xxx rows=1 width=xxx)
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop  (cost=xxx rows=1 width=xxx)
                Join Filter: (t1.c1 = t3.c1)
                ->  Merge Join  (cost=xxx rows=1 width=xxx)
@@ -3815,10 +3807,11 @@ error hint:
                            Sort Key: t2.c1
                            ->  Seq Scan on t2  (cost=xxx rows=1 width=xxx)
                                  Filter: (ctid = '(1,1)'::tid)
-               ->  Materialize  (cost=xxx rows=1 width=xxx)
-                     ->  Tid Scan on t3  (cost=xxx rows=1 width=xxx)
-                           TID Cond: (ctid = '(1,1)'::tid)
-(65 rows)
+               ->  Tid Scan on t3  (cost=xxx rows=1 width=xxx)
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4  (cost=xxx rows=1 width=xxx)
+               TID Cond: (ctid = '(1,1)'::tid)
+(62 rows)
 
 \o results/ut-R.tmpout
 /*+
@@ -3965,8 +3958,6 @@ error hint:
  Aggregate  (cost=xxx rows=1 width=xxx)
    ->  Nested Loop  (cost=xxx rows=1 width=xxx)
          Join Filter: (b1t1.c1 = b1t4.c1)
-         ->  Tid Scan on t4 b1t4  (cost=xxx rows=1 width=xxx)
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop  (cost=xxx rows=1 width=xxx)
                Join Filter: (b1t1.c1 = b1t3.c1)
                ->  Merge Join  (cost=xxx rows=1 width=xxx)
@@ -3980,15 +3971,14 @@ error hint:
                            Sort Key: b1t2.c1
                            ->  Seq Scan on t2 b1t2  (cost=xxx rows=1 width=xxx)
                                  Filter: (ctid = '(1,1)'::tid)
-               ->  Materialize  (cost=xxx rows=1 width=xxx)
-                     ->  Tid Scan on t3 b1t3  (cost=xxx rows=1 width=xxx)
-                           TID Cond: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 b1t3  (cost=xxx rows=1 width=xxx)
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 b1t4  (cost=xxx rows=1 width=xxx)
+               TID Cond: (ctid = '(1,1)'::tid)
  
  Aggregate  (cost=xxx rows=1 width=xxx)
    ->  Nested Loop  (cost=xxx rows=1 width=xxx)
          Join Filter: (b2t1.c1 = b2t4.c1)
-         ->  Tid Scan on t4 b2t4  (cost=xxx rows=1 width=xxx)
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop  (cost=xxx rows=1 width=xxx)
                Join Filter: (b2t1.c1 = b2t3.c1)
                ->  Merge Join  (cost=xxx rows=1 width=xxx)
@@ -4002,15 +3992,14 @@ error hint:
                            Sort Key: b2t2.c1
                            ->  Seq Scan on t2 b2t2  (cost=xxx rows=1 width=xxx)
                                  Filter: (ctid = '(1,1)'::tid)
-               ->  Materialize  (cost=xxx rows=1 width=xxx)
-                     ->  Tid Scan on t3 b2t3  (cost=xxx rows=1 width=xxx)
-                           TID Cond: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 b2t3  (cost=xxx rows=1 width=xxx)
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 b2t4  (cost=xxx rows=1 width=xxx)
+               TID Cond: (ctid = '(1,1)'::tid)
  
  Aggregate  (cost=xxx rows=1 width=xxx)
    ->  Nested Loop  (cost=xxx rows=1 width=xxx)
          Join Filter: (b3t1.c1 = b3t4.c1)
-         ->  Tid Scan on t4 b3t4  (cost=xxx rows=1 width=xxx)
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop  (cost=xxx rows=1 width=xxx)
                Join Filter: (b3t1.c1 = b3t3.c1)
                ->  Merge Join  (cost=xxx rows=1 width=xxx)
@@ -4024,10 +4013,11 @@ error hint:
                            Sort Key: b3t2.c1
                            ->  Seq Scan on t2 b3t2  (cost=xxx rows=1 width=xxx)
                                  Filter: (ctid = '(1,1)'::tid)
-               ->  Materialize  (cost=xxx rows=1 width=xxx)
-                     ->  Tid Scan on t3 b3t3  (cost=xxx rows=1 width=xxx)
-                           TID Cond: (ctid = '(1,1)'::tid)
-(65 rows)
+               ->  Tid Scan on t3 b3t3  (cost=xxx rows=1 width=xxx)
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 b3t4  (cost=xxx rows=1 width=xxx)
+               TID Cond: (ctid = '(1,1)'::tid)
+(62 rows)
 
 \o results/ut-R.tmpout
 /*+

diff --git a/expected/ut-S.out b/expected/ut-S.out
index 9cc3fc2..07ffe41 100644 (file)
--- a/expected/ut-S.out
+++ b/expected/ut-S.out
@@ -1620,8 +1620,8 @@ AND bmt1.c1 <> (
 SELECT max(b3t1.c1) FROM s1.t1 b3t1, s1.t2 b3t2 WHERE b3t1.ctid = '(1,1)' AND b3t1.c1 = b3t2.c1 AND b3t2.ctid = '(1,1)'
 )
 ;
-                        QUERY PLAN                         
------------------------------------------------------------
+                      QUERY PLAN                       
+-------------------------------------------------------
  Aggregate
    CTE c1
      ->  Aggregate
@@ -1629,37 +1629,34 @@ SELECT max(b3t1.c1) FROM s1.t1 b3t1, s1.t2 b3t2 WHERE b3t1.ctid = '(1,1)' AND b3
                  Join Filter: (b1t1.c1 = b1t2.c1)
                  ->  Tid Scan on t1 b1t1
                        TID Cond: (ctid = '(1,1)'::tid)
-                 ->  Materialize
-                       ->  Seq Scan on t2 b1t2
-                             Filter: (ctid = '(1,1)'::tid)
+                 ->  Seq Scan on t2 b1t2
+                       Filter: (ctid = '(1,1)'::tid)
    InitPlan 2 (returns $1)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b2t1.c1 = b2t2.c1)
                  ->  Tid Scan on t1 b2t1
                        TID Cond: (ctid = '(1,1)'::tid)
-                 ->  Materialize
-                       ->  Seq Scan on t2 b2t2
-                             Filter: (ctid = '(1,1)'::tid)
+                 ->  Seq Scan on t2 b2t2
+                       Filter: (ctid = '(1,1)'::tid)
    InitPlan 3 (returns $2)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b3t1.c1 = b3t2.c1)
                  ->  Tid Scan on t1 b3t1
                        TID Cond: (ctid = '(1,1)'::tid)
-                 ->  Materialize
-                       ->  Seq Scan on t2 b3t2
-                             Filter: (ctid = '(1,1)'::tid)
+                 ->  Seq Scan on t2 b3t2
+                       Filter: (ctid = '(1,1)'::tid)
    ->  Nested Loop
-         Join Filter: (bmt1.c1 = bmt2.c1)
-         ->  Seq Scan on t2 bmt2
-               Filter: (ctid = '(1,1)'::tid)
          ->  Nested Loop
-               ->  CTE Scan on c1
+               Join Filter: (bmt1.c1 = bmt2.c1)
                ->  Tid Scan on t1 bmt1
                      TID Cond: (ctid = '(1,1)'::tid)
                      Filter: (c1 <> $2)
-(37 rows)
+               ->  Seq Scan on t2 bmt2
+                     Filter: (ctid = '(1,1)'::tid)
+         ->  CTE Scan on c1
+(34 rows)
 
 /*+SeqScan(bmt1)IndexScan(bmt2 t2_pkey)
 TidScan(b1t1)SeqScan(b1t2)
@@ -1730,10 +1727,10 @@ error hint:
    ->  Nested Loop
          ->  Nested Loop
                Join Filter: (bmt1.c1 = bmt2.c1)
-               ->  Index Scan using t2_pkey on t2 bmt2
-                     Filter: (ctid = '(1,1)'::tid)
                ->  Seq Scan on t1 bmt1
                      Filter: ((c1 <> $4) AND (ctid = '(1,1)'::tid))
+               ->  Index Scan using t2_pkey on t2 bmt2
+                     Filter: (ctid = '(1,1)'::tid)
          ->  CTE Scan on c1
 (37 rows)
 
@@ -1750,79 +1747,76 @@ AND bmt1.c1 <> (
 SELECT max(b3t1.c1) FROM s1.t1 b3t1, s1.t2 b3t2, s1.t3 b3t3, s1.t4 b3t4 WHERE b3t1.ctid = '(1,1)' AND b3t1.c1 = b3t2.c1 AND b3t2.ctid = '(1,1)' AND b3t1.c1 = b3t3.c1 AND b3t3.ctid = '(1,1)' AND b3t1.c1 = b3t4.c1 AND b3t4.ctid = '(1,1)'
 )
 ;
-                              QUERY PLAN                               
------------------------------------------------------------------------
+                            QUERY PLAN                             
+-------------------------------------------------------------------
  Aggregate
    CTE c1
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b1t1.c1 = b1t4.c1)
-                 ->  Tid Scan on t4 b1t4
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b1t1.c1 = b1t3.c1)
-                       ->  Tid Scan on t3 b1t3
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b1t1.c1 = b1t2.c1)
                              ->  Tid Scan on t1 b1t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Seq Scan on t2 b1t2
-                                         Filter: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b1t2
+                                   Filter: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t3 b1t3
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t4 b1t4
+                       TID Cond: (ctid = '(1,1)'::tid)
    InitPlan 2 (returns $1)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b2t1.c1 = b2t4.c1)
-                 ->  Tid Scan on t4 b2t4
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b2t1.c1 = b2t3.c1)
-                       ->  Tid Scan on t3 b2t3
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b2t1.c1 = b2t2.c1)
                              ->  Tid Scan on t1 b2t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Seq Scan on t2 b2t2
-                                         Filter: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b2t2
+                                   Filter: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t3 b2t3
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t4 b2t4
+                       TID Cond: (ctid = '(1,1)'::tid)
    InitPlan 3 (returns $2)
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b3t1.c1 = b3t4.c1)
-                 ->  Tid Scan on t4 b3t4
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b3t1.c1 = b3t3.c1)
-                       ->  Tid Scan on t3 b3t3
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b3t1.c1 = b3t2.c1)
                              ->  Tid Scan on t1 b3t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Seq Scan on t2 b3t2
-                                         Filter: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b3t2
+                                   Filter: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t3 b3t3
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t4 b3t4
+                       TID Cond: (ctid = '(1,1)'::tid)
    ->  Nested Loop
-         Join Filter: (bmt1.c1 = bmt4.c1)
-         ->  Tid Scan on t4 bmt4
-               TID Cond: (ctid = '(1,1)'::tid)
+         Join Filter: (bmt1.c1 = c1.c1)
          ->  Nested Loop
-               Join Filter: (bmt1.c1 = bmt3.c1)
-               ->  Tid Scan on t3 bmt3
-                     TID Cond: (ctid = '(1,1)'::tid)
+               Join Filter: (bmt1.c1 = bmt4.c1)
                ->  Nested Loop
-                     Join Filter: (bmt1.c1 = bmt2.c1)
-                     ->  Seq Scan on t2 bmt2
-                           Filter: (ctid = '(1,1)'::tid)
+                     Join Filter: (bmt1.c1 = bmt3.c1)
                      ->  Nested Loop
-                           Join Filter: (bmt1.c1 = c1.c1)
+                           Join Filter: (bmt1.c1 = bmt2.c1)
                            ->  Tid Scan on t1 bmt1
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 <> $2)
-                           ->  CTE Scan on c1
-(70 rows)
+                           ->  Seq Scan on t2 bmt2
+                                 Filter: (ctid = '(1,1)'::tid)
+                     ->  Tid Scan on t3 bmt3
+                           TID Cond: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t4 bmt4
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  CTE Scan on c1
+(67 rows)
 
 /*+SeqScan(bmt1)IndexScan(bmt2 t2_pkey)BitmapScan(bmt3 t3_pkey)TidScan(bmt4)
 TidScan(b1t1)SeqScan(b1t2)IndexScan(b1t3 t3_pkey)BitmapScan(b1t4 t4_pkey)
@@ -1877,7 +1871,9 @@ error hint:
    CTE c1
      ->  Aggregate
            ->  Nested Loop
+                 Join Filter: (b1t1.c1 = b1t4.c1)
                  ->  Nested Loop
+                       Join Filter: (b1t1.c1 = b1t3.c1)
                        ->  Nested Loop
                              Join Filter: (b1t1.c1 = b1t2.c1)
                              ->  Tid Scan on t1 b1t1
@@ -1885,69 +1881,75 @@ error hint:
                              ->  Seq Scan on t2 b1t2
                                    Filter: (ctid = '(1,1)'::tid)
                        ->  Index Scan using t3_pkey on t3 b1t3
-                             Index Cond: (c1 = b1t1.c1)
+                             Index Cond: (c1 = b1t2.c1)
                              Filter: (ctid = '(1,1)'::tid)
                  ->  Bitmap Heap Scan on t4 b1t4
-                       Recheck Cond: (c1 = b1t1.c1)
+                       Recheck Cond: (c1 = b1t2.c1)
                        Filter: (ctid = '(1,1)'::tid)
                        ->  Bitmap Index Scan on t4_pkey
-                             Index Cond: (c1 = b1t1.c1)
+                             Index Cond: (c1 = b1t2.c1)
    InitPlan 2 (returns $4)
      ->  Aggregate
            ->  Nested Loop
+                 Join Filter: (b2t1.c1 = b2t4.c1)
                  ->  Nested Loop
-                       Join Filter: (b2t1.c1 = b2t3.c1)
+                       Join Filter: (b2t2.c1 = b2t1.c1)
                        ->  Nested Loop
+                             Join Filter: (b2t2.c1 = b2t3.c1)
                              ->  Tid Scan on t2 b2t2
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Bitmap Heap Scan on t1 b2t1
-                                   Recheck Cond: (c1 = b2t2.c1)
+                             ->  Seq Scan on t3 b2t3
                                    Filter: (ctid = '(1,1)'::tid)
-                                   ->  Bitmap Index Scan on t1_pkey
-                                         Index Cond: (c1 = b2t2.c1)
-                       ->  Seq Scan on t3 b2t3
+                       ->  Bitmap Heap Scan on t1 b2t1
+                             Recheck Cond: (c1 = b2t3.c1)
                              Filter: (ctid = '(1,1)'::tid)
+                             ->  Bitmap Index Scan on t1_pkey
+                                   Index Cond: (c1 = b2t3.c1)
                  ->  Index Scan using t4_pkey on t4 b2t4
-                       Index Cond: (c1 = b2t1.c1)
+                       Index Cond: (c1 = b2t2.c1)
                        Filter: (ctid = '(1,1)'::tid)
    InitPlan 3 (returns $7)
      ->  Aggregate
            ->  Nested Loop
-                 Join Filter: (b3t1.c1 = b3t4.c1)
+                 Join Filter: (b3t1.c1 = b3t2.c1)
                  ->  Nested Loop
+                       Join Filter: (b3t3.c1 = b3t1.c1)
                        ->  Nested Loop
+                             Join Filter: (b3t3.c1 = b3t4.c1)
                              ->  Tid Scan on t3 b3t3
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Index Scan using t1_pkey on t1 b3t1
-                                   Index Cond: (c1 = b3t3.c1)
+                             ->  Seq Scan on t4 b3t4
                                    Filter: (ctid = '(1,1)'::tid)
-                       ->  Bitmap Heap Scan on t2 b3t2
-                             Recheck Cond: (c1 = b3t1.c1)
+                       ->  Index Scan using t1_pkey on t1 b3t1
+                             Index Cond: (c1 = b3t4.c1)
                              Filter: (ctid = '(1,1)'::tid)
-                             ->  Bitmap Index Scan on t2_pkey
-                                   Index Cond: (c1 = b3t1.c1)
-                 ->  Seq Scan on t4 b3t4
+                 ->  Bitmap Heap Scan on t2 b3t2
+                       Recheck Cond: (c1 = b3t3.c1)
                        Filter: (ctid = '(1,1)'::tid)
+                       ->  Bitmap Index Scan on t2_pkey
+                             Index Cond: (c1 = b3t3.c1)
    ->  Nested Loop
          Join Filter: (bmt1.c1 = c1.c1)
          ->  Nested Loop
-               Join Filter: (bmt1.c1 = bmt4.c1)
+               Join Filter: (bmt1.c1 = bmt3.c1)
                ->  Nested Loop
+                     Join Filter: (bmt1.c1 = bmt2.c1)
                      ->  Nested Loop
-                           Join Filter: (bmt1.c1 = bmt2.c1)
-                           ->  Index Scan using t2_pkey on t2 bmt2
-                                 Filter: (ctid = '(1,1)'::tid)
+                           Join Filter: (bmt1.c1 = bmt4.c1)
                            ->  Seq Scan on t1 bmt1
                                  Filter: ((c1 <> $7) AND (ctid = '(1,1)'::tid))
-                     ->  Bitmap Heap Scan on t3 bmt3
-                           Recheck Cond: (c1 = bmt1.c1)
+                           ->  Tid Scan on t4 bmt4
+                                 TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Index Scan using t2_pkey on t2 bmt2
+                           Index Cond: (c1 = bmt4.c1)
                            Filter: (ctid = '(1,1)'::tid)
-                           ->  Bitmap Index Scan on t3_pkey
-                                 Index Cond: (c1 = bmt1.c1)
-               ->  Tid Scan on t4 bmt4
-                     TID Cond: (ctid = '(1,1)'::tid)
+               ->  Bitmap Heap Scan on t3 bmt3
+                     Recheck Cond: (c1 = bmt2.c1)
+                     Filter: (ctid = '(1,1)'::tid)
+                     ->  Bitmap Index Scan on t3_pkey
+                           Index Cond: (c1 = bmt2.c1)
          ->  CTE Scan on c1
-(74 rows)
+(82 rows)
 
 -- No. S-2-2-4
 EXPLAIN (COSTS false)
@@ -1962,26 +1964,25 @@ AND bmt1.c1 <> (
 SELECT max(b3t1.c1) FROM s1.t1 b3t1 WHERE b3t1.ctid = '(1,1)'
 )
 ;
-                              QUERY PLAN                               
------------------------------------------------------------------------
+                            QUERY PLAN                             
+-------------------------------------------------------------------
  Aggregate
    CTE c1
      ->  Aggregate
            ->  Nested Loop
                  Join Filter: (b1t1.c1 = b1t4.c1)
-                 ->  Tid Scan on t4 b1t4
-                       TID Cond: (ctid = '(1,1)'::tid)
                  ->  Nested Loop
                        Join Filter: (b1t1.c1 = b1t3.c1)
-                       ->  Tid Scan on t3 b1t3
-                             TID Cond: (ctid = '(1,1)'::tid)
                        ->  Nested Loop
                              Join Filter: (b1t1.c1 = b1t2.c1)
                              ->  Tid Scan on t1 b1t1
                                    TID Cond: (ctid = '(1,1)'::tid)
-                             ->  Materialize
-                                   ->  Seq Scan on t2 b1t2
-                                         Filter: (ctid = '(1,1)'::tid)
+                             ->  Seq Scan on t2 b1t2
+                                   Filter: (ctid = '(1,1)'::tid)
+                       ->  Tid Scan on t3 b1t3
+                             TID Cond: (ctid = '(1,1)'::tid)
+                 ->  Tid Scan on t4 b1t4
+                       TID Cond: (ctid = '(1,1)'::tid)
    InitPlan 3 (returns $2)
      ->  Result
            InitPlan 2 (returns $1)
@@ -1994,24 +1995,24 @@ SELECT max(b3t1.c1) FROM s1.t1 b3t1 WHERE b3t1.ctid = '(1,1)'
            ->  Tid Scan on t1 b3t1
                  TID Cond: (ctid = '(1,1)'::tid)
    ->  Nested Loop
-         Join Filter: (bmt1.c1 = bmt4.c1)
-         ->  Tid Scan on t4 bmt4
-               TID Cond: (ctid = '(1,1)'::tid)
+         Join Filter: (bmt1.c1 = c1.c1)
          ->  Nested Loop
-               Join Filter: (bmt1.c1 = bmt3.c1)
-               ->  Tid Scan on t3 bmt3
-                     TID Cond: (ctid = '(1,1)'::tid)
+               Join Filter: (bmt1.c1 = bmt4.c1)
                ->  Nested Loop
-                     Join Filter: (bmt1.c1 = bmt2.c1)
-                     ->  Seq Scan on t2 bmt2
-                           Filter: (ctid = '(1,1)'::tid)
+                     Join Filter: (bmt1.c1 = bmt3.c1)
                      ->  Nested Loop
-                           Join Filter: (bmt1.c1 = c1.c1)
+                           Join Filter: (bmt1.c1 = bmt2.c1)
                            ->  Tid Scan on t1 bmt1
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 <> $4)
-                           ->  CTE Scan on c1
-(47 rows)
+                           ->  Seq Scan on t2 bmt2
+                                 Filter: (ctid = '(1,1)'::tid)
+                     ->  Tid Scan on t3 bmt3
+                           TID Cond: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t4 bmt4
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  CTE Scan on c1
+(46 rows)
 
 /*+SeqScan(bmt1)IndexScan(bmt2 t2_pkey)BitmapScan(bmt3 t3_pkey)TidScan(bmt4)
 TidScan(b1t1)SeqScan(b1t2)IndexScan(b1t3 t3_pkey)BitmapScan(b1t4 t4_pkey)
@@ -2060,7 +2061,9 @@ error hint:
    CTE c1
      ->  Aggregate
            ->  Nested Loop
+                 Join Filter: (b1t1.c1 = b1t4.c1)
                  ->  Nested Loop
+                       Join Filter: (b1t1.c1 = b1t3.c1)
                        ->  Nested Loop
                              Join Filter: (b1t1.c1 = b1t2.c1)
                              ->  Tid Scan on t1 b1t1
@@ -2068,13 +2071,13 @@ error hint:
                              ->  Seq Scan on t2 b1t2
                                    Filter: (ctid = '(1,1)'::tid)
                        ->  Index Scan using t3_pkey on t3 b1t3
-                             Index Cond: (c1 = b1t1.c1)
+                             Index Cond: (c1 = b1t2.c1)
                              Filter: (ctid = '(1,1)'::tid)
                  ->  Bitmap Heap Scan on t4 b1t4
-                       Recheck Cond: (c1 = b1t1.c1)
+                       Recheck Cond: (c1 = b1t2.c1)
                        Filter: (ctid = '(1,1)'::tid)
                        ->  Bitmap Index Scan on t4_pkey
-                             Index Cond: (c1 = b1t1.c1)
+                             Index Cond: (c1 = b1t2.c1)
    InitPlan 3 (returns $3)
      ->  Result
            InitPlan 2 (returns $2)
@@ -2094,23 +2097,25 @@ error hint:
    ->  Nested Loop
          Join Filter: (bmt1.c1 = c1.c1)
          ->  Nested Loop
-               Join Filter: (bmt1.c1 = bmt4.c1)
+               Join Filter: (bmt1.c1 = bmt3.c1)
                ->  Nested Loop
+                     Join Filter: (bmt1.c1 = bmt2.c1)
                      ->  Nested Loop
-                           Join Filter: (bmt1.c1 = bmt2.c1)
-                           ->  Index Scan using t2_pkey on t2 bmt2
-                                 Filter: (ctid = '(1,1)'::tid)
+                           Join Filter: (bmt1.c1 = bmt4.c1)
                            ->  Seq Scan on t1 bmt1
                                  Filter: ((c1 <> $5) AND (ctid = '(1,1)'::tid))
-                     ->  Bitmap Heap Scan on t3 bmt3
-                           Recheck Cond: (c1 = bmt1.c1)
+                           ->  Tid Scan on t4 bmt4
+                                 TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Index Scan using t2_pkey on t2 bmt2
+                           Index Cond: (c1 = bmt4.c1)
                            Filter: (ctid = '(1,1)'::tid)
-                           ->  Bitmap Index Scan on t3_pkey
-                                 Index Cond: (c1 = bmt1.c1)
-               ->  Tid Scan on t4 bmt4
-                     TID Cond: (ctid = '(1,1)'::tid)
+               ->  Bitmap Heap Scan on t3 bmt3
+                     Recheck Cond: (c1 = bmt2.c1)
+                     Filter: (ctid = '(1,1)'::tid)
+                     ->  Bitmap Index Scan on t3_pkey
+                           Index Cond: (c1 = bmt2.c1)
          ->  CTE Scan on c1
-(54 rows)
+(58 rows)
 
 ----
 ---- No. S-2-3 RULE or VIEW
@@ -2122,22 +2127,22 @@ EXPLAIN (COSTS false) UPDATE s1.r1 SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
  Aggregate
    ->  Nested Loop
          Join Filter: (t1.c1 = t4.c1)
-         ->  Tid Scan on t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (t1.c1 = t3.c1)
-               ->  Tid Scan on t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (t1.c1 = t2.c1)
-                     ->  Seq Scan on t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r1
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4
+               TID Cond: (ctid = '(1,1)'::tid)
 (19 rows)
 
 /*+TidScan(t1)SeqScan(t2)IndexScan(t3 t3_pkey)BitmapScan(t4 t4_pkey)
@@ -2160,7 +2165,9 @@ error hint:
 ------------------------------------------------------------------------------
  Aggregate
    ->  Nested Loop
+         Join Filter: (t1.c1 = t4.c1)
          ->  Nested Loop
+               Join Filter: (t1.c1 = t3.c1)
                ->  Nested Loop
                      Join Filter: (t1.c1 = t2.c1)
                      ->  Nested Loop
@@ -2171,14 +2178,14 @@ error hint:
                      ->  Seq Scan on t2
                            Filter: (ctid = '(1,1)'::tid)
                ->  Index Scan using t3_pkey on t3
-                     Index Cond: (c1 = t1.c1)
+                     Index Cond: (c1 = t2.c1)
                      Filter: (ctid = '(1,1)'::tid)
          ->  Bitmap Heap Scan on t4
-               Recheck Cond: (c1 = t1.c1)
+               Recheck Cond: (c1 = t2.c1)
                Filter: (ctid = '(1,1)'::tid)
                ->  Bitmap Index Scan on t4_pkey
-                     Index Cond: (c1 = t1.c1)
-(20 rows)
+                     Index Cond: (c1 = t2.c1)
+(22 rows)
 
 EXPLAIN (COSTS false) UPDATE s1.r1_ SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
                            QUERY PLAN                            
@@ -2186,22 +2193,22 @@ EXPLAIN (COSTS false) UPDATE s1.r1_ SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
  Aggregate
    ->  Nested Loop
          Join Filter: (b1t1.c1 = b1t4.c1)
-         ->  Tid Scan on t4 b1t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (b1t1.c1 = b1t3.c1)
-               ->  Tid Scan on t3 b1t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (b1t1.c1 = b1t2.c1)
-                     ->  Seq Scan on t2 b1t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r1_
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1 b1t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2 b1t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 b1t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 b1t4
+               TID Cond: (ctid = '(1,1)'::tid)
 (19 rows)
 
 /*+TidScan(b1t1)SeqScan(b1t2)IndexScan(b1t3 t3_pkey)BitmapScan(b1t4 t4_pkey)
@@ -2224,7 +2231,9 @@ error hint:
 ------------------------------------------------------------------------------
  Aggregate
    ->  Nested Loop
+         Join Filter: (b1t1.c1 = b1t4.c1)
          ->  Nested Loop
+               Join Filter: (b1t1.c1 = b1t3.c1)
                ->  Nested Loop
                      Join Filter: (b1t1.c1 = b1t2.c1)
                      ->  Nested Loop
@@ -2235,14 +2244,14 @@ error hint:
                      ->  Seq Scan on t2 b1t2
                            Filter: (ctid = '(1,1)'::tid)
                ->  Index Scan using t3_pkey on t3 b1t3
-                     Index Cond: (c1 = b1t1.c1)
+                     Index Cond: (c1 = b1t2.c1)
                      Filter: (ctid = '(1,1)'::tid)
          ->  Bitmap Heap Scan on t4 b1t4
-               Recheck Cond: (c1 = b1t1.c1)
+               Recheck Cond: (c1 = b1t2.c1)
                Filter: (ctid = '(1,1)'::tid)
                ->  Bitmap Index Scan on t4_pkey
-                     Index Cond: (c1 = b1t1.c1)
-(20 rows)
+                     Index Cond: (c1 = b1t2.c1)
+(22 rows)
 
 -- No. S-2-3-2
 EXPLAIN (COSTS false) UPDATE s1.r2 SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
@@ -2251,42 +2260,42 @@ EXPLAIN (COSTS false) UPDATE s1.r2 SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
  Aggregate
    ->  Nested Loop
          Join Filter: (t1.c1 = t4.c1)
-         ->  Tid Scan on t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (t1.c1 = t3.c1)
-               ->  Tid Scan on t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (t1.c1 = t2.c1)
-                     ->  Seq Scan on t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r2
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4
+               TID Cond: (ctid = '(1,1)'::tid)
  
  Aggregate
    ->  Nested Loop
          Join Filter: (t1.c1 = t4.c1)
-         ->  Tid Scan on t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (t1.c1 = t3.c1)
-               ->  Tid Scan on t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (t1.c1 = t2.c1)
-                     ->  Seq Scan on t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r2
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4
+               TID Cond: (ctid = '(1,1)'::tid)
 (39 rows)
 
 /*+TidScan(t1)SeqScan(t2)IndexScan(t3 t3_pkey)BitmapScan(t4 t4_pkey)
@@ -2322,7 +2331,9 @@ error hint:
 ------------------------------------------------------------------------------
  Aggregate
    ->  Nested Loop
+         Join Filter: (t1.c1 = t4.c1)
          ->  Nested Loop
+               Join Filter: (t1.c1 = t3.c1)
                ->  Nested Loop
                      Join Filter: (t1.c1 = t2.c1)
                      ->  Nested Loop
@@ -2333,17 +2344,19 @@ error hint:
                      ->  Seq Scan on t2
                            Filter: (ctid = '(1,1)'::tid)
                ->  Index Scan using t3_pkey on t3
-                     Index Cond: (c1 = t1.c1)
+                     Index Cond: (c1 = t2.c1)
                      Filter: (ctid = '(1,1)'::tid)
          ->  Bitmap Heap Scan on t4
-               Recheck Cond: (c1 = t1.c1)
+               Recheck Cond: (c1 = t2.c1)
                Filter: (ctid = '(1,1)'::tid)
                ->  Bitmap Index Scan on t4_pkey
-                     Index Cond: (c1 = t1.c1)
+                     Index Cond: (c1 = t2.c1)
  
  Aggregate
    ->  Nested Loop
+         Join Filter: (t1.c1 = t4.c1)
          ->  Nested Loop
+               Join Filter: (t1.c1 = t3.c1)
                ->  Nested Loop
                      Join Filter: (t1.c1 = t2.c1)
                      ->  Nested Loop
@@ -2354,14 +2367,14 @@ error hint:
                      ->  Seq Scan on t2
                            Filter: (ctid = '(1,1)'::tid)
                ->  Index Scan using t3_pkey on t3
-                     Index Cond: (c1 = t1.c1)
+                     Index Cond: (c1 = t2.c1)
                      Filter: (ctid = '(1,1)'::tid)
          ->  Bitmap Heap Scan on t4
-               Recheck Cond: (c1 = t1.c1)
+               Recheck Cond: (c1 = t2.c1)
                Filter: (ctid = '(1,1)'::tid)
                ->  Bitmap Index Scan on t4_pkey
-                     Index Cond: (c1 = t1.c1)
-(41 rows)
+                     Index Cond: (c1 = t2.c1)
+(45 rows)
 
 EXPLAIN (COSTS false) UPDATE s1.r2_ SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
                            QUERY PLAN                            
@@ -2369,42 +2382,42 @@ EXPLAIN (COSTS false) UPDATE s1.r2_ SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
  Aggregate
    ->  Nested Loop
          Join Filter: (b1t1.c1 = b1t4.c1)
-         ->  Tid Scan on t4 b1t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (b1t1.c1 = b1t3.c1)
-               ->  Tid Scan on t3 b1t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (b1t1.c1 = b1t2.c1)
-                     ->  Seq Scan on t2 b1t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r2_
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1 b1t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2 b1t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 b1t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 b1t4
+               TID Cond: (ctid = '(1,1)'::tid)
  
  Aggregate
    ->  Nested Loop
          Join Filter: (b2t1.c1 = b2t4.c1)
-         ->  Tid Scan on t4 b2t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (b2t1.c1 = b2t3.c1)
-               ->  Tid Scan on t3 b2t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (b2t1.c1 = b2t2.c1)
-                     ->  Seq Scan on t2 b2t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r2_
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1 b2t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2 b2t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 b2t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 b2t4
+               TID Cond: (ctid = '(1,1)'::tid)
 (39 rows)
 
 /*+TidScan(b1t1)SeqScan(b1t2)IndexScan(b1t3 t3_pkey)BitmapScan(b1t4 t4_pkey)
@@ -2449,7 +2462,9 @@ error hint:
 ------------------------------------------------------------------------------
  Aggregate
    ->  Nested Loop
+         Join Filter: (b1t1.c1 = b1t4.c1)
          ->  Nested Loop
+               Join Filter: (b1t1.c1 = b1t3.c1)
                ->  Nested Loop
                      Join Filter: (b1t1.c1 = b1t2.c1)
                      ->  Nested Loop
@@ -2460,35 +2475,37 @@ error hint:
                      ->  Seq Scan on t2 b1t2
                            Filter: (ctid = '(1,1)'::tid)
                ->  Index Scan using t3_pkey on t3 b1t3
-                     Index Cond: (c1 = b1t1.c1)
+                     Index Cond: (c1 = b1t2.c1)
                      Filter: (ctid = '(1,1)'::tid)
          ->  Bitmap Heap Scan on t4 b1t4
-               Recheck Cond: (c1 = b1t1.c1)
+               Recheck Cond: (c1 = b1t2.c1)
                Filter: (ctid = '(1,1)'::tid)
                ->  Bitmap Index Scan on t4_pkey
-                     Index Cond: (c1 = b1t1.c1)
+                     Index Cond: (c1 = b1t2.c1)
  
  Aggregate
    ->  Nested Loop
+         Join Filter: (b2t1.c1 = b2t4.c1)
          ->  Nested Loop
-               Join Filter: (b2t1.c1 = b2t3.c1)
+               Join Filter: (b2t2.c1 = b2t1.c1)
                ->  Nested Loop
+                     Join Filter: (b2t2.c1 = b2t3.c1)
                      ->  Nested Loop
                            ->  Seq Scan on r2_
                                  Filter: ((ctid = '(1,1)'::tid) AND (c1 = 1))
                            ->  Tid Scan on t2 b2t2
                                  TID Cond: (ctid = '(1,1)'::tid)
-                     ->  Bitmap Heap Scan on t1 b2t1
-                           Recheck Cond: (c1 = b2t2.c1)
+                     ->  Seq Scan on t3 b2t3
                            Filter: (ctid = '(1,1)'::tid)
-                           ->  Bitmap Index Scan on t1_pkey
-                                 Index Cond: (c1 = b2t2.c1)
-               ->  Seq Scan on t3 b2t3
+               ->  Bitmap Heap Scan on t1 b2t1
+                     Recheck Cond: (c1 = b2t3.c1)
                      Filter: (ctid = '(1,1)'::tid)
+                     ->  Bitmap Index Scan on t1_pkey
+                           Index Cond: (c1 = b2t3.c1)
          ->  Index Scan using t4_pkey on t4 b2t4
-               Index Cond: (c1 = b2t1.c1)
+               Index Cond: (c1 = b2t2.c1)
                Filter: (ctid = '(1,1)'::tid)
-(41 rows)
+(45 rows)
 
 -- No. S-2-3-3
 EXPLAIN (COSTS false) UPDATE s1.r3 SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
@@ -2497,62 +2514,62 @@ EXPLAIN (COSTS false) UPDATE s1.r3 SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
  Aggregate
    ->  Nested Loop
          Join Filter: (t1.c1 = t4.c1)
-         ->  Tid Scan on t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (t1.c1 = t3.c1)
-               ->  Tid Scan on t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (t1.c1 = t2.c1)
-                     ->  Seq Scan on t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r3
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4
+               TID Cond: (ctid = '(1,1)'::tid)
  
  Aggregate
    ->  Nested Loop
          Join Filter: (t1.c1 = t4.c1)
-         ->  Tid Scan on t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (t1.c1 = t3.c1)
-               ->  Tid Scan on t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (t1.c1 = t2.c1)
-                     ->  Seq Scan on t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r3
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4
+               TID Cond: (ctid = '(1,1)'::tid)
  
  Aggregate
    ->  Nested Loop
          Join Filter: (t1.c1 = t4.c1)
-         ->  Tid Scan on t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (t1.c1 = t3.c1)
-               ->  Tid Scan on t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (t1.c1 = t2.c1)
-                     ->  Seq Scan on t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r3
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4
+               TID Cond: (ctid = '(1,1)'::tid)
 (59 rows)
 
 /*+TidScan(t1)SeqScan(t2)IndexScan(t3 t3_pkey)BitmapScan(t4 t4_pkey)
@@ -2601,7 +2618,9 @@ error hint:
 ------------------------------------------------------------------------------
  Aggregate
    ->  Nested Loop
+         Join Filter: (t1.c1 = t4.c1)
          ->  Nested Loop
+               Join Filter: (t1.c1 = t3.c1)
                ->  Nested Loop
                      Join Filter: (t1.c1 = t2.c1)
                      ->  Nested Loop
@@ -2612,17 +2631,19 @@ error hint:
                      ->  Seq Scan on t2
                            Filter: (ctid = '(1,1)'::tid)
                ->  Index Scan using t3_pkey on t3
-                     Index Cond: (c1 = t1.c1)
+                     Index Cond: (c1 = t2.c1)
                      Filter: (ctid = '(1,1)'::tid)
          ->  Bitmap Heap Scan on t4
-               Recheck Cond: (c1 = t1.c1)
+               Recheck Cond: (c1 = t2.c1)
                Filter: (ctid = '(1,1)'::tid)
                ->  Bitmap Index Scan on t4_pkey
-                     Index Cond: (c1 = t1.c1)
+                     Index Cond: (c1 = t2.c1)
  
  Aggregate
    ->  Nested Loop
+         Join Filter: (t1.c1 = t4.c1)
          ->  Nested Loop
+               Join Filter: (t1.c1 = t3.c1)
                ->  Nested Loop
                      Join Filter: (t1.c1 = t2.c1)
                      ->  Nested Loop
@@ -2633,17 +2654,19 @@ error hint:
                      ->  Seq Scan on t2
                            Filter: (ctid = '(1,1)'::tid)
                ->  Index Scan using t3_pkey on t3
-                     Index Cond: (c1 = t1.c1)
+                     Index Cond: (c1 = t2.c1)
                      Filter: (ctid = '(1,1)'::tid)
          ->  Bitmap Heap Scan on t4
-               Recheck Cond: (c1 = t1.c1)
+               Recheck Cond: (c1 = t2.c1)
                Filter: (ctid = '(1,1)'::tid)
                ->  Bitmap Index Scan on t4_pkey
-                     Index Cond: (c1 = t1.c1)
+                     Index Cond: (c1 = t2.c1)
  
  Aggregate
    ->  Nested Loop
+         Join Filter: (t1.c1 = t4.c1)
          ->  Nested Loop
+               Join Filter: (t1.c1 = t3.c1)
                ->  Nested Loop
                      Join Filter: (t1.c1 = t2.c1)
                      ->  Nested Loop
@@ -2654,14 +2677,14 @@ error hint:
                      ->  Seq Scan on t2
                            Filter: (ctid = '(1,1)'::tid)
                ->  Index Scan using t3_pkey on t3
-                     Index Cond: (c1 = t1.c1)
+                     Index Cond: (c1 = t2.c1)
                      Filter: (ctid = '(1,1)'::tid)
          ->  Bitmap Heap Scan on t4
-               Recheck Cond: (c1 = t1.c1)
+               Recheck Cond: (c1 = t2.c1)
                Filter: (ctid = '(1,1)'::tid)
                ->  Bitmap Index Scan on t4_pkey
-                     Index Cond: (c1 = t1.c1)
-(62 rows)
+                     Index Cond: (c1 = t2.c1)
+(68 rows)
 
 EXPLAIN (COSTS false) UPDATE s1.r3_ SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
                            QUERY PLAN                            
@@ -2669,62 +2692,62 @@ EXPLAIN (COSTS false) UPDATE s1.r3_ SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
  Aggregate
    ->  Nested Loop
          Join Filter: (b1t1.c1 = b1t4.c1)
-         ->  Tid Scan on t4 b1t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (b1t1.c1 = b1t3.c1)
-               ->  Tid Scan on t3 b1t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (b1t1.c1 = b1t2.c1)
-                     ->  Seq Scan on t2 b1t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r3_
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1 b1t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2 b1t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 b1t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 b1t4
+               TID Cond: (ctid = '(1,1)'::tid)
  
  Aggregate
    ->  Nested Loop
          Join Filter: (b2t1.c1 = b2t4.c1)
-         ->  Tid Scan on t4 b2t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (b2t1.c1 = b2t3.c1)
-               ->  Tid Scan on t3 b2t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (b2t1.c1 = b2t2.c1)
-                     ->  Seq Scan on t2 b2t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r3_
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1 b2t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2 b2t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 b2t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 b2t4
+               TID Cond: (ctid = '(1,1)'::tid)
  
  Aggregate
    ->  Nested Loop
          Join Filter: (b3t1.c1 = b3t4.c1)
-         ->  Tid Scan on t4 b3t4
-               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
                Join Filter: (b3t1.c1 = b3t3.c1)
-               ->  Tid Scan on t3 b3t3
-                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
                      Join Filter: (b3t1.c1 = b3t2.c1)
-                     ->  Seq Scan on t2 b3t2
-                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
                            ->  Tid Scan on r3_
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 = 1)
                            ->  Tid Scan on t1 b3t1
                                  TID Cond: (ctid = '(1,1)'::tid)
+                     ->  Seq Scan on t2 b3t2
+                           Filter: (ctid = '(1,1)'::tid)
+               ->  Tid Scan on t3 b3t3
+                     TID Cond: (ctid = '(1,1)'::tid)
+         ->  Tid Scan on t4 b3t4
+               TID Cond: (ctid = '(1,1)'::tid)
 (59 rows)
 
 /*+TidScan(b1t1)SeqScan(b1t2)IndexScan(b1t3 t3_pkey)BitmapScan(b1t4 t4_pkey)
@@ -2799,7 +2822,9 @@ error hint:
 ------------------------------------------------------------------------------
  Aggregate
    ->  Nested Loop
+         Join Filter: (b1t1.c1 = b1t4.c1)
          ->  Nested Loop
+               Join Filter: (b1t1.c1 = b1t3.c1)
                ->  Nested Loop
                      Join Filter: (b1t1.c1 = b1t2.c1)
                      ->  Nested Loop
@@ -2810,56 +2835,60 @@ error hint:
                      ->  Seq Scan on t2 b1t2
                            Filter: (ctid = '(1,1)'::tid)
                ->  Index Scan using t3_pkey on t3 b1t3
-                     Index Cond: (c1 = b1t1.c1)
+                     Index Cond: (c1 = b1t2.c1)
                      Filter: (ctid = '(1,1)'::tid)
          ->  Bitmap Heap Scan on t4 b1t4
-               Recheck Cond: (c1 = b1t1.c1)
+               Recheck Cond: (c1 = b1t2.c1)
                Filter: (ctid = '(1,1)'::tid)
                ->  Bitmap Index Scan on t4_pkey
-                     Index Cond: (c1 = b1t1.c1)
+                     Index Cond: (c1 = b1t2.c1)
  
  Aggregate
    ->  Nested Loop
+         Join Filter: (b2t1.c1 = b2t4.c1)
          ->  Nested Loop
-               Join Filter: (b2t1.c1 = b2t3.c1)
+               Join Filter: (b2t2.c1 = b2t1.c1)
                ->  Nested Loop
+                     Join Filter: (b2t2.c1 = b2t3.c1)
                      ->  Nested Loop
                            ->  Seq Scan on r3_
                                  Filter: ((ctid = '(1,1)'::tid) AND (c1 = 1))
                            ->  Tid Scan on t2 b2t2
                                  TID Cond: (ctid = '(1,1)'::tid)
-                     ->  Bitmap Heap Scan on t1 b2t1
-                           Recheck Cond: (c1 = b2t2.c1)
+                     ->  Seq Scan on t3 b2t3
                            Filter: (ctid = '(1,1)'::tid)
-                           ->  Bitmap Index Scan on t1_pkey
-                                 Index Cond: (c1 = b2t2.c1)
-               ->  Seq Scan on t3 b2t3
+               ->  Bitmap Heap Scan on t1 b2t1
+                     Recheck Cond: (c1 = b2t3.c1)
                      Filter: (ctid = '(1,1)'::tid)
+                     ->  Bitmap Index Scan on t1_pkey
+                           Index Cond: (c1 = b2t3.c1)
          ->  Index Scan using t4_pkey on t4 b2t4
-               Index Cond: (c1 = b2t1.c1)
+               Index Cond: (c1 = b2t2.c1)
                Filter: (ctid = '(1,1)'::tid)
  
  Aggregate
    ->  Nested Loop
-         Join Filter: (b3t1.c1 = b3t4.c1)
+         Join Filter: (b3t1.c1 = b3t2.c1)
          ->  Nested Loop
+               Join Filter: (b3t3.c1 = b3t1.c1)
                ->  Nested Loop
+                     Join Filter: (b3t3.c1 = b3t4.c1)
                      ->  Nested Loop
                            ->  Seq Scan on r3_
                                  Filter: ((ctid = '(1,1)'::tid) AND (c1 = 1))
                            ->  Tid Scan on t3 b3t3
                                  TID Cond: (ctid = '(1,1)'::tid)
-                     ->  Index Scan using t1_pkey on t1 b3t1
-                           Index Cond: (c1 = b3t3.c1)
+                     ->  Seq Scan on t4 b3t4
                            Filter: (ctid = '(1,1)'::tid)
-               ->  Bitmap Heap Scan on t2 b3t2
-                     Recheck Cond: (c1 = b3t1.c1)
+               ->  Index Scan using t1_pkey on t1 b3t1
+                     Index Cond: (c1 = b3t4.c1)
                      Filter: (ctid = '(1,1)'::tid)
-                     ->  Bitmap Index Scan on t2_pkey
-                           Index Cond: (c1 = b3t1.c1)
-         ->  Seq Scan on t4 b3t4
+         ->  Bitmap Heap Scan on t2 b3t2
+               Recheck Cond: (c1 = b3t3.c1)
                Filter: (ctid = '(1,1)'::tid)
-(62 rows)
+               ->  Bitmap Index Scan on t2_pkey
+                     Index Cond: (c1 = b3t3.c1)
+(68 rows)
 
 -- No. S-2-3-4
 EXPLAIN (COSTS false) SELECT * FROM s1.v1 v1, s1.v1 v2 WHERE v1.c1 = v2.c1;
@@ -4605,13 +4634,12 @@ error hint:
 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1 AND t1.ctid = '(1,1)';
                QUERY PLAN                
 -----------------------------------------
- Hash Join
-   Hash Cond: (t1.c1 = t2.c1)
+ Nested Loop
+   Join Filter: (t1.c1 = t2.c1)
    ->  Tid Scan on t1
          TID Cond: (ctid = '(1,1)'::tid)
-   ->  Hash
-         ->  Seq Scan on t2
-(6 rows)
+   ->  Seq Scan on t2
+(5 rows)
 
 -- No. S-3-6-1
 /*+SeqScan(t1)*/

diff --git a/expected/ut-fdw.out~ b/expected/ut-fdw.out~
new file mode 100644 (file)
index 0000000..d1cb57c
--- /dev/null
+++ b/expected/ut-fdw.out~
@@ -0,0 +1,144 @@
+LOAD 'pg_hint_plan';
+SET search_path TO public;
+SET pg_hint_plan.debug_print TO on;
+SET client_min_messages TO LOG;
+SET pg_hint_plan.enable_hint TO on;
+CREATE EXTENSION file_fdw;
+CREATE SERVER file_server FOREIGN DATA WRAPPER file_fdw;
+CREATE USER MAPPING FOR PUBLIC SERVER file_server;
+CREATE FOREIGN TABLE ft1 (id int, val int) SERVER file_server OPTIONS (format 'csv', filename '/home/horiguti/work/pg_hint_plan/pg_hint_plan/data/data.csv');
+-- foreign table test
+SELECT * FROM ft1;
+ id | val 
+----+-----
+  1 |   1
+  2 |   2
+  3 |   3
+  4 |   4
+  5 |   5
+  6 |   6
+  7 |   7
+  8 |   8
+  9 |   9
+ 10 |  10
+(10 rows)
+
+\t
+EXPLAIN (COSTS false) SELECT * FROM s1.t1, ft1 ft_1, ft1 ft_2 WHERE t1.c1 = ft_1.id AND t1.c1 = ft_2.id;
+ Nested Loop
+   Join Filter: (t1.c1 = ft_2.id)
+   ->  Nested Loop
+         ->  Foreign Scan on ft1 ft_1
+               Foreign File: /home/horiguti/work/pg_hint_plan/pg_hint_plan/data/data.csv
+         ->  Index Scan using t1_i1 on t1
+               Index Cond: (c1 = ft_1.id)
+   ->  Foreign Scan on ft1 ft_2
+         Foreign File: /home/horiguti/work/pg_hint_plan/pg_hint_plan/data/data.csv
+
+----
+---- No. S-1-5 object type for the hint
+----
+-- No. S-1-5-6
+/*+SeqScan(t1)SeqScan(ft_1)SeqScan(ft_2)*/
+EXPLAIN (COSTS false) SELECT * FROM s1.t1, ft1 ft_1, ft1 ft_2 WHERE t1.c1 = ft_1.id AND t1.c1 = ft_2.id;
+LOG:  pg_hint_plan:
+used hint:
+SeqScan(t1)
+not used hint:
+SeqScan(ft_1)
+SeqScan(ft_2)
+duplication hint:
+error hint:
+
+ Nested Loop
+   Join Filter: (t1.c1 = ft_2.id)
+   ->  Hash Join
+         Hash Cond: (t1.c1 = ft_1.id)
+         ->  Seq Scan on t1
+         ->  Hash
+               ->  Foreign Scan on ft1 ft_1
+                     Foreign File: /home/horiguti/work/pg_hint_plan/pg_hint_plan/data/data.csv
+   ->  Foreign Scan on ft1 ft_2
+         Foreign File: /home/horiguti/work/pg_hint_plan/pg_hint_plan/data/data.csv
+
+----
+---- No. J-1-6 object type for the hint
+----
+-- No. J-1-6-6
+/*+MergeJoin(ft_1 ft_2)Leading(ft_1 ft_2 t1)*/
+EXPLAIN (COSTS false) SELECT * FROM s1.t1, ft1 ft_1, ft1 ft_2 WHERE t1.c1 = ft_1.id AND t1.c1 = ft_2.id;
+LOG:  pg_hint_plan:
+used hint:
+MergeJoin(ft_1 ft_2)
+Leading(ft_1 ft_2 t1)
+not used hint:
+duplication hint:
+error hint:
+
+ Nested Loop
+   ->  Merge Join
+         Merge Cond: (ft_1.id = ft_2.id)
+         ->  Sort
+               Sort Key: ft_1.id
+               ->  Foreign Scan on ft1 ft_1
+                     Foreign File: /home/horiguti/work/pg_hint_plan/pg_hint_plan/data/data.csv
+         ->  Sort
+               Sort Key: ft_2.id
+               ->  Foreign Scan on ft1 ft_2
+                     Foreign File: /home/horiguti/work/pg_hint_plan/pg_hint_plan/data/data.csv
+   ->  Index Scan using t1_i1 on t1
+         Index Cond: (c1 = ft_1.id)
+
+----
+---- No. L-1-6 object type for the hint
+----
+-- No. L-1-6-6
+/*+Leading(ft_1 ft_2 t1)*/
+EXPLAIN (COSTS false) SELECT * FROM s1.t1, ft1 ft_1, ft1 ft_2 WHERE t1.c1 = ft_1.id AND t1.c1 = ft_2.id;
+LOG:  pg_hint_plan:
+used hint:
+Leading(ft_1 ft_2 t1)
+not used hint:
+duplication hint:
+error hint:
+
+ Nested Loop
+   ->  Nested Loop
+         Join Filter: (ft_1.id = ft_2.id)
+         ->  Foreign Scan on ft1 ft_1
+               Foreign File: /home/horiguti/work/pg_hint_plan/pg_hint_plan/data/data.csv
+         ->  Foreign Scan on ft1 ft_2
+               Foreign File: /home/horiguti/work/pg_hint_plan/pg_hint_plan/data/data.csv
+   ->  Index Scan using t1_i1 on t1
+         Index Cond: (c1 = ft_1.id)
+
+----
+---- No. R-1-6 object type for the hint
+----
+-- No. R-1-6-6
+\o results/ut-fdw.tmpout
+/*+Rows(ft_1 ft_2 #1)Leading(ft_1 ft_2 t1)*/
+EXPLAIN SELECT * FROM s1.t1, ft1 ft_1, ft1 ft_2 WHERE t1.c1 = ft_1.id AND t1.c1 = ft_2.id;
+LOG:  pg_hint_plan:
+used hint:
+Leading(ft_1 ft_2 t1)
+Rows(ft_1 ft_2 #1)
+not used hint:
+duplication hint:
+error hint:
+
+\o
+\! sql/maskout.sh results/ut-fdw.tmpout
+ Nested Loop  (cost=xxx rows=1 width=xxx)
+   ->  Nested Loop  (cost=xxx rows=1 width=xxx)
+         Join Filter: (ft_1.id = ft_2.id)
+         ->  Foreign Scan on ft1 ft_1  (cost=xxx rows=1 width=xxx)
+               Foreign File: /home/horiguti/work/pg_hint_plan/pg_hint_plan/data/data.csv
+               Foreign File Size: 42
+         ->  Foreign Scan on ft1 ft_2  (cost=xxx rows=1 width=xxx)
+               Foreign File: /home/horiguti/work/pg_hint_plan/pg_hint_plan/data/data.csv
+               Foreign File Size: 42
+   ->  Index Scan using t1_i1 on t1  (cost=xxx rows=1 width=xxx)
+         Index Cond: (c1 = ft_1.id)
+
+\! rm results/ut-fdw.tmpout

diff --git a/output/ut-fdw.source b/output/ut-fdw.source
index 4907980..5d2e949 100644 (file)
--- a/output/ut-fdw.source
+++ b/output/ut-fdw.source
@@ -26,14 +26,15 @@ SELECT * FROM ft1;
 \t
 EXPLAIN (COSTS false) SELECT * FROM s1.t1, ft1 ft_1, ft1 ft_2 WHERE t1.c1 = ft_1.id AND t1.c1 = ft_2.id;
  Nested Loop
-   Join Filter: (t1.c1 = ft_2.id)
+   Join Filter: (ft_1.id = t1.c1)
    ->  Nested Loop
+         Join Filter: (ft_1.id = ft_2.id)
          ->  Foreign Scan on ft1 ft_1
-               Foreign File: @abs_srcdir@/data/data.csv
-         ->  Index Scan using t1_i1 on t1
-               Index Cond: (c1 = ft_1.id)
-   ->  Foreign Scan on ft1 ft_2
-         Foreign File: @abs_srcdir@/data/data.csv
+               Foreign File: /home/horiguti/work/pg_hint_plan/pg_hint_plan/data/data.csv
+         ->  Foreign Scan on ft1 ft_2
+               Foreign File: /home/horiguti/work/pg_hint_plan/pg_hint_plan/data/data.csv
+   ->  Index Scan using t1_i1 on t1
+         Index Cond: (c1 = ft_2.id)
 
 ----
 ---- No. S-1-5 object type for the hint
@@ -76,6 +77,7 @@ duplication hint:
 error hint:
 
  Nested Loop
+   Join Filter: (ft_1.id = t1.c1)
    ->  Merge Join
          Merge Cond: (ft_1.id = ft_2.id)
          ->  Sort
@@ -87,7 +89,7 @@ error hint:
                ->  Foreign Scan on ft1 ft_2
                      Foreign File: @abs_srcdir@/data/data.csv
    ->  Index Scan using t1_i1 on t1
-         Index Cond: (c1 = ft_1.id)
+         Index Cond: (c1 = ft_2.id)
 
 ----
 ---- No. L-1-6 object type for the hint
@@ -103,6 +105,7 @@ duplication hint:
 error hint:
 
  Nested Loop
+   Join Filter: (ft_1.id = t1.c1)
    ->  Nested Loop
          Join Filter: (ft_1.id = ft_2.id)
          ->  Foreign Scan on ft1 ft_1
@@ -110,7 +113,7 @@ error hint:
          ->  Foreign Scan on ft1 ft_2
                Foreign File: @abs_srcdir@/data/data.csv
    ->  Index Scan using t1_i1 on t1
-         Index Cond: (c1 = ft_1.id)
+         Index Cond: (c1 = ft_2.id)
 
 ----
 ---- No. R-1-6 object type for the hint
@@ -130,6 +133,7 @@ error hint:
 \o
 \! sql/maskout.sh results/ut-fdw.tmpout
  Nested Loop  (cost=xxx rows=1 width=xxx)
+   Join Filter: (ft_1.id = t1.c1)
    ->  Nested Loop  (cost=xxx rows=1 width=xxx)
          Join Filter: (ft_1.id = ft_2.id)
          ->  Foreign Scan on ft1 ft_1  (cost=xxx rows=1 width=xxx)
@@ -139,6 +143,6 @@ error hint:
                Foreign File: @abs_srcdir@/data/data.csv
                Foreign File Size: 42
    ->  Index Scan using t1_i1 on t1  (cost=xxx rows=1 width=xxx)
-         Index Cond: (c1 = ft_1.id)
+         Index Cond: (c1 = ft_2.id)
 
 \! rm results/ut-fdw.tmpout