Support PostgreSQL 10 beta 1 step 1/2

[pghintplan/pg_hint_plan.git] / expected / ut-L.out

diff --git a/expected/ut-L.out b/expected/ut-L.out
index f64ab95..bdf67d4 100644 (file)
--- a/expected/ut-L.out
+++ b/expected/ut-L.out
@@ -8,7 +8,6 @@ EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2, s1.t3, s1.t4 WHERE t1.c1 = t2.
                    QUERY PLAN                   
 ------------------------------------------------
  Nested Loop
-   Join Filter: (t1.c1 = t4.c1)
    ->  Merge Join
          Merge Cond: (t1.c1 = t2.c1)
          ->  Merge Join
@@ -19,8 +18,8 @@ EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2, s1.t3, s1.t4 WHERE t1.c1 = t2.
                Sort Key: t2.c1
                ->  Seq Scan on t2
    ->  Index Scan using t4_i1 on t4
-         Index Cond: (c1 = t3.c1)
-(13 rows)
+         Index Cond: (c1 = t1.c1)
+(12 rows)
 
 ----
 ---- No. L-1-1 specified pattern of the object name
@@ -66,7 +65,6 @@ error hint:
                      QUERY PLAN                     
 ----------------------------------------------------
  Nested Loop
-   Join Filter: (t_1.c1 = t_4.c1)
    ->  Merge Join
          Merge Cond: (t_1.c1 = t_2.c1)
          ->  Merge Join
@@ -77,8 +75,8 @@ error hint:
                Sort Key: t_2.c1
                ->  Seq Scan on t2 t_2
    ->  Index Scan using t4_i1 on t4 t_4
-         Index Cond: (c1 = t_3.c1)
-(13 rows)
+         Index Cond: (c1 = t_1.c1)
+(12 rows)
 
 -- No. L-1-1-3
 /*+Leading(t_4 t_2 t_3 t_1)*/
@@ -152,7 +150,6 @@ error hint:
                    QUERY PLAN                   
 ------------------------------------------------
  Nested Loop
-   Join Filter: (t1.c1 = t4.c1)
    ->  Merge Join
          Merge Cond: (t1.c1 = t2.c1)
          ->  Merge Join
@@ -163,8 +160,8 @@ error hint:
                Sort Key: t2.c1
                ->  Seq Scan on t2
    ->  Index Scan using t4_i1 on t4
-         Index Cond: (c1 = t3.c1)
-(13 rows)
+         Index Cond: (c1 = t1.c1)
+(12 rows)
 
 ----
 ---- No. L-1-3 table doesn't exist in the hint option
@@ -210,7 +207,6 @@ error hint:
                    QUERY PLAN                   
 ------------------------------------------------
  Nested Loop
-   Join Filter: (t1.c1 = t4.c1)
    ->  Merge Join
          Merge Cond: (t1.c1 = t2.c1)
          ->  Merge Join
@@ -221,8 +217,8 @@ error hint:
                Sort Key: t2.c1
                ->  Seq Scan on t2
    ->  Index Scan using t4_i1 on t4
-         Index Cond: (c1 = t3.c1)
-(13 rows)
+         Index Cond: (c1 = t1.c1)
+(12 rows)
 
 ----
 ---- No. L-1-4 conflict table name
@@ -382,11 +378,9 @@ EXPLAIN (COSTS false) SELECT *, (SELECT max(t1.c1) FROM s1.t1, s1.t2, s1.t3, s1.
                                QUERY PLAN                               
 ------------------------------------------------------------------------
  Nested Loop
-   Join Filter: (t1.c1 = t4.c1)
    InitPlan 1 (returns $1)
      ->  Aggregate
            ->  Nested Loop
-                 Join Filter: (t1_1.c1 = t4_1.c1)
                  ->  Merge Join
                        Merge Cond: (t1_1.c1 = t2_1.c1)
                        ->  Merge Join
@@ -397,7 +391,7 @@ EXPLAIN (COSTS false) SELECT *, (SELECT max(t1.c1) FROM s1.t1, s1.t2, s1.t3, s1.
                              Sort Key: t2_1.c1
                              ->  Seq Scan on t2 t2_1
                  ->  Index Only Scan using t4_i1 on t4 t4_1
-                       Index Cond: (c1 = t3_1.c1)
+                       Index Cond: (c1 = t1_1.c1)
    ->  Merge Join
          Merge Cond: (t1.c1 = t2.c1)
          ->  Merge Join
@@ -408,8 +402,8 @@ EXPLAIN (COSTS false) SELECT *, (SELECT max(t1.c1) FROM s1.t1, s1.t2, s1.t3, s1.
                Sort Key: t2.c1
                ->  Seq Scan on t2
    ->  Index Scan using t4_i1 on t4
-         Index Cond: (c1 = t3.c1)
-(28 rows)
+         Index Cond: (c1 = t1.c1)
+(26 rows)
 
 /*+Leading(t4 t2 t3 t1)*/
 EXPLAIN (COSTS false) SELECT *, (SELECT max(t1.c1) FROM s1.t1, s1.t2, s1.t3, s1.t4 WHERE t1.c1 = t2.c1 AND t1.c1 = t3.c1 AND t1.c1 = t4.c1) FROM s1.t1, s1.t2, s1.t3, s1.t4 WHERE t1.c1 = t2.c1 AND t1.c1 = t3.c1 AND t1.c1 = t4.c1;
@@ -542,7 +536,6 @@ Leading(t4 t2 t3 t1 t4)
                    QUERY PLAN                   
 ------------------------------------------------
  Nested Loop
-   Join Filter: (t1.c1 = t4.c1)
    ->  Merge Join
          Merge Cond: (t1.c1 = t2.c1)
          ->  Merge Join
@@ -553,8 +546,8 @@ Leading(t4 t2 t3 t1 t4)
                Sort Key: t2.c1
                ->  Seq Scan on t2
    ->  Index Scan using t4_i1 on t4
-         Index Cond: (c1 = t3.c1)
-(13 rows)
+         Index Cond: (c1 = t1.c1)
+(12 rows)
 
 /*+Leading(t4 t2 t3 t4)*/
 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2, s1.t3, s1.t4 WHERE t1.c1 = t2.c1 AND t1.c1 = t3.c1 AND t1.c1 = t4.c1;
@@ -570,7 +563,6 @@ Leading(t4 t2 t3 t4)
                    QUERY PLAN                   
 ------------------------------------------------
  Nested Loop
-   Join Filter: (t1.c1 = t4.c1)
    ->  Merge Join
          Merge Cond: (t1.c1 = t2.c1)
          ->  Merge Join
@@ -581,8 +573,8 @@ Leading(t4 t2 t3 t4)
                Sort Key: t2.c1
                ->  Seq Scan on t2
    ->  Index Scan using t4_i1 on t4
-         Index Cond: (c1 = t3.c1)
-(13 rows)
+         Index Cond: (c1 = t1.c1)
+(12 rows)
 
 -- No. L-1-5-3
 /*+Leading(t4 t2 t3 t1 t4 t2 t3 t1)*/
@@ -599,7 +591,6 @@ Leading(t4 t2 t3 t1 t4 t2 t3 t1)
                    QUERY PLAN                   
 ------------------------------------------------
  Nested Loop
-   Join Filter: (t1.c1 = t4.c1)
    ->  Merge Join
          Merge Cond: (t1.c1 = t2.c1)
          ->  Merge Join
@@ -610,8 +601,8 @@ Leading(t4 t2 t3 t1 t4 t2 t3 t1)
                Sort Key: t2.c1
                ->  Seq Scan on t2
    ->  Index Scan using t4_i1 on t4
-         Index Cond: (c1 = t3.c1)
-(13 rows)
+         Index Cond: (c1 = t1.c1)
+(12 rows)
 
 /*+Leading(t4 t2 t2 t4)*/
 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2, s1.t3, s1.t4 WHERE t1.c1 = t2.c1 AND t1.c1 = t3.c1 AND t1.c1 = t4.c1;
@@ -627,7 +618,6 @@ Leading(t4 t2 t2 t4)
                    QUERY PLAN                   
 ------------------------------------------------
  Nested Loop
-   Join Filter: (t1.c1 = t4.c1)
    ->  Merge Join
          Merge Cond: (t1.c1 = t2.c1)
          ->  Merge Join
@@ -638,8 +628,8 @@ Leading(t4 t2 t2 t4)
                Sort Key: t2.c1
                ->  Seq Scan on t2
    ->  Index Scan using t4_i1 on t4
-         Index Cond: (c1 = t3.c1)
-(13 rows)
+         Index Cond: (c1 = t1.c1)
+(12 rows)
 
 ----
 ---- No. L-1-6 object type for the hint
@@ -1152,7 +1142,6 @@ EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2, s1.t3, (SELECT t4.c1 FROM s1.t
                    QUERY PLAN                   
 ------------------------------------------------
  Nested Loop
-   Join Filter: (t1.c1 = t4.c1)
    ->  Merge Join
          Merge Cond: (t1.c1 = t2.c1)
          ->  Merge Join
@@ -1163,8 +1152,8 @@ EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2, s1.t3, (SELECT t4.c1 FROM s1.t
                Sort Key: t2.c1
                ->  Seq Scan on t2
    ->  Index Only Scan using t4_i1 on t4
-         Index Cond: (c1 = t3.c1)
-(13 rows)
+         Index Cond: (c1 = t1.c1)
+(12 rows)
 
 /*+Leading(st4 t2 t3 t1)*/
 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2, s1.t3, (SELECT t4.c1 FROM s1.t4) st4 WHERE t1.c1 = t2.c1 AND t1.c1 = t3.c1 AND t1.c1 = st4.c1;
@@ -1178,7 +1167,6 @@ error hint:
                    QUERY PLAN                   
 ------------------------------------------------
  Nested Loop
-   Join Filter: (t1.c1 = t4.c1)
    ->  Merge Join
          Merge Cond: (t1.c1 = t2.c1)
          ->  Merge Join
@@ -1189,8 +1177,8 @@ error hint:
                Sort Key: t2.c1
                ->  Seq Scan on t2
    ->  Index Only Scan using t4_i1 on t4
-         Index Cond: (c1 = t3.c1)
-(13 rows)
+         Index Cond: (c1 = t1.c1)
+(12 rows)
 
 /*+Leading(t4 t2 t3 t1)*/
 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2, s1.t3, (SELECT t4.c1 FROM s1.t4) st4 WHERE t1.c1 = t2.c1 AND t1.c1 = t3.c1 AND t1.c1 = st4.c1;
@@ -1231,56 +1219,59 @@ 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)
-                             ->  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)
+                             ->  Materialize
+                                   ->  Seq Scan on t2 b1t2
+                                         Filter: (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)
-                             ->  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)
+                             ->  Materialize
+                                   ->  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)
-                     ->  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)
+                     ->  Materialize
+                           ->  Seq Scan on t2 bmt2
+                                 Filter: (ctid = '(1,1)'::tid)
+(50 rows)
 
 /*+
 Leading(bmt1 bmt2 bmt3 bmt4)
@@ -1304,56 +1295,59 @@ 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)
-                             ->  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)
+                             ->  Materialize
+                                   ->  Tid Scan on t3 b1t3
+                                         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)
-                             ->  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)
+                             ->  Materialize
+                                   ->  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)
-                     ->  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)
+                     ->  Materialize
+                           ->  Seq Scan on t2 bmt2
+                                 Filter: (ctid = '(1,1)'::tid)
+(50 rows)
 
 -- No. L-2-1-2
 EXPLAIN (COSTS false)
@@ -1366,72 +1360,76 @@ 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)
-                             ->  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)
+                             ->  Materialize
+                                   ->  Seq Scan on t2 b1t2
+                                         Filter: (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)
-                             ->  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)
+                             ->  Materialize
+                                   ->  Seq Scan on t2 b2t2
+                                         Filter: (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)
-                             ->  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)
+                             ->  Materialize
+                                   ->  Seq Scan on t2 b3t2
+                                         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)
-                     ->  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)
+                     ->  Materialize
+                           ->  Seq Scan on t2 bmt2
+                                 Filter: (ctid = '(1,1)'::tid)
+(67 rows)
 
 /*+
 Leading(bmt1 bmt2 bmt3 bmt4)
@@ -1459,93 +1457,98 @@ 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)
-                             ->  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)
+                             ->  Materialize
+                                   ->  Tid Scan on t3 b1t3
+                                         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)
-                             ->  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)
+                             ->  Materialize
+                                   ->  Tid Scan on t4 b2t4
+                                         TID Cond: (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)
-                             ->  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)
+                             ->  Materialize
+                                   ->  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)
-                     ->  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)
+                     ->  Materialize
+                           ->  Seq Scan on t2 bmt2
+                                 Filter: (ctid = '(1,1)'::tid)
+(67 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)
-                     ->  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)
+                     ->  Materialize
+                           ->  Seq Scan on t2 bmt2
+                                 Filter: (ctid = '(1,1)'::tid)
+(16 rows)
 
 /*+
 Leading(bmt4 bmt3 bmt2 bmt1)
@@ -1558,45 +1561,47 @@ 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)
-                     ->  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)
+                     ->  Materialize
+                           ->  Tid Scan on t4 bmt4
+                                 TID Cond: (ctid = '(1,1)'::tid)
+(16 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)
-                     ->  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)
+                     ->  Materialize
+                           ->  Seq Scan on t2 bmt2
+                                 Filter: (ctid = '(1,1)'::tid)
+(16 rows)
 
 /*+
 Leading(bmt4 bmt3 bmt2 bmt1)
@@ -1609,24 +1614,25 @@ 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)
-                     ->  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)
+                     ->  Materialize
+                           ->  Tid Scan on t4 bmt4
+                                 TID Cond: (ctid = '(1,1)'::tid)
+(16 rows)
 
 -- No. L-2-1-5
 EXPLAIN (COSTS false)
@@ -1637,57 +1643,60 @@ 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)
-                             ->  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)
+                             ->  Materialize
+                                   ->  Seq Scan on t2 b1t2
+                                         Filter: (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)
-                             ->  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)
+                             ->  Materialize
+                                   ->  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))
-                     ->  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)
+                     ->  Materialize
+                           ->  Seq Scan on t2 bmt2
+                                 Filter: (ctid = '(1,1)'::tid)
+(51 rows)
 
 /*+
 Leading(bmt1 bmt2 bmt3 bmt4)
@@ -1711,57 +1720,60 @@ 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)
-                             ->  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)
+                             ->  Materialize
+                                   ->  Tid Scan on t3 b1t3
+                                         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)
-                             ->  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)
+                             ->  Materialize
+                                   ->  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))
-                     ->  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)
+                     ->  Materialize
+                           ->  Seq Scan on t2 bmt2
+                                 Filter: (ctid = '(1,1)'::tid)
+(51 rows)
 
 -- No. L-2-1-6
 EXPLAIN (COSTS false)
@@ -1781,66 +1793,70 @@ 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)
-                             ->  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)
+                             ->  Materialize
+                                   ->  Seq Scan on t2 b1t2
+                                         Filter: (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)
-                             ->  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)
+                             ->  Materialize
+                                   ->  Seq Scan on t2 b2t2
+                                         Filter: (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)
-                             ->  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)
+                             ->  Materialize
+                                   ->  Seq Scan on t2 b3t2
+                                         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) AND (c1 <> $2))
-                     ->  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)
+                     ->  Materialize
+                           ->  Seq Scan on t2 bmt2
+                                 Filter: (ctid = '(1,1)'::tid)
+(68 rows)
 
 /*+
 Leading(bmt1 bmt2 bmt3 bmt4)
@@ -1875,66 +1891,70 @@ 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)
-                             ->  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)
+                             ->  Materialize
+                                   ->  Tid Scan on t3 b1t3
+                                         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)
-                             ->  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)
+                             ->  Materialize
+                                   ->  Tid Scan on t4 b2t4
+                                         TID Cond: (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)
-                             ->  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)
+                             ->  Materialize
+                                   ->  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))
-                     ->  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)
+                     ->  Materialize
+                           ->  Seq Scan on t2 bmt2
+                                 Filter: (ctid = '(1,1)'::tid)
+(68 rows)
 
 -- No. L-2-1-7
 EXPLAIN (COSTS false)
@@ -1957,55 +1977,57 @@ 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)
-                             ->  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)
+                             ->  Materialize
+                                   ->  Seq Scan on t2 b1t2
+                                         Filter: (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)
-                             ->  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)
+                             ->  Materialize
+                                   ->  Seq Scan on t2 b2t2
+                                         Filter: (ctid = '(1,1)'::tid)
    ->  Nested Loop
          Join Filter: (bmt1.c1 = c2.c1)
          ->  Nested Loop
-               Join Filter: (bmt1.c1 = c1.c1)
+               Join Filter: (bmt1.c1 = bmt4.c1)
+               ->  Tid Scan on t4 bmt4
+                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
-                     Join Filter: (bmt1.c1 = bmt4.c1)
+                     Join Filter: (bmt1.c1 = bmt3.c1)
+                     ->  Tid Scan on t3 bmt3
+                           TID Cond: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
-                           Join Filter: (bmt1.c1 = bmt3.c1)
+                           Join Filter: (bmt1.c1 = bmt2.c1)
+                           ->  Seq Scan on t2 bmt2
+                                 Filter: (ctid = '(1,1)'::tid)
                            ->  Nested Loop
-                                 Join Filter: (bmt1.c1 = bmt2.c1)
+                                 Join Filter: (bmt1.c1 = c1.c1)
                                  ->  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)
-               ->  CTE Scan on c1
+                                 ->  CTE Scan on c1
          ->  CTE Scan on c2
-(53 rows)
+(55 rows)
 
 /*+
 Leading(c2 c1 bmt1 bmt2 bmt3 bmt4)
@@ -2034,62 +2056,64 @@ 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)
-                             ->  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)
+                             ->  Materialize
+                                   ->  Tid Scan on t3 b1t3
+                                         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)
-                             ->  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)
+                             ->  Materialize
+                                   ->  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)
+                     ->  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
-                           ->  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)
+(55 rows)
 
 -- No. L-2-1-8
 EXPLAIN (COSTS false)
@@ -2116,74 +2140,77 @@ 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)
-                             ->  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)
+                             ->  Materialize
+                                   ->  Seq Scan on t2 b1t2
+                                         Filter: (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)
-                             ->  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)
+                             ->  Materialize
+                                   ->  Seq Scan on t2 b2t2
+                                         Filter: (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)
-                             ->  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)
+                             ->  Materialize
+                                   ->  Seq Scan on t2 b3t2
+                                         Filter: (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 = c1.c1)
+                     Join Filter: (bmt1.c1 = bmt4.c1)
+                     ->  Tid Scan on t4 bmt4
+                           TID Cond: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
-                           Join Filter: (bmt1.c1 = bmt4.c1)
+                           Join Filter: (bmt1.c1 = bmt3.c1)
+                           ->  Tid Scan on t3 bmt3
+                                 TID Cond: (ctid = '(1,1)'::tid)
                            ->  Nested Loop
-                                 Join Filter: (bmt1.c1 = bmt3.c1)
+                                 Join Filter: (bmt1.c1 = bmt2.c1)
+                                 ->  Seq Scan on t2 bmt2
+                                       Filter: (ctid = '(1,1)'::tid)
                                  ->  Nested Loop
-                                       Join Filter: (bmt1.c1 = bmt2.c1)
+                                       Join Filter: (bmt1.c1 = c1.c1)
                                        ->  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)
-                     ->  CTE Scan on c1
+                                       ->  CTE Scan on c1
                ->  CTE Scan on c2
          ->  CTE Scan on c3
-(72 rows)
+(75 rows)
 
 /*+
 Leading(c3 c2 c1 bmt1 bmt2 bmt3 bmt4)
@@ -2218,65 +2245,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: (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)
-                             ->  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)
+                             ->  Materialize
+                                   ->  Tid Scan on t3 b1t3
+                                         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)
-                             ->  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)
+                             ->  Materialize
+                                   ->  Tid Scan on t4 b2t4
+                                         TID Cond: (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)
                  ->  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)
-                             ->  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)
+                             ->  Materialize
+                                   ->  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)
+                     ->  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
@@ -2284,15 +2322,7 @@ error hint:
                                        ->  CTE Scan on c2
                                        ->  CTE Scan on c3
                                  ->  CTE Scan on c1
-                           ->  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)
+(75 rows)
 
 ----
 ---- No. L-2-2 the number of the tables per quiry block
@@ -2408,8 +2438,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
@@ -2417,35 +2447,38 @@ 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)
-                 ->  Seq Scan on t2 b1t2
-                       Filter: (ctid = '(1,1)'::tid)
+                 ->  Materialize
+                       ->  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)
-                 ->  Seq Scan on t2 b2t2
-                       Filter: (ctid = '(1,1)'::tid)
+                 ->  Materialize
+                       ->  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)
-                 ->  Seq Scan on t2 b3t2
-                       Filter: (ctid = '(1,1)'::tid)
+                 ->  Materialize
+                       ->  Seq Scan on t2 b3t2
+                             Filter: (ctid = '(1,1)'::tid)
    ->  Nested Loop
-         Join Filter: (bmt1.c1 = c1.c1)
+         Join Filter: (bmt1.c1 = bmt2.c1)
+         ->  Seq Scan on t2 bmt2
+               Filter: (ctid = '(1,1)'::tid)
          ->  Nested Loop
-               Join Filter: (bmt1.c1 = bmt2.c1)
+               Join Filter: (bmt1.c1 = c1.c1)
                ->  Tid Scan on t1 bmt1
                      TID Cond: (ctid = '(1,1)'::tid)
                      Filter: (c1 <> $2)
-               ->  Seq Scan on t2 bmt2
-                     Filter: (ctid = '(1,1)'::tid)
-         ->  CTE Scan on c1
-(35 rows)
+               ->  CTE Scan on c1
+(38 rows)
 
 /*+
 Leading(c1 bmt2 bmt1)
@@ -2476,8 +2509,8 @@ not used hint:
 duplication hint:
 error hint:
 
-                      QUERY PLAN                       
--------------------------------------------------------
+                        QUERY PLAN                         
+-----------------------------------------------------------
  Aggregate
    CTE c1
      ->  Aggregate
@@ -2485,35 +2518,38 @@ error hint:
                  Join Filter: (b1t1.c1 = b1t2.c1)
                  ->  Tid Scan on t1 b1t1
                        TID Cond: (ctid = '(1,1)'::tid)
-                 ->  Seq Scan on t2 b1t2
-                       Filter: (ctid = '(1,1)'::tid)
+                 ->  Materialize
+                       ->  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)
-                 ->  Seq Scan on t2 b2t2
-                       Filter: (ctid = '(1,1)'::tid)
+                 ->  Materialize
+                       ->  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)
-                 ->  Seq Scan on t2 b3t2
-                       Filter: (ctid = '(1,1)'::tid)
+                 ->  Materialize
+                       ->  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
-         ->  Tid Scan on t1 bmt1
-               TID Cond: (ctid = '(1,1)'::tid)
-               Filter: (c1 <> $2)
-(35 rows)
+(38 rows)
 
 -- No. L-2-2-3
 EXPLAIN (COSTS false)
@@ -2528,76 +2564,79 @@ 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)
-                             ->  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)
+                             ->  Materialize
+                                   ->  Seq Scan on t2 b1t2
+                                         Filter: (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)
-                             ->  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)
+                             ->  Materialize
+                                   ->  Seq Scan on t2 b2t2
+                                         Filter: (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)
-                             ->  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)
+                             ->  Materialize
+                                   ->  Seq Scan on t2 b3t2
+                                         Filter: (ctid = '(1,1)'::tid)
    ->  Nested Loop
-         Join Filter: (bmt1.c1 = c1.c1)
+         Join Filter: (bmt1.c1 = bmt4.c1)
+         ->  Tid Scan on t4 bmt4
+               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
-               Join Filter: (bmt1.c1 = bmt4.c1)
+               Join Filter: (bmt1.c1 = bmt3.c1)
+               ->  Tid Scan on t3 bmt3
+                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
-                     Join Filter: (bmt1.c1 = bmt3.c1)
+                     Join Filter: (bmt1.c1 = bmt2.c1)
+                     ->  Seq Scan on t2 bmt2
+                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
-                           Join Filter: (bmt1.c1 = bmt2.c1)
+                           Join Filter: (bmt1.c1 = c1.c1)
                            ->  Tid Scan on t1 bmt1
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 <> $2)
-                           ->  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)
+                           ->  CTE Scan on c1
+(70 rows)
 
 /*+
 Leading(c1 bmt4 bmt3 bmt2 bmt1)
@@ -2627,76 +2666,79 @@ 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)
-                             ->  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)
+                             ->  Materialize
+                                   ->  Tid Scan on t4 b1t4
+                                         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)
-                             ->  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)
+                             ->  Materialize
+                                   ->  Tid Scan on t4 b2t4
+                                         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)
-                             ->  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)
+                             ->  Materialize
+                                   ->  Tid Scan on t4 b3t4
+                                         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
-                     ->  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)
+(70 rows)
 
 -- No. L-2-2-4
 EXPLAIN (COSTS false)
@@ -2711,25 +2753,26 @@ 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)
-                             ->  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)
+                             ->  Materialize
+                                   ->  Seq Scan on t2 b1t2
+                                         Filter: (ctid = '(1,1)'::tid)
    InitPlan 3 (returns $2)
      ->  Result
            InitPlan 2 (returns $1)
@@ -2742,24 +2785,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 = c1.c1)
+         Join Filter: (bmt1.c1 = bmt4.c1)
+         ->  Tid Scan on t4 bmt4
+               TID Cond: (ctid = '(1,1)'::tid)
          ->  Nested Loop
-               Join Filter: (bmt1.c1 = bmt4.c1)
+               Join Filter: (bmt1.c1 = bmt3.c1)
+               ->  Tid Scan on t3 bmt3
+                     TID Cond: (ctid = '(1,1)'::tid)
                ->  Nested Loop
-                     Join Filter: (bmt1.c1 = bmt3.c1)
+                     Join Filter: (bmt1.c1 = bmt2.c1)
+                     ->  Seq Scan on t2 bmt2
+                           Filter: (ctid = '(1,1)'::tid)
                      ->  Nested Loop
-                           Join Filter: (bmt1.c1 = bmt2.c1)
+                           Join Filter: (bmt1.c1 = c1.c1)
                            ->  Tid Scan on t1 bmt1
                                  TID Cond: (ctid = '(1,1)'::tid)
                                  Filter: (c1 <> $4)
-                           ->  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)
+                           ->  CTE Scan on c1
+(47 rows)
 
 /*+
 Leading(c1 bmt4 bmt3 bmt2 bmt1)
@@ -2785,25 +2828,26 @@ 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)
-                             ->  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)
+                             ->  Materialize
+                                   ->  Tid Scan on t4 b1t4
+                                         TID Cond: (ctid = '(1,1)'::tid)
    InitPlan 3 (returns $2)
      ->  Result
            InitPlan 2 (returns $1)
@@ -2817,23 +2861,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
-                     ->  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)
+(47 rows)
 
 ----
 ---- No. L-2-3 RULE or VIEW
@@ -2845,22 +2889,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) */
@@ -2872,28 +2916,29 @@ 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)
-                           ->  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)
+                           ->  Materialize
+                                 ->  Tid Scan on t4
+                                       TID Cond: (ctid = '(1,1)'::tid)
          ->  Tid Scan on r1
                TID Cond: (ctid = '(1,1)'::tid)
                Filter: (c1 = 1)
-(19 rows)
+(20 rows)
 
 EXPLAIN (COSTS false) UPDATE s1.r1_ SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
                            QUERY PLAN                            
@@ -2901,22 +2946,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)
 
 /*+ Leading(b1t1 b1t2 b1t3 b1t4 r1_) */
@@ -2928,28 +2973,29 @@ 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)
-                           ->  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)
+                           ->  Materialize
+                                 ->  Seq Scan on t2 b1t2
+                                       Filter: (ctid = '(1,1)'::tid)
          ->  Tid Scan on r1_
                TID Cond: (ctid = '(1,1)'::tid)
                Filter: (c1 = 1)
-(19 rows)
+(20 rows)
 
 -- No. L-2-3-2
 EXPLAIN (COSTS false) UPDATE s1.r2 SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
@@ -2958,42 +3004,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) */
@@ -3012,24 +3058,25 @@ 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)
-                           ->  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)
+                           ->  Materialize
+                                 ->  Tid Scan on t4
+                                       TID Cond: (ctid = '(1,1)'::tid)
          ->  Tid Scan on r2
                TID Cond: (ctid = '(1,1)'::tid)
                Filter: (c1 = 1)
@@ -3038,22 +3085,23 @@ 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)
-                           ->  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)
+                           ->  Materialize
+                                 ->  Tid Scan on t4
+                                       TID Cond: (ctid = '(1,1)'::tid)
          ->  Tid Scan on r2
                TID Cond: (ctid = '(1,1)'::tid)
                Filter: (c1 = 1)
-(39 rows)
+(41 rows)
 
 EXPLAIN (COSTS false) UPDATE s1.r2_ SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
                            QUERY PLAN                            
@@ -3061,42 +3109,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)
 
 /*+
@@ -3120,24 +3168,25 @@ 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)
-                           ->  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)
+                           ->  Materialize
+                                 ->  Seq Scan on t2 b1t2
+                                       Filter: (ctid = '(1,1)'::tid)
          ->  Tid Scan on r2_
                TID Cond: (ctid = '(1,1)'::tid)
                Filter: (c1 = 1)
@@ -3146,22 +3195,23 @@ 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)
-                           ->  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)
+                           ->  Materialize
+                                 ->  Seq Scan on t2 b2t2
+                                       Filter: (ctid = '(1,1)'::tid)
          ->  Tid Scan on r2_
                TID Cond: (ctid = '(1,1)'::tid)
                Filter: (c1 = 1)
-(39 rows)
+(41 rows)
 
 -- No. L-2-3-3
 EXPLAIN (COSTS false) UPDATE s1.r3 SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
@@ -3170,62 +3220,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) */
@@ -3251,24 +3301,25 @@ 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)
-                           ->  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)
+                           ->  Materialize
+                                 ->  Tid Scan on t4
+                                       TID Cond: (ctid = '(1,1)'::tid)
          ->  Tid Scan on r3
                TID Cond: (ctid = '(1,1)'::tid)
                Filter: (c1 = 1)
@@ -3277,18 +3328,19 @@ 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)
-                           ->  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)
+                           ->  Materialize
+                                 ->  Tid Scan on t4
+                                       TID Cond: (ctid = '(1,1)'::tid)
          ->  Tid Scan on r3
                TID Cond: (ctid = '(1,1)'::tid)
                Filter: (c1 = 1)
@@ -3297,22 +3349,23 @@ 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)
-                           ->  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)
+                           ->  Materialize
+                                 ->  Tid Scan on t4
+                                       TID Cond: (ctid = '(1,1)'::tid)
          ->  Tid Scan on r3
                TID Cond: (ctid = '(1,1)'::tid)
                Filter: (c1 = 1)
-(59 rows)
+(62 rows)
 
 EXPLAIN (COSTS false) UPDATE s1.r3_ SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
                            QUERY PLAN                            
@@ -3320,62 +3373,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)
 
 /*+
@@ -3411,24 +3464,25 @@ 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)
-                           ->  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)
+                           ->  Materialize
+                                 ->  Seq Scan on t2 b1t2
+                                       Filter: (ctid = '(1,1)'::tid)
          ->  Tid Scan on r3_
                TID Cond: (ctid = '(1,1)'::tid)
                Filter: (c1 = 1)
@@ -3437,18 +3491,19 @@ 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)
-                           ->  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)
+                           ->  Materialize
+                                 ->  Seq Scan on t2 b2t2
+                                       Filter: (ctid = '(1,1)'::tid)
          ->  Tid Scan on r3_
                TID Cond: (ctid = '(1,1)'::tid)
                Filter: (c1 = 1)
@@ -3457,22 +3512,23 @@ 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)
-                           ->  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)
+                           ->  Materialize
+                                 ->  Seq Scan on t2 b3t2
+                                       Filter: (ctid = '(1,1)'::tid)
          ->  Tid Scan on r3_
                TID Cond: (ctid = '(1,1)'::tid)
                Filter: (c1 = 1)
-(59 rows)
+(62 rows)
 
 -- No. L-2-3-4
 EXPLAIN (COSTS false) SELECT * FROM s1.v1 v1, s1.v1 v2 WHERE v1.c1 = v2.c1;
@@ -4358,7 +4414,6 @@ Leading((t2))
                    QUERY PLAN                   
 ------------------------------------------------
  Nested Loop
-   Join Filter: (t1.c1 = t4.c1)
    ->  Merge Join
          Merge Cond: (t1.c1 = t2.c1)
          ->  Merge Join
@@ -4369,8 +4424,8 @@ Leading((t2))
                Sort Key: t2.c1
                ->  Seq Scan on t2
    ->  Index Scan using t4_i1 on t4
-         Index Cond: (c1 = t3.c1)
-(13 rows)
+         Index Cond: (c1 = t1.c1)
+(12 rows)
 
 -- No. L-3-6-2
 /*+Leading((t2 t3))*/
@@ -4413,7 +4468,6 @@ Leading((t2 t3 t4))
                    QUERY PLAN                   
 ------------------------------------------------
  Nested Loop
-   Join Filter: (t1.c1 = t4.c1)
    ->  Merge Join
          Merge Cond: (t1.c1 = t2.c1)
          ->  Merge Join
@@ -4424,8 +4478,8 @@ Leading((t2 t3 t4))
                Sort Key: t2.c1
                ->  Seq Scan on t2
    ->  Index Scan using t4_i1 on t4
-         Index Cond: (c1 = t3.c1)
-(13 rows)
+         Index Cond: (c1 = t1.c1)
+(12 rows)
 
 -- No. L-3-6-4
 /*+Leading(((t1 t2) (t3 t4)))*/