SET search_path TO public;
SET client_min_messages TO log;
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
              QUERY PLAN              
--------------------------------------
 Merge Join
   Merge Cond: (t1.id = t2.id)
   ->  Index Scan using t1_pkey on t1
   ->  Index Scan using t2_pkey on t2
(4 rows)

EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.val = t2.val;
                QUERY PLAN                 
-------------------------------------------
 Merge Join
   Merge Cond: (t2.val = t1.val)
   ->  Index Scan using t2_val on t2
   ->  Materialize
         ->  Index Scan using t1_val on t1
(5 rows)

LOAD 'pg_hint_plan';
SET pg_hint_plan.debug_print TO on;
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
              QUERY PLAN              
--------------------------------------
 Merge Join
   Merge Cond: (t1.id = t2.id)
   ->  Index Scan using t1_pkey on t1
   ->  Index Scan using t2_pkey on t2
(4 rows)

EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.val = t2.val;
                QUERY PLAN                 
-------------------------------------------
 Merge Join
   Merge Cond: (t2.val = t1.val)
   ->  Index Scan using t2_val on t2
   ->  Materialize
         ->  Index Scan using t1_val on t1
(5 rows)

/*+ Test (t1 t2) */
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
INFO:  pg_hint_plan: hint syntax error at or near "Test (t1 t2) "
DETAIL:  Unrecognized hint keyword "Test".
              QUERY PLAN              
--------------------------------------
 Merge Join
   Merge Cond: (t1.id = t2.id)
   ->  Index Scan using t1_pkey on t1
   ->  Index Scan using t2_pkey on t2
(4 rows)

SET pg_hint_plan.enable_hint TO off;
/*+ Test (t1 t2) */
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
              QUERY PLAN              
--------------------------------------
 Merge Join
   Merge Cond: (t1.id = t2.id)
   ->  Index Scan using t1_pkey on t1
   ->  Index Scan using t2_pkey on t2
(4 rows)

SET pg_hint_plan.enable_hint TO on;
/*Set(enable_indexscan off)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
              QUERY PLAN              
--------------------------------------
 Merge Join
   Merge Cond: (t1.id = t2.id)
   ->  Index Scan using t1_pkey on t1
   ->  Index Scan using t2_pkey on t2
(4 rows)

--+Set(enable_indexscan off)
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
              QUERY PLAN              
--------------------------------------
 Merge Join
   Merge Cond: (t1.id = t2.id)
   ->  Index Scan using t1_pkey on t1
   ->  Index Scan using t2_pkey on t2
(4 rows)

/*+Set(enable_indexscan off) /* nest comment */ */
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
INFO:  pg_hint_plan: hint syntax error at or near "/* nest comment */ */
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;"
DETAIL:  Nested block comments are not supported.
              QUERY PLAN              
--------------------------------------
 Merge Join
   Merge Cond: (t1.id = t2.id)
   ->  Index Scan using t1_pkey on t1
   ->  Index Scan using t2_pkey on t2
(4 rows)

/*+Set(enable_indexscan off)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
LOG:  pg_hint_plan:
used hint:
Set(enable_indexscan off)
not used hint:
duplication hint:
error hint:

          QUERY PLAN          
------------------------------
 Hash Join
   Hash Cond: (t1.id = t2.id)
   ->  Seq Scan on t1
   ->  Hash
         ->  Seq Scan on t2
(5 rows)

EXPLAIN (COSTS false) /*+Set(enable_indexscan off)*/
 SELECT * FROM t1, t2 WHERE t1.id = t2.id;
LOG:  pg_hint_plan:
used hint:
Set(enable_indexscan off)
not used hint:
duplication hint:
error hint:

          QUERY PLAN          
------------------------------
 Hash Join
   Hash Cond: (t1.id = t2.id)
   ->  Seq Scan on t1
   ->  Hash
         ->  Seq Scan on t2
(5 rows)

/*+ Set(enable_indexscan off) Set(enable_hashjoin off) */
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
LOG:  pg_hint_plan:
used hint:
Set(enable_hashjoin off)
Set(enable_indexscan off)
not used hint:
duplication hint:
error hint:

          QUERY PLAN           
-------------------------------
 Merge Join
   Merge Cond: (t1.id = t2.id)
   ->  Sort
         Sort Key: t1.id
         ->  Seq Scan on t1
   ->  Sort
         Sort Key: t2.id
         ->  Seq Scan on t2
(8 rows)

/*+ 	 Set 	 ( 	 enable_indexscan 	 off 	 ) 	 */
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
LOG:  pg_hint_plan:
used hint:
Set(enable_indexscan off)
not used hint:
duplication hint:
error hint:

          QUERY PLAN          
------------------------------
 Hash Join
   Hash Cond: (t1.id = t2.id)
   ->  Seq Scan on t1
   ->  Hash
         ->  Seq Scan on t2
(5 rows)

/*+ 	 
	 	Set 	 
	 	( 	 
	 	enable_indexscan 	 
	 	off 	 
	 	) 	 
	 	*/	 	
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
LOG:  pg_hint_plan:
used hint:
Set(enable_indexscan off)
not used hint:
duplication hint:
error hint:

          QUERY PLAN          
------------------------------
 Hash Join
   Hash Cond: (t1.id = t2.id)
   ->  Seq Scan on t1
   ->  Hash
         ->  Seq Scan on t2
(5 rows)

/*+ Set(enable_indexscan off)Set(enable_nestloop off)Set(enable_mergejoin off)	 	
	 	Set(enable_seqscan off)
	 	*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
LOG:  pg_hint_plan:
used hint:
Set(enable_indexscan off)
Set(enable_mergejoin off)
Set(enable_nestloop off)
Set(enable_seqscan off)
not used hint:
duplication hint:
error hint:

                 QUERY PLAN                 
--------------------------------------------
 Hash Join
   Hash Cond: (t1.id = t2.id)
   ->  Index Scan using t1_pkey on t1
   ->  Hash
         ->  Index Scan using t2_pkey on t2
(5 rows)

/*+Set(work_mem "1M")*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
INFO:  invalid value for parameter "work_mem": "1M"
HINT:  Valid units for this parameter are "kB", "MB", "GB", and "TB".
LOG:  pg_hint_plan:
used hint:
not used hint:
duplication hint:
error hint:
Set(work_mem 1M)

              QUERY PLAN              
--------------------------------------
 Merge Join
   Merge Cond: (t1.id = t2.id)
   ->  Index Scan using t1_pkey on t1
   ->  Index Scan using t2_pkey on t2
(4 rows)

/*+Set(work_mem "1MB")*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
LOG:  pg_hint_plan:
used hint:
Set(work_mem 1MB)
not used hint:
duplication hint:
error hint:

              QUERY PLAN              
--------------------------------------
 Merge Join
   Merge Cond: (t1.id = t2.id)
   ->  Index Scan using t1_pkey on t1
   ->  Index Scan using t2_pkey on t2
(4 rows)

/*+Set(work_mem TO "1MB")*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
INFO:  pg_hint_plan: hint syntax error at or near "Set(work_mem TO "1MB")"
DETAIL:  Set hint requires name and value of GUC parameter.
LOG:  pg_hint_plan:
used hint:
not used hint:
duplication hint:
error hint:
Set(work_mem TO 1MB)

              QUERY PLAN              
--------------------------------------
 Merge Join
   Merge Cond: (t1.id = t2.id)
   ->  Index Scan using t1_pkey on t1
   ->  Index Scan using t2_pkey on t2
(4 rows)

/*+SeqScan(t1 t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
INFO:  pg_hint_plan: hint syntax error at or near ""
DETAIL:  SeqScan hint accepts only one relation.
LOG:  pg_hint_plan:
used hint:
not used hint:
duplication hint:
error hint:
SeqScan(t1 t2)

              QUERY PLAN              
--------------------------------------
 Merge Join
   Merge Cond: (t1.id = t2.id)
   ->  Index Scan using t1_pkey on t1
   ->  Index Scan using t2_pkey on t2
(4 rows)

/*+SeqScan(t1)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
LOG:  pg_hint_plan:
used hint:
SeqScan(t1)
not used hint:
duplication hint:
error hint:

          QUERY PLAN          
------------------------------
 Hash Join
   Hash Cond: (t1.id = t2.id)
   ->  Seq Scan on t1
   ->  Hash
         ->  Seq Scan on t2
(5 rows)

/*+SeqScan(t1)IndexScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
LOG:  pg_hint_plan:
used hint:
SeqScan(t1)
IndexScan(t2)
not used hint:
duplication hint:
error hint:

                 QUERY PLAN                 
--------------------------------------------
 Hash Join
   Hash Cond: (t1.id = t2.id)
   ->  Seq Scan on t1
   ->  Hash
         ->  Index Scan using t2_pkey on t2
(5 rows)

/*+BitmapScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
LOG:  pg_hint_plan:
used hint:
BitmapScan(t2)
not used hint:
duplication hint:
error hint:

                QUERY PLAN                
------------------------------------------
 Nested Loop
   ->  Seq Scan on t1
   ->  Bitmap Heap Scan on t2
         Recheck Cond: (id = t1.id)
         ->  Bitmap Index Scan on t2_pkey
               Index Cond: (id = t1.id)
(6 rows)

/*+BitmapScan(t2)NoSeqScan(t1)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
LOG:  pg_hint_plan:
used hint:
NoSeqScan(t1)
BitmapScan(t2)
not used hint:
duplication hint:
error hint:

                QUERY PLAN                
------------------------------------------
 Nested Loop
   ->  Index Scan using t1_pkey on t1
   ->  Bitmap Heap Scan on t2
         Recheck Cond: (id = t1.id)
         ->  Bitmap Index Scan on t2_pkey
               Index Cond: (id = t1.id)
(6 rows)

/*+NoIndexScan(t1)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
LOG:  pg_hint_plan:
used hint:
NoIndexScan(t1)
not used hint:
duplication hint:
error hint:

          QUERY PLAN          
------------------------------
 Hash Join
   Hash Cond: (t1.id = t2.id)
   ->  Seq Scan on t1
   ->  Hash
         ->  Seq Scan on t2
(5 rows)

/*+NoBitmapScan(t1)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t4 WHERE t1.val < 10;
LOG:  pg_hint_plan:
used hint:
NoBitmapScan(t1)
not used hint:
duplication hint:
error hint:

         QUERY PLAN         
----------------------------
 Nested Loop
   ->  Seq Scan on t1
         Filter: (val < 10)
   ->  Materialize
         ->  Seq Scan on t4
(5 rows)

/*+TidScan(t4)*/
EXPLAIN (COSTS false) SELECT * FROM t3, t4 WHERE t3.id = t4.id AND t4.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
TidScan(t4)
not used hint:
duplication hint:
error hint:

                  QUERY PLAN                   
-----------------------------------------------
 Merge Join
   Merge Cond: (t3.id = t4.id)
   ->  Index Scan using t3_pkey on t3
   ->  Sort
         Sort Key: t4.id
         ->  Tid Scan on t4
               TID Cond: (ctid = '(1,1)'::tid)
(7 rows)

/*+NoTidScan(t1)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoTidScan(t1)
not used hint:
duplication hint:
error hint:

              QUERY PLAN               
---------------------------------------
 Nested Loop
   ->  Seq Scan on t1
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using t2_pkey on t2
         Index Cond: (id = t1.id)
(5 rows)

/*+HashJoin(t1 t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
LOG:  pg_hint_plan:
used hint:
HashJoin(t1 t2)
not used hint:
duplication hint:
error hint:

          QUERY PLAN          
------------------------------
 Hash Join
   Hash Cond: (t1.id = t2.id)
   ->  Seq Scan on t1
   ->  Hash
         ->  Seq Scan on t2
(5 rows)

/*+NestLoop(t1 t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
LOG:  pg_hint_plan:
used hint:
NestLoop(t1 t2)
not used hint:
duplication hint:
error hint:

              QUERY PLAN              
--------------------------------------
 Nested Loop
   ->  Seq Scan on t2
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id = t2.id)
(4 rows)

/*+NoMergeJoin(t1 t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
LOG:  pg_hint_plan:
used hint:
NoMergeJoin(t1 t2)
not used hint:
duplication hint:
error hint:

          QUERY PLAN          
------------------------------
 Hash Join
   Hash Cond: (t1.id = t2.id)
   ->  Seq Scan on t1
   ->  Hash
         ->  Seq Scan on t2
(5 rows)

/*+MergeJoin(t1 t3)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t3 WHERE t1.val = t3.val;
LOG:  pg_hint_plan:
used hint:
MergeJoin(t1 t3)
not used hint:
duplication hint:
error hint:

             QUERY PLAN              
-------------------------------------
 Merge Join
   Merge Cond: (t1.val = t3.val)
   ->  Index Scan using t1_val on t1
   ->  Sort
         Sort Key: t3.val
         ->  Seq Scan on t3
(6 rows)

/*+NestLoop(t1 t3)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t3 WHERE t1.val = t3.val;
LOG:  pg_hint_plan:
used hint:
NestLoop(t1 t3)
not used hint:
duplication hint:
error hint:

             QUERY PLAN              
-------------------------------------
 Nested Loop
   ->  Seq Scan on t3
   ->  Index Scan using t1_val on t1
         Index Cond: (val = t3.val)
(4 rows)

/*+NoHashJoin(t1 t3)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t3 WHERE t1.val = t3.val;
LOG:  pg_hint_plan:
used hint:
NoHashJoin(t1 t3)
not used hint:
duplication hint:
error hint:

             QUERY PLAN              
-------------------------------------
 Nested Loop
   ->  Seq Scan on t3
   ->  Index Scan using t1_val on t1
         Index Cond: (val = t3.val)
(4 rows)

/*+MergeJoin(t4 t1 t2 t3)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id;
LOG:  pg_hint_plan:
used hint:
MergeJoin(t1 t2 t3 t4)
not used hint:
duplication hint:
error hint:

                    QUERY PLAN                    
--------------------------------------------------
 Merge Join
   Merge Cond: (t1.id = t3.id)
   ->  Merge Join
         Merge Cond: (t1.id = t2.id)
         ->  Index Scan using t1_pkey on t1
         ->  Index Scan using t2_pkey on t2
   ->  Materialize
         ->  Merge Join
               Merge Cond: (t3.id = t4.id)
               ->  Index Scan using t3_pkey on t3
               ->  Sort
                     Sort Key: t4.id
                     ->  Seq Scan on t4
(13 rows)

/*+HashJoin(t3 t4 t1 t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id;
LOG:  pg_hint_plan:
used hint:
HashJoin(t1 t2 t3 t4)
not used hint:
duplication hint:
error hint:

                       QUERY PLAN                       
--------------------------------------------------------
 Hash Join
   Hash Cond: (t3.id = t1.id)
   ->  Seq Scan on t3
   ->  Hash
         ->  Merge Join
               Merge Cond: (t1.id = t4.id)
               ->  Merge Join
                     Merge Cond: (t1.id = t2.id)
                     ->  Index Scan using t1_pkey on t1
                     ->  Index Scan using t2_pkey on t2
               ->  Sort
                     Sort Key: t4.id
                     ->  Seq Scan on t4
(13 rows)

/*+NestLoop(t2 t3 t4 t1) IndexScan(t3)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id;
LOG:  pg_hint_plan:
used hint:
IndexScan(t3)
NestLoop(t1 t2 t3 t4)
not used hint:
duplication hint:
error hint:

                    QUERY PLAN                    
--------------------------------------------------
 Nested Loop
   ->  Merge Join
         Merge Cond: (t1.id = t4.id)
         ->  Merge Join
               Merge Cond: (t1.id = t2.id)
               ->  Index Scan using t1_pkey on t1
               ->  Index Scan using t2_pkey on t2
         ->  Sort
               Sort Key: t4.id
               ->  Seq Scan on t4
   ->  Index Scan using t3_pkey on t3
         Index Cond: (id = t1.id)
(12 rows)

/*+NoNestLoop(t4 t1 t3 t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id;
LOG:  pg_hint_plan:
used hint:
NoNestLoop(t1 t2 t3 t4)
not used hint:
duplication hint:
error hint:

                    QUERY PLAN                    
--------------------------------------------------
 Merge Join
   Merge Cond: (t1.id = t3.id)
   ->  Merge Join
         Merge Cond: (t1.id = t2.id)
         ->  Index Scan using t1_pkey on t1
         ->  Index Scan using t2_pkey on t2
   ->  Materialize
         ->  Merge Join
               Merge Cond: (t3.id = t4.id)
               ->  Index Scan using t3_pkey on t3
               ->  Sort
                     Sort Key: t4.id
                     ->  Seq Scan on t4
(13 rows)

/*+Leading( */
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id;
INFO:  pg_hint_plan: hint syntax error at or near ""
DETAIL:  Closing parenthesis is necessary.
                    QUERY PLAN                    
--------------------------------------------------
 Nested Loop
   ->  Merge Join
         Merge Cond: (t1.id = t4.id)
         ->  Merge Join
               Merge Cond: (t1.id = t2.id)
               ->  Index Scan using t1_pkey on t1
               ->  Index Scan using t2_pkey on t2
         ->  Sort
               Sort Key: t4.id
               ->  Seq Scan on t4
   ->  Index Scan using t3_pkey on t3
         Index Cond: (id = t1.id)
(12 rows)

/*+Leading( )*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id;
INFO:  pg_hint_plan: hint syntax error at or near "Leading( )"
DETAIL:  Leading hint requires at least two relations.
LOG:  pg_hint_plan:
used hint:
not used hint:
duplication hint:
error hint:
Leading()

                    QUERY PLAN                    
--------------------------------------------------
 Nested Loop
   ->  Merge Join
         Merge Cond: (t1.id = t4.id)
         ->  Merge Join
               Merge Cond: (t1.id = t2.id)
               ->  Index Scan using t1_pkey on t1
               ->  Index Scan using t2_pkey on t2
         ->  Sort
               Sort Key: t4.id
               ->  Seq Scan on t4
   ->  Index Scan using t3_pkey on t3
         Index Cond: (id = t1.id)
(12 rows)

/*+Leading( t3 )*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id;
INFO:  pg_hint_plan: hint syntax error at or near "Leading( t3 )"
DETAIL:  Leading hint requires at least two relations.
LOG:  pg_hint_plan:
used hint:
not used hint:
duplication hint:
error hint:
Leading(t3)

                    QUERY PLAN                    
--------------------------------------------------
 Nested Loop
   ->  Merge Join
         Merge Cond: (t1.id = t4.id)
         ->  Merge Join
               Merge Cond: (t1.id = t2.id)
               ->  Index Scan using t1_pkey on t1
               ->  Index Scan using t2_pkey on t2
         ->  Sort
               Sort Key: t4.id
               ->  Seq Scan on t4
   ->  Index Scan using t3_pkey on t3
         Index Cond: (id = t1.id)
(12 rows)

/*+Leading( t3 t4 )*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id;
LOG:  pg_hint_plan:
used hint:
Leading(t3 t4)
not used hint:
duplication hint:
error hint:

                    QUERY PLAN                    
--------------------------------------------------
 Nested Loop
   ->  Nested Loop
         ->  Merge Join
               Merge Cond: (t3.id = t4.id)
               ->  Index Scan using t3_pkey on t3
               ->  Sort
                     Sort Key: t4.id
                     ->  Seq Scan on t4
         ->  Index Scan using t2_pkey on t2
               Index Cond: (id = t3.id)
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id = t2.id)
(12 rows)

/*+Leading(t3 t4 t1)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id;
LOG:  pg_hint_plan:
used hint:
Leading(t3 t4 t1)
not used hint:
duplication hint:
error hint:

                    QUERY PLAN                    
--------------------------------------------------
 Nested Loop
   ->  Merge Join
         Merge Cond: (t3.id = t1.id)
         ->  Merge Join
               Merge Cond: (t3.id = t4.id)
               ->  Index Scan using t3_pkey on t3
               ->  Sort
                     Sort Key: t4.id
                     ->  Seq Scan on t4
         ->  Index Scan using t1_pkey on t1
   ->  Index Scan using t2_pkey on t2
         Index Cond: (id = t1.id)
(12 rows)

/*+Leading(t3 t4 t1 t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id;
LOG:  pg_hint_plan:
used hint:
Leading(t3 t4 t1 t2)
not used hint:
duplication hint:
error hint:

                    QUERY PLAN                    
--------------------------------------------------
 Nested Loop
   ->  Merge Join
         Merge Cond: (t3.id = t1.id)
         ->  Merge Join
               Merge Cond: (t3.id = t4.id)
               ->  Index Scan using t3_pkey on t3
               ->  Sort
                     Sort Key: t4.id
                     ->  Seq Scan on t4
         ->  Index Scan using t1_pkey on t1
   ->  Index Scan using t2_pkey on t2
         Index Cond: (id = t1.id)
(12 rows)

/*+Leading(t3 t4 t1 t2 t1)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id;
INFO:  pg_hint_plan: hint syntax error at or near "Leading(t3 t4 t1 t2 t1)"
DETAIL:  Relation name "t1" is duplicated.
LOG:  pg_hint_plan:
used hint:
not used hint:
duplication hint:
error hint:
Leading(t3 t4 t1 t2 t1)

                    QUERY PLAN                    
--------------------------------------------------
 Nested Loop
   ->  Merge Join
         Merge Cond: (t1.id = t4.id)
         ->  Merge Join
               Merge Cond: (t1.id = t2.id)
               ->  Index Scan using t1_pkey on t1
               ->  Index Scan using t2_pkey on t2
         ->  Sort
               Sort Key: t4.id
               ->  Seq Scan on t4
   ->  Index Scan using t3_pkey on t3
         Index Cond: (id = t1.id)
(12 rows)

/*+Leading(t3 t4 t4)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id;
INFO:  pg_hint_plan: hint syntax error at or near "Leading(t3 t4 t4)"
DETAIL:  Relation name "t4" is duplicated.
LOG:  pg_hint_plan:
used hint:
not used hint:
duplication hint:
error hint:
Leading(t3 t4 t4)

                    QUERY PLAN                    
--------------------------------------------------
 Nested Loop
   ->  Merge Join
         Merge Cond: (t1.id = t4.id)
         ->  Merge Join
               Merge Cond: (t1.id = t2.id)
               ->  Index Scan using t1_pkey on t1
               ->  Index Scan using t2_pkey on t2
         ->  Sort
               Sort Key: t4.id
               ->  Seq Scan on t4
   ->  Index Scan using t3_pkey on t3
         Index Cond: (id = t1.id)
(12 rows)

EXPLAIN (COSTS false) SELECT * FROM t1, (VALUES(1,1),(2,2),(3,3)) AS t2(id,val) WHERE t1.id = t2.id;
                  QUERY PLAN                   
-----------------------------------------------
 Nested Loop
   ->  Values Scan on "*VALUES*"
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id = "*VALUES*".column1)
(4 rows)

/*+HashJoin(t1 t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, (VALUES(1,1),(2,2),(3,3)) AS t2(id,val) WHERE t1.id = t2.id;
LOG:  pg_hint_plan:
used hint:
not used hint:
HashJoin(t1 t2)
duplication hint:
error hint:

                  QUERY PLAN                   
-----------------------------------------------
 Nested Loop
   ->  Values Scan on "*VALUES*"
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id = "*VALUES*".column1)
(4 rows)

/*+HashJoin(t1 *VALUES*)*/
EXPLAIN (COSTS false) SELECT * FROM t1, (VALUES(1,1),(2,2),(3,3)) AS t2(id,val) WHERE t1.id = t2.id;
LOG:  pg_hint_plan:
used hint:
HashJoin(*VALUES* t1)
not used hint:
duplication hint:
error hint:

                QUERY PLAN                 
-------------------------------------------
 Hash Join
   Hash Cond: (t1.id = "*VALUES*".column1)
   ->  Seq Scan on t1
   ->  Hash
         ->  Values Scan on "*VALUES*"
(5 rows)

/*+HashJoin(t1 *VALUES*) IndexScan(t1) IndexScan(*VALUES*)*/
EXPLAIN (COSTS false) SELECT * FROM t1, (VALUES(1,1),(2,2),(3,3)) AS t2(id,val) WHERE t1.id = t2.id;
LOG:  pg_hint_plan:
used hint:
IndexScan(t1)
HashJoin(*VALUES* t1)
not used hint:
IndexScan(*VALUES*)
duplication hint:
error hint:

                QUERY PLAN                 
-------------------------------------------
 Hash Join
   Hash Cond: (t1.id = "*VALUES*".column1)
   ->  Index Scan using t1_pkey on t1
   ->  Hash
         ->  Values Scan on "*VALUES*"
(5 rows)

-- single table scan hint test
EXPLAIN (COSTS false) SELECT (SELECT max(id) FROM t1 v_1 WHERE id < 10), id FROM v1 WHERE v1.id = (SELECT max(id) FROM t1 v_2 WHERE id < 10);
                               QUERY PLAN                               
------------------------------------------------------------------------
 Index Only Scan using t1_pkey on t1
   Index Cond: (id = $3)
   InitPlan 2 (returns $1)
     ->  Result
           InitPlan 1 (returns $0)
             ->  Limit
                   ->  Index Only Scan Backward using t1_pkey on t1 v_1
                         Index Cond: ((id IS NOT NULL) AND (id < 10))
   InitPlan 4 (returns $3)
     ->  Result
           InitPlan 3 (returns $2)
             ->  Limit
                   ->  Index Only Scan Backward using t1_pkey on t1 v_2
                         Index Cond: ((id IS NOT NULL) AND (id < 10))
(14 rows)

/*+BitmapScan(v_1)*/
EXPLAIN (COSTS false) SELECT (SELECT max(id) FROM t1 v_1 WHERE id < 10), id FROM v1 WHERE v1.id = (SELECT max(id) FROM t1 v_2 WHERE id < 10);
LOG:  pg_hint_plan:
used hint:
BitmapScan(v_1)
not used hint:
duplication hint:
error hint:

                               QUERY PLAN                               
------------------------------------------------------------------------
 Index Only Scan using t1_pkey on t1
   Index Cond: (id = $2)
   InitPlan 1 (returns $0)
     ->  Aggregate
           ->  Bitmap Heap Scan on t1 v_1
                 Recheck Cond: (id < 10)
                 ->  Bitmap Index Scan on t1_pkey
                       Index Cond: (id < 10)
   InitPlan 3 (returns $2)
     ->  Result
           InitPlan 2 (returns $1)
             ->  Limit
                   ->  Index Only Scan Backward using t1_pkey on t1 v_2
                         Index Cond: ((id IS NOT NULL) AND (id < 10))
(14 rows)

/*+BitmapScan(v_2)*/
EXPLAIN (COSTS false) SELECT (SELECT max(id) FROM t1 v_1 WHERE id < 10), id FROM v1 WHERE v1.id = (SELECT max(id) FROM t1 v_2 WHERE id < 10);
LOG:  pg_hint_plan:
used hint:
BitmapScan(v_2)
not used hint:
duplication hint:
error hint:

                               QUERY PLAN                               
------------------------------------------------------------------------
 Index Only Scan using t1_pkey on t1
   Index Cond: (id = $2)
   InitPlan 2 (returns $1)
     ->  Result
           InitPlan 1 (returns $0)
             ->  Limit
                   ->  Index Only Scan Backward using t1_pkey on t1 v_1
                         Index Cond: ((id IS NOT NULL) AND (id < 10))
   InitPlan 3 (returns $2)
     ->  Aggregate
           ->  Bitmap Heap Scan on t1 v_2
                 Recheck Cond: (id < 10)
                 ->  Bitmap Index Scan on t1_pkey
                       Index Cond: (id < 10)
(14 rows)

/*+BitmapScan(t1)*/
EXPLAIN (COSTS false) SELECT (SELECT max(id) FROM t1 v_1 WHERE id < 10), id FROM v1 WHERE v1.id = (SELECT max(id) FROM t1 v_2 WHERE id < 10);
LOG:  pg_hint_plan:
used hint:
BitmapScan(t1)
not used hint:
duplication hint:
error hint:

                               QUERY PLAN                               
------------------------------------------------------------------------
 Bitmap Heap Scan on t1
   Recheck Cond: (id = $3)
   InitPlan 2 (returns $1)
     ->  Result
           InitPlan 1 (returns $0)
             ->  Limit
                   ->  Index Only Scan Backward using t1_pkey on t1 v_1
                         Index Cond: ((id IS NOT NULL) AND (id < 10))
   InitPlan 4 (returns $3)
     ->  Result
           InitPlan 3 (returns $2)
             ->  Limit
                   ->  Index Only Scan Backward using t1_pkey on t1 v_2
                         Index Cond: ((id IS NOT NULL) AND (id < 10))
   ->  Bitmap Index Scan on t1_pkey
         Index Cond: (id = $3)
(16 rows)

/*+BitmapScan(v_1)BitmapScan(v_2)*/
EXPLAIN (COSTS false) SELECT (SELECT max(id) FROM t1 v_1 WHERE id < 10), id FROM v1 WHERE v1.id = (SELECT max(id) FROM t1 v_2 WHERE id < 10);
LOG:  pg_hint_plan:
used hint:
BitmapScan(v_1)
BitmapScan(v_2)
not used hint:
duplication hint:
error hint:

                    QUERY PLAN                    
--------------------------------------------------
 Index Only Scan using t1_pkey on t1
   Index Cond: (id = $1)
   InitPlan 1 (returns $0)
     ->  Aggregate
           ->  Bitmap Heap Scan on t1 v_1
                 Recheck Cond: (id < 10)
                 ->  Bitmap Index Scan on t1_pkey
                       Index Cond: (id < 10)
   InitPlan 2 (returns $1)
     ->  Aggregate
           ->  Bitmap Heap Scan on t1 v_2
                 Recheck Cond: (id < 10)
                 ->  Bitmap Index Scan on t1_pkey
                       Index Cond: (id < 10)
(14 rows)

/*+BitmapScan(v_1)BitmapScan(t1)*/
EXPLAIN (COSTS false) SELECT (SELECT max(id) FROM t1 v_1 WHERE id < 10), id FROM v1 WHERE v1.id = (SELECT max(id) FROM t1 v_2 WHERE id < 10);
LOG:  pg_hint_plan:
used hint:
BitmapScan(t1)
BitmapScan(v_1)
not used hint:
duplication hint:
error hint:

                               QUERY PLAN                               
------------------------------------------------------------------------
 Bitmap Heap Scan on t1
   Recheck Cond: (id = $2)
   InitPlan 1 (returns $0)
     ->  Aggregate
           ->  Bitmap Heap Scan on t1 v_1
                 Recheck Cond: (id < 10)
                 ->  Bitmap Index Scan on t1_pkey
                       Index Cond: (id < 10)
   InitPlan 3 (returns $2)
     ->  Result
           InitPlan 2 (returns $1)
             ->  Limit
                   ->  Index Only Scan Backward using t1_pkey on t1 v_2
                         Index Cond: ((id IS NOT NULL) AND (id < 10))
   ->  Bitmap Index Scan on t1_pkey
         Index Cond: (id = $2)
(16 rows)

/*+BitmapScan(v_2)BitmapScan(t1)*/
EXPLAIN (COSTS false) SELECT (SELECT max(id) FROM t1 v_1 WHERE id < 10), id FROM v1 WHERE v1.id = (SELECT max(id) FROM t1 v_2 WHERE id < 10);
LOG:  pg_hint_plan:
used hint:
BitmapScan(t1)
BitmapScan(v_2)
not used hint:
duplication hint:
error hint:

                               QUERY PLAN                               
------------------------------------------------------------------------
 Bitmap Heap Scan on t1
   Recheck Cond: (id = $2)
   InitPlan 2 (returns $1)
     ->  Result
           InitPlan 1 (returns $0)
             ->  Limit
                   ->  Index Only Scan Backward using t1_pkey on t1 v_1
                         Index Cond: ((id IS NOT NULL) AND (id < 10))
   InitPlan 3 (returns $2)
     ->  Aggregate
           ->  Bitmap Heap Scan on t1 v_2
                 Recheck Cond: (id < 10)
                 ->  Bitmap Index Scan on t1_pkey
                       Index Cond: (id < 10)
   ->  Bitmap Index Scan on t1_pkey
         Index Cond: (id = $2)
(16 rows)

/*+BitmapScan(v_1)BitmapScan(v_2)BitmapScan(t1)*/
EXPLAIN (COSTS false) SELECT (SELECT max(id) FROM t1 v_1 WHERE id < 10), id FROM v1 WHERE v1.id = (SELECT max(id) FROM t1 v_2 WHERE id < 10);
LOG:  pg_hint_plan:
used hint:
BitmapScan(t1)
BitmapScan(v_1)
BitmapScan(v_2)
not used hint:
duplication hint:
error hint:

                    QUERY PLAN                    
--------------------------------------------------
 Bitmap Heap Scan on t1
   Recheck Cond: (id = $1)
   InitPlan 1 (returns $0)
     ->  Aggregate
           ->  Bitmap Heap Scan on t1 v_1
                 Recheck Cond: (id < 10)
                 ->  Bitmap Index Scan on t1_pkey
                       Index Cond: (id < 10)
   InitPlan 2 (returns $1)
     ->  Aggregate
           ->  Bitmap Heap Scan on t1 v_2
                 Recheck Cond: (id < 10)
                 ->  Bitmap Index Scan on t1_pkey
                       Index Cond: (id < 10)
   ->  Bitmap Index Scan on t1_pkey
         Index Cond: (id = $1)
(16 rows)

-- full scan hint pattern test
EXPLAIN (COSTS false) SELECT * FROM t1 WHERE id < 10 AND ctid = '(1,1)';
            QUERY PLAN             
-----------------------------------
 Tid Scan on t1
   TID Cond: (ctid = '(1,1)'::tid)
   Filter: (id < 10)
(3 rows)

/*+SeqScan(t1)*/
EXPLAIN (COSTS false) SELECT * FROM t1 WHERE id < 10 AND ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
SeqScan(t1)
not used hint:
duplication hint:
error hint:

                   QUERY PLAN                    
-------------------------------------------------
 Seq Scan on t1
   Filter: ((id < 10) AND (ctid = '(1,1)'::tid))
(2 rows)

/*+IndexScan(t1)*/
EXPLAIN (COSTS false) SELECT * FROM t1 WHERE id < 10 AND ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
IndexScan(t1)
not used hint:
duplication hint:
error hint:

           QUERY PLAN            
---------------------------------
 Index Scan using t1_pkey on t1
   Index Cond: (id < 10)
   Filter: (ctid = '(1,1)'::tid)
(3 rows)

/*+BitmapScan(t1)*/
EXPLAIN (COSTS false) SELECT * FROM t1 WHERE id < 10 AND ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
BitmapScan(t1)
not used hint:
duplication hint:
error hint:

             QUERY PLAN             
------------------------------------
 Bitmap Heap Scan on t1
   Recheck Cond: (id < 10)
   Filter: (ctid = '(1,1)'::tid)
   ->  Bitmap Index Scan on t1_pkey
         Index Cond: (id < 10)
(5 rows)

/*+TidScan(t1)*/
EXPLAIN (COSTS false) SELECT * FROM t1 WHERE id < 10 AND ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
TidScan(t1)
not used hint:
duplication hint:
error hint:

            QUERY PLAN             
-----------------------------------
 Tid Scan on t1
   TID Cond: (ctid = '(1,1)'::tid)
   Filter: (id < 10)
(3 rows)

/*+NoSeqScan(t1)*/
EXPLAIN (COSTS false) SELECT * FROM t1 WHERE id < 10 AND ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoSeqScan(t1)
not used hint:
duplication hint:
error hint:

            QUERY PLAN             
-----------------------------------
 Tid Scan on t1
   TID Cond: (ctid = '(1,1)'::tid)
   Filter: (id < 10)
(3 rows)

/*+NoIndexScan(t1)*/
EXPLAIN (COSTS false) SELECT * FROM t1 WHERE id < 10 AND ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoIndexScan(t1)
not used hint:
duplication hint:
error hint:

            QUERY PLAN             
-----------------------------------
 Tid Scan on t1
   TID Cond: (ctid = '(1,1)'::tid)
   Filter: (id < 10)
(3 rows)

/*+NoBitmapScan(t1)*/
EXPLAIN (COSTS false) SELECT * FROM t1 WHERE id < 10 AND ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoBitmapScan(t1)
not used hint:
duplication hint:
error hint:

            QUERY PLAN             
-----------------------------------
 Tid Scan on t1
   TID Cond: (ctid = '(1,1)'::tid)
   Filter: (id < 10)
(3 rows)

/*+NoTidScan(t1)*/
EXPLAIN (COSTS false) SELECT * FROM t1 WHERE id < 10 AND ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoTidScan(t1)
not used hint:
duplication hint:
error hint:

           QUERY PLAN            
---------------------------------
 Index Scan using t1_pkey on t1
   Index Cond: (id < 10)
   Filter: (ctid = '(1,1)'::tid)
(3 rows)

EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
               QUERY PLAN                
-----------------------------------------
 Nested Loop
   Join Filter: (t1.id = t2.id)
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
(6 rows)

/*+SeqScan(t1)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
SeqScan(t1)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   Join Filter: (t1.id = t2.id)
   ->  Seq Scan on t1
         Filter: (ctid = '(1,1)'::tid)
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
(6 rows)

/*+SeqScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
SeqScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   Join Filter: (t1.id = t2.id)
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Seq Scan on t2
         Filter: (ctid = '(1,1)'::tid)
(6 rows)

/*+SeqScan(t1) SeqScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
SeqScan(t1)
SeqScan(t2)
not used hint:
duplication hint:
error hint:

              QUERY PLAN               
---------------------------------------
 Nested Loop
   Join Filter: (t1.id = t2.id)
   ->  Seq Scan on t1
         Filter: (ctid = '(1,1)'::tid)
   ->  Seq Scan on t2
         Filter: (ctid = '(1,1)'::tid)
(6 rows)

/*+SeqScan(t1) IndexScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
SeqScan(t1)
IndexScan(t2)
not used hint:
duplication hint:
error hint:

              QUERY PLAN               
---------------------------------------
 Nested Loop
   ->  Seq Scan on t1
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using t2_pkey on t2
         Index Cond: (id = t1.id)
         Filter: (ctid = '(1,1)'::tid)
(6 rows)

/*+SeqScan(t1) BitmapScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
SeqScan(t1)
BitmapScan(t2)
not used hint:
duplication hint:
error hint:

                QUERY PLAN                
------------------------------------------
 Nested Loop
   ->  Seq Scan on t1
         Filter: (ctid = '(1,1)'::tid)
   ->  Bitmap Heap Scan on t2
         Recheck Cond: (id = t1.id)
         Filter: (ctid = '(1,1)'::tid)
         ->  Bitmap Index Scan on t2_pkey
               Index Cond: (id = t1.id)
(8 rows)

/*+SeqScan(t1) TidScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
SeqScan(t1)
TidScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   Join Filter: (t1.id = t2.id)
   ->  Seq Scan on t1
         Filter: (ctid = '(1,1)'::tid)
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
(6 rows)

/*+SeqScan(t1) NoSeqScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
SeqScan(t1)
NoSeqScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   Join Filter: (t1.id = t2.id)
   ->  Seq Scan on t1
         Filter: (ctid = '(1,1)'::tid)
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
(6 rows)

/*+SeqScan(t1) NoIndexScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
SeqScan(t1)
NoIndexScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   Join Filter: (t1.id = t2.id)
   ->  Seq Scan on t1
         Filter: (ctid = '(1,1)'::tid)
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
(6 rows)

/*+SeqScan(t1) NoBitmapScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
SeqScan(t1)
NoBitmapScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   Join Filter: (t1.id = t2.id)
   ->  Seq Scan on t1
         Filter: (ctid = '(1,1)'::tid)
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
(6 rows)

/*+SeqScan(t1) NoTidScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
SeqScan(t1)
NoTidScan(t2)
not used hint:
duplication hint:
error hint:

              QUERY PLAN               
---------------------------------------
 Nested Loop
   ->  Seq Scan on t1
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using t2_pkey on t2
         Index Cond: (id = t1.id)
         Filter: (ctid = '(1,1)'::tid)
(6 rows)

/*+IndexScan(t1)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
IndexScan(t1)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id = t2.id)
         Filter: (ctid = '(1,1)'::tid)
(6 rows)

/*+IndexScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
IndexScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Index Scan using t2_pkey on t2
         Index Cond: (id = t1.id)
         Filter: (ctid = '(1,1)'::tid)
(6 rows)

/*+IndexScan(t1) SeqScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
IndexScan(t1)
SeqScan(t2)
not used hint:
duplication hint:
error hint:

              QUERY PLAN               
---------------------------------------
 Nested Loop
   ->  Seq Scan on t2
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id = t2.id)
         Filter: (ctid = '(1,1)'::tid)
(6 rows)

/*+IndexScan(t1) IndexScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
IndexScan(t1)
IndexScan(t2)
not used hint:
duplication hint:
error hint:

              QUERY PLAN               
---------------------------------------
 Nested Loop
   ->  Index Scan using t2_pkey on t2
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id = t2.id)
         Filter: (ctid = '(1,1)'::tid)
(6 rows)

/*+IndexScan(t1) BitmapScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
IndexScan(t1)
BitmapScan(t2)
not used hint:
duplication hint:
error hint:

                QUERY PLAN                
------------------------------------------
 Nested Loop
   ->  Index Scan using t1_pkey on t1
         Filter: (ctid = '(1,1)'::tid)
   ->  Bitmap Heap Scan on t2
         Recheck Cond: (id = t1.id)
         Filter: (ctid = '(1,1)'::tid)
         ->  Bitmap Index Scan on t2_pkey
               Index Cond: (id = t1.id)
(8 rows)

/*+IndexScan(t1) TidScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
IndexScan(t1)
TidScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id = t2.id)
         Filter: (ctid = '(1,1)'::tid)
(6 rows)

/*+IndexScan(t1) NoSeqScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
IndexScan(t1)
NoSeqScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id = t2.id)
         Filter: (ctid = '(1,1)'::tid)
(6 rows)

/*+IndexScan(t1) NoIndexScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
IndexScan(t1)
NoIndexScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id = t2.id)
         Filter: (ctid = '(1,1)'::tid)
(6 rows)

/*+IndexScan(t1) NoBitmapScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
IndexScan(t1)
NoBitmapScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id = t2.id)
         Filter: (ctid = '(1,1)'::tid)
(6 rows)

/*+IndexScan(t1) NoTidScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
IndexScan(t1)
NoTidScan(t2)
not used hint:
duplication hint:
error hint:

              QUERY PLAN               
---------------------------------------
 Nested Loop
   ->  Seq Scan on t2
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id = t2.id)
         Filter: (ctid = '(1,1)'::tid)
(6 rows)

/*+BitmapScan(t1)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
BitmapScan(t1)
not used hint:
duplication hint:
error hint:

                QUERY PLAN                
------------------------------------------
 Nested Loop
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Bitmap Heap Scan on t1
         Recheck Cond: (id = t2.id)
         Filter: (ctid = '(1,1)'::tid)
         ->  Bitmap Index Scan on t1_pkey
               Index Cond: (id = t2.id)
(8 rows)

/*+BitmapScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
BitmapScan(t2)
not used hint:
duplication hint:
error hint:

                QUERY PLAN                
------------------------------------------
 Nested Loop
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Bitmap Heap Scan on t2
         Recheck Cond: (id = t1.id)
         Filter: (ctid = '(1,1)'::tid)
         ->  Bitmap Index Scan on t2_pkey
               Index Cond: (id = t1.id)
(8 rows)

/*+BitmapScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
BitmapScan(t2)
not used hint:
duplication hint:
error hint:

                QUERY PLAN                
------------------------------------------
 Nested Loop
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Bitmap Heap Scan on t2
         Recheck Cond: (id = t1.id)
         Filter: (ctid = '(1,1)'::tid)
         ->  Bitmap Index Scan on t2_pkey
               Index Cond: (id = t1.id)
(8 rows)

/*+BitmapScan(t1) SeqScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
BitmapScan(t1)
SeqScan(t2)
not used hint:
duplication hint:
error hint:

                QUERY PLAN                
------------------------------------------
 Nested Loop
   ->  Seq Scan on t2
         Filter: (ctid = '(1,1)'::tid)
   ->  Bitmap Heap Scan on t1
         Recheck Cond: (id = t2.id)
         Filter: (ctid = '(1,1)'::tid)
         ->  Bitmap Index Scan on t1_pkey
               Index Cond: (id = t2.id)
(8 rows)

/*+BitmapScan(t1) IndexScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
BitmapScan(t1)
IndexScan(t2)
not used hint:
duplication hint:
error hint:

                QUERY PLAN                
------------------------------------------
 Nested Loop
   ->  Index Scan using t2_pkey on t2
         Filter: (ctid = '(1,1)'::tid)
   ->  Bitmap Heap Scan on t1
         Recheck Cond: (id = t2.id)
         Filter: (ctid = '(1,1)'::tid)
         ->  Bitmap Index Scan on t1_pkey
               Index Cond: (id = t2.id)
(8 rows)

/*+BitmapScan(t1) BitmapScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
BitmapScan(t1)
BitmapScan(t2)
not used hint:
duplication hint:
error hint:

                QUERY PLAN                
------------------------------------------
 Nested Loop
   ->  Index Scan using t2_pkey on t2
         Filter: (ctid = '(1,1)'::tid)
   ->  Bitmap Heap Scan on t1
         Recheck Cond: (id = t2.id)
         Filter: (ctid = '(1,1)'::tid)
         ->  Bitmap Index Scan on t1_pkey
               Index Cond: (id = t2.id)
(8 rows)

/*+BitmapScan(t1) TidScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
BitmapScan(t1)
TidScan(t2)
not used hint:
duplication hint:
error hint:

                QUERY PLAN                
------------------------------------------
 Nested Loop
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Bitmap Heap Scan on t1
         Recheck Cond: (id = t2.id)
         Filter: (ctid = '(1,1)'::tid)
         ->  Bitmap Index Scan on t1_pkey
               Index Cond: (id = t2.id)
(8 rows)

/*+BitmapScan(t1) NoSeqScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
BitmapScan(t1)
NoSeqScan(t2)
not used hint:
duplication hint:
error hint:

                QUERY PLAN                
------------------------------------------
 Nested Loop
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Bitmap Heap Scan on t1
         Recheck Cond: (id = t2.id)
         Filter: (ctid = '(1,1)'::tid)
         ->  Bitmap Index Scan on t1_pkey
               Index Cond: (id = t2.id)
(8 rows)

/*+BitmapScan(t1) NoIndexScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
BitmapScan(t1)
NoIndexScan(t2)
not used hint:
duplication hint:
error hint:

                QUERY PLAN                
------------------------------------------
 Nested Loop
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Bitmap Heap Scan on t1
         Recheck Cond: (id = t2.id)
         Filter: (ctid = '(1,1)'::tid)
         ->  Bitmap Index Scan on t1_pkey
               Index Cond: (id = t2.id)
(8 rows)

/*+BitmapScan(t1) NoBitmapScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
BitmapScan(t1)
NoBitmapScan(t2)
not used hint:
duplication hint:
error hint:

                QUERY PLAN                
------------------------------------------
 Nested Loop
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Bitmap Heap Scan on t1
         Recheck Cond: (id = t2.id)
         Filter: (ctid = '(1,1)'::tid)
         ->  Bitmap Index Scan on t1_pkey
               Index Cond: (id = t2.id)
(8 rows)

/*+BitmapScan(t1) NoTidScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
BitmapScan(t1)
NoTidScan(t2)
not used hint:
duplication hint:
error hint:

                QUERY PLAN                
------------------------------------------
 Nested Loop
   ->  Seq Scan on t2
         Filter: (ctid = '(1,1)'::tid)
   ->  Bitmap Heap Scan on t1
         Recheck Cond: (id = t2.id)
         Filter: (ctid = '(1,1)'::tid)
         ->  Bitmap Index Scan on t1_pkey
               Index Cond: (id = t2.id)
(8 rows)

/*+TidScan(t1)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
TidScan(t1)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   Join Filter: (t1.id = t2.id)
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
(6 rows)

/*+TidScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
TidScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   Join Filter: (t1.id = t2.id)
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
(6 rows)

/*+TidScan(t1) SeqScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
TidScan(t1)
SeqScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   Join Filter: (t1.id = t2.id)
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Seq Scan on t2
         Filter: (ctid = '(1,1)'::tid)
(6 rows)

/*+TidScan(t1) IndexScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
TidScan(t1)
IndexScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Index Scan using t2_pkey on t2
         Index Cond: (id = t1.id)
         Filter: (ctid = '(1,1)'::tid)
(6 rows)

/*+TidScan(t1) BitmapScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
TidScan(t1)
BitmapScan(t2)
not used hint:
duplication hint:
error hint:

                QUERY PLAN                
------------------------------------------
 Nested Loop
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Bitmap Heap Scan on t2
         Recheck Cond: (id = t1.id)
         Filter: (ctid = '(1,1)'::tid)
         ->  Bitmap Index Scan on t2_pkey
               Index Cond: (id = t1.id)
(8 rows)

/*+TidScan(t1) TidScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
TidScan(t1)
TidScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   Join Filter: (t1.id = t2.id)
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
(6 rows)

/*+TidScan(t1) NoSeqScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
TidScan(t1)
NoSeqScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   Join Filter: (t1.id = t2.id)
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
(6 rows)

/*+TidScan(t1) NoIndexScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
TidScan(t1)
NoIndexScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   Join Filter: (t1.id = t2.id)
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
(6 rows)

/*+TidScan(t1) NoBitmapScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
TidScan(t1)
NoBitmapScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   Join Filter: (t1.id = t2.id)
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
(6 rows)

/*+TidScan(t1) NoTidScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
TidScan(t1)
NoTidScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Index Scan using t2_pkey on t2
         Index Cond: (id = t1.id)
         Filter: (ctid = '(1,1)'::tid)
(6 rows)

/*+NoSeqScan(t1)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoSeqScan(t1)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   Join Filter: (t1.id = t2.id)
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
(6 rows)

/*+NoSeqScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoSeqScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   Join Filter: (t1.id = t2.id)
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
(6 rows)

/*+NoSeqScan(t1) SeqScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoSeqScan(t1)
SeqScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   Join Filter: (t1.id = t2.id)
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Seq Scan on t2
         Filter: (ctid = '(1,1)'::tid)
(6 rows)

/*+NoSeqScan(t1) IndexScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoSeqScan(t1)
IndexScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Index Scan using t2_pkey on t2
         Index Cond: (id = t1.id)
         Filter: (ctid = '(1,1)'::tid)
(6 rows)

/*+NoSeqScan(t1) BitmapScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoSeqScan(t1)
BitmapScan(t2)
not used hint:
duplication hint:
error hint:

                QUERY PLAN                
------------------------------------------
 Nested Loop
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Bitmap Heap Scan on t2
         Recheck Cond: (id = t1.id)
         Filter: (ctid = '(1,1)'::tid)
         ->  Bitmap Index Scan on t2_pkey
               Index Cond: (id = t1.id)
(8 rows)

/*+NoSeqScan(t1) TidScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoSeqScan(t1)
TidScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   Join Filter: (t1.id = t2.id)
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
(6 rows)

/*+NoSeqScan(t1) NoSeqScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoSeqScan(t1)
NoSeqScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   Join Filter: (t1.id = t2.id)
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
(6 rows)

/*+NoSeqScan(t1) NoIndexScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoSeqScan(t1)
NoIndexScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   Join Filter: (t1.id = t2.id)
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
(6 rows)

/*+NoSeqScan(t1) NoBitmapScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoSeqScan(t1)
NoBitmapScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   Join Filter: (t1.id = t2.id)
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
(6 rows)

/*+NoSeqScan(t1) NoTidScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoSeqScan(t1)
NoTidScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Index Scan using t2_pkey on t2
         Index Cond: (id = t1.id)
         Filter: (ctid = '(1,1)'::tid)
(6 rows)

/*+NoIndexScan(t1)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoIndexScan(t1)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   Join Filter: (t1.id = t2.id)
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
(6 rows)

/*+NoIndexScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoIndexScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   Join Filter: (t1.id = t2.id)
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
(6 rows)

/*+NoIndexScan(t1) SeqScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoIndexScan(t1)
SeqScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   Join Filter: (t1.id = t2.id)
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Seq Scan on t2
         Filter: (ctid = '(1,1)'::tid)
(6 rows)

/*+NoIndexScan(t1) IndexScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoIndexScan(t1)
IndexScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Index Scan using t2_pkey on t2
         Index Cond: (id = t1.id)
         Filter: (ctid = '(1,1)'::tid)
(6 rows)

/*+NoIndexScan(t1) BitmapScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoIndexScan(t1)
BitmapScan(t2)
not used hint:
duplication hint:
error hint:

                QUERY PLAN                
------------------------------------------
 Nested Loop
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Bitmap Heap Scan on t2
         Recheck Cond: (id = t1.id)
         Filter: (ctid = '(1,1)'::tid)
         ->  Bitmap Index Scan on t2_pkey
               Index Cond: (id = t1.id)
(8 rows)

/*+NoIndexScan(t1) TidScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoIndexScan(t1)
TidScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   Join Filter: (t1.id = t2.id)
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
(6 rows)

/*+NoIndexScan(t1) NoSeqScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoIndexScan(t1)
NoSeqScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   Join Filter: (t1.id = t2.id)
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
(6 rows)

/*+NoIndexScan(t1) NoIndexScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoIndexScan(t1)
NoIndexScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   Join Filter: (t1.id = t2.id)
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
(6 rows)

/*+NoIndexScan(t1) NoBitmapScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoIndexScan(t1)
NoBitmapScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   Join Filter: (t1.id = t2.id)
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
(6 rows)

/*+NoIndexScan(t1) NoTidScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoIndexScan(t1)
NoTidScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Index Scan using t2_pkey on t2
         Index Cond: (id = t1.id)
         Filter: (ctid = '(1,1)'::tid)
(6 rows)

/*+NoBitmapScan(t1)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoBitmapScan(t1)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   Join Filter: (t1.id = t2.id)
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
(6 rows)

/*+NoBitmapScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoBitmapScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   Join Filter: (t1.id = t2.id)
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
(6 rows)

/*+NoBitmapScan(t1) SeqScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoBitmapScan(t1)
SeqScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   Join Filter: (t1.id = t2.id)
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Seq Scan on t2
         Filter: (ctid = '(1,1)'::tid)
(6 rows)

/*+NoBitmapScan(t1) IndexScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoBitmapScan(t1)
IndexScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Index Scan using t2_pkey on t2
         Index Cond: (id = t1.id)
         Filter: (ctid = '(1,1)'::tid)
(6 rows)

/*+NoBitmapScan(t1) BitmapScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoBitmapScan(t1)
BitmapScan(t2)
not used hint:
duplication hint:
error hint:

                QUERY PLAN                
------------------------------------------
 Nested Loop
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Bitmap Heap Scan on t2
         Recheck Cond: (id = t1.id)
         Filter: (ctid = '(1,1)'::tid)
         ->  Bitmap Index Scan on t2_pkey
               Index Cond: (id = t1.id)
(8 rows)

/*+NoBitmapScan(t1) TidScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoBitmapScan(t1)
TidScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   Join Filter: (t1.id = t2.id)
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
(6 rows)

/*+NoBitmapScan(t1) NoSeqScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoBitmapScan(t1)
NoSeqScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   Join Filter: (t1.id = t2.id)
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
(6 rows)

/*+NoBitmapScan(t1) NoIndexScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoBitmapScan(t1)
NoIndexScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   Join Filter: (t1.id = t2.id)
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
(6 rows)

/*+NoBitmapScan(t1) NoBitmapScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoBitmapScan(t1)
NoBitmapScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   Join Filter: (t1.id = t2.id)
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
(6 rows)

/*+NoBitmapScan(t1) NoTidScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoBitmapScan(t1)
NoTidScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Index Scan using t2_pkey on t2
         Index Cond: (id = t1.id)
         Filter: (ctid = '(1,1)'::tid)
(6 rows)

/*+NoTidScan(t1)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoTidScan(t1)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id = t2.id)
         Filter: (ctid = '(1,1)'::tid)
(6 rows)

/*+NoTidScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoTidScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Index Scan using t2_pkey on t2
         Index Cond: (id = t1.id)
         Filter: (ctid = '(1,1)'::tid)
(6 rows)

/*+NoTidScan(t1) SeqScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoTidScan(t1)
SeqScan(t2)
not used hint:
duplication hint:
error hint:

              QUERY PLAN               
---------------------------------------
 Nested Loop
   ->  Seq Scan on t2
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id = t2.id)
         Filter: (ctid = '(1,1)'::tid)
(6 rows)

/*+NoTidScan(t1) IndexScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoTidScan(t1)
IndexScan(t2)
not used hint:
duplication hint:
error hint:

              QUERY PLAN               
---------------------------------------
 Nested Loop
   ->  Index Scan using t2_pkey on t2
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id = t2.id)
         Filter: (ctid = '(1,1)'::tid)
(6 rows)

/*+NoTidScan(t1) BitmapScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoTidScan(t1)
BitmapScan(t2)
not used hint:
duplication hint:
error hint:

                QUERY PLAN                
------------------------------------------
 Nested Loop
   ->  Seq Scan on t1
         Filter: (ctid = '(1,1)'::tid)
   ->  Bitmap Heap Scan on t2
         Recheck Cond: (id = t1.id)
         Filter: (ctid = '(1,1)'::tid)
         ->  Bitmap Index Scan on t2_pkey
               Index Cond: (id = t1.id)
(8 rows)

/*+NoTidScan(t1) TidScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoTidScan(t1)
TidScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id = t2.id)
         Filter: (ctid = '(1,1)'::tid)
(6 rows)

/*+NoTidScan(t1) NoSeqScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoTidScan(t1)
NoSeqScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id = t2.id)
         Filter: (ctid = '(1,1)'::tid)
(6 rows)

/*+NoTidScan(t1) NoIndexScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoTidScan(t1)
NoIndexScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id = t2.id)
         Filter: (ctid = '(1,1)'::tid)
(6 rows)

/*+NoTidScan(t1) NoBitmapScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoTidScan(t1)
NoBitmapScan(t2)
not used hint:
duplication hint:
error hint:

               QUERY PLAN                
-----------------------------------------
 Nested Loop
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id = t2.id)
         Filter: (ctid = '(1,1)'::tid)
(6 rows)

/*+NoTidScan(t1) NoTidScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
NoTidScan(t1)
NoTidScan(t2)
not used hint:
duplication hint:
error hint:

              QUERY PLAN               
---------------------------------------
 Nested Loop
   ->  Seq Scan on t2
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id = t2.id)
         Filter: (ctid = '(1,1)'::tid)
(6 rows)

-- additional test
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)' AND t1.id < 10 AND t2.id < 10;
               QUERY PLAN                
-----------------------------------------
 Nested Loop
   Join Filter: (t1.id = t2.id)
   ->  Tid Scan on t1
         TID Cond: (ctid = '(1,1)'::tid)
         Filter: (id < 10)
   ->  Tid Scan on t2
         TID Cond: (ctid = '(1,1)'::tid)
         Filter: (id < 10)
(8 rows)

/*+BitmapScan(t1) BitmapScan(t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)' AND t1.id < 10 AND t2.id < 10;
LOG:  pg_hint_plan:
used hint:
BitmapScan(t1)
BitmapScan(t2)
not used hint:
duplication hint:
error hint:

                       QUERY PLAN                       
--------------------------------------------------------
 Nested Loop
   ->  Bitmap Heap Scan on t2
         Recheck Cond: (id < 10)
         Filter: (ctid = '(1,1)'::tid)
         ->  Bitmap Index Scan on t2_pkey
               Index Cond: (id < 10)
   ->  Bitmap Heap Scan on t1
         Recheck Cond: ((id = t2.id) AND (id < 10))
         Filter: (ctid = '(1,1)'::tid)
         ->  Bitmap Index Scan on t1_pkey
               Index Cond: ((id = t2.id) AND (id < 10))
(11 rows)

-- outer join test
EXPLAIN (COSTS false) SELECT * FROM t1 FULL OUTER JOIN  t2 ON (t1.id = t2.id);
          QUERY PLAN          
------------------------------
 Hash Full Join
   Hash Cond: (t1.id = t2.id)
   ->  Seq Scan on t1
   ->  Hash
         ->  Seq Scan on t2
(5 rows)

/*+MergeJoin(t1 t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1 FULL OUTER JOIN  t2 ON (t1.id = t2.id);
LOG:  pg_hint_plan:
used hint:
MergeJoin(t1 t2)
not used hint:
duplication hint:
error hint:

              QUERY PLAN              
--------------------------------------
 Merge Full Join
   Merge Cond: (t1.id = t2.id)
   ->  Index Scan using t1_pkey on t1
   ->  Index Scan using t2_pkey on t2
(4 rows)

/*+NestLoop(t1 t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1 FULL OUTER JOIN  t2 ON (t1.id = t2.id);
LOG:  pg_hint_plan:
used hint:
NestLoop(t1 t2)
not used hint:
duplication hint:
error hint:

          QUERY PLAN          
------------------------------
 Hash Full Join
   Hash Cond: (t1.id = t2.id)
   ->  Seq Scan on t1
   ->  Hash
         ->  Seq Scan on t2
(5 rows)

-- inherite table test
SET constraint_exclusion TO off;
EXPLAIN (COSTS false) SELECT * FROM p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
                              QUERY PLAN                               
-----------------------------------------------------------------------
 Append
   ->  Seq Scan on p1
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p1_c1
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p1_c2
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p1_c3
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p1_c4
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p1_c1_c1
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p1_c1_c2
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p1_c3_c1
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p1_c3_c2
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
(19 rows)

SET constraint_exclusion TO on;
EXPLAIN (COSTS false) SELECT * FROM p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
                              QUERY PLAN                               
-----------------------------------------------------------------------
 Append
   ->  Seq Scan on p1
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p1_c1
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p1_c1_c1
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p1_c1_c2
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
(9 rows)

SET constraint_exclusion TO off;
/*+SeqScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
SeqScan(p1)
not used hint:
duplication hint:
error hint:

                              QUERY PLAN                               
-----------------------------------------------------------------------
 Append
   ->  Seq Scan on p1
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p1_c1
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p1_c2
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p1_c3
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p1_c4
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p1_c1_c1
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p1_c1_c2
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p1_c3_c1
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p1_c3_c2
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
(19 rows)

/*+IndexScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
IndexScan(p1)
not used hint:
duplication hint:
error hint:

                    QUERY PLAN                    
--------------------------------------------------
 Append
   ->  Index Scan using p1_pkey on p1
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p1_c1_pkey on p1_c1
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p1_c2_pkey on p1_c2
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p1_c3_pkey on p1_c3
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p1_c4_pkey on p1_c4
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p1_c1_c1_pkey on p1_c1_c1
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p1_c1_c2_pkey on p1_c1_c2
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p1_c3_c1_pkey on p1_c3_c1
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p1_c3_c2_pkey on p1_c3_c2
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
(28 rows)

/*+BitmapScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
BitmapScan(p1)
not used hint:
duplication hint:
error hint:

                      QUERY PLAN                       
-------------------------------------------------------
 Append
   ->  Bitmap Heap Scan on p1
         Recheck Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
         ->  Bitmap Index Scan on p1_pkey
               Index Cond: ((id >= 50) AND (id <= 51))
   ->  Bitmap Heap Scan on p1_c1
         Recheck Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
         ->  Bitmap Index Scan on p1_c1_pkey
               Index Cond: ((id >= 50) AND (id <= 51))
   ->  Bitmap Heap Scan on p1_c2
         Recheck Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
         ->  Bitmap Index Scan on p1_c2_pkey
               Index Cond: ((id >= 50) AND (id <= 51))
   ->  Bitmap Heap Scan on p1_c3
         Recheck Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
         ->  Bitmap Index Scan on p1_c3_pkey
               Index Cond: ((id >= 50) AND (id <= 51))
   ->  Bitmap Heap Scan on p1_c4
         Recheck Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
         ->  Bitmap Index Scan on p1_c4_pkey
               Index Cond: ((id >= 50) AND (id <= 51))
   ->  Bitmap Heap Scan on p1_c1_c1
         Recheck Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
         ->  Bitmap Index Scan on p1_c1_c1_pkey
               Index Cond: ((id >= 50) AND (id <= 51))
   ->  Bitmap Heap Scan on p1_c1_c2
         Recheck Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
         ->  Bitmap Index Scan on p1_c1_c2_pkey
               Index Cond: ((id >= 50) AND (id <= 51))
   ->  Bitmap Heap Scan on p1_c3_c1
         Recheck Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
         ->  Bitmap Index Scan on p1_c3_c1_pkey
               Index Cond: ((id >= 50) AND (id <= 51))
   ->  Bitmap Heap Scan on p1_c3_c2
         Recheck Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
         ->  Bitmap Index Scan on p1_c3_c2_pkey
               Index Cond: ((id >= 50) AND (id <= 51))
(46 rows)

/*+TidScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
TidScan(p1)
not used hint:
duplication hint:
error hint:

                 QUERY PLAN                  
---------------------------------------------
 Append
   ->  Tid Scan on p1
         TID Cond: (ctid = '(1,1)'::tid)
         Filter: ((id >= 50) AND (id <= 51))
   ->  Tid Scan on p1_c1
         TID Cond: (ctid = '(1,1)'::tid)
         Filter: ((id >= 50) AND (id <= 51))
   ->  Tid Scan on p1_c2
         TID Cond: (ctid = '(1,1)'::tid)
         Filter: ((id >= 50) AND (id <= 51))
   ->  Tid Scan on p1_c3
         TID Cond: (ctid = '(1,1)'::tid)
         Filter: ((id >= 50) AND (id <= 51))
   ->  Tid Scan on p1_c4
         TID Cond: (ctid = '(1,1)'::tid)
         Filter: ((id >= 50) AND (id <= 51))
   ->  Tid Scan on p1_c1_c1
         TID Cond: (ctid = '(1,1)'::tid)
         Filter: ((id >= 50) AND (id <= 51))
   ->  Tid Scan on p1_c1_c2
         TID Cond: (ctid = '(1,1)'::tid)
         Filter: ((id >= 50) AND (id <= 51))
   ->  Tid Scan on p1_c3_c1
         TID Cond: (ctid = '(1,1)'::tid)
         Filter: ((id >= 50) AND (id <= 51))
   ->  Tid Scan on p1_c3_c2
         TID Cond: (ctid = '(1,1)'::tid)
         Filter: ((id >= 50) AND (id <= 51))
(28 rows)

SET constraint_exclusion TO on;
/*+SeqScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
SeqScan(p1)
not used hint:
duplication hint:
error hint:

                              QUERY PLAN                               
-----------------------------------------------------------------------
 Append
   ->  Seq Scan on p1
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p1_c1
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p1_c1_c1
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p1_c1_c2
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
(9 rows)

/*+IndexScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
IndexScan(p1)
not used hint:
duplication hint:
error hint:

                    QUERY PLAN                    
--------------------------------------------------
 Append
   ->  Index Scan using p1_pkey on p1
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p1_c1_pkey on p1_c1
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p1_c1_c1_pkey on p1_c1_c1
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p1_c1_c2_pkey on p1_c1_c2
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
(13 rows)

/*+BitmapScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
BitmapScan(p1)
not used hint:
duplication hint:
error hint:

                      QUERY PLAN                       
-------------------------------------------------------
 Append
   ->  Bitmap Heap Scan on p1
         Recheck Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
         ->  Bitmap Index Scan on p1_pkey
               Index Cond: ((id >= 50) AND (id <= 51))
   ->  Bitmap Heap Scan on p1_c1
         Recheck Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
         ->  Bitmap Index Scan on p1_c1_pkey
               Index Cond: ((id >= 50) AND (id <= 51))
   ->  Bitmap Heap Scan on p1_c1_c1
         Recheck Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
         ->  Bitmap Index Scan on p1_c1_c1_pkey
               Index Cond: ((id >= 50) AND (id <= 51))
   ->  Bitmap Heap Scan on p1_c1_c2
         Recheck Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
         ->  Bitmap Index Scan on p1_c1_c2_pkey
               Index Cond: ((id >= 50) AND (id <= 51))
(21 rows)

/*+TidScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
TidScan(p1)
not used hint:
duplication hint:
error hint:

                 QUERY PLAN                  
---------------------------------------------
 Append
   ->  Tid Scan on p1
         TID Cond: (ctid = '(1,1)'::tid)
         Filter: ((id >= 50) AND (id <= 51))
   ->  Tid Scan on p1_c1
         TID Cond: (ctid = '(1,1)'::tid)
         Filter: ((id >= 50) AND (id <= 51))
   ->  Tid Scan on p1_c1_c1
         TID Cond: (ctid = '(1,1)'::tid)
         Filter: ((id >= 50) AND (id <= 51))
   ->  Tid Scan on p1_c1_c2
         TID Cond: (ctid = '(1,1)'::tid)
         Filter: ((id >= 50) AND (id <= 51))
(13 rows)

SET constraint_exclusion TO off;
EXPLAIN (COSTS false) SELECT * FROM p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
                                    QUERY PLAN                                     
-----------------------------------------------------------------------------------
 Merge Join
   Merge Cond: (p1.id = t1.id)
   ->  Sort
         Sort Key: p1.id
         ->  Append
               ->  Seq Scan on p1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c2
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c3
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c4
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c1_c1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c1_c2
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c3_c1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c3_c2
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id < 10)
(25 rows)

SET constraint_exclusion TO on;
EXPLAIN (COSTS false) SELECT * FROM p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
                                    QUERY PLAN                                     
-----------------------------------------------------------------------------------
 Merge Join
   Merge Cond: (p1.id = t1.id)
   ->  Sort
         Sort Key: p1.id
         ->  Append
               ->  Seq Scan on p1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c1_c1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c1_c2
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id < 10)
(15 rows)

SET constraint_exclusion TO off;
/*+SeqScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
SeqScan(p1)
not used hint:
duplication hint:
error hint:

                                    QUERY PLAN                                     
-----------------------------------------------------------------------------------
 Merge Join
   Merge Cond: (p1.id = t1.id)
   ->  Sort
         Sort Key: p1.id
         ->  Append
               ->  Seq Scan on p1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c2
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c3
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c4
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c1_c1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c1_c2
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c3_c1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c3_c2
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id < 10)
(25 rows)

/*+IndexScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
IndexScan(p1)
not used hint:
duplication hint:
error hint:

                                    QUERY PLAN                                     
-----------------------------------------------------------------------------------
 Merge Join
   Merge Cond: (p1.id = t1.id)
   ->  Sort
         Sort Key: p1.id
         ->  Append
               ->  Seq Scan on p1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c2
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c3
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c4
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c1_c1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c1_c2
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c3_c1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c3_c2
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id < 10)
(25 rows)

/*+BitmapScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
BitmapScan(p1)
not used hint:
duplication hint:
error hint:

                                    QUERY PLAN                                     
-----------------------------------------------------------------------------------
 Merge Join
   Merge Cond: (p1.id = t1.id)
   ->  Sort
         Sort Key: p1.id
         ->  Append
               ->  Seq Scan on p1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c2
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c3
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c4
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c1_c1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c1_c2
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c3_c1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c3_c2
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id < 10)
(25 rows)

/*+TidScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
TidScan(p1)
not used hint:
duplication hint:
error hint:

                                    QUERY PLAN                                     
-----------------------------------------------------------------------------------
 Merge Join
   Merge Cond: (p1.id = t1.id)
   ->  Sort
         Sort Key: p1.id
         ->  Append
               ->  Seq Scan on p1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c2
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c3
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c4
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c1_c1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c1_c2
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c3_c1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c3_c2
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id < 10)
(25 rows)

/*+NestLoop(p1 t1)*/
EXPLAIN (COSTS false) SELECT * FROM p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
NestLoop(p1 t1)
not used hint:
duplication hint:
error hint:

                                 QUERY PLAN                                  
-----------------------------------------------------------------------------
 Nested Loop
   Join Filter: (p1.id = t1.id)
   ->  Append
         ->  Seq Scan on p1
               Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
         ->  Seq Scan on p1_c1
               Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
         ->  Seq Scan on p1_c2
               Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
         ->  Seq Scan on p1_c3
               Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
         ->  Seq Scan on p1_c4
               Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
         ->  Seq Scan on p1_c1_c1
               Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
         ->  Seq Scan on p1_c1_c2
               Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
         ->  Seq Scan on p1_c3_c1
               Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
         ->  Seq Scan on p1_c3_c2
               Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Materialize
         ->  Index Scan using t1_pkey on t1
               Index Cond: (id < 10)
(24 rows)

/*+MergeJoin(p1 t1)*/
EXPLAIN (COSTS false) SELECT * FROM p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
MergeJoin(p1 t1)
not used hint:
duplication hint:
error hint:

                                    QUERY PLAN                                     
-----------------------------------------------------------------------------------
 Merge Join
   Merge Cond: (p1.id = t1.id)
   ->  Sort
         Sort Key: p1.id
         ->  Append
               ->  Seq Scan on p1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c2
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c3
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c4
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c1_c1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c1_c2
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c3_c1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c3_c2
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id < 10)
(25 rows)

/*+HashJoin(p1 t1)*/
EXPLAIN (COSTS false) SELECT * FROM p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
HashJoin(p1 t1)
not used hint:
duplication hint:
error hint:

                                 QUERY PLAN                                  
-----------------------------------------------------------------------------
 Hash Join
   Hash Cond: (p1.id = t1.id)
   ->  Append
         ->  Seq Scan on p1
               Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
         ->  Seq Scan on p1_c1
               Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
         ->  Seq Scan on p1_c2
               Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
         ->  Seq Scan on p1_c3
               Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
         ->  Seq Scan on p1_c4
               Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
         ->  Seq Scan on p1_c1_c1
               Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
         ->  Seq Scan on p1_c1_c2
               Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
         ->  Seq Scan on p1_c3_c1
               Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
         ->  Seq Scan on p1_c3_c2
               Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Hash
         ->  Index Scan using t1_pkey on t1
               Index Cond: (id < 10)
(24 rows)

SET constraint_exclusion TO on;
/*+SeqScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
SeqScan(p1)
not used hint:
duplication hint:
error hint:

                                    QUERY PLAN                                     
-----------------------------------------------------------------------------------
 Merge Join
   Merge Cond: (p1.id = t1.id)
   ->  Sort
         Sort Key: p1.id
         ->  Append
               ->  Seq Scan on p1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c1_c1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c1_c2
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id < 10)
(15 rows)

/*+IndexScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
IndexScan(p1)
not used hint:
duplication hint:
error hint:

                                    QUERY PLAN                                     
-----------------------------------------------------------------------------------
 Merge Join
   Merge Cond: (p1.id = t1.id)
   ->  Sort
         Sort Key: p1.id
         ->  Append
               ->  Seq Scan on p1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c1_c1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c1_c2
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id < 10)
(15 rows)

/*+BitmapScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
BitmapScan(p1)
not used hint:
duplication hint:
error hint:

                                    QUERY PLAN                                     
-----------------------------------------------------------------------------------
 Merge Join
   Merge Cond: (p1.id = t1.id)
   ->  Sort
         Sort Key: p1.id
         ->  Append
               ->  Seq Scan on p1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c1_c1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c1_c2
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id < 10)
(15 rows)

/*+TidScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
TidScan(p1)
not used hint:
duplication hint:
error hint:

                                    QUERY PLAN                                     
-----------------------------------------------------------------------------------
 Merge Join
   Merge Cond: (p1.id = t1.id)
   ->  Sort
         Sort Key: p1.id
         ->  Append
               ->  Seq Scan on p1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c1_c1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c1_c2
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id < 10)
(15 rows)

/*+NestLoop(p1 t1)*/
EXPLAIN (COSTS false) SELECT * FROM p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
NestLoop(p1 t1)
not used hint:
duplication hint:
error hint:

                                    QUERY PLAN                                     
-----------------------------------------------------------------------------------
 Nested Loop
   Join Filter: (p1.id = t1.id)
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id < 10)
   ->  Materialize
         ->  Append
               ->  Seq Scan on p1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c1_c1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c1_c2
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
(14 rows)

/*+MergeJoin(p1 t1)*/
EXPLAIN (COSTS false) SELECT * FROM p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
MergeJoin(p1 t1)
not used hint:
duplication hint:
error hint:

                                    QUERY PLAN                                     
-----------------------------------------------------------------------------------
 Merge Join
   Merge Cond: (p1.id = t1.id)
   ->  Sort
         Sort Key: p1.id
         ->  Append
               ->  Seq Scan on p1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c1_c1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c1_c2
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id < 10)
(15 rows)

/*+HashJoin(p1 t1)*/
EXPLAIN (COSTS false) SELECT * FROM p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
HashJoin(p1 t1)
not used hint:
duplication hint:
error hint:

                                    QUERY PLAN                                     
-----------------------------------------------------------------------------------
 Hash Join
   Hash Cond: (t1.id = p1.id)
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id < 10)
   ->  Hash
         ->  Append
               ->  Seq Scan on p1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c1_c1
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
               ->  Seq Scan on p1_c1_c2
                     Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
(14 rows)

SET constraint_exclusion TO off;
EXPLAIN (COSTS false) SELECT * FROM ONLY p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
                           QUERY PLAN                            
-----------------------------------------------------------------
 Seq Scan on p1
   Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
(2 rows)

SET constraint_exclusion TO on;
EXPLAIN (COSTS false) SELECT * FROM ONLY p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
                           QUERY PLAN                            
-----------------------------------------------------------------
 Seq Scan on p1
   Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
(2 rows)

SET constraint_exclusion TO off;
/*+SeqScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM ONLY p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
SeqScan(p1)
not used hint:
duplication hint:
error hint:

                           QUERY PLAN                            
-----------------------------------------------------------------
 Seq Scan on p1
   Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
(2 rows)

/*+IndexScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM ONLY p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
IndexScan(p1)
not used hint:
duplication hint:
error hint:

                QUERY PLAN                 
-------------------------------------------
 Index Scan using p1_pkey on p1
   Index Cond: ((id >= 50) AND (id <= 51))
   Filter: (ctid = '(1,1)'::tid)
(3 rows)

/*+BitmapScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM ONLY p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
BitmapScan(p1)
not used hint:
duplication hint:
error hint:

                   QUERY PLAN                    
-------------------------------------------------
 Bitmap Heap Scan on p1
   Recheck Cond: ((id >= 50) AND (id <= 51))
   Filter: (ctid = '(1,1)'::tid)
   ->  Bitmap Index Scan on p1_pkey
         Index Cond: ((id >= 50) AND (id <= 51))
(5 rows)

/*+TidScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM ONLY p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
TidScan(p1)
not used hint:
duplication hint:
error hint:

              QUERY PLAN               
---------------------------------------
 Tid Scan on p1
   TID Cond: (ctid = '(1,1)'::tid)
   Filter: ((id >= 50) AND (id <= 51))
(3 rows)

/*+NestLoop(p1 t1)*/
EXPLAIN (COSTS false) SELECT * FROM ONLY p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
NestLoop(p1 t1)
not used hint:
duplication hint:
error hint:

                              QUERY PLAN                               
-----------------------------------------------------------------------
 Nested Loop
   ->  Seq Scan on p1
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Index Scan using t1_pkey on t1
         Index Cond: ((id = p1.id) AND (id < 10))
(5 rows)

/*+MergeJoin(p1 t1)*/
EXPLAIN (COSTS false) SELECT * FROM ONLY p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
MergeJoin(p1 t1)
not used hint:
duplication hint:
error hint:

                                 QUERY PLAN                                  
-----------------------------------------------------------------------------
 Merge Join
   Merge Cond: (p1.id = t1.id)
   ->  Sort
         Sort Key: p1.id
         ->  Seq Scan on p1
               Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id < 10)
(8 rows)

/*+HashJoin(p1 t1)*/
EXPLAIN (COSTS false) SELECT * FROM ONLY p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
HashJoin(p1 t1)
not used hint:
duplication hint:
error hint:

                                 QUERY PLAN                                  
-----------------------------------------------------------------------------
 Hash Join
   Hash Cond: (t1.id = p1.id)
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id < 10)
   ->  Hash
         ->  Seq Scan on p1
               Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
(7 rows)

SET constraint_exclusion TO on;
/*+SeqScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM ONLY p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
SeqScan(p1)
not used hint:
duplication hint:
error hint:

                           QUERY PLAN                            
-----------------------------------------------------------------
 Seq Scan on p1
   Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
(2 rows)

/*+IndexScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM ONLY p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
IndexScan(p1)
not used hint:
duplication hint:
error hint:

                QUERY PLAN                 
-------------------------------------------
 Index Scan using p1_pkey on p1
   Index Cond: ((id >= 50) AND (id <= 51))
   Filter: (ctid = '(1,1)'::tid)
(3 rows)

/*+BitmapScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM ONLY p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
BitmapScan(p1)
not used hint:
duplication hint:
error hint:

                   QUERY PLAN                    
-------------------------------------------------
 Bitmap Heap Scan on p1
   Recheck Cond: ((id >= 50) AND (id <= 51))
   Filter: (ctid = '(1,1)'::tid)
   ->  Bitmap Index Scan on p1_pkey
         Index Cond: ((id >= 50) AND (id <= 51))
(5 rows)

/*+TidScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM ONLY p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
LOG:  pg_hint_plan:
used hint:
TidScan(p1)
not used hint:
duplication hint:
error hint:

              QUERY PLAN               
---------------------------------------
 Tid Scan on p1
   TID Cond: (ctid = '(1,1)'::tid)
   Filter: ((id >= 50) AND (id <= 51))
(3 rows)

/*+NestLoop(p1 t1)*/
EXPLAIN (COSTS false) SELECT * FROM ONLY p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
NestLoop(p1 t1)
not used hint:
duplication hint:
error hint:

                              QUERY PLAN                               
-----------------------------------------------------------------------
 Nested Loop
   ->  Seq Scan on p1
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Index Scan using t1_pkey on t1
         Index Cond: ((id = p1.id) AND (id < 10))
(5 rows)

/*+MergeJoin(p1 t1)*/
EXPLAIN (COSTS false) SELECT * FROM ONLY p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
MergeJoin(p1 t1)
not used hint:
duplication hint:
error hint:

                                 QUERY PLAN                                  
-----------------------------------------------------------------------------
 Merge Join
   Merge Cond: (p1.id = t1.id)
   ->  Sort
         Sort Key: p1.id
         ->  Seq Scan on p1
               Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id < 10)
(8 rows)

/*+HashJoin(p1 t1)*/
EXPLAIN (COSTS false) SELECT * FROM ONLY p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
HashJoin(p1 t1)
not used hint:
duplication hint:
error hint:

                                 QUERY PLAN                                  
-----------------------------------------------------------------------------
 Hash Join
   Hash Cond: (t1.id = p1.id)
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id < 10)
   ->  Hash
         ->  Seq Scan on p1
               Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
(7 rows)

SET constraint_exclusion TO off;
EXPLAIN (COSTS false) SELECT * FROM ONLY p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
                              QUERY PLAN                               
-----------------------------------------------------------------------
 Nested Loop
   ->  Seq Scan on p1
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Index Scan using t1_pkey on t1
         Index Cond: ((id = p1.id) AND (id < 10))
(5 rows)

SET constraint_exclusion TO on;
EXPLAIN (COSTS false) SELECT * FROM ONLY p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
                              QUERY PLAN                               
-----------------------------------------------------------------------
 Nested Loop
   ->  Seq Scan on p1
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Index Scan using t1_pkey on t1
         Index Cond: ((id = p1.id) AND (id < 10))
(5 rows)

SET constraint_exclusion TO off;
/*+SeqScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM ONLY p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
SeqScan(p1)
not used hint:
duplication hint:
error hint:

                              QUERY PLAN                               
-----------------------------------------------------------------------
 Nested Loop
   ->  Seq Scan on p1
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Index Scan using t1_pkey on t1
         Index Cond: ((id = p1.id) AND (id < 10))
(5 rows)

/*+IndexScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM ONLY p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
IndexScan(p1)
not used hint:
duplication hint:
error hint:

                    QUERY PLAN                    
--------------------------------------------------
 Nested Loop
   ->  Index Scan using p1_pkey on p1
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using t1_pkey on t1
         Index Cond: ((id = p1.id) AND (id < 10))
(6 rows)

/*+BitmapScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM ONLY p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
BitmapScan(p1)
not used hint:
duplication hint:
error hint:

                      QUERY PLAN                       
-------------------------------------------------------
 Nested Loop
   ->  Bitmap Heap Scan on p1
         Recheck Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
         ->  Bitmap Index Scan on p1_pkey
               Index Cond: ((id >= 50) AND (id <= 51))
   ->  Index Scan using t1_pkey on t1
         Index Cond: ((id = p1.id) AND (id < 10))
(8 rows)

/*+TidScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM ONLY p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
TidScan(p1)
not used hint:
duplication hint:
error hint:

                    QUERY PLAN                    
--------------------------------------------------
 Nested Loop
   ->  Tid Scan on p1
         TID Cond: (ctid = '(1,1)'::tid)
         Filter: ((id >= 50) AND (id <= 51))
   ->  Index Scan using t1_pkey on t1
         Index Cond: ((id = p1.id) AND (id < 10))
(6 rows)

SET constraint_exclusion TO on;
/*+SeqScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM ONLY p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
SeqScan(p1)
not used hint:
duplication hint:
error hint:

                              QUERY PLAN                               
-----------------------------------------------------------------------
 Nested Loop
   ->  Seq Scan on p1
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Index Scan using t1_pkey on t1
         Index Cond: ((id = p1.id) AND (id < 10))
(5 rows)

/*+IndexScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM ONLY p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
IndexScan(p1)
not used hint:
duplication hint:
error hint:

                    QUERY PLAN                    
--------------------------------------------------
 Nested Loop
   ->  Index Scan using p1_pkey on p1
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using t1_pkey on t1
         Index Cond: ((id = p1.id) AND (id < 10))
(6 rows)

/*+BitmapScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM ONLY p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
BitmapScan(p1)
not used hint:
duplication hint:
error hint:

                      QUERY PLAN                       
-------------------------------------------------------
 Nested Loop
   ->  Bitmap Heap Scan on p1
         Recheck Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
         ->  Bitmap Index Scan on p1_pkey
               Index Cond: ((id >= 50) AND (id <= 51))
   ->  Index Scan using t1_pkey on t1
         Index Cond: ((id = p1.id) AND (id < 10))
(8 rows)

/*+TidScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM ONLY p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
TidScan(p1)
not used hint:
duplication hint:
error hint:

                    QUERY PLAN                    
--------------------------------------------------
 Nested Loop
   ->  Tid Scan on p1
         TID Cond: (ctid = '(1,1)'::tid)
         Filter: ((id >= 50) AND (id <= 51))
   ->  Index Scan using t1_pkey on t1
         Index Cond: ((id = p1.id) AND (id < 10))
(6 rows)

-- quote test
/*+SeqScan("""t1 )	")IndexScan("t	2 """)HashJoin("""t1 )	"T3"t	2 """)Leading("""t1 )	"T3"t	2 """)Set(application_name"a	a	a""	a	A")*/
EXPLAIN (COSTS false) SELECT * FROM t1 """t1 )	", t2 "t	2 """, t3 "T3" WHERE """t1 )	".id = "t	2 """.id AND """t1 )	".id = "T3".id;
LOG:  pg_hint_plan:
used hint:
SeqScan("""t1 )	")
IndexScan("t	2 """)
HashJoin("""t1 )	" T3 "t	2 """)
Leading("""t1 )	" T3 "t	2 """)
Set(application_name "a	a	a""	a	A")
not used hint:
duplication hint:
error hint:

                       QUERY PLAN                        
---------------------------------------------------------
 Hash Join
   Hash Cond: ("t        2 """.id = """t1 )      ".id)
   ->  Index Scan using t2_pkey on t2 "t 2 """
   ->  Hash
         ->  Hash Join
               Hash Cond: ("""t1 )       ".id = "T3".id)
               ->  Seq Scan on t1 """t1 )        "
               ->  Hash
                     ->  Seq Scan on t3 "T3"
(9 rows)

-- duplicate hint test
/*+SeqScan(t1)SeqScan(t2)IndexScan(t1)IndexScan(t2)BitmapScan(t1)BitmapScan(t2)TidScan(t1)TidScan(t2)HashJoin(t1 t2)NestLoop(t2 t1)MergeJoin(t1 t2)Leading(t1 t2)Leading(t2 t1)Set(enable_seqscan off)Set(enable_mergejoin on)Set(enable_seqscan on)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
INFO:  pg_hint_plan: hint syntax error at or near "SeqScan(t1)SeqScan(t2)IndexScan(t1)IndexScan(t2)BitmapScan(t1)BitmapScan(t2)TidScan(t1)TidScan(t2)HashJoin(t1 t2)NestLoop(t2 t1)MergeJoin(t1 t2)Leading(t1 t2)Leading(t2 t1)Set(enable_seqscan off)Set(enable_mergejoin on)Set(enable_seqscan on)"
DETAIL:  Conflict scan method hint.
INFO:  pg_hint_plan: hint syntax error at or near "IndexScan(t1)IndexScan(t2)BitmapScan(t1)BitmapScan(t2)TidScan(t1)TidScan(t2)HashJoin(t1 t2)NestLoop(t2 t1)MergeJoin(t1 t2)Leading(t1 t2)Leading(t2 t1)Set(enable_seqscan off)Set(enable_mergejoin on)Set(enable_seqscan on)"
DETAIL:  Conflict scan method hint.
INFO:  pg_hint_plan: hint syntax error at or near "BitmapScan(t1)BitmapScan(t2)TidScan(t1)TidScan(t2)HashJoin(t1 t2)NestLoop(t2 t1)MergeJoin(t1 t2)Leading(t1 t2)Leading(t2 t1)Set(enable_seqscan off)Set(enable_mergejoin on)Set(enable_seqscan on)"
DETAIL:  Conflict scan method hint.
INFO:  pg_hint_plan: hint syntax error at or near "SeqScan(t2)IndexScan(t1)IndexScan(t2)BitmapScan(t1)BitmapScan(t2)TidScan(t1)TidScan(t2)HashJoin(t1 t2)NestLoop(t2 t1)MergeJoin(t1 t2)Leading(t1 t2)Leading(t2 t1)Set(enable_seqscan off)Set(enable_mergejoin on)Set(enable_seqscan on)"
DETAIL:  Conflict scan method hint.
INFO:  pg_hint_plan: hint syntax error at or near "IndexScan(t2)BitmapScan(t1)BitmapScan(t2)TidScan(t1)TidScan(t2)HashJoin(t1 t2)NestLoop(t2 t1)MergeJoin(t1 t2)Leading(t1 t2)Leading(t2 t1)Set(enable_seqscan off)Set(enable_mergejoin on)Set(enable_seqscan on)"
DETAIL:  Conflict scan method hint.
INFO:  pg_hint_plan: hint syntax error at or near "BitmapScan(t2)TidScan(t1)TidScan(t2)HashJoin(t1 t2)NestLoop(t2 t1)MergeJoin(t1 t2)Leading(t1 t2)Leading(t2 t1)Set(enable_seqscan off)Set(enable_mergejoin on)Set(enable_seqscan on)"
DETAIL:  Conflict scan method hint.
INFO:  pg_hint_plan: hint syntax error at or near "HashJoin(t1 t2)NestLoop(t2 t1)MergeJoin(t1 t2)Leading(t1 t2)Leading(t2 t1)Set(enable_seqscan off)Set(enable_mergejoin on)Set(enable_seqscan on)"
DETAIL:  Conflict join method hint.
INFO:  pg_hint_plan: hint syntax error at or near "NestLoop(t2 t1)MergeJoin(t1 t2)Leading(t1 t2)Leading(t2 t1)Set(enable_seqscan off)Set(enable_mergejoin on)Set(enable_seqscan on)"
DETAIL:  Conflict join method hint.
INFO:  pg_hint_plan: hint syntax error at or near "Set(enable_seqscan off)Set(enable_mergejoin on)Set(enable_seqscan on)"
DETAIL:  Conflict set hint.
INFO:  pg_hint_plan: hint syntax error at or near "Leading(t1 t2)Leading(t2 t1)Set(enable_seqscan off)Set(enable_mergejoin on)Set(enable_seqscan on)"
DETAIL:  Conflict leading hint.
LOG:  pg_hint_plan:
used hint:
TidScan(t1)
TidScan(t2)
MergeJoin(t1 t2)
Leading(t2 t1)
Set(enable_mergejoin on)
Set(enable_seqscan on)
not used hint:
duplication hint:
SeqScan(t1)
IndexScan(t1)
BitmapScan(t1)
SeqScan(t2)
IndexScan(t2)
BitmapScan(t2)
HashJoin(t1 t2)
NestLoop(t1 t2)
Leading(t1 t2)
Set(enable_seqscan off)
error hint:

                  QUERY PLAN                   
-----------------------------------------------
 Merge Join
   Merge Cond: (t1.id = t2.id)
   ->  Sort
         Sort Key: t1.id
         ->  Tid Scan on t1
               TID Cond: (ctid = '(1,1)'::tid)
   ->  Sort
         Sort Key: t2.id
         ->  Tid Scan on t2
               TID Cond: (ctid = '(1,1)'::tid)
(10 rows)

-- sub query Leading hint test
SET from_collapse_limit TO 100;
SET geqo_threshold TO 100;
EXPLAIN (COSTS false)
WITH c1_1(id) AS (
SELECT max(t1_5.id) FROM t1 t1_5, t2 t2_5, t3 t3_5 WHERE t1_5.id = t2_5.id AND t2_5.id = t3_5.id
)
SELECT t1_1.id, (
SELECT max(t1_2.id) FROM t1 t1_2, t2 t2_2, t3 t3_2 WHERE t1_2.id = t2_2.id AND t2_2.id = t3_2.id
) FROM t1 t1_1, t2 t2_1, t3 t3_1, (
SELECT t1_3.id FROM t1 t1_3, t2 t2_3, t3 t3_3 WHERE t1_3.id = t2_3.id AND t2_3.id = t3_3.id
) v1_1(id), c1_1 WHERE t1_1.id = t2_1.id AND t2_1.id = t3_1.id AND t2_1.id = v1_1.id AND v1_1.id = c1_1.id AND t1_1.id = (
SELECT max(t1_4.id) FROM t1 t1_4, t2 t2_4, t3 t3_4 WHERE t1_4.id = t2_4.id AND t2_4.id = t3_4.id 
);
                                  QUERY PLAN                                  
------------------------------------------------------------------------------
 Nested Loop
   CTE c1_1
     ->  Aggregate
           ->  Merge Join
                 Merge Cond: (t1_5.id = t3_5.id)
                 ->  Merge Join
                       Merge Cond: (t1_5.id = t2_5.id)
                       ->  Index Only Scan using t1_pkey on t1 t1_5
                       ->  Index Only Scan using t2_pkey on t2 t2_5
                 ->  Sort
                       Sort Key: t3_5.id
                       ->  Seq Scan on t3 t3_5
   InitPlan 2 (returns $1)
     ->  Aggregate
           ->  Merge Join
                 Merge Cond: (t1_2.id = t3_2.id)
                 ->  Merge Join
                       Merge Cond: (t1_2.id = t2_2.id)
                       ->  Index Only Scan using t1_pkey on t1 t1_2
                       ->  Index Only Scan using t2_pkey on t2 t2_2
                 ->  Sort
                       Sort Key: t3_2.id
                       ->  Seq Scan on t3 t3_2
   InitPlan 3 (returns $2)
     ->  Aggregate
           ->  Merge Join
                 Merge Cond: (t1_4.id = t3_4.id)
                 ->  Merge Join
                       Merge Cond: (t1_4.id = t2_4.id)
                       ->  Index Only Scan using t1_pkey on t1 t1_4
                       ->  Index Only Scan using t2_pkey on t2 t2_4
                 ->  Sort
                       Sort Key: t3_4.id
                       ->  Seq Scan on t3 t3_4
   ->  Nested Loop
         ->  Nested Loop
               ->  Nested Loop
                     ->  Nested Loop
                           ->  Nested Loop
                                 ->  Index Only Scan using t1_pkey on t1 t1_1
                                       Index Cond: (id = $2)
                                 ->  Index Only Scan using t2_pkey on t2 t2_1
                                       Index Cond: (id = $2)
                           ->  Seq Scan on t3 t3_1
                                 Filter: (id = $2)
                     ->  Index Only Scan using t1_pkey on t1 t1_3
                           Index Cond: (id = $2)
               ->  Index Only Scan using t2_pkey on t2 t2_3
                     Index Cond: (id = $2)
         ->  Seq Scan on t3 t3_3
               Filter: (id = $2)
   ->  CTE Scan on c1_1
         Filter: (id = $2)
(53 rows)

/*+HashJoin(t1_1 t3_1)MergeJoin(t1_3 t3_3)NestLoop(t1_2 t2_2)NestLoop(t1_4 t2_4)NestLoop(t1_5 t2_5)*/
EXPLAIN (COSTS false)
WITH c1_1(id) AS (
SELECT max(t1_5.id) FROM t1 t1_5, t2 t2_5, t3 t3_5 WHERE t1_5.id = t2_5.id AND t2_5.id = t3_5.id
)
SELECT t1_1.id, (
SELECT max(t1_2.id) FROM t1 t1_2, t2 t2_2, t3 t3_2 WHERE t1_2.id = t2_2.id AND t2_2.id = t3_2.id
) FROM t1 t1_1, t2 t2_1, t3 t3_1, (
SELECT t1_3.id FROM t1 t1_3, t2 t2_3, t3 t3_3 WHERE t1_3.id = t2_3.id AND t2_3.id = t3_3.id
) v1_1(id), c1_1 WHERE t1_1.id = t2_1.id AND t2_1.id = t3_1.id AND t2_1.id = v1_1.id AND v1_1.id = c1_1.id AND t1_1.id = (
SELECT max(t1_4.id) FROM t1 t1_4, t2 t2_4, t3 t3_4 WHERE t1_4.id = t2_4.id AND t2_4.id = t3_4.id 
);
LOG:  pg_hint_plan:
used hint:
HashJoin(t1_1 t3_1)
NestLoop(t1_2 t2_2)
MergeJoin(t1_3 t3_3)
NestLoop(t1_4 t2_4)
NestLoop(t1_5 t2_5)
not used hint:
duplication hint:
error hint:

                                  QUERY PLAN                                  
------------------------------------------------------------------------------
 Nested Loop
   CTE c1_1
     ->  Aggregate
           ->  Merge Join
                 Merge Cond: (t1_5.id = t3_5.id)
                 ->  Nested Loop
                       ->  Index Only Scan using t2_pkey on t2 t2_5
                       ->  Index Only Scan using t1_pkey on t1 t1_5
                             Index Cond: (id = t2_5.id)
                 ->  Sort
                       Sort Key: t3_5.id
                       ->  Seq Scan on t3 t3_5
   InitPlan 2 (returns $3)
     ->  Aggregate
           ->  Merge Join
                 Merge Cond: (t1_2.id = t3_2.id)
                 ->  Nested Loop
                       ->  Index Only Scan using t2_pkey on t2 t2_2
                       ->  Index Only Scan using t1_pkey on t1 t1_2
                             Index Cond: (id = t2_2.id)
                 ->  Sort
                       Sort Key: t3_2.id
                       ->  Seq Scan on t3 t3_2
   InitPlan 3 (returns $5)
     ->  Aggregate
           ->  Merge Join
                 Merge Cond: (t1_4.id = t3_4.id)
                 ->  Nested Loop
                       ->  Index Only Scan using t2_pkey on t2 t2_4
                       ->  Index Only Scan using t1_pkey on t1 t1_4
                             Index Cond: (id = t2_4.id)
                 ->  Sort
                       Sort Key: t3_4.id
                       ->  Seq Scan on t3 t3_4
   ->  Nested Loop
         ->  Nested Loop
               ->  Nested Loop
                     ->  Nested Loop
                           ->  Nested Loop
                                 ->  Index Only Scan using t1_pkey on t1 t1_1
                                       Index Cond: (id = $5)
                                 ->  Index Only Scan using t2_pkey on t2 t2_1
                                       Index Cond: (id = $5)
                           ->  Seq Scan on t3 t3_1
                                 Filter: (id = $5)
                     ->  Index Only Scan using t1_pkey on t1 t1_3
                           Index Cond: (id = $5)
               ->  Index Only Scan using t2_pkey on t2 t2_3
                     Index Cond: (id = $5)
         ->  Seq Scan on t3 t3_3
               Filter: (id = $5)
   ->  CTE Scan on c1_1
         Filter: (id = $5)
(53 rows)

/*+HashJoin(t1_1 t3_1)MergeJoin(t1_3 t3_3)NestLoop(t1_2 t2_2)NestLoop(t1_4 t2_4)NestLoop(t1_5 t2_5)Leading(a t1_1 t1_2 t1_4 t1_5)*/
EXPLAIN (COSTS false)
WITH c1_1(id) AS (
SELECT max(t1_5.id) FROM t1 t1_5, t2 t2_5, t3 t3_5 WHERE t1_5.id = t2_5.id AND t2_5.id = t3_5.id
)
SELECT t1_1.id, (
SELECT max(t1_2.id) FROM t1 t1_2, t2 t2_2, t3 t3_2 WHERE t1_2.id = t2_2.id AND t2_2.id = t3_2.id
) FROM t1 t1_1, t2 t2_1, t3 t3_1, (
SELECT t1_3.id FROM t1 t1_3, t2 t2_3, t3 t3_3 WHERE t1_3.id = t2_3.id AND t2_3.id = t3_3.id
) v1_1(id), c1_1 WHERE t1_1.id = t2_1.id AND t2_1.id = t3_1.id AND t2_1.id = v1_1.id AND v1_1.id = c1_1.id AND t1_1.id = (
SELECT max(t1_4.id) FROM t1 t1_4, t2 t2_4, t3 t3_4 WHERE t1_4.id = t2_4.id AND t2_4.id = t3_4.id 
);
LOG:  pg_hint_plan:
used hint:
HashJoin(t1_1 t3_1)
NestLoop(t1_2 t2_2)
MergeJoin(t1_3 t3_3)
NestLoop(t1_4 t2_4)
NestLoop(t1_5 t2_5)
not used hint:
Leading(a t1_1 t1_2 t1_4 t1_5)
duplication hint:
error hint:

                                  QUERY PLAN                                  
------------------------------------------------------------------------------
 Nested Loop
   CTE c1_1
     ->  Aggregate
           ->  Merge Join
                 Merge Cond: (t1_5.id = t3_5.id)
                 ->  Nested Loop
                       ->  Index Only Scan using t2_pkey on t2 t2_5
                       ->  Index Only Scan using t1_pkey on t1 t1_5
                             Index Cond: (id = t2_5.id)
                 ->  Sort
                       Sort Key: t3_5.id
                       ->  Seq Scan on t3 t3_5
   InitPlan 2 (returns $3)
     ->  Aggregate
           ->  Merge Join
                 Merge Cond: (t1_2.id = t3_2.id)
                 ->  Nested Loop
                       ->  Index Only Scan using t2_pkey on t2 t2_2
                       ->  Index Only Scan using t1_pkey on t1 t1_2
                             Index Cond: (id = t2_2.id)
                 ->  Sort
                       Sort Key: t3_2.id
                       ->  Seq Scan on t3 t3_2
   InitPlan 3 (returns $5)
     ->  Aggregate
           ->  Merge Join
                 Merge Cond: (t1_4.id = t3_4.id)
                 ->  Nested Loop
                       ->  Index Only Scan using t2_pkey on t2 t2_4
                       ->  Index Only Scan using t1_pkey on t1 t1_4
                             Index Cond: (id = t2_4.id)
                 ->  Sort
                       Sort Key: t3_4.id
                       ->  Seq Scan on t3 t3_4
   ->  Nested Loop
         ->  Nested Loop
               ->  Nested Loop
                     ->  Nested Loop
                           ->  Nested Loop
                                 ->  Index Only Scan using t1_pkey on t1 t1_1
                                       Index Cond: (id = $5)
                                 ->  Index Only Scan using t2_pkey on t2 t2_1
                                       Index Cond: (id = $5)
                           ->  Seq Scan on t3 t3_1
                                 Filter: (id = $5)
                     ->  Index Only Scan using t1_pkey on t1 t1_3
                           Index Cond: (id = $5)
               ->  Index Only Scan using t2_pkey on t2 t2_3
                     Index Cond: (id = $5)
         ->  Seq Scan on t3 t3_3
               Filter: (id = $5)
   ->  CTE Scan on c1_1
         Filter: (id = $5)
(53 rows)

/*+HashJoin(t1_1 t3_1)MergeJoin(t1_3 t3_3)NestLoop(t1_2 t2_2)NestLoop(t1_4 t2_4)NestLoop(t1_5 t2_5)Leading(a t3_2 t3_5 t2_2 c1_1 t3_4 t3_3 t2_3 t2_4 t1_3 t2_5 t1_2 t3_1 t1_4 t2_1 t1_5 t1_1)*/
EXPLAIN (COSTS false)
WITH c1_1(id) AS (
SELECT max(t1_5.id) FROM t1 t1_5, t2 t2_5, t3 t3_5 WHERE t1_5.id = t2_5.id AND t2_5.id = t3_5.id
)
SELECT t1_1.id, (
SELECT max(t1_2.id) FROM t1 t1_2, t2 t2_2, t3 t3_2 WHERE t1_2.id = t2_2.id AND t2_2.id = t3_2.id
) FROM t1 t1_1, t2 t2_1, t3 t3_1, (
SELECT t1_3.id FROM t1 t1_3, t2 t2_3, t3 t3_3 WHERE t1_3.id = t2_3.id AND t2_3.id = t3_3.id
) v1_1(id), c1_1 WHERE t1_1.id = t2_1.id AND t2_1.id = t3_1.id AND t2_1.id = v1_1.id AND v1_1.id = c1_1.id AND t1_1.id = (
SELECT max(t1_4.id) FROM t1 t1_4, t2 t2_4, t3 t3_4 WHERE t1_4.id = t2_4.id AND t2_4.id = t3_4.id 
);
LOG:  pg_hint_plan:
used hint:
HashJoin(t1_1 t3_1)
NestLoop(t1_2 t2_2)
MergeJoin(t1_3 t3_3)
NestLoop(t1_4 t2_4)
NestLoop(t1_5 t2_5)
not used hint:
Leading(a t3_2 t3_5 t2_2 c1_1 t3_4 t3_3 t2_3 t2_4 t1_3 t2_5 t1_2 t3_1 t1_4 t2_1 t1_5 t1_1)
duplication hint:
error hint:

                                  QUERY PLAN                                  
------------------------------------------------------------------------------
 Nested Loop
   CTE c1_1
     ->  Aggregate
           ->  Merge Join
                 Merge Cond: (t1_5.id = t3_5.id)
                 ->  Nested Loop
                       ->  Index Only Scan using t2_pkey on t2 t2_5
                       ->  Index Only Scan using t1_pkey on t1 t1_5
                             Index Cond: (id = t2_5.id)
                 ->  Sort
                       Sort Key: t3_5.id
                       ->  Seq Scan on t3 t3_5
   InitPlan 2 (returns $3)
     ->  Aggregate
           ->  Merge Join
                 Merge Cond: (t1_2.id = t3_2.id)
                 ->  Nested Loop
                       ->  Index Only Scan using t2_pkey on t2 t2_2
                       ->  Index Only Scan using t1_pkey on t1 t1_2
                             Index Cond: (id = t2_2.id)
                 ->  Sort
                       Sort Key: t3_2.id
                       ->  Seq Scan on t3 t3_2
   InitPlan 3 (returns $5)
     ->  Aggregate
           ->  Merge Join
                 Merge Cond: (t1_4.id = t3_4.id)
                 ->  Nested Loop
                       ->  Index Only Scan using t2_pkey on t2 t2_4
                       ->  Index Only Scan using t1_pkey on t1 t1_4
                             Index Cond: (id = t2_4.id)
                 ->  Sort
                       Sort Key: t3_4.id
                       ->  Seq Scan on t3 t3_4
   ->  Nested Loop
         ->  Nested Loop
               ->  Nested Loop
                     ->  Nested Loop
                           ->  Nested Loop
                                 ->  Index Only Scan using t1_pkey on t1 t1_1
                                       Index Cond: (id = $5)
                                 ->  Index Only Scan using t2_pkey on t2 t2_1
                                       Index Cond: (id = $5)
                           ->  Seq Scan on t3 t3_1
                                 Filter: (id = $5)
                     ->  Index Only Scan using t1_pkey on t1 t1_3
                           Index Cond: (id = $5)
               ->  Index Only Scan using t2_pkey on t2 t2_3
                     Index Cond: (id = $5)
         ->  Seq Scan on t3 t3_3
               Filter: (id = $5)
   ->  CTE Scan on c1_1
         Filter: (id = $5)
(53 rows)

/*+HashJoin(t1_1 t3_1)MergeJoin(t1_3 t3_3)NestLoop(t1_2 t2_2)NestLoop(t1_4 t2_4)NestLoop(t1_5 t2_5)Leading(t3_5 t2_5 t1_5)Leading(t3_2 t2_2 t1_2)Leading(t3_4 t2_4 t1_4)Leading(c1_1 t3_3 t2_3 t1_3 t3_1 t2_1 t1_1)*/
EXPLAIN (COSTS false)
WITH c1_1(id) AS (
SELECT max(t1_5.id) FROM t1 t1_5, t2 t2_5, t3 t3_5 WHERE t1_5.id = t2_5.id AND t2_5.id = t3_5.id
)
SELECT t1_1.id, (
SELECT max(t1_2.id) FROM t1 t1_2, t2 t2_2, t3 t3_2 WHERE t1_2.id = t2_2.id AND t2_2.id = t3_2.id
) FROM t1 t1_1, t2 t2_1, t3 t3_1, (
SELECT t1_3.id FROM t1 t1_3, t2 t2_3, t3 t3_3 WHERE t1_3.id = t2_3.id AND t2_3.id = t3_3.id
) v1_1(id), c1_1 WHERE t1_1.id = t2_1.id AND t2_1.id = t3_1.id AND t2_1.id = v1_1.id AND v1_1.id = c1_1.id AND t1_1.id = (
SELECT max(t1_4.id) FROM t1 t1_4, t2 t2_4, t3 t3_4 WHERE t1_4.id = t2_4.id AND t2_4.id = t3_4.id 
);
LOG:  pg_hint_plan:
used hint:
Leading(t3_5 t2_5 t1_5)
Leading(t3_2 t2_2 t1_2)
Leading(t3_4 t2_4 t1_4)
Leading(c1_1 t3_3 t2_3 t1_3 t3_1 t2_1 t1_1)
not used hint:
HashJoin(t1_1 t3_1)
NestLoop(t1_2 t2_2)
MergeJoin(t1_3 t3_3)
NestLoop(t1_4 t2_4)
NestLoop(t1_5 t2_5)
duplication hint:
error hint:

                               QUERY PLAN                               
------------------------------------------------------------------------
 Nested Loop
   CTE c1_1
     ->  Aggregate
           ->  Merge Join
                 Merge Cond: (t2_5.id = t1_5.id)
                 ->  Merge Join
                       Merge Cond: (t2_5.id = t3_5.id)
                       ->  Index Only Scan using t2_pkey on t2 t2_5
                       ->  Sort
                             Sort Key: t3_5.id
                             ->  Seq Scan on t3 t3_5
                 ->  Index Only Scan using t1_pkey on t1 t1_5
   InitPlan 2 (returns $1)
     ->  Aggregate
           ->  Merge Join
                 Merge Cond: (t2_2.id = t1_2.id)
                 ->  Merge Join
                       Merge Cond: (t2_2.id = t3_2.id)
                       ->  Index Only Scan using t2_pkey on t2 t2_2
                       ->  Sort
                             Sort Key: t3_2.id
                             ->  Seq Scan on t3 t3_2
                 ->  Index Only Scan using t1_pkey on t1 t1_2
   InitPlan 3 (returns $2)
     ->  Aggregate
           ->  Merge Join
                 Merge Cond: (t2_4.id = t1_4.id)
                 ->  Merge Join
                       Merge Cond: (t2_4.id = t3_4.id)
                       ->  Index Only Scan using t2_pkey on t2 t2_4
                       ->  Sort
                             Sort Key: t3_4.id
                             ->  Seq Scan on t3 t3_4
                 ->  Index Only Scan using t1_pkey on t1 t1_4
   ->  Nested Loop
         ->  Nested Loop
               ->  Nested Loop
                     ->  Nested Loop
                           ->  Nested Loop
                                 ->  Seq Scan on t3 t3_3
                                       Filter: (id = $2)
                                 ->  CTE Scan on c1_1
                                       Filter: (id = $2)
                           ->  Index Only Scan using t2_pkey on t2 t2_3
                                 Index Cond: (id = $2)
                     ->  Index Only Scan using t1_pkey on t1 t1_3
                           Index Cond: (id = $2)
               ->  Seq Scan on t3 t3_1
                     Filter: (id = $2)
         ->  Index Only Scan using t2_pkey on t2 t2_1
               Index Cond: (id = $2)
   ->  Index Only Scan using t1_pkey on t1 t1_1
         Index Cond: (id = $2)
(53 rows)

SET from_collapse_limit TO 1;
EXPLAIN (COSTS false)
WITH c1_1(id) AS (
SELECT max(t1_5.id) FROM t1 t1_5, t2 t2_5, t3 t3_5 WHERE t1_5.id = t2_5.id AND t2_5.id = t3_5.id
)
SELECT t1_1.id, (
SELECT max(t1_2.id) FROM t1 t1_2, t2 t2_2, t3 t3_2 WHERE t1_2.id = t2_2.id AND t2_2.id = t3_2.id
) FROM t1 t1_1, t2 t2_1, t3 t3_1, (
SELECT t1_3.id FROM t1 t1_3, t2 t2_3, t3 t3_3 WHERE t1_3.id = t2_3.id AND t2_3.id = t3_3.id
) v1_1(id), c1_1 WHERE t1_1.id = t2_1.id AND t2_1.id = t3_1.id AND t2_1.id = v1_1.id AND v1_1.id = c1_1.id AND t1_1.id = (
SELECT max(t1_4.id) FROM t1 t1_4, t2 t2_4, t3 t3_4 WHERE t1_4.id = t2_4.id AND t2_4.id = t3_4.id 
);
                             QUERY PLAN                             
--------------------------------------------------------------------
 Nested Loop
   CTE c1_1
     ->  Aggregate
           ->  Merge Join
                 Merge Cond: (t1_5.id = t3_5.id)
                 ->  Merge Join
                       Merge Cond: (t1_5.id = t2_5.id)
                       ->  Index Only Scan using t1_pkey on t1 t1_5
                       ->  Index Only Scan using t2_pkey on t2 t2_5
                 ->  Sort
                       Sort Key: t3_5.id
                       ->  Seq Scan on t3 t3_5
   InitPlan 2 (returns $1)
     ->  Aggregate
           ->  Merge Join
                 Merge Cond: (t1_2.id = t3_2.id)
                 ->  Merge Join
                       Merge Cond: (t1_2.id = t2_2.id)
                       ->  Index Only Scan using t1_pkey on t1 t1_2
                       ->  Index Only Scan using t2_pkey on t2 t2_2
                 ->  Sort
                       Sort Key: t3_2.id
                       ->  Seq Scan on t3 t3_2
   InitPlan 3 (returns $2)
     ->  Aggregate
           ->  Merge Join
                 Merge Cond: (t1_4.id = t3_4.id)
                 ->  Merge Join
                       Merge Cond: (t1_4.id = t2_4.id)
                       ->  Index Only Scan using t1_pkey on t1 t1_4
                       ->  Index Only Scan using t2_pkey on t2 t2_4
                 ->  Sort
                       Sort Key: t3_4.id
                       ->  Seq Scan on t3 t3_4
   ->  Nested Loop
         ->  Nested Loop
               ->  Nested Loop
                     ->  Index Only Scan using t1_pkey on t1 t1_1
                           Index Cond: (id = $2)
                     ->  Index Only Scan using t2_pkey on t2 t2_1
                           Index Cond: (id = $2)
               ->  Seq Scan on t3 t3_1
                     Filter: (id = $2)
         ->  Nested Loop
               ->  Nested Loop
                     ->  Index Only Scan using t1_pkey on t1 t1_3
                           Index Cond: (id = $2)
                     ->  Index Only Scan using t2_pkey on t2 t2_3
                           Index Cond: (id = $2)
               ->  Seq Scan on t3 t3_3
                     Filter: (id = $2)
   ->  CTE Scan on c1_1
         Filter: (id = $2)
(53 rows)

/*+HashJoin(t1_1 t3_1)MergeJoin(t1_3 t3_3)NestLoop(t1_2 t2_2)NestLoop(t1_4 t2_4)NestLoop(t1_5 t2_5)*/
EXPLAIN (COSTS false)
WITH c1_1(id) AS (
SELECT max(t1_5.id) FROM t1 t1_5, t2 t2_5, t3 t3_5 WHERE t1_5.id = t2_5.id AND t2_5.id = t3_5.id
)
SELECT t1_1.id, (
SELECT max(t1_2.id) FROM t1 t1_2, t2 t2_2, t3 t3_2 WHERE t1_2.id = t2_2.id AND t2_2.id = t3_2.id
) FROM t1 t1_1, t2 t2_1, t3 t3_1, (
SELECT t1_3.id FROM t1 t1_3, t2 t2_3, t3 t3_3 WHERE t1_3.id = t2_3.id AND t2_3.id = t3_3.id
) v1_1(id), c1_1 WHERE t1_1.id = t2_1.id AND t2_1.id = t3_1.id AND t2_1.id = v1_1.id AND v1_1.id = c1_1.id AND t1_1.id = (
SELECT max(t1_4.id) FROM t1 t1_4, t2 t2_4, t3 t3_4 WHERE t1_4.id = t2_4.id AND t2_4.id = t3_4.id 
);
LOG:  pg_hint_plan:
used hint:
HashJoin(t1_1 t3_1)
NestLoop(t1_2 t2_2)
MergeJoin(t1_3 t3_3)
NestLoop(t1_4 t2_4)
NestLoop(t1_5 t2_5)
not used hint:
duplication hint:
error hint:

                             QUERY PLAN                             
--------------------------------------------------------------------
 Nested Loop
   CTE c1_1
     ->  Aggregate
           ->  Merge Join
                 Merge Cond: (t1_5.id = t3_5.id)
                 ->  Nested Loop
                       ->  Index Only Scan using t2_pkey on t2 t2_5
                       ->  Index Only Scan using t1_pkey on t1 t1_5
                             Index Cond: (id = t2_5.id)
                 ->  Sort
                       Sort Key: t3_5.id
                       ->  Seq Scan on t3 t3_5
   InitPlan 2 (returns $3)
     ->  Aggregate
           ->  Merge Join
                 Merge Cond: (t1_2.id = t3_2.id)
                 ->  Nested Loop
                       ->  Index Only Scan using t2_pkey on t2 t2_2
                       ->  Index Only Scan using t1_pkey on t1 t1_2
                             Index Cond: (id = t2_2.id)
                 ->  Sort
                       Sort Key: t3_2.id
                       ->  Seq Scan on t3 t3_2
   InitPlan 3 (returns $5)
     ->  Aggregate
           ->  Merge Join
                 Merge Cond: (t1_4.id = t3_4.id)
                 ->  Nested Loop
                       ->  Index Only Scan using t2_pkey on t2 t2_4
                       ->  Index Only Scan using t1_pkey on t1 t1_4
                             Index Cond: (id = t2_4.id)
                 ->  Sort
                       Sort Key: t3_4.id
                       ->  Seq Scan on t3 t3_4
   ->  Nested Loop
         ->  Nested Loop
               ->  Nested Loop
                     ->  Index Only Scan using t1_pkey on t1 t1_1
                           Index Cond: (id = $5)
                     ->  Index Only Scan using t2_pkey on t2 t2_1
                           Index Cond: (id = $5)
               ->  Seq Scan on t3 t3_1
                     Filter: (id = $5)
         ->  Nested Loop
               ->  Nested Loop
                     ->  Index Only Scan using t1_pkey on t1 t1_3
                           Index Cond: (id = $5)
                     ->  Index Only Scan using t2_pkey on t2 t2_3
                           Index Cond: (id = $5)
               ->  Seq Scan on t3 t3_3
                     Filter: (id = $5)
   ->  CTE Scan on c1_1
         Filter: (id = $5)
(53 rows)

/*+HashJoin(t1_1 t3_1)MergeJoin(t1_3 t3_3)NestLoop(t1_2 t2_2)NestLoop(t1_4 t2_4)NestLoop(t1_5 t2_5)Leading(a t1_1 t1_2 t1_4 t1_5)*/
EXPLAIN (COSTS false)
WITH c1_1(id) AS (
SELECT max(t1_5.id) FROM t1 t1_5, t2 t2_5, t3 t3_5 WHERE t1_5.id = t2_5.id AND t2_5.id = t3_5.id
)
SELECT t1_1.id, (
SELECT max(t1_2.id) FROM t1 t1_2, t2 t2_2, t3 t3_2 WHERE t1_2.id = t2_2.id AND t2_2.id = t3_2.id
) FROM t1 t1_1, t2 t2_1, t3 t3_1, (
SELECT t1_3.id FROM t1 t1_3, t2 t2_3, t3 t3_3 WHERE t1_3.id = t2_3.id AND t2_3.id = t3_3.id
) v1_1(id), c1_1 WHERE t1_1.id = t2_1.id AND t2_1.id = t3_1.id AND t2_1.id = v1_1.id AND v1_1.id = c1_1.id AND t1_1.id = (
SELECT max(t1_4.id) FROM t1 t1_4, t2 t2_4, t3 t3_4 WHERE t1_4.id = t2_4.id AND t2_4.id = t3_4.id 
);
LOG:  pg_hint_plan:
used hint:
HashJoin(t1_1 t3_1)
NestLoop(t1_2 t2_2)
MergeJoin(t1_3 t3_3)
NestLoop(t1_4 t2_4)
NestLoop(t1_5 t2_5)
not used hint:
Leading(a t1_1 t1_2 t1_4 t1_5)
duplication hint:
error hint:

                             QUERY PLAN                             
--------------------------------------------------------------------
 Nested Loop
   CTE c1_1
     ->  Aggregate
           ->  Merge Join
                 Merge Cond: (t1_5.id = t3_5.id)
                 ->  Nested Loop
                       ->  Index Only Scan using t2_pkey on t2 t2_5
                       ->  Index Only Scan using t1_pkey on t1 t1_5
                             Index Cond: (id = t2_5.id)
                 ->  Sort
                       Sort Key: t3_5.id
                       ->  Seq Scan on t3 t3_5
   InitPlan 2 (returns $3)
     ->  Aggregate
           ->  Merge Join
                 Merge Cond: (t1_2.id = t3_2.id)
                 ->  Nested Loop
                       ->  Index Only Scan using t2_pkey on t2 t2_2
                       ->  Index Only Scan using t1_pkey on t1 t1_2
                             Index Cond: (id = t2_2.id)
                 ->  Sort
                       Sort Key: t3_2.id
                       ->  Seq Scan on t3 t3_2
   InitPlan 3 (returns $5)
     ->  Aggregate
           ->  Merge Join
                 Merge Cond: (t1_4.id = t3_4.id)
                 ->  Nested Loop
                       ->  Index Only Scan using t2_pkey on t2 t2_4
                       ->  Index Only Scan using t1_pkey on t1 t1_4
                             Index Cond: (id = t2_4.id)
                 ->  Sort
                       Sort Key: t3_4.id
                       ->  Seq Scan on t3 t3_4
   ->  Nested Loop
         ->  Nested Loop
               ->  Nested Loop
                     ->  Index Only Scan using t1_pkey on t1 t1_1
                           Index Cond: (id = $5)
                     ->  Index Only Scan using t2_pkey on t2 t2_1
                           Index Cond: (id = $5)
               ->  Seq Scan on t3 t3_1
                     Filter: (id = $5)
         ->  Nested Loop
               ->  Nested Loop
                     ->  Index Only Scan using t1_pkey on t1 t1_3
                           Index Cond: (id = $5)
                     ->  Index Only Scan using t2_pkey on t2 t2_3
                           Index Cond: (id = $5)
               ->  Seq Scan on t3 t3_3
                     Filter: (id = $5)
   ->  CTE Scan on c1_1
         Filter: (id = $5)
(53 rows)

/*+HashJoin(t1_1 t3_1)MergeJoin(t1_3 t3_3)NestLoop(t1_2 t2_2)NestLoop(t1_4 t2_4)NestLoop(t1_5 t2_5)Leading(a t3_2 t3_5 t2_2 c1_1 t3_4 t3_3 t2_3 t2_4 t1_3 t2_5 t1_2 t3_1 t1_4 t2_1 t1_5 t1_1)*/
EXPLAIN (COSTS false)
WITH c1_1(id) AS (
SELECT max(t1_5.id) FROM t1 t1_5, t2 t2_5, t3 t3_5 WHERE t1_5.id = t2_5.id AND t2_5.id = t3_5.id
)
SELECT t1_1.id, (
SELECT max(t1_2.id) FROM t1 t1_2, t2 t2_2, t3 t3_2 WHERE t1_2.id = t2_2.id AND t2_2.id = t3_2.id
) FROM t1 t1_1, t2 t2_1, t3 t3_1, (
SELECT t1_3.id FROM t1 t1_3, t2 t2_3, t3 t3_3 WHERE t1_3.id = t2_3.id AND t2_3.id = t3_3.id
) v1_1(id), c1_1 WHERE t1_1.id = t2_1.id AND t2_1.id = t3_1.id AND t2_1.id = v1_1.id AND v1_1.id = c1_1.id AND t1_1.id = (
SELECT max(t1_4.id) FROM t1 t1_4, t2 t2_4, t3 t3_4 WHERE t1_4.id = t2_4.id AND t2_4.id = t3_4.id 
);
LOG:  pg_hint_plan:
used hint:
HashJoin(t1_1 t3_1)
NestLoop(t1_2 t2_2)
MergeJoin(t1_3 t3_3)
NestLoop(t1_4 t2_4)
NestLoop(t1_5 t2_5)
not used hint:
Leading(a t3_2 t3_5 t2_2 c1_1 t3_4 t3_3 t2_3 t2_4 t1_3 t2_5 t1_2 t3_1 t1_4 t2_1 t1_5 t1_1)
duplication hint:
error hint:

                             QUERY PLAN                             
--------------------------------------------------------------------
 Nested Loop
   CTE c1_1
     ->  Aggregate
           ->  Merge Join
                 Merge Cond: (t1_5.id = t3_5.id)
                 ->  Nested Loop
                       ->  Index Only Scan using t2_pkey on t2 t2_5
                       ->  Index Only Scan using t1_pkey on t1 t1_5
                             Index Cond: (id = t2_5.id)
                 ->  Sort
                       Sort Key: t3_5.id
                       ->  Seq Scan on t3 t3_5
   InitPlan 2 (returns $3)
     ->  Aggregate
           ->  Merge Join
                 Merge Cond: (t1_2.id = t3_2.id)
                 ->  Nested Loop
                       ->  Index Only Scan using t2_pkey on t2 t2_2
                       ->  Index Only Scan using t1_pkey on t1 t1_2
                             Index Cond: (id = t2_2.id)
                 ->  Sort
                       Sort Key: t3_2.id
                       ->  Seq Scan on t3 t3_2
   InitPlan 3 (returns $5)
     ->  Aggregate
           ->  Merge Join
                 Merge Cond: (t1_4.id = t3_4.id)
                 ->  Nested Loop
                       ->  Index Only Scan using t2_pkey on t2 t2_4
                       ->  Index Only Scan using t1_pkey on t1 t1_4
                             Index Cond: (id = t2_4.id)
                 ->  Sort
                       Sort Key: t3_4.id
                       ->  Seq Scan on t3 t3_4
   ->  Nested Loop
         ->  Nested Loop
               ->  Nested Loop
                     ->  Index Only Scan using t1_pkey on t1 t1_1
                           Index Cond: (id = $5)
                     ->  Index Only Scan using t2_pkey on t2 t2_1
                           Index Cond: (id = $5)
               ->  Seq Scan on t3 t3_1
                     Filter: (id = $5)
         ->  Nested Loop
               ->  Nested Loop
                     ->  Index Only Scan using t1_pkey on t1 t1_3
                           Index Cond: (id = $5)
                     ->  Index Only Scan using t2_pkey on t2 t2_3
                           Index Cond: (id = $5)
               ->  Seq Scan on t3 t3_3
                     Filter: (id = $5)
   ->  CTE Scan on c1_1
         Filter: (id = $5)
(53 rows)

/*+HashJoin(t1_1 t3_1)MergeJoin(t1_3 t3_3)NestLoop(t1_2 t2_2)NestLoop(t1_4 t2_4)NestLoop(t1_5 t2_5)Leading(t3_5 t2_5 t1_5)Leading(t3_2 t2_2 t1_2)Leading(t3_4 t2_4 t1_4)Leading(c1_1 t3_3 t2_3 t1_3 t3_1 t2_1 t1_1)*/
EXPLAIN (COSTS false)
WITH c1_1(id) AS (
SELECT max(t1_5.id) FROM t1 t1_5, t2 t2_5, t3 t3_5 WHERE t1_5.id = t2_5.id AND t2_5.id = t3_5.id
)
SELECT t1_1.id, (
SELECT max(t1_2.id) FROM t1 t1_2, t2 t2_2, t3 t3_2 WHERE t1_2.id = t2_2.id AND t2_2.id = t3_2.id
) FROM t1 t1_1, t2 t2_1, t3 t3_1, (
SELECT t1_3.id FROM t1 t1_3, t2 t2_3, t3 t3_3 WHERE t1_3.id = t2_3.id AND t2_3.id = t3_3.id
) v1_1(id), c1_1 WHERE t1_1.id = t2_1.id AND t2_1.id = t3_1.id AND t2_1.id = v1_1.id AND v1_1.id = c1_1.id AND t1_1.id = (
SELECT max(t1_4.id) FROM t1 t1_4, t2 t2_4, t3 t3_4 WHERE t1_4.id = t2_4.id AND t2_4.id = t3_4.id 
);
LOG:  pg_hint_plan:
used hint:
MergeJoin(t1_3 t3_3)
Leading(t3_5 t2_5 t1_5)
Leading(t3_2 t2_2 t1_2)
Leading(t3_4 t2_4 t1_4)
Leading(c1_1 t3_3 t2_3 t1_3 t3_1 t2_1 t1_1)
not used hint:
HashJoin(t1_1 t3_1)
NestLoop(t1_2 t2_2)
NestLoop(t1_4 t2_4)
NestLoop(t1_5 t2_5)
duplication hint:
error hint:

                                  QUERY PLAN                                  
------------------------------------------------------------------------------
 Nested Loop
   CTE c1_1
     ->  Aggregate
           ->  Merge Join
                 Merge Cond: (t2_5.id = t1_5.id)
                 ->  Merge Join
                       Merge Cond: (t2_5.id = t3_5.id)
                       ->  Index Only Scan using t2_pkey on t2 t2_5
                       ->  Sort
                             Sort Key: t3_5.id
                             ->  Seq Scan on t3 t3_5
                 ->  Index Only Scan using t1_pkey on t1 t1_5
   InitPlan 2 (returns $1)
     ->  Aggregate
           ->  Merge Join
                 Merge Cond: (t2_2.id = t1_2.id)
                 ->  Merge Join
                       Merge Cond: (t2_2.id = t3_2.id)
                       ->  Index Only Scan using t2_pkey on t2 t2_2
                       ->  Sort
                             Sort Key: t3_2.id
                             ->  Seq Scan on t3 t3_2
                 ->  Index Only Scan using t1_pkey on t1 t1_2
   InitPlan 3 (returns $2)
     ->  Aggregate
           ->  Merge Join
                 Merge Cond: (t2_4.id = t1_4.id)
                 ->  Merge Join
                       Merge Cond: (t2_4.id = t3_4.id)
                       ->  Index Only Scan using t2_pkey on t2 t2_4
                       ->  Sort
                             Sort Key: t3_4.id
                             ->  Seq Scan on t3 t3_4
                 ->  Index Only Scan using t1_pkey on t1 t1_4
   ->  Nested Loop
         ->  Nested Loop
               ->  Nested Loop
                     ->  Nested Loop
                           ->  Nested Loop
                                 ->  Index Only Scan using t1_pkey on t1 t1_3
                                       Index Cond: (id = $2)
                                 ->  Index Only Scan using t2_pkey on t2 t2_3
                                       Index Cond: (id = $2)
                           ->  Seq Scan on t3 t3_3
                                 Filter: (id = $2)
                     ->  CTE Scan on c1_1
                           Filter: (id = $2)
               ->  Seq Scan on t3 t3_1
                     Filter: (id = $2)
         ->  Index Only Scan using t2_pkey on t2 t2_1
               Index Cond: (id = $2)
   ->  Index Only Scan using t1_pkey on t1 t1_1
         Index Cond: (id = $2)
(53 rows)

-- ambigous error
EXPLAIN (COSTS false) SELECT * FROM t1, s0.t1, t2 WHERE public.t1.id = s0.t1.id AND public.t1.id = t2.id;
                   QUERY PLAN                    
-------------------------------------------------
 Merge Join
   Merge Cond: (t1.id = t2.id)
   ->  Merge Join
         Merge Cond: (t1.id = t1_1.id)
         ->  Index Scan using t1_pkey on t1
         ->  Index Scan using t1_pkey on t1 t1_1
   ->  Index Scan using t2_pkey on t2
(7 rows)

/*+NestLoop(t1 t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, s0.t1, t2 WHERE public.t1.id = s0.t1.id AND public.t1.id = t2.id;
INFO:  pg_hint_plan: hint syntax error at or near "NestLoop(t1 t2)"
DETAIL:  Relation name "t1" is ambiguous.
LOG:  pg_hint_plan:
used hint:
not used hint:
duplication hint:
error hint:
NestLoop(t1 t2)

                   QUERY PLAN                    
-------------------------------------------------
 Merge Join
   Merge Cond: (t1.id = t2.id)
   ->  Merge Join
         Merge Cond: (t1.id = t1_1.id)
         ->  Index Scan using t1_pkey on t1
         ->  Index Scan using t1_pkey on t1 t1_1
   ->  Index Scan using t2_pkey on t2
(7 rows)

/*+Leading(t1 t2 t1)*/
EXPLAIN (COSTS false) SELECT * FROM t1, s0.t1, t2 WHERE public.t1.id = s0.t1.id AND public.t1.id = t2.id;
INFO:  pg_hint_plan: hint syntax error at or near "Leading(t1 t2 t1)"
DETAIL:  Relation name "t1" is ambiguous.
LOG:  pg_hint_plan:
used hint:
not used hint:
duplication hint:
error hint:
Leading(t1 t2 t1)

                   QUERY PLAN                    
-------------------------------------------------
 Merge Join
   Merge Cond: (t1.id = t2.id)
   ->  Merge Join
         Merge Cond: (t1.id = t1_1.id)
         ->  Index Scan using t1_pkey on t1
         ->  Index Scan using t1_pkey on t1 t1_1
   ->  Index Scan using t2_pkey on t2
(7 rows)

-- identifier length test
EXPLAIN (COSTS false) SELECT * FROM t1 "123456789012345678901234567890123456789012345678901234567890123" JOIN t2 ON ("123456789012345678901234567890123456789012345678901234567890123".id = t2.id) JOIN t3 ON (t2.id = t3.id);
                                                  QUERY PLAN                                                  
--------------------------------------------------------------------------------------------------------------
 Merge Join
   Merge Cond: ("123456789012345678901234567890123456789012345678901234567890123".id = t3.id)
   ->  Merge Join
         Merge Cond: ("123456789012345678901234567890123456789012345678901234567890123".id = t2.id)
         ->  Index Scan using t1_pkey on t1 "123456789012345678901234567890123456789012345678901234567890123"
         ->  Index Scan using t2_pkey on t2
   ->  Sort
         Sort Key: t3.id
         ->  Seq Scan on t3
(9 rows)

/*+
Leading(123456789012345678901234567890123456789012345678901234567890123 t2 t3)
SeqScan(123456789012345678901234567890123456789012345678901234567890123)
MergeJoin(123456789012345678901234567890123456789012345678901234567890123 t2)
Set(123456789012345678901234567890123456789012345678901234567890123 1)
*/
EXPLAIN (COSTS false) SELECT * FROM t1 "123456789012345678901234567890123456789012345678901234567890123" JOIN t2 ON ("123456789012345678901234567890123456789012345678901234567890123".id = t2.id) JOIN t3 ON (t2.id = t3.id);
INFO:  unrecognized configuration parameter "123456789012345678901234567890123456789012345678901234567890123"
LOG:  pg_hint_plan:
used hint:
SeqScan(123456789012345678901234567890123456789012345678901234567890123)
MergeJoin(123456789012345678901234567890123456789012345678901234567890123 t2)
Leading(123456789012345678901234567890123456789012345678901234567890123 t2 t3)
not used hint:
duplication hint:
error hint:
Set(123456789012345678901234567890123456789012345678901234567890123 1)

                                             QUERY PLAN                                             
----------------------------------------------------------------------------------------------------
 Merge Join
   Merge Cond: ("123456789012345678901234567890123456789012345678901234567890123".id = t3.id)
   ->  Merge Join
         Merge Cond: (t2.id = "123456789012345678901234567890123456789012345678901234567890123".id)
         ->  Index Scan using t2_pkey on t2
         ->  Sort
               Sort Key: "123456789012345678901234567890123456789012345678901234567890123".id
               ->  Seq Scan on t1 "123456789012345678901234567890123456789012345678901234567890123"
   ->  Sort
         Sort Key: t3.id
         ->  Seq Scan on t3
(11 rows)

/*+
Leading(1234567890123456789012345678901234567890123456789012345678901234 t2 t3)
SeqScan(1234567890123456789012345678901234567890123456789012345678901234)
MergeJoin(1234567890123456789012345678901234567890123456789012345678901234 t2)
Set(1234567890123456789012345678901234567890123456789012345678901234 1)
Set(cursor_tuple_fraction 0.1234567890123456789012345678901234567890123456789012345678901234)
*/
EXPLAIN (COSTS false) SELECT * FROM t1 "1234567890123456789012345678901234567890123456789012345678901234" JOIN t2 ON ("1234567890123456789012345678901234567890123456789012345678901234".id = t2.id) JOIN t3 ON (t2.id = t3.id);
NOTICE:  identifier "1234567890123456789012345678901234567890123456789012345678901234" will be truncated to "123456789012345678901234567890123456789012345678901234567890123"
NOTICE:  identifier "1234567890123456789012345678901234567890123456789012345678901234" will be truncated to "123456789012345678901234567890123456789012345678901234567890123"
NOTICE:  identifier "1234567890123456789012345678901234567890123456789012345678901234" will be truncated to "123456789012345678901234567890123456789012345678901234567890123"
NOTICE:  identifier "1234567890123456789012345678901234567890123456789012345678901234" will be truncated to "123456789012345678901234567890123456789012345678901234567890123"
NOTICE:  identifier "1234567890123456789012345678901234567890123456789012345678901234" will be truncated to "123456789012345678901234567890123456789012345678901234567890123"
NOTICE:  identifier "1234567890123456789012345678901234567890123456789012345678901234" will be truncated to "123456789012345678901234567890123456789012345678901234567890123"
INFO:  unrecognized configuration parameter "123456789012345678901234567890123456789012345678901234567890123"
LOG:  pg_hint_plan:
used hint:
SeqScan(123456789012345678901234567890123456789012345678901234567890123)
MergeJoin(123456789012345678901234567890123456789012345678901234567890123 t2)
Leading(123456789012345678901234567890123456789012345678901234567890123 t2 t3)
Set(cursor_tuple_fraction 0.1234567890123456789012345678901234567890123456789012345678901234)
not used hint:
duplication hint:
error hint:
Set(123456789012345678901234567890123456789012345678901234567890123 1)

                                             QUERY PLAN                                             
----------------------------------------------------------------------------------------------------
 Merge Join
   Merge Cond: ("123456789012345678901234567890123456789012345678901234567890123".id = t3.id)
   ->  Merge Join
         Merge Cond: (t2.id = "123456789012345678901234567890123456789012345678901234567890123".id)
         ->  Index Scan using t2_pkey on t2
         ->  Sort
               Sort Key: "123456789012345678901234567890123456789012345678901234567890123".id
               ->  Seq Scan on t1 "123456789012345678901234567890123456789012345678901234567890123"
   ->  Sort
         Sort Key: t3.id
         ->  Seq Scan on t3
(11 rows)

SET "123456789012345678901234567890123456789012345678901234567890123" TO 1;
ERROR:  unrecognized configuration parameter "123456789012345678901234567890123456789012345678901234567890123"
SET "1234567890123456789012345678901234567890123456789012345678901234" TO 1;
NOTICE:  identifier "1234567890123456789012345678901234567890123456789012345678901234" will be truncated to "123456789012345678901234567890123456789012345678901234567890123"
ERROR:  unrecognized configuration parameter "123456789012345678901234567890123456789012345678901234567890123"
SET cursor_tuple_fraction TO 1234567890123456789012345678901234567890123456789012345678901234;
ERROR:  1.23457e+63 is outside the valid range for parameter "cursor_tuple_fraction" (0 .. 1)
-- multi error
/*+ Set(enable_seqscan 100)Set(seq_page_cost on)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
INFO:  parameter "enable_seqscan" requires a Boolean value
INFO:  parameter "seq_page_cost" requires a numeric value
LOG:  pg_hint_plan:
used hint:
not used hint:
duplication hint:
error hint:
Set(enable_seqscan 100)
Set(seq_page_cost on)

              QUERY PLAN              
--------------------------------------
 Merge Join
   Merge Cond: (t1.id = t2.id)
   ->  Index Scan using t1_pkey on t1
   ->  Index Scan using t2_pkey on t2
(4 rows)

-- debug log of candidate index to use IndexScan
EXPLAIN (COSTS false) SELECT * FROM t5 WHERE t5.id = 1;
                                       QUERY PLAN                                       
----------------------------------------------------------------------------------------
 Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
   Index Cond: (id = 1)
(2 rows)

/*+IndexScan(t5 t5_id2)*/
EXPLAIN (COSTS false) SELECT * FROM t5 WHERE t5.id = 1;
LOG:  available indexes for IndexScan(t5): t5_id2
LOG:  pg_hint_plan:
used hint:
IndexScan(t5 t5_id2)
not used hint:
duplication hint:
error hint:

          QUERY PLAN           
-------------------------------
 Index Scan using t5_id2 on t5
   Index Cond: (id = 1)
(2 rows)

/*+IndexScan(t5 no_exist)*/
EXPLAIN (COSTS false) SELECT * FROM t5 WHERE t5.id = 1;
LOG:  available indexes for IndexScan(t5):
LOG:  pg_hint_plan:
used hint:
IndexScan(t5 no_exist)
not used hint:
duplication hint:
error hint:

     QUERY PLAN     
--------------------
 Seq Scan on t5
   Filter: (id = 1)
(2 rows)

/*+IndexScan(t5 t5_id1 t5_id2)*/
EXPLAIN (COSTS false) SELECT * FROM t5 WHERE t5.id = 1;
LOG:  available indexes for IndexScan(t5): t5_id2 t5_id1
LOG:  pg_hint_plan:
used hint:
IndexScan(t5 t5_id1 t5_id2)
not used hint:
duplication hint:
error hint:

          QUERY PLAN           
-------------------------------
 Index Scan using t5_id2 on t5
   Index Cond: (id = 1)
(2 rows)

/*+IndexScan(t5 no_exist t5_id2)*/
EXPLAIN (COSTS false) SELECT * FROM t5 WHERE t5.id = 1;
LOG:  available indexes for IndexScan(t5): t5_id2
LOG:  pg_hint_plan:
used hint:
IndexScan(t5 no_exist t5_id2)
not used hint:
duplication hint:
error hint:

          QUERY PLAN           
-------------------------------
 Index Scan using t5_id2 on t5
   Index Cond: (id = 1)
(2 rows)

/*+IndexScan(t5 no_exist5 no_exist2)*/
EXPLAIN (COSTS false) SELECT * FROM t5 WHERE t5.id = 1;
LOG:  available indexes for IndexScan(t5):
LOG:  pg_hint_plan:
used hint:
IndexScan(t5 no_exist5 no_exist2)
not used hint:
duplication hint:
error hint:

     QUERY PLAN     
--------------------
 Seq Scan on t5
   Filter: (id = 1)
(2 rows)

-- outer inner
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
                       QUERY PLAN                       
--------------------------------------------------------
 Hash Join
   Hash Cond: (t3.val = t2.val)
   ->  Seq Scan on t3
   ->  Hash
         ->  Hash Join
               Hash Cond: (t2.id = t1.id)
               ->  Seq Scan on t2
               ->  Hash
                     ->  Index Scan using t1_pkey on t1
                           Index Cond: (id < 10)
(10 rows)

/*+Leading((t1))*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
INFO:  pg_hint_plan: hint syntax error at or near "Leading((t1))"
DETAIL:  Leading hint requires two sets of relations when parentheses nests.
LOG:  pg_hint_plan:
used hint:
not used hint:
duplication hint:
error hint:
Leading((t1))

                       QUERY PLAN                       
--------------------------------------------------------
 Hash Join
   Hash Cond: (t3.val = t2.val)
   ->  Seq Scan on t3
   ->  Hash
         ->  Hash Join
               Hash Cond: (t2.id = t1.id)
               ->  Seq Scan on t2
               ->  Hash
                     ->  Index Scan using t1_pkey on t1
                           Index Cond: (id < 10)
(10 rows)

/*+Leading((t1 t2))*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
Leading((t1 t2))
not used hint:
duplication hint:
error hint:

                 QUERY PLAN                 
--------------------------------------------
 Nested Loop
   Join Filter: (t2.val = t3.val)
   ->  Hash Join
         Hash Cond: (t1.id = t2.id)
         ->  Index Scan using t1_pkey on t1
               Index Cond: (id < 10)
         ->  Hash
               ->  Seq Scan on t2
   ->  Seq Scan on t3
(9 rows)

/*+Leading((t1 t2 t3))*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
INFO:  pg_hint_plan: hint syntax error at or near "Leading((t1 t2 t3))"
DETAIL:  Leading hint requires two sets of relations when parentheses nests.
LOG:  pg_hint_plan:
used hint:
not used hint:
duplication hint:
error hint:
Leading((t1 t2 t3))

                       QUERY PLAN                       
--------------------------------------------------------
 Hash Join
   Hash Cond: (t3.val = t2.val)
   ->  Seq Scan on t3
   ->  Hash
         ->  Hash Join
               Hash Cond: (t2.id = t1.id)
               ->  Seq Scan on t2
               ->  Hash
                     ->  Index Scan using t1_pkey on t1
                           Index Cond: (id < 10)
(10 rows)

EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.id < 10;
                 QUERY PLAN                 
--------------------------------------------
 Hash Join
   Hash Cond: (t2.id = t1.id)
   ->  Seq Scan on t2
   ->  Hash
         ->  Index Scan using t1_pkey on t1
               Index Cond: (id < 10)
(6 rows)

/*+Leading((t1 t2))*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
Leading((t1 t2))
not used hint:
duplication hint:
error hint:

              QUERY PLAN              
--------------------------------------
 Hash Join
   Hash Cond: (t1.id = t2.id)
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id < 10)
   ->  Hash
         ->  Seq Scan on t2
(6 rows)

EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
                       QUERY PLAN                       
--------------------------------------------------------
 Hash Join
   Hash Cond: (t3.val = t2.val)
   ->  Seq Scan on t3
   ->  Hash
         ->  Hash Join
               Hash Cond: (t2.id = t1.id)
               ->  Seq Scan on t2
               ->  Hash
                     ->  Index Scan using t1_pkey on t1
                           Index Cond: (id < 10)
(10 rows)

/*+Leading(((t1 t2) t3))*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
Leading(((t1 t2) t3))
not used hint:
duplication hint:
error hint:

                 QUERY PLAN                 
--------------------------------------------
 Nested Loop
   Join Filter: (t2.val = t3.val)
   ->  Hash Join
         Hash Cond: (t1.id = t2.id)
         ->  Index Scan using t1_pkey on t1
               Index Cond: (id < 10)
         ->  Hash
               ->  Seq Scan on t2
   ->  Seq Scan on t3
(9 rows)

EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t3.id = t4.id AND t1.val = t3.val AND t1.id < 10;
                       QUERY PLAN                       
--------------------------------------------------------
 Nested Loop
   ->  Merge Join
         Merge Cond: (t3.id = t4.id)
         ->  Nested Loop
               Join Filter: (t1.val = t3.val)
               ->  Index Scan using t3_pkey on t3
               ->  Materialize
                     ->  Index Scan using t1_pkey on t1
                           Index Cond: (id < 10)
         ->  Sort
               Sort Key: t4.id
               ->  Seq Scan on t4
   ->  Index Scan using t2_pkey on t2
         Index Cond: (id = t1.id)
(14 rows)

/*+Leading((((t1 t2) t3) t4))*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t3.id = t4.id AND t1.val = t3.val AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
Leading((((t1 t2) t3) t4))
not used hint:
duplication hint:
error hint:

                    QUERY PLAN                    
--------------------------------------------------
 Nested Loop
   ->  Nested Loop
         Join Filter: (t1.val = t3.val)
         ->  Hash Join
               Hash Cond: (t1.id = t2.id)
               ->  Index Scan using t1_pkey on t1
                     Index Cond: (id < 10)
               ->  Hash
                     ->  Seq Scan on t2
         ->  Seq Scan on t3
   ->  Index Scan using t4_pkey on t4
         Index Cond: (id = t3.id)
(12 rows)

EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
                       QUERY PLAN                       
--------------------------------------------------------
 Hash Join
   Hash Cond: (t3.val = t2.val)
   ->  Seq Scan on t3
   ->  Hash
         ->  Hash Join
               Hash Cond: (t2.id = t1.id)
               ->  Seq Scan on t2
               ->  Hash
                     ->  Index Scan using t1_pkey on t1
                           Index Cond: (id < 10)
(10 rows)

/*+Leading(((t1 t2) t3))*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
Leading(((t1 t2) t3))
not used hint:
duplication hint:
error hint:

                 QUERY PLAN                 
--------------------------------------------
 Nested Loop
   Join Filter: (t2.val = t3.val)
   ->  Hash Join
         Hash Cond: (t1.id = t2.id)
         ->  Index Scan using t1_pkey on t1
               Index Cond: (id < 10)
         ->  Hash
               ->  Seq Scan on t2
   ->  Seq Scan on t3
(9 rows)

/*+Leading((t1 (t2 t3)))*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
Leading((t1 (t2 t3)))
not used hint:
duplication hint:
error hint:

                 QUERY PLAN                 
--------------------------------------------
 Hash Join
   Hash Cond: (t1.id = t2.id)
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id < 10)
   ->  Hash
         ->  Hash Join
               Hash Cond: (t2.val = t3.val)
               ->  Seq Scan on t2
               ->  Hash
                     ->  Seq Scan on t3
(10 rows)

EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t3.id = t4.id AND t1.val = t3.val AND t1.id < 10;
                       QUERY PLAN                       
--------------------------------------------------------
 Nested Loop
   ->  Merge Join
         Merge Cond: (t3.id = t4.id)
         ->  Nested Loop
               Join Filter: (t1.val = t3.val)
               ->  Index Scan using t3_pkey on t3
               ->  Materialize
                     ->  Index Scan using t1_pkey on t1
                           Index Cond: (id < 10)
         ->  Sort
               Sort Key: t4.id
               ->  Seq Scan on t4
   ->  Index Scan using t2_pkey on t2
         Index Cond: (id = t1.id)
(14 rows)

/*+Leading(((t1 t2) (t3 t4)))*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t3.id = t4.id AND t1.val = t3.val AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
Leading(((t1 t2) (t3 t4)))
not used hint:
duplication hint:
error hint:

                 QUERY PLAN                 
--------------------------------------------
 Nested Loop
   Join Filter: (t1.val = t3.val)
   ->  Hash Join
         Hash Cond: (t1.id = t2.id)
         ->  Index Scan using t1_pkey on t1
               Index Cond: (id < 10)
         ->  Hash
               ->  Seq Scan on t2
   ->  Merge Join
         Merge Cond: (t3.id = t4.id)
         ->  Index Scan using t3_pkey on t3
         ->  Sort
               Sort Key: t4.id
               ->  Seq Scan on t4
(14 rows)

EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < ( SELECT t1_2.id FROM t1 t1_2, t2 t2_2 WHERE t1_2.id = t2_2.id AND t2_2.val > 100 ORDER BY t1_2.id LIMIT 1);
                             QUERY PLAN                             
--------------------------------------------------------------------
 Hash Join
   Hash Cond: (t2.val = t3.val)
   InitPlan 1 (returns $1)
     ->  Limit
           ->  Sort
                 Sort Key: t1_2.id
                 ->  Nested Loop
                       ->  Index Scan using t2_val on t2 t2_2
                             Index Cond: (val > 100)
                       ->  Index Only Scan using t1_pkey on t1 t1_2
                             Index Cond: (id = t2_2.id)
   ->  Merge Join
         Merge Cond: (t1.id = t2.id)
         ->  Index Scan using t1_pkey on t1
               Index Cond: (id < $1)
         ->  Index Scan using t2_pkey on t2
   ->  Hash
         ->  Seq Scan on t3
(18 rows)

/*+Leading(((t1 t2) t3)) Leading(((t3 t1) t2))*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t1.val = t3.val AND t1.id < ( SELECT t1_2.id FROM t1 t1_2, t2 t2_2 WHERE t1_2.id = t2_2.id AND t2_2.val > 100 ORDER BY t1_2.id LIMIT 1);
INFO:  pg_hint_plan: hint syntax error at or near "Leading(((t1 t2) t3)) Leading(((t3 t1) t2))"
DETAIL:  Conflict leading hint.
LOG:  pg_hint_plan:
used hint:
Leading(((t3 t1) t2))
not used hint:
duplication hint:
Leading(((t1 t2) t3))
error hint:

                             QUERY PLAN                             
--------------------------------------------------------------------
 Hash Join
   Hash Cond: (t1.id = t2.id)
   InitPlan 1 (returns $1)
     ->  Limit
           ->  Sort
                 Sort Key: t1_2.id
                 ->  Nested Loop
                       ->  Index Scan using t2_val on t2 t2_2
                             Index Cond: (val > 100)
                       ->  Index Only Scan using t1_pkey on t1 t1_2
                             Index Cond: (id = t2_2.id)
   ->  Hash Join
         Hash Cond: (t3.val = t1.val)
         ->  Seq Scan on t3
         ->  Hash
               ->  Index Scan using t1_pkey on t1
                     Index Cond: (id < $1)
   ->  Hash
         ->  Seq Scan on t2
(19 rows)

/*+Leading(((t1 t2) t3)) Leading((t1_2 t2_2))*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < ( SELECT t1_2.id FROM t1 t1_2, t2 t2_2 WHERE t1_2.id = t2_2.id AND t2_2.val > 100 ORDER BY t1_2.id LIMIT 1);
LOG:  pg_hint_plan:
used hint:
Leading(((t1 t2) t3))
Leading((t1_2 t2_2))
not used hint:
duplication hint:
error hint:

                          QUERY PLAN                          
--------------------------------------------------------------
 Hash Join
   Hash Cond: (t2.val = t3.val)
   InitPlan 1 (returns $0)
     ->  Limit
           ->  Merge Join
                 Merge Cond: (t1_2.id = t2_2.id)
                 ->  Index Only Scan using t1_pkey on t1 t1_2
                 ->  Sort
                       Sort Key: t2_2.id
                       ->  Index Scan using t2_val on t2 t2_2
                             Index Cond: (val > 100)
   ->  Merge Join
         Merge Cond: (t1.id = t2.id)
         ->  Index Scan using t1_pkey on t1
               Index Cond: (id < $0)
         ->  Index Scan using t2_pkey on t2
   ->  Hash
         ->  Seq Scan on t3
(18 rows)

/*+Leading(((((t1 t2) t3) t1_2) t2_2))*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < ( SELECT t1_2.id FROM t1 t1_2, t2 t2_2 WHERE t1_2.id = t2_2.id AND t2_2.val > 100 ORDER BY t1_2.id LIMIT 1);
LOG:  pg_hint_plan:
used hint:
not used hint:
Leading(((((t1 t2) t3) t1_2) t2_2))
duplication hint:
error hint:

                             QUERY PLAN                             
--------------------------------------------------------------------
 Hash Join
   Hash Cond: (t2.val = t3.val)
   InitPlan 1 (returns $1)
     ->  Limit
           ->  Sort
                 Sort Key: t1_2.id
                 ->  Nested Loop
                       ->  Index Scan using t2_val on t2 t2_2
                             Index Cond: (val > 100)
                       ->  Index Only Scan using t1_pkey on t1 t1_2
                             Index Cond: (id = t2_2.id)
   ->  Merge Join
         Merge Cond: (t1.id = t2.id)
         ->  Index Scan using t1_pkey on t1
               Index Cond: (id < $1)
         ->  Index Scan using t2_pkey on t2
   ->  Hash
         ->  Seq Scan on t3
(18 rows)

-- Specified outer/inner leading hint and join method hint at the same time
/*+Leading(((t1 t2) t3))*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
Leading(((t1 t2) t3))
not used hint:
duplication hint:
error hint:

                 QUERY PLAN                 
--------------------------------------------
 Nested Loop
   Join Filter: (t2.val = t3.val)
   ->  Hash Join
         Hash Cond: (t1.id = t2.id)
         ->  Index Scan using t1_pkey on t1
               Index Cond: (id < 10)
         ->  Hash
               ->  Seq Scan on t2
   ->  Seq Scan on t3
(9 rows)

/*+Leading(((t1 t2) t3)) MergeJoin(t1 t2)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
MergeJoin(t1 t2)
Leading(((t1 t2) t3))
not used hint:
duplication hint:
error hint:

                 QUERY PLAN                 
--------------------------------------------
 Nested Loop
   Join Filter: (t2.val = t3.val)
   ->  Merge Join
         Merge Cond: (t1.id = t2.id)
         ->  Index Scan using t1_pkey on t1
               Index Cond: (id < 10)
         ->  Index Scan using t2_pkey on t2
   ->  Seq Scan on t3
(8 rows)

/*+Leading(((t1 t2) t3)) MergeJoin(t1 t2 t3)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
MergeJoin(t1 t2 t3)
Leading(((t1 t2) t3))
not used hint:
duplication hint:
error hint:

                    QUERY PLAN                    
--------------------------------------------------
 Merge Join
   Merge Cond: (t2.val = t3.val)
   ->  Sort
         Sort Key: t2.val
         ->  Hash Join
               Hash Cond: (t1.id = t2.id)
               ->  Index Scan using t1_pkey on t1
                     Index Cond: (id < 10)
               ->  Hash
                     ->  Seq Scan on t2
   ->  Sort
         Sort Key: t3.val
         ->  Seq Scan on t3
(13 rows)

/*+Leading(((t1 t2) t3)) MergeJoin(t1 t3)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
Leading(((t1 t2) t3))
not used hint:
MergeJoin(t1 t3)
duplication hint:
error hint:

                 QUERY PLAN                 
--------------------------------------------
 Nested Loop
   Join Filter: (t2.val = t3.val)
   ->  Hash Join
         Hash Cond: (t1.id = t2.id)
         ->  Index Scan using t1_pkey on t1
               Index Cond: (id < 10)
         ->  Hash
               ->  Seq Scan on t2
   ->  Seq Scan on t3
(9 rows)

EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t3.id = t4.id AND t1.val = t3.val AND t1.id < 10;
                       QUERY PLAN                       
--------------------------------------------------------
 Nested Loop
   ->  Merge Join
         Merge Cond: (t3.id = t4.id)
         ->  Nested Loop
               Join Filter: (t1.val = t3.val)
               ->  Index Scan using t3_pkey on t3
               ->  Materialize
                     ->  Index Scan using t1_pkey on t1
                           Index Cond: (id < 10)
         ->  Sort
               Sort Key: t4.id
               ->  Seq Scan on t4
   ->  Index Scan using t2_pkey on t2
         Index Cond: (id = t1.id)
(14 rows)

/*+Leading(((t1 t2) t3)) MergeJoin(t3 t4)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t3.id = t4.id AND t1.val = t3.val AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
Leading(((t1 t2) t3))
not used hint:
MergeJoin(t3 t4)
duplication hint:
error hint:

                    QUERY PLAN                    
--------------------------------------------------
 Nested Loop
   Join Filter: (t3.id = t4.id)
   ->  Nested Loop
         Join Filter: (t1.val = t3.val)
         ->  Hash Join
               Hash Cond: (t1.id = t2.id)
               ->  Index Scan using t1_pkey on t1
                     Index Cond: (id < 10)
               ->  Hash
                     ->  Seq Scan on t2
         ->  Seq Scan on t3
   ->  Seq Scan on t4
(12 rows)

/*+Leading(((t1 t2) t3)) MergeJoin(t1 t2 t3 t4)*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t3.id = t4.id AND t1.val = t3.val AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
MergeJoin(t1 t2 t3 t4)
Leading(((t1 t2) t3))
not used hint:
duplication hint:
error hint:

                       QUERY PLAN                       
--------------------------------------------------------
 Merge Join
   Merge Cond: (t3.id = t4.id)
   ->  Sort
         Sort Key: t3.id
         ->  Nested Loop
               Join Filter: (t1.val = t3.val)
               ->  Hash Join
                     Hash Cond: (t1.id = t2.id)
                     ->  Index Scan using t1_pkey on t1
                           Index Cond: (id < 10)
                     ->  Hash
                           ->  Seq Scan on t2
               ->  Seq Scan on t3
   ->  Sort
         Sort Key: t4.id
         ->  Seq Scan on t4
(16 rows)

/*+ Leading ( ( t1 ( t2 t3 ) ) ) */
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
Leading((t1 (t2 t3)))
not used hint:
duplication hint:
error hint:

                 QUERY PLAN                 
--------------------------------------------
 Hash Join
   Hash Cond: (t1.id = t2.id)
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id < 10)
   ->  Hash
         ->  Hash Join
               Hash Cond: (t2.val = t3.val)
               ->  Seq Scan on t2
               ->  Hash
                     ->  Seq Scan on t3
(10 rows)

/*+Leading((t1(t2 t3)))*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
Leading((t1 (t2 t3)))
not used hint:
duplication hint:
error hint:

                 QUERY PLAN                 
--------------------------------------------
 Hash Join
   Hash Cond: (t1.id = t2.id)
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id < 10)
   ->  Hash
         ->  Hash Join
               Hash Cond: (t2.val = t3.val)
               ->  Seq Scan on t2
               ->  Hash
                     ->  Seq Scan on t3
(10 rows)

/*+Leading(("t1(t2" "t3)"))*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
not used hint:
Leading(("t1(t2" "t3)"))
duplication hint:
error hint:

                       QUERY PLAN                       
--------------------------------------------------------
 Hash Join
   Hash Cond: (t3.val = t2.val)
   ->  Seq Scan on t3
   ->  Hash
         ->  Hash Join
               Hash Cond: (t2.id = t1.id)
               ->  Seq Scan on t2
               ->  Hash
                     ->  Index Scan using t1_pkey on t1
                           Index Cond: (id < 10)
(10 rows)

/*+ Leading ( ( ( t1 t2 ) t3 ) ) */
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
Leading(((t1 t2) t3))
not used hint:
duplication hint:
error hint:

                 QUERY PLAN                 
--------------------------------------------
 Nested Loop
   Join Filter: (t2.val = t3.val)
   ->  Hash Join
         Hash Cond: (t1.id = t2.id)
         ->  Index Scan using t1_pkey on t1
               Index Cond: (id < 10)
         ->  Hash
               ->  Seq Scan on t2
   ->  Seq Scan on t3
(9 rows)

/*+Leading(((t1 t2)t3))*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
Leading(((t1 t2) t3))
not used hint:
duplication hint:
error hint:

                 QUERY PLAN                 
--------------------------------------------
 Nested Loop
   Join Filter: (t2.val = t3.val)
   ->  Hash Join
         Hash Cond: (t1.id = t2.id)
         ->  Index Scan using t1_pkey on t1
               Index Cond: (id < 10)
         ->  Hash
               ->  Seq Scan on t2
   ->  Seq Scan on t3
(9 rows)

/*+Leading(("(t1" "t2)t3"))*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
LOG:  pg_hint_plan:
used hint:
not used hint:
Leading(("(t1" "t2)t3"))
duplication hint:
error hint:

                       QUERY PLAN                       
--------------------------------------------------------
 Hash Join
   Hash Cond: (t3.val = t2.val)
   ->  Seq Scan on t3
   ->  Hash
         ->  Hash Join
               Hash Cond: (t2.id = t1.id)
               ->  Seq Scan on t2
               ->  Hash
                     ->  Index Scan using t1_pkey on t1
                           Index Cond: (id < 10)
(10 rows)

/*+Leading((t1(t2(t3(t4 t5)))))*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4, t5 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id AND t1.id = t5.id;
LOG:  pg_hint_plan:
used hint:
Leading((t1 (t2 (t3 (t4 t5)))))
not used hint:
duplication hint:
error hint:

                                                            QUERY PLAN                                                            
----------------------------------------------------------------------------------------------------------------------------------
 Merge Join
   Merge Cond: (t1.id = t2.id)
   ->  Index Scan using t1_pkey on t1
   ->  Materialize
         ->  Merge Join
               Merge Cond: (t2.id = t3.id)
               ->  Index Scan using t2_pkey on t2
               ->  Materialize
                     ->  Merge Join
                           Merge Cond: (t3.id = t4.id)
                           ->  Index Scan using t3_pkey on t3
                           ->  Materialize
                                 ->  Merge Join
                                       Merge Cond: (t4.id = t5.id)
                                       ->  Index Scan using t4_pkey on t4
                                       ->  Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
(16 rows)

/*+Leading((t5(t4(t3(t2 t1)))))*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4, t5 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id AND t1.id = t5.id;
LOG:  pg_hint_plan:
used hint:
Leading((t5 (t4 (t3 (t2 t1)))))
not used hint:
duplication hint:
error hint:

                                QUERY PLAN                                
--------------------------------------------------------------------------
 Hash Join
   Hash Cond: (t5.id = t1.id)
   ->  Seq Scan on t5
   ->  Hash
         ->  Merge Join
               Merge Cond: (t4.id = t1.id)
               ->  Sort
                     Sort Key: t4.id
                     ->  Seq Scan on t4
               ->  Materialize
                     ->  Merge Join
                           Merge Cond: (t3.id = t1.id)
                           ->  Sort
                                 Sort Key: t3.id
                                 ->  Seq Scan on t3
                           ->  Materialize
                                 ->  Merge Join
                                       Merge Cond: (t2.id = t1.id)
                                       ->  Index Scan using t2_pkey on t2
                                       ->  Index Scan using t1_pkey on t1
(20 rows)

/*+Leading(((((t1 t2)t3)t4)t5))*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4, t5 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id AND t1.id = t5.id;
LOG:  pg_hint_plan:
used hint:
Leading(((((t1 t2) t3) t4) t5))
not used hint:
duplication hint:
error hint:

                                          QUERY PLAN                                          
----------------------------------------------------------------------------------------------
 Nested Loop
   ->  Merge Join
         Merge Cond: (t1.id = t4.id)
         ->  Merge Join
               Merge Cond: (t1.id = t3.id)
               ->  Merge Join
                     Merge Cond: (t1.id = t2.id)
                     ->  Index Scan using t1_pkey on t1
                     ->  Index Scan using t2_pkey on t2
               ->  Sort
                     Sort Key: t3.id
                     ->  Seq Scan on t3
         ->  Sort
               Sort Key: t4.id
               ->  Seq Scan on t4
   ->  Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
         Index Cond: (id = t1.id)
(17 rows)

/*+Leading(((((t5 t4)t3)t2)t1))*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4, t5 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id AND t1.id = t5.id;
LOG:  pg_hint_plan:
used hint:
Leading(((((t5 t4) t3) t2) t1))
not used hint:
duplication hint:
error hint:

                                                   QUERY PLAN                                                   
----------------------------------------------------------------------------------------------------------------
 Nested Loop
   Join Filter: (t2.id = t1.id)
   ->  Nested Loop
         Join Filter: (t3.id = t2.id)
         ->  Merge Join
               Merge Cond: (t4.id = t3.id)
               ->  Merge Join
                     Merge Cond: (t5.id = t4.id)
                     ->  Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
                     ->  Sort
                           Sort Key: t4.id
                           ->  Seq Scan on t4
               ->  Index Scan using t3_pkey on t3
         ->  Index Scan using t2_pkey on t2
               Index Cond: (id = t5.id)
   ->  Index Scan using t1_pkey on t1
         Index Cond: (id = t5.id)
(17 rows)

/*+Leading(((t1 t2)(t3(t4 t5))))*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4, t5 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id AND t1.id = t5.id;
LOG:  pg_hint_plan:
used hint:
Leading(((t1 t2) (t3 (t4 t5))))
not used hint:
duplication hint:
error hint:

                                                      QUERY PLAN                                                      
----------------------------------------------------------------------------------------------------------------------
 Merge Join
   Merge Cond: (t1.id = t3.id)
   ->  Merge Join
         Merge Cond: (t1.id = t2.id)
         ->  Index Scan using t1_pkey on t1
         ->  Index Scan using t2_pkey on t2
   ->  Materialize
         ->  Merge Join
               Merge Cond: (t3.id = t4.id)
               ->  Index Scan using t3_pkey on t3
               ->  Materialize
                     ->  Merge Join
                           Merge Cond: (t4.id = t5.id)
                           ->  Index Scan using t4_pkey on t4
                           ->  Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
(15 rows)

/*+Leading(((t5 t4)(t3(t2 t1))))*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4, t5 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id AND t1.id = t5.id;
LOG:  pg_hint_plan:
used hint:
Leading(((t5 t4) (t3 (t2 t1))))
not used hint:
duplication hint:
error hint:

                                             QUERY PLAN                                             
----------------------------------------------------------------------------------------------------
 Merge Join
   Merge Cond: (t4.id = t1.id)
   ->  Merge Join
         Merge Cond: (t5.id = t4.id)
         ->  Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
         ->  Sort
               Sort Key: t4.id
               ->  Seq Scan on t4
   ->  Materialize
         ->  Merge Join
               Merge Cond: (t3.id = t1.id)
               ->  Sort
                     Sort Key: t3.id
                     ->  Seq Scan on t3
               ->  Materialize
                     ->  Merge Join
                           Merge Cond: (t2.id = t1.id)
                           ->  Index Scan using t2_pkey on t2
                           ->  Index Scan using t1_pkey on t1
(19 rows)

/*+Leading((((t1 t2)t3)(t4 t5)))*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4, t5 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id AND t1.id = t5.id;
LOG:  pg_hint_plan:
used hint:
Leading((((t1 t2) t3) (t4 t5)))
not used hint:
duplication hint:
error hint:

                                                QUERY PLAN                                                
----------------------------------------------------------------------------------------------------------
 Merge Join
   Merge Cond: (t1.id = t4.id)
   ->  Merge Join
         Merge Cond: (t1.id = t3.id)
         ->  Merge Join
               Merge Cond: (t1.id = t2.id)
               ->  Index Scan using t1_pkey on t1
               ->  Index Scan using t2_pkey on t2
         ->  Sort
               Sort Key: t3.id
               ->  Seq Scan on t3
   ->  Materialize
         ->  Merge Join
               Merge Cond: (t4.id = t5.id)
               ->  Index Scan using t4_pkey on t4
               ->  Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
(16 rows)

/*+Leading((((t5 t4)t3)(t2 t1)))*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4, t5 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id AND t1.id = t5.id;
LOG:  pg_hint_plan:
used hint:
Leading((((t5 t4) t3) (t2 t1)))
not used hint:
duplication hint:
error hint:

                                                QUERY PLAN                                                
----------------------------------------------------------------------------------------------------------
 Merge Join
   Merge Cond: (t3.id = t1.id)
   ->  Merge Join
         Merge Cond: (t4.id = t3.id)
         ->  Merge Join
               Merge Cond: (t5.id = t4.id)
               ->  Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
               ->  Sort
                     Sort Key: t4.id
                     ->  Seq Scan on t4
         ->  Index Scan using t3_pkey on t3
   ->  Materialize
         ->  Merge Join
               Merge Cond: (t2.id = t1.id)
               ->  Index Scan using t2_pkey on t2
               ->  Index Scan using t1_pkey on t1
(16 rows)

-- inherite table test to specify the index's name
EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
                              QUERY PLAN                               
-----------------------------------------------------------------------
 Append
   ->  Seq Scan on p2
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c1
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c1_c1
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c1_c2
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
(9 rows)

/*+IndexScan(p2 p2_pkey)*/
EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
LOG:  available indexes for IndexScan(p2): p2_pkey
LOG:  available indexes for IndexScan(p2_c1): p2_c1_pkey
LOG:  available indexes for IndexScan(p2_c2): p2_c2_pkey
LOG:  available indexes for IndexScan(p2_c3): p2_c3_pkey
LOG:  available indexes for IndexScan(p2_c4): p2_c4_pkey
LOG:  available indexes for IndexScan(p2_c1_c1): p2_c1_c1_pkey
LOG:  available indexes for IndexScan(p2_c1_c2): p2_c1_c2_pkey
LOG:  available indexes for IndexScan(p2_c3_c1): p2_c3_c1_pkey
LOG:  available indexes for IndexScan(p2_c3_c2): p2_c3_c2_pkey
LOG:  pg_hint_plan:
used hint:
IndexScan(p2 p2_pkey)
not used hint:
duplication hint:
error hint:

                    QUERY PLAN                    
--------------------------------------------------
 Append
   ->  Index Scan using p2_pkey on p2
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p2_c1_pkey on p2_c1
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p2_c1_c1_pkey on p2_c1_c1
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p2_c1_c2_pkey on p2_c1_c2
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
(13 rows)

/*+IndexScan(p2 p2_id_val_idx)*/
EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
LOG:  available indexes for IndexScan(p2): p2_id_val_idx
LOG:  available indexes for IndexScan(p2_c1): p2_c1_id_val_idx
LOG:  available indexes for IndexScan(p2_c2): p2_c2_id_val_idx
LOG:  available indexes for IndexScan(p2_c3): p2_c3_id_val_idx
LOG:  available indexes for IndexScan(p2_c4): p2_c4_id_val_idx
LOG:  available indexes for IndexScan(p2_c1_c1): p2_c1_c1_id_val_idx
LOG:  available indexes for IndexScan(p2_c1_c2): p2_c1_c2_id_val_idx
LOG:  available indexes for IndexScan(p2_c3_c1): p2_c3_c1_id_val_idx
LOG:  available indexes for IndexScan(p2_c3_c2): p2_c3_c2_id_val_idx
LOG:  pg_hint_plan:
used hint:
IndexScan(p2 p2_id_val_idx)
not used hint:
duplication hint:
error hint:

                       QUERY PLAN                       
--------------------------------------------------------
 Append
   ->  Index Scan using p2_id_val_idx on p2
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p2_c1_id_val_idx on p2_c1
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p2_c1_c1_id_val_idx on p2_c1_c1
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p2_c1_c2_id_val_idx on p2_c1_c2
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
(13 rows)

/*+IndexScan(p2 p2_val_id_idx)*/
EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
LOG:  available indexes for IndexScan(p2): p2_val_id_idx
LOG:  available indexes for IndexScan(p2_c1): p2_c1_val_id_idx
LOG:  available indexes for IndexScan(p2_c2): p2_c2_val_id_idx
LOG:  available indexes for IndexScan(p2_c3): p2_c3_val_id_idx
LOG:  available indexes for IndexScan(p2_c4):
LOG:  available indexes for IndexScan(p2_c1_c1): p2_c1_c1_val_id_idx
LOG:  available indexes for IndexScan(p2_c1_c2): p2_c1_c2_val_id_idx
LOG:  available indexes for IndexScan(p2_c3_c1): p2_c3_c1_val_id_idx
LOG:  available indexes for IndexScan(p2_c3_c2): p2_c3_c2_val_id_idx
LOG:  pg_hint_plan:
used hint:
IndexScan(p2 p2_val_id_idx)
not used hint:
duplication hint:
error hint:

                       QUERY PLAN                       
--------------------------------------------------------
 Append
   ->  Index Scan using p2_val_id_idx on p2
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p2_c1_val_id_idx on p2_c1
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p2_c1_c1_val_id_idx on p2_c1_c1
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p2_c1_c2_val_id_idx on p2_c1_c2
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
(13 rows)

EXPLAIN (COSTS false) SELECT val FROM p2 WHERE val >= '50' AND val <= '51' AND p2.ctid = '(1,1)';
                                       QUERY PLAN                                        
-----------------------------------------------------------------------------------------
 Append
   ->  Seq Scan on p2
         Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c1
         Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c2
         Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c3
         Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c4
         Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c1_c1
         Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c1_c2
         Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c3_c1
         Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c3_c2
         Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
(19 rows)

/*+IndexScan(p2 p2_val)*/
EXPLAIN (COSTS false) SELECT val FROM p2 WHERE val >= '50' AND val <= '51' AND p2.ctid = '(1,1)';
LOG:  available indexes for IndexScan(p2):
LOG:  available indexes for IndexScan(p2_c1):
LOG:  available indexes for IndexScan(p2_c2):
LOG:  available indexes for IndexScan(p2_c3):
LOG:  available indexes for IndexScan(p2_c4):
LOG:  available indexes for IndexScan(p2_c1_c1):
LOG:  available indexes for IndexScan(p2_c1_c2):
LOG:  available indexes for IndexScan(p2_c3_c1):
LOG:  available indexes for IndexScan(p2_c3_c2):
LOG:  pg_hint_plan:
used hint:
IndexScan(p2 p2_val)
not used hint:
duplication hint:
error hint:

                                       QUERY PLAN                                        
-----------------------------------------------------------------------------------------
 Append
   ->  Seq Scan on p2
         Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c1
         Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c2
         Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c3
         Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c4
         Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c1_c1
         Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c1_c2
         Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c3_c1
         Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c3_c2
         Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
(19 rows)

/*+IndexScan(p2 p2_pkey)*/
EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
LOG:  available indexes for IndexScan(p2): p2_pkey
LOG:  available indexes for IndexScan(p2_c1): p2_c1_pkey
LOG:  available indexes for IndexScan(p2_c2): p2_c2_pkey
LOG:  available indexes for IndexScan(p2_c3): p2_c3_pkey
LOG:  available indexes for IndexScan(p2_c4): p2_c4_pkey
LOG:  available indexes for IndexScan(p2_c1_c1): p2_c1_c1_pkey
LOG:  available indexes for IndexScan(p2_c1_c2): p2_c1_c2_pkey
LOG:  available indexes for IndexScan(p2_c3_c1): p2_c3_c1_pkey
LOG:  available indexes for IndexScan(p2_c3_c2): p2_c3_c2_pkey
LOG:  pg_hint_plan:
used hint:
IndexScan(p2 p2_pkey)
not used hint:
duplication hint:
error hint:

                    QUERY PLAN                    
--------------------------------------------------
 Append
   ->  Index Scan using p2_pkey on p2
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p2_c1_pkey on p2_c1
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p2_c1_c1_pkey on p2_c1_c1
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p2_c1_c2_pkey on p2_c1_c2
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
(13 rows)

/*+IndexScan(p2 p2_id2_val)*/
EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
LOG:  available indexes for IndexScan(p2): p2_id2_val
LOG:  available indexes for IndexScan(p2_c1): p2_c1_id2_val
LOG:  available indexes for IndexScan(p2_c2): p2_c2_id2_val
LOG:  available indexes for IndexScan(p2_c3):
LOG:  available indexes for IndexScan(p2_c4):
LOG:  available indexes for IndexScan(p2_c1_c1):
LOG:  available indexes for IndexScan(p2_c1_c2):
LOG:  available indexes for IndexScan(p2_c3_c1):
LOG:  available indexes for IndexScan(p2_c3_c2):
LOG:  pg_hint_plan:
used hint:
IndexScan(p2 p2_id2_val)
not used hint:
duplication hint:
error hint:

                              QUERY PLAN                               
-----------------------------------------------------------------------
 Append
   ->  Index Scan using p2_id2_val on p2
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p2_c1_id2_val on p2_c1
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
   ->  Seq Scan on p2_c1_c1
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c1_c2
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
(11 rows)

/*+IndexScan(p2 p2_val2_id)*/
EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
LOG:  available indexes for IndexScan(p2): p2_val2_id
LOG:  available indexes for IndexScan(p2_c1):
LOG:  available indexes for IndexScan(p2_c2):
LOG:  available indexes for IndexScan(p2_c3):
LOG:  available indexes for IndexScan(p2_c4):
LOG:  available indexes for IndexScan(p2_c1_c1):
LOG:  available indexes for IndexScan(p2_c1_c2):
LOG:  available indexes for IndexScan(p2_c3_c1):
LOG:  available indexes for IndexScan(p2_c3_c2):
LOG:  pg_hint_plan:
used hint:
IndexScan(p2 p2_val2_id)
not used hint:
duplication hint:
error hint:

                              QUERY PLAN                               
-----------------------------------------------------------------------
 Append
   ->  Index Scan using p2_val2_id on p2
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
   ->  Seq Scan on p2_c1
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c1_c1
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c1_c2
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
(10 rows)

/*+IndexScan(p2 p2_pkey)*/
EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
LOG:  available indexes for IndexScan(p2): p2_pkey
LOG:  available indexes for IndexScan(p2_c1): p2_c1_pkey
LOG:  available indexes for IndexScan(p2_c2): p2_c2_pkey
LOG:  available indexes for IndexScan(p2_c3): p2_c3_pkey
LOG:  available indexes for IndexScan(p2_c4): p2_c4_pkey
LOG:  available indexes for IndexScan(p2_c1_c1): p2_c1_c1_pkey
LOG:  available indexes for IndexScan(p2_c1_c2): p2_c1_c2_pkey
LOG:  available indexes for IndexScan(p2_c3_c1): p2_c3_c1_pkey
LOG:  available indexes for IndexScan(p2_c3_c2): p2_c3_c2_pkey
LOG:  pg_hint_plan:
used hint:
IndexScan(p2 p2_pkey)
not used hint:
duplication hint:
error hint:

                    QUERY PLAN                    
--------------------------------------------------
 Append
   ->  Index Scan using p2_pkey on p2
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p2_c1_pkey on p2_c1
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p2_c1_c1_pkey on p2_c1_c1
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p2_c1_c2_pkey on p2_c1_c2
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
(13 rows)

/*+IndexScan(p2 p2_c1_id_val_idx)*/
EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
LOG:  available indexes for IndexScan(p2):
LOG:  available indexes for IndexScan(p2_c1): p2_c1_id_val_idx
LOG:  available indexes for IndexScan(p2_c2):
LOG:  available indexes for IndexScan(p2_c3):
LOG:  available indexes for IndexScan(p2_c4):
LOG:  available indexes for IndexScan(p2_c1_c1):
LOG:  available indexes for IndexScan(p2_c1_c2):
LOG:  available indexes for IndexScan(p2_c3_c1):
LOG:  available indexes for IndexScan(p2_c3_c2):
LOG:  pg_hint_plan:
used hint:
IndexScan(p2 p2_c1_id_val_idx)
not used hint:
duplication hint:
error hint:

                              QUERY PLAN                               
-----------------------------------------------------------------------
 Append
   ->  Seq Scan on p2
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Index Scan using p2_c1_id_val_idx on p2_c1
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
   ->  Seq Scan on p2_c1_c1
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c1_c2
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
(10 rows)

/*+IndexScan(p2 no_exist)*/
EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
LOG:  available indexes for IndexScan(p2):
LOG:  available indexes for IndexScan(p2_c1):
LOG:  available indexes for IndexScan(p2_c2):
LOG:  available indexes for IndexScan(p2_c3):
LOG:  available indexes for IndexScan(p2_c4):
LOG:  available indexes for IndexScan(p2_c1_c1):
LOG:  available indexes for IndexScan(p2_c1_c2):
LOG:  available indexes for IndexScan(p2_c3_c1):
LOG:  available indexes for IndexScan(p2_c3_c2):
LOG:  pg_hint_plan:
used hint:
IndexScan(p2 no_exist)
not used hint:
duplication hint:
error hint:

                              QUERY PLAN                               
-----------------------------------------------------------------------
 Append
   ->  Seq Scan on p2
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c1
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c1_c1
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c1_c2
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
(9 rows)

/*+IndexScan(p2 p2_pkey p2_c1_id_val_idx)*/
EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
LOG:  available indexes for IndexScan(p2): p2_pkey
LOG:  available indexes for IndexScan(p2_c1): p2_c1_id_val_idx p2_c1_pkey
LOG:  available indexes for IndexScan(p2_c2): p2_c2_pkey
LOG:  available indexes for IndexScan(p2_c3): p2_c3_pkey
LOG:  available indexes for IndexScan(p2_c4): p2_c4_pkey
LOG:  available indexes for IndexScan(p2_c1_c1): p2_c1_c1_pkey
LOG:  available indexes for IndexScan(p2_c1_c2): p2_c1_c2_pkey
LOG:  available indexes for IndexScan(p2_c3_c1): p2_c3_c1_pkey
LOG:  available indexes for IndexScan(p2_c3_c2): p2_c3_c2_pkey
LOG:  pg_hint_plan:
used hint:
IndexScan(p2 p2_pkey p2_c1_id_val_idx)
not used hint:
duplication hint:
error hint:

                    QUERY PLAN                    
--------------------------------------------------
 Append
   ->  Index Scan using p2_pkey on p2
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p2_c1_id_val_idx on p2_c1
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p2_c1_c1_pkey on p2_c1_c1
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p2_c1_c2_pkey on p2_c1_c2
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
(13 rows)

/*+IndexScan(p2 p2_pkey no_exist)*/
EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
LOG:  available indexes for IndexScan(p2): p2_pkey
LOG:  available indexes for IndexScan(p2_c1): p2_c1_pkey
LOG:  available indexes for IndexScan(p2_c2): p2_c2_pkey
LOG:  available indexes for IndexScan(p2_c3): p2_c3_pkey
LOG:  available indexes for IndexScan(p2_c4): p2_c4_pkey
LOG:  available indexes for IndexScan(p2_c1_c1): p2_c1_c1_pkey
LOG:  available indexes for IndexScan(p2_c1_c2): p2_c1_c2_pkey
LOG:  available indexes for IndexScan(p2_c3_c1): p2_c3_c1_pkey
LOG:  available indexes for IndexScan(p2_c3_c2): p2_c3_c2_pkey
LOG:  pg_hint_plan:
used hint:
IndexScan(p2 p2_pkey no_exist)
not used hint:
duplication hint:
error hint:

                    QUERY PLAN                    
--------------------------------------------------
 Append
   ->  Index Scan using p2_pkey on p2
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p2_c1_pkey on p2_c1
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p2_c1_c1_pkey on p2_c1_c1
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p2_c1_c2_pkey on p2_c1_c2
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
(13 rows)

/*+IndexScan(p2 p2_c1_id_val_idx no_exist)*/
EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
LOG:  available indexes for IndexScan(p2):
LOG:  available indexes for IndexScan(p2_c1): p2_c1_id_val_idx
LOG:  available indexes for IndexScan(p2_c2):
LOG:  available indexes for IndexScan(p2_c3):
LOG:  available indexes for IndexScan(p2_c4):
LOG:  available indexes for IndexScan(p2_c1_c1):
LOG:  available indexes for IndexScan(p2_c1_c2):
LOG:  available indexes for IndexScan(p2_c3_c1):
LOG:  available indexes for IndexScan(p2_c3_c2):
LOG:  pg_hint_plan:
used hint:
IndexScan(p2 p2_c1_id_val_idx no_exist)
not used hint:
duplication hint:
error hint:

                              QUERY PLAN                               
-----------------------------------------------------------------------
 Append
   ->  Seq Scan on p2
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Index Scan using p2_c1_id_val_idx on p2_c1
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
   ->  Seq Scan on p2_c1_c1
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c1_c2
         Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
(10 rows)

/*+IndexScan(p2 p2_pkey p2_c1_id_val_idx no_exist)*/
EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
LOG:  available indexes for IndexScan(p2): p2_pkey
LOG:  available indexes for IndexScan(p2_c1): p2_c1_id_val_idx p2_c1_pkey
LOG:  available indexes for IndexScan(p2_c2): p2_c2_pkey
LOG:  available indexes for IndexScan(p2_c3): p2_c3_pkey
LOG:  available indexes for IndexScan(p2_c4): p2_c4_pkey
LOG:  available indexes for IndexScan(p2_c1_c1): p2_c1_c1_pkey
LOG:  available indexes for IndexScan(p2_c1_c2): p2_c1_c2_pkey
LOG:  available indexes for IndexScan(p2_c3_c1): p2_c3_c1_pkey
LOG:  available indexes for IndexScan(p2_c3_c2): p2_c3_c2_pkey
LOG:  pg_hint_plan:
used hint:
IndexScan(p2 p2_pkey p2_c1_id_val_idx no_exist)
not used hint:
duplication hint:
error hint:

                    QUERY PLAN                    
--------------------------------------------------
 Append
   ->  Index Scan using p2_pkey on p2
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p2_c1_id_val_idx on p2_c1
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p2_c1_c1_pkey on p2_c1_c1
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p2_c1_c2_pkey on p2_c1_c2
         Index Cond: ((id >= 50) AND (id <= 51))
         Filter: (ctid = '(1,1)'::tid)
(13 rows)

/*+IndexScan(p2 p2_val_idx)*/
EXPLAIN (COSTS false) SELECT val FROM p2 WHERE val >= '50' AND val <= '51' AND p2.ctid = '(1,1)';
LOG:  available indexes for IndexScan(p2): p2_val_idx
LOG:  available indexes for IndexScan(p2_c1): p2_c1_val_idx
LOG:  available indexes for IndexScan(p2_c2): p2_c2_val_idx
LOG:  available indexes for IndexScan(p2_c3): p2_c3_val_idx
LOG:  available indexes for IndexScan(p2_c4): p2_c4_val_idx
LOG:  available indexes for IndexScan(p2_c1_c1): p2_c1_c1_val_idx
LOG:  available indexes for IndexScan(p2_c1_c2): p2_c1_c2_val_idx
LOG:  available indexes for IndexScan(p2_c3_c1): p2_c3_c1_val_idx
LOG:  available indexes for IndexScan(p2_c3_c2): p2_c3_c2_val_idx
LOG:  pg_hint_plan:
used hint:
IndexScan(p2 p2_val_idx)
not used hint:
duplication hint:
error hint:

                            QUERY PLAN                             
-------------------------------------------------------------------
 Append
   ->  Index Scan using p2_val_idx on p2
         Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p2_c1_val_idx on p2_c1
         Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p2_c2_val_idx on p2_c2
         Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p2_c3_val_idx on p2_c3
         Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p2_c4_val_idx on p2_c4
         Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p2_c1_c1_val_idx on p2_c1_c1
         Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p2_c1_c2_val_idx on p2_c1_c2
         Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p2_c3_c1_val_idx on p2_c3_c1
         Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p2_c3_c2_val_idx on p2_c3_c2
         Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
         Filter: (ctid = '(1,1)'::tid)
(28 rows)

/*+IndexScan(p2 p2_expr)*/
EXPLAIN (COSTS false) SELECT val FROM p2 WHERE val >= '50' AND val <= '51' AND p2.ctid = '(1,1)';
LOG:  available indexes for IndexScan(p2): p2_expr
LOG:  available indexes for IndexScan(p2_c1): p2_c1_expr_idx
LOG:  available indexes for IndexScan(p2_c2): p2_c2_expr_idx
LOG:  available indexes for IndexScan(p2_c3): p2_c3_expr_idx
LOG:  available indexes for IndexScan(p2_c4): p2_c4_expr_idx
LOG:  available indexes for IndexScan(p2_c1_c1): p2_c1_c1_expr_idx
LOG:  available indexes for IndexScan(p2_c1_c2): p2_c1_c2_expr_idx
LOG:  available indexes for IndexScan(p2_c3_c1): p2_c3_c1_expr_idx
LOG:  available indexes for IndexScan(p2_c3_c2): p2_c3_c2_expr_idx
LOG:  pg_hint_plan:
used hint:
IndexScan(p2 p2_expr)
not used hint:
duplication hint:
error hint:

                                       QUERY PLAN                                        
-----------------------------------------------------------------------------------------
 Append
   ->  Seq Scan on p2
         Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c1
         Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c2
         Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c3
         Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c4
         Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c1_c1
         Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c1_c2
         Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c3_c1
         Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c3_c2
         Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
(19 rows)

/*+IndexScan(p2 p2_val_idx6)*/
EXPLAIN (COSTS false) SELECT val FROM p2 WHERE val >= '50' AND val <= '51' AND p2.ctid = '(1,1)';
LOG:  available indexes for IndexScan(p2): p2_val_idx6
LOG:  available indexes for IndexScan(p2_c1): p2_c1_val_idx6
LOG:  available indexes for IndexScan(p2_c2): p2_c2_val_idx6
LOG:  available indexes for IndexScan(p2_c3): p2_c3_val_idx6
LOG:  available indexes for IndexScan(p2_c4): p2_c4_val_idx6
LOG:  available indexes for IndexScan(p2_c1_c1): p2_c1_c1_val_idx6
LOG:  available indexes for IndexScan(p2_c1_c2): p2_c1_c2_val_idx6
LOG:  available indexes for IndexScan(p2_c3_c1): p2_c3_c1_val_idx6
LOG:  available indexes for IndexScan(p2_c3_c2): p2_c3_c2_val_idx6
LOG:  pg_hint_plan:
used hint:
IndexScan(p2 p2_val_idx6)
not used hint:
duplication hint:
error hint:

                                       QUERY PLAN                                        
-----------------------------------------------------------------------------------------
 Append
   ->  Seq Scan on p2
         Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c1
         Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c2
         Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c3
         Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c4
         Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c1_c1
         Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c1_c2
         Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c3_c1
         Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
   ->  Seq Scan on p2_c3_c2
         Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
(19 rows)

/*+IndexScan(p2 p2_val_idx p2_val_idx6)*/
EXPLAIN (COSTS false) SELECT val FROM p2 WHERE val >= '50' AND val <= '51' AND p2.ctid = '(1,1)';
LOG:  available indexes for IndexScan(p2): p2_val_idx6 p2_val_idx
LOG:  available indexes for IndexScan(p2_c1): p2_c1_val_idx6 p2_c1_val_idx
LOG:  available indexes for IndexScan(p2_c2): p2_c2_val_idx6 p2_c2_val_idx
LOG:  available indexes for IndexScan(p2_c3): p2_c3_val_idx6 p2_c3_val_idx
LOG:  available indexes for IndexScan(p2_c4): p2_c4_val_idx6 p2_c4_val_idx
LOG:  available indexes for IndexScan(p2_c1_c1): p2_c1_c1_val_idx6 p2_c1_c1_val_idx
LOG:  available indexes for IndexScan(p2_c1_c2): p2_c1_c2_val_idx6 p2_c1_c2_val_idx
LOG:  available indexes for IndexScan(p2_c3_c1): p2_c3_c1_val_idx6 p2_c3_c1_val_idx
LOG:  available indexes for IndexScan(p2_c3_c2): p2_c3_c2_val_idx6 p2_c3_c2_val_idx
LOG:  pg_hint_plan:
used hint:
IndexScan(p2 p2_val_idx p2_val_idx6)
not used hint:
duplication hint:
error hint:

                            QUERY PLAN                             
-------------------------------------------------------------------
 Append
   ->  Index Scan using p2_val_idx on p2
         Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p2_c1_val_idx on p2_c1
         Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p2_c2_val_idx on p2_c2
         Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p2_c3_val_idx on p2_c3
         Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p2_c4_val_idx on p2_c4
         Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p2_c1_c1_val_idx on p2_c1_c1
         Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p2_c1_c2_val_idx on p2_c1_c2
         Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p2_c3_c1_val_idx on p2_c3_c1
         Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
         Filter: (ctid = '(1,1)'::tid)
   ->  Index Scan using p2_c3_c2_val_idx on p2_c3_c2
         Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
         Filter: (ctid = '(1,1)'::tid)
(28 rows)

-- regular expression
-- ordinary table
EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
                                         QUERY PLAN                                          
---------------------------------------------------------------------------------------------
 Index Only Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
   Index Cond: (id = 1)
(2 rows)

/*+ IndexScanRegexp(t5 t5_[^i].*)*/
EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
LOG:  available indexes for IndexScanRegexp(t5): t5_val t5_pkey
LOG:  pg_hint_plan:
used hint:
IndexScanRegexp(t5 t5_[^i].*)
not used hint:
duplication hint:
error hint:

           QUERY PLAN           
--------------------------------
 Index Scan using t5_pkey on t5
   Index Cond: (id = 1)
(2 rows)

/*+ IndexScanRegexp(t5 t5_id[0-9].*)*/
EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
LOG:  available indexes for IndexScanRegexp(t5): t5_id3 t5_id2 t5_id1
LOG:  pg_hint_plan:
used hint:
IndexScanRegexp(t5 t5_id[0-9].*)
not used hint:
duplication hint:
error hint:

          QUERY PLAN           
-------------------------------
 Index Scan using t5_id3 on t5
   Index Cond: (id = 1)
(2 rows)

/*+ IndexScanRegexp(t5 t5[^_].*)*/
EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
LOG:  available indexes for IndexScanRegexp(t5):
LOG:  pg_hint_plan:
used hint:
IndexScanRegexp(t5 t5[^_].*)
not used hint:
duplication hint:
error hint:

     QUERY PLAN     
--------------------
 Seq Scan on t5
   Filter: (id = 1)
(2 rows)

/*+ IndexScanRegexp(t5 ^.*t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab)*/
EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
LOG:  available indexes for IndexScanRegexp(t5):
LOG:  pg_hint_plan:
used hint:
IndexScanRegexp(t5 ^.*t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab)
not used hint:
duplication hint:
error hint:

     QUERY PLAN     
--------------------
 Seq Scan on t5
   Filter: (id = 1)
(2 rows)

/*+ IndexScan(t5 t5_id[0-9].*)*/
EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
LOG:  available indexes for IndexScan(t5):
LOG:  pg_hint_plan:
used hint:
IndexScan(t5 t5_id[0-9].*)
not used hint:
duplication hint:
error hint:

     QUERY PLAN     
--------------------
 Seq Scan on t5
   Filter: (id = 1)
(2 rows)

/*+ IndexOnlyScanRegexp(t5 t5_[^i].*)*/
EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
LOG:  available indexes for IndexOnlyScanRegexp(t5): t5_val t5_pkey
LOG:  pg_hint_plan:
used hint:
IndexOnlyScanRegexp(t5 t5_[^i].*)
not used hint:
duplication hint:
error hint:

             QUERY PLAN              
-------------------------------------
 Index Only Scan using t5_pkey on t5
   Index Cond: (id = 1)
(2 rows)

/*+ IndexOnlyScanRegexp(t5 t5_id[0-9].*)*/
EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
LOG:  available indexes for IndexOnlyScanRegexp(t5): t5_id3 t5_id2 t5_id1
LOG:  pg_hint_plan:
used hint:
IndexOnlyScanRegexp(t5 t5_id[0-9].*)
not used hint:
duplication hint:
error hint:

             QUERY PLAN             
------------------------------------
 Index Only Scan using t5_id3 on t5
   Index Cond: (id = 1)
(2 rows)

/*+ IndexOnlyScanRegexp(t5 t5[^_].*)*/
EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
LOG:  available indexes for IndexOnlyScanRegexp(t5):
LOG:  pg_hint_plan:
used hint:
IndexOnlyScanRegexp(t5 t5[^_].*)
not used hint:
duplication hint:
error hint:

     QUERY PLAN     
--------------------
 Seq Scan on t5
   Filter: (id = 1)
(2 rows)

/*+ IndexOnlyScanRegexp(t5 ^.*t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab)*/
EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
LOG:  available indexes for IndexOnlyScanRegexp(t5):
LOG:  pg_hint_plan:
used hint:
IndexOnlyScanRegexp(t5 ^.*t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab)
not used hint:
duplication hint:
error hint:

     QUERY PLAN     
--------------------
 Seq Scan on t5
   Filter: (id = 1)
(2 rows)

/*+ IndexOnlyScan(t5 t5_id[0-9].*)*/
EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
LOG:  available indexes for IndexOnlyScan(t5):
LOG:  pg_hint_plan:
used hint:
IndexOnlyScan(t5 t5_id[0-9].*)
not used hint:
duplication hint:
error hint:

     QUERY PLAN     
--------------------
 Seq Scan on t5
   Filter: (id = 1)
(2 rows)

/*+ BitmapScanRegexp(t5 t5_[^i].*)*/
EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
LOG:  available indexes for BitmapScanRegexp(t5): t5_val t5_pkey
LOG:  pg_hint_plan:
used hint:
BitmapScanRegexp(t5 t5_[^i].*)
not used hint:
duplication hint:
error hint:

             QUERY PLAN             
------------------------------------
 Bitmap Heap Scan on t5
   Recheck Cond: (id = 1)
   ->  Bitmap Index Scan on t5_pkey
         Index Cond: (id = 1)
(4 rows)

/*+ BitmapScanRegexp(t5 t5_id[0-9].*)*/
EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
LOG:  available indexes for BitmapScanRegexp(t5): t5_id3 t5_id2 t5_id1
LOG:  pg_hint_plan:
used hint:
BitmapScanRegexp(t5 t5_id[0-9].*)
not used hint:
duplication hint:
error hint:

            QUERY PLAN             
-----------------------------------
 Bitmap Heap Scan on t5
   Recheck Cond: (id = 1)
   ->  Bitmap Index Scan on t5_id3
         Index Cond: (id = 1)
(4 rows)

/*+ BitmapScanRegexp(t5 t5[^_].*)*/
EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
LOG:  available indexes for BitmapScanRegexp(t5):
LOG:  pg_hint_plan:
used hint:
BitmapScanRegexp(t5 t5[^_].*)
not used hint:
duplication hint:
error hint:

     QUERY PLAN     
--------------------
 Seq Scan on t5
   Filter: (id = 1)
(2 rows)

/*+ BitmapScanRegexp(t5 ^.*t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab)*/
EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
LOG:  available indexes for BitmapScanRegexp(t5):
LOG:  pg_hint_plan:
used hint:
BitmapScanRegexp(t5 ^.*t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab)
not used hint:
duplication hint:
error hint:

     QUERY PLAN     
--------------------
 Seq Scan on t5
   Filter: (id = 1)
(2 rows)

/*+ BitmapScan(t5 t5_id[0-9].*)*/
EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
LOG:  available indexes for BitmapScan(t5):
LOG:  pg_hint_plan:
used hint:
BitmapScan(t5 t5_id[0-9].*)
not used hint:
duplication hint:
error hint:

     QUERY PLAN     
--------------------
 Seq Scan on t5
   Filter: (id = 1)
(2 rows)

-- Inheritance
EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
         QUERY PLAN         
----------------------------
 Append
   ->  Seq Scan on p1
         Filter: (val = 1)
   ->  Seq Scan on p1_c1
         Filter: (val = 1)
   ->  Seq Scan on p1_c2
         Filter: (val = 1)
   ->  Seq Scan on p1_c3
         Filter: (val = 1)
   ->  Seq Scan on p1_c4
         Filter: (val = 1)
   ->  Seq Scan on p1_c1_c1
         Filter: (val = 1)
   ->  Seq Scan on p1_c1_c2
         Filter: (val = 1)
   ->  Seq Scan on p1_c3_c1
         Filter: (val = 1)
   ->  Seq Scan on p1_c3_c2
         Filter: (val = 1)
(19 rows)

/*+ IndexScanRegexp(p1 p1_.*[^0-9]$)*/
EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
LOG:  available indexes for IndexScanRegexp(p1): p1_pkey
LOG:  available indexes for IndexScanRegexp(p1_c1): p1_c1_pkey
LOG:  available indexes for IndexScanRegexp(p1_c2): p1_c2_pkey
LOG:  available indexes for IndexScanRegexp(p1_c3): p1_c3_pkey
LOG:  available indexes for IndexScanRegexp(p1_c4): p1_c4_pkey
LOG:  available indexes for IndexScanRegexp(p1_c1_c1): p1_c1_c1_pkey
LOG:  available indexes for IndexScanRegexp(p1_c1_c2): p1_c1_c2_pkey
LOG:  available indexes for IndexScanRegexp(p1_c3_c1): p1_c3_c1_pkey
LOG:  available indexes for IndexScanRegexp(p1_c3_c2): p1_c3_c2_pkey
LOG:  pg_hint_plan:
used hint:
IndexScanRegexp(p1 p1_.*[^0-9]$)
not used hint:
duplication hint:
error hint:

         QUERY PLAN         
----------------------------
 Append
   ->  Seq Scan on p1
         Filter: (val = 1)
   ->  Seq Scan on p1_c1
         Filter: (val = 1)
   ->  Seq Scan on p1_c2
         Filter: (val = 1)
   ->  Seq Scan on p1_c3
         Filter: (val = 1)
   ->  Seq Scan on p1_c4
         Filter: (val = 1)
   ->  Seq Scan on p1_c1_c1
         Filter: (val = 1)
   ->  Seq Scan on p1_c1_c2
         Filter: (val = 1)
   ->  Seq Scan on p1_c3_c1
         Filter: (val = 1)
   ->  Seq Scan on p1_c3_c2
         Filter: (val = 1)
(19 rows)

/*+ IndexScanRegexp(p1 p1_.*val2.*)*/
EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
LOG:  available indexes for IndexScanRegexp(p1): p1_val2
LOG:  available indexes for IndexScanRegexp(p1_c1): p1_c1_val2
LOG:  available indexes for IndexScanRegexp(p1_c2): p1_c2_val2
LOG:  available indexes for IndexScanRegexp(p1_c3): p1_c3_val2
LOG:  available indexes for IndexScanRegexp(p1_c4): p1_c4_val2
LOG:  available indexes for IndexScanRegexp(p1_c1_c1): p1_c1_c1_val2
LOG:  available indexes for IndexScanRegexp(p1_c1_c2): p1_c1_c2_val2
LOG:  available indexes for IndexScanRegexp(p1_c3_c1): p1_c3_c1_val2
LOG:  available indexes for IndexScanRegexp(p1_c3_c2): p1_c3_c2_val2
LOG:  pg_hint_plan:
used hint:
IndexScanRegexp(p1 p1_.*val2.*)
not used hint:
duplication hint:
error hint:

                    QUERY PLAN                    
--------------------------------------------------
 Append
   ->  Index Scan using p1_val2 on p1
         Index Cond: (val = 1)
   ->  Index Scan using p1_c1_val2 on p1_c1
         Index Cond: (val = 1)
   ->  Index Scan using p1_c2_val2 on p1_c2
         Index Cond: (val = 1)
   ->  Index Scan using p1_c3_val2 on p1_c3
         Index Cond: (val = 1)
   ->  Index Scan using p1_c4_val2 on p1_c4
         Index Cond: (val = 1)
   ->  Index Scan using p1_c1_c1_val2 on p1_c1_c1
         Index Cond: (val = 1)
   ->  Index Scan using p1_c1_c2_val2 on p1_c1_c2
         Index Cond: (val = 1)
   ->  Index Scan using p1_c3_c1_val2 on p1_c3_c1
         Index Cond: (val = 1)
   ->  Index Scan using p1_c3_c2_val2 on p1_c3_c2
         Index Cond: (val = 1)
(19 rows)

/*+ IndexScanRegexp(p1 p1[^_].*)*/
EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
LOG:  available indexes for IndexScanRegexp(p1):
LOG:  available indexes for IndexScanRegexp(p1_c1):
LOG:  available indexes for IndexScanRegexp(p1_c2):
LOG:  available indexes for IndexScanRegexp(p1_c3):
LOG:  available indexes for IndexScanRegexp(p1_c4):
LOG:  available indexes for IndexScanRegexp(p1_c1_c1):
LOG:  available indexes for IndexScanRegexp(p1_c1_c2):
LOG:  available indexes for IndexScanRegexp(p1_c3_c1):
LOG:  available indexes for IndexScanRegexp(p1_c3_c2):
LOG:  pg_hint_plan:
used hint:
IndexScanRegexp(p1 p1[^_].*)
not used hint:
duplication hint:
error hint:

         QUERY PLAN         
----------------------------
 Append
   ->  Seq Scan on p1
         Filter: (val = 1)
   ->  Seq Scan on p1_c1
         Filter: (val = 1)
   ->  Seq Scan on p1_c2
         Filter: (val = 1)
   ->  Seq Scan on p1_c3
         Filter: (val = 1)
   ->  Seq Scan on p1_c4
         Filter: (val = 1)
   ->  Seq Scan on p1_c1_c1
         Filter: (val = 1)
   ->  Seq Scan on p1_c1_c2
         Filter: (val = 1)
   ->  Seq Scan on p1_c3_c1
         Filter: (val = 1)
   ->  Seq Scan on p1_c3_c2
         Filter: (val = 1)
(19 rows)

/*+ IndexScan(p1 p1_.*val2.*)*/
EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
LOG:  available indexes for IndexScan(p1):
LOG:  available indexes for IndexScan(p1_c1):
LOG:  available indexes for IndexScan(p1_c2):
LOG:  available indexes for IndexScan(p1_c3):
LOG:  available indexes for IndexScan(p1_c4):
LOG:  available indexes for IndexScan(p1_c1_c1):
LOG:  available indexes for IndexScan(p1_c1_c2):
LOG:  available indexes for IndexScan(p1_c3_c1):
LOG:  available indexes for IndexScan(p1_c3_c2):
LOG:  pg_hint_plan:
used hint:
IndexScan(p1 p1_.*val2.*)
not used hint:
duplication hint:
error hint:

         QUERY PLAN         
----------------------------
 Append
   ->  Seq Scan on p1
         Filter: (val = 1)
   ->  Seq Scan on p1_c1
         Filter: (val = 1)
   ->  Seq Scan on p1_c2
         Filter: (val = 1)
   ->  Seq Scan on p1_c3
         Filter: (val = 1)
   ->  Seq Scan on p1_c4
         Filter: (val = 1)
   ->  Seq Scan on p1_c1_c1
         Filter: (val = 1)
   ->  Seq Scan on p1_c1_c2
         Filter: (val = 1)
   ->  Seq Scan on p1_c3_c1
         Filter: (val = 1)
   ->  Seq Scan on p1_c3_c2
         Filter: (val = 1)
(19 rows)

/*+ IndexOnlyScanRegexp(p1 p1_.*[^0-9]$)*/
EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
LOG:  available indexes for IndexOnlyScanRegexp(p1): p1_pkey
LOG:  available indexes for IndexOnlyScanRegexp(p1_c1): p1_c1_pkey
LOG:  available indexes for IndexOnlyScanRegexp(p1_c2): p1_c2_pkey
LOG:  available indexes for IndexOnlyScanRegexp(p1_c3): p1_c3_pkey
LOG:  available indexes for IndexOnlyScanRegexp(p1_c4): p1_c4_pkey
LOG:  available indexes for IndexOnlyScanRegexp(p1_c1_c1): p1_c1_c1_pkey
LOG:  available indexes for IndexOnlyScanRegexp(p1_c1_c2): p1_c1_c2_pkey
LOG:  available indexes for IndexOnlyScanRegexp(p1_c3_c1): p1_c3_c1_pkey
LOG:  available indexes for IndexOnlyScanRegexp(p1_c3_c2): p1_c3_c2_pkey
LOG:  pg_hint_plan:
used hint:
IndexOnlyScanRegexp(p1 p1_.*[^0-9]$)
not used hint:
duplication hint:
error hint:

         QUERY PLAN         
----------------------------
 Append
   ->  Seq Scan on p1
         Filter: (val = 1)
   ->  Seq Scan on p1_c1
         Filter: (val = 1)
   ->  Seq Scan on p1_c2
         Filter: (val = 1)
   ->  Seq Scan on p1_c3
         Filter: (val = 1)
   ->  Seq Scan on p1_c4
         Filter: (val = 1)
   ->  Seq Scan on p1_c1_c1
         Filter: (val = 1)
   ->  Seq Scan on p1_c1_c2
         Filter: (val = 1)
   ->  Seq Scan on p1_c3_c1
         Filter: (val = 1)
   ->  Seq Scan on p1_c3_c2
         Filter: (val = 1)
(19 rows)

/*+ IndexOnlyScanRegexp(p1 p1_.*val2.*)*/
EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
LOG:  available indexes for IndexOnlyScanRegexp(p1): p1_val2
LOG:  available indexes for IndexOnlyScanRegexp(p1_c1): p1_c1_val2
LOG:  available indexes for IndexOnlyScanRegexp(p1_c2): p1_c2_val2
LOG:  available indexes for IndexOnlyScanRegexp(p1_c3): p1_c3_val2
LOG:  available indexes for IndexOnlyScanRegexp(p1_c4): p1_c4_val2
LOG:  available indexes for IndexOnlyScanRegexp(p1_c1_c1): p1_c1_c1_val2
LOG:  available indexes for IndexOnlyScanRegexp(p1_c1_c2): p1_c1_c2_val2
LOG:  available indexes for IndexOnlyScanRegexp(p1_c3_c1): p1_c3_c1_val2
LOG:  available indexes for IndexOnlyScanRegexp(p1_c3_c2): p1_c3_c2_val2
LOG:  pg_hint_plan:
used hint:
IndexOnlyScanRegexp(p1 p1_.*val2.*)
not used hint:
duplication hint:
error hint:

                      QUERY PLAN                       
-------------------------------------------------------
 Append
   ->  Index Only Scan using p1_val2 on p1
         Index Cond: (val = 1)
   ->  Index Only Scan using p1_c1_val2 on p1_c1
         Index Cond: (val = 1)
   ->  Index Only Scan using p1_c2_val2 on p1_c2
         Index Cond: (val = 1)
   ->  Index Only Scan using p1_c3_val2 on p1_c3
         Index Cond: (val = 1)
   ->  Index Only Scan using p1_c4_val2 on p1_c4
         Index Cond: (val = 1)
   ->  Index Only Scan using p1_c1_c1_val2 on p1_c1_c1
         Index Cond: (val = 1)
   ->  Index Only Scan using p1_c1_c2_val2 on p1_c1_c2
         Index Cond: (val = 1)
   ->  Index Only Scan using p1_c3_c1_val2 on p1_c3_c1
         Index Cond: (val = 1)
   ->  Index Only Scan using p1_c3_c2_val2 on p1_c3_c2
         Index Cond: (val = 1)
(19 rows)

/*+ IndexOnlyScanRegexp(p1 p1[^_].*)*/
EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
LOG:  available indexes for IndexOnlyScanRegexp(p1):
LOG:  available indexes for IndexOnlyScanRegexp(p1_c1):
LOG:  available indexes for IndexOnlyScanRegexp(p1_c2):
LOG:  available indexes for IndexOnlyScanRegexp(p1_c3):
LOG:  available indexes for IndexOnlyScanRegexp(p1_c4):
LOG:  available indexes for IndexOnlyScanRegexp(p1_c1_c1):
LOG:  available indexes for IndexOnlyScanRegexp(p1_c1_c2):
LOG:  available indexes for IndexOnlyScanRegexp(p1_c3_c1):
LOG:  available indexes for IndexOnlyScanRegexp(p1_c3_c2):
LOG:  pg_hint_plan:
used hint:
IndexOnlyScanRegexp(p1 p1[^_].*)
not used hint:
duplication hint:
error hint:

         QUERY PLAN         
----------------------------
 Append
   ->  Seq Scan on p1
         Filter: (val = 1)
   ->  Seq Scan on p1_c1
         Filter: (val = 1)
   ->  Seq Scan on p1_c2
         Filter: (val = 1)
   ->  Seq Scan on p1_c3
         Filter: (val = 1)
   ->  Seq Scan on p1_c4
         Filter: (val = 1)
   ->  Seq Scan on p1_c1_c1
         Filter: (val = 1)
   ->  Seq Scan on p1_c1_c2
         Filter: (val = 1)
   ->  Seq Scan on p1_c3_c1
         Filter: (val = 1)
   ->  Seq Scan on p1_c3_c2
         Filter: (val = 1)
(19 rows)

/*+ IndexOnlyScan(p1 p1_.*val2.*)*/
EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
LOG:  available indexes for IndexOnlyScan(p1):
LOG:  available indexes for IndexOnlyScan(p1_c1):
LOG:  available indexes for IndexOnlyScan(p1_c2):
LOG:  available indexes for IndexOnlyScan(p1_c3):
LOG:  available indexes for IndexOnlyScan(p1_c4):
LOG:  available indexes for IndexOnlyScan(p1_c1_c1):
LOG:  available indexes for IndexOnlyScan(p1_c1_c2):
LOG:  available indexes for IndexOnlyScan(p1_c3_c1):
LOG:  available indexes for IndexOnlyScan(p1_c3_c2):
LOG:  pg_hint_plan:
used hint:
IndexOnlyScan(p1 p1_.*val2.*)
not used hint:
duplication hint:
error hint:

         QUERY PLAN         
----------------------------
 Append
   ->  Seq Scan on p1
         Filter: (val = 1)
   ->  Seq Scan on p1_c1
         Filter: (val = 1)
   ->  Seq Scan on p1_c2
         Filter: (val = 1)
   ->  Seq Scan on p1_c3
         Filter: (val = 1)
   ->  Seq Scan on p1_c4
         Filter: (val = 1)
   ->  Seq Scan on p1_c1_c1
         Filter: (val = 1)
   ->  Seq Scan on p1_c1_c2
         Filter: (val = 1)
   ->  Seq Scan on p1_c3_c1
         Filter: (val = 1)
   ->  Seq Scan on p1_c3_c2
         Filter: (val = 1)
(19 rows)

/*+ BitmapScanRegexp(p1 p1_.*[^0-9]$)*/
EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
LOG:  available indexes for BitmapScanRegexp(p1): p1_pkey
LOG:  available indexes for BitmapScanRegexp(p1_c1): p1_c1_pkey
LOG:  available indexes for BitmapScanRegexp(p1_c2): p1_c2_pkey
LOG:  available indexes for BitmapScanRegexp(p1_c3): p1_c3_pkey
LOG:  available indexes for BitmapScanRegexp(p1_c4): p1_c4_pkey
LOG:  available indexes for BitmapScanRegexp(p1_c1_c1): p1_c1_c1_pkey
LOG:  available indexes for BitmapScanRegexp(p1_c1_c2): p1_c1_c2_pkey
LOG:  available indexes for BitmapScanRegexp(p1_c3_c1): p1_c3_c1_pkey
LOG:  available indexes for BitmapScanRegexp(p1_c3_c2): p1_c3_c2_pkey
LOG:  pg_hint_plan:
used hint:
BitmapScanRegexp(p1 p1_.*[^0-9]$)
not used hint:
duplication hint:
error hint:

         QUERY PLAN         
----------------------------
 Append
   ->  Seq Scan on p1
         Filter: (val = 1)
   ->  Seq Scan on p1_c1
         Filter: (val = 1)
   ->  Seq Scan on p1_c2
         Filter: (val = 1)
   ->  Seq Scan on p1_c3
         Filter: (val = 1)
   ->  Seq Scan on p1_c4
         Filter: (val = 1)
   ->  Seq Scan on p1_c1_c1
         Filter: (val = 1)
   ->  Seq Scan on p1_c1_c2
         Filter: (val = 1)
   ->  Seq Scan on p1_c3_c1
         Filter: (val = 1)
   ->  Seq Scan on p1_c3_c2
         Filter: (val = 1)
(19 rows)

/*+ BitmapScanRegexp(p1 p1_.*val2.*)*/
EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
LOG:  available indexes for BitmapScanRegexp(p1): p1_val2
LOG:  available indexes for BitmapScanRegexp(p1_c1): p1_c1_val2
LOG:  available indexes for BitmapScanRegexp(p1_c2): p1_c2_val2
LOG:  available indexes for BitmapScanRegexp(p1_c3): p1_c3_val2
LOG:  available indexes for BitmapScanRegexp(p1_c4): p1_c4_val2
LOG:  available indexes for BitmapScanRegexp(p1_c1_c1): p1_c1_c1_val2
LOG:  available indexes for BitmapScanRegexp(p1_c1_c2): p1_c1_c2_val2
LOG:  available indexes for BitmapScanRegexp(p1_c3_c1): p1_c3_c1_val2
LOG:  available indexes for BitmapScanRegexp(p1_c3_c2): p1_c3_c2_val2
LOG:  pg_hint_plan:
used hint:
BitmapScanRegexp(p1 p1_.*val2.*)
not used hint:
duplication hint:
error hint:

                   QUERY PLAN                   
------------------------------------------------
 Append
   ->  Bitmap Heap Scan on p1
         Recheck Cond: (val = 1)
         ->  Bitmap Index Scan on p1_val2
               Index Cond: (val = 1)
   ->  Bitmap Heap Scan on p1_c1
         Recheck Cond: (val = 1)
         ->  Bitmap Index Scan on p1_c1_val2
               Index Cond: (val = 1)
   ->  Bitmap Heap Scan on p1_c2
         Recheck Cond: (val = 1)
         ->  Bitmap Index Scan on p1_c2_val2
               Index Cond: (val = 1)
   ->  Bitmap Heap Scan on p1_c3
         Recheck Cond: (val = 1)
         ->  Bitmap Index Scan on p1_c3_val2
               Index Cond: (val = 1)
   ->  Bitmap Heap Scan on p1_c4
         Recheck Cond: (val = 1)
         ->  Bitmap Index Scan on p1_c4_val2
               Index Cond: (val = 1)
   ->  Bitmap Heap Scan on p1_c1_c1
         Recheck Cond: (val = 1)
         ->  Bitmap Index Scan on p1_c1_c1_val2
               Index Cond: (val = 1)
   ->  Bitmap Heap Scan on p1_c1_c2
         Recheck Cond: (val = 1)
         ->  Bitmap Index Scan on p1_c1_c2_val2
               Index Cond: (val = 1)
   ->  Bitmap Heap Scan on p1_c3_c1
         Recheck Cond: (val = 1)
         ->  Bitmap Index Scan on p1_c3_c1_val2
               Index Cond: (val = 1)
   ->  Bitmap Heap Scan on p1_c3_c2
         Recheck Cond: (val = 1)
         ->  Bitmap Index Scan on p1_c3_c2_val2
               Index Cond: (val = 1)
(37 rows)

/*+ BitmapScanRegexp(p1 p1[^_].*)*/
EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
LOG:  available indexes for BitmapScanRegexp(p1):
LOG:  available indexes for BitmapScanRegexp(p1_c1):
LOG:  available indexes for BitmapScanRegexp(p1_c2):
LOG:  available indexes for BitmapScanRegexp(p1_c3):
LOG:  available indexes for BitmapScanRegexp(p1_c4):
LOG:  available indexes for BitmapScanRegexp(p1_c1_c1):
LOG:  available indexes for BitmapScanRegexp(p1_c1_c2):
LOG:  available indexes for BitmapScanRegexp(p1_c3_c1):
LOG:  available indexes for BitmapScanRegexp(p1_c3_c2):
LOG:  pg_hint_plan:
used hint:
BitmapScanRegexp(p1 p1[^_].*)
not used hint:
duplication hint:
error hint:

         QUERY PLAN         
----------------------------
 Append
   ->  Seq Scan on p1
         Filter: (val = 1)
   ->  Seq Scan on p1_c1
         Filter: (val = 1)
   ->  Seq Scan on p1_c2
         Filter: (val = 1)
   ->  Seq Scan on p1_c3
         Filter: (val = 1)
   ->  Seq Scan on p1_c4
         Filter: (val = 1)
   ->  Seq Scan on p1_c1_c1
         Filter: (val = 1)
   ->  Seq Scan on p1_c1_c2
         Filter: (val = 1)
   ->  Seq Scan on p1_c3_c1
         Filter: (val = 1)
   ->  Seq Scan on p1_c3_c2
         Filter: (val = 1)
(19 rows)

/*+ BitmapScan(p1 p1_.*val2.*)*/
EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
LOG:  available indexes for BitmapScan(p1):
LOG:  available indexes for BitmapScan(p1_c1):
LOG:  available indexes for BitmapScan(p1_c2):
LOG:  available indexes for BitmapScan(p1_c3):
LOG:  available indexes for BitmapScan(p1_c4):
LOG:  available indexes for BitmapScan(p1_c1_c1):
LOG:  available indexes for BitmapScan(p1_c1_c2):
LOG:  available indexes for BitmapScan(p1_c3_c1):
LOG:  available indexes for BitmapScan(p1_c3_c2):
LOG:  pg_hint_plan:
used hint:
BitmapScan(p1 p1_.*val2.*)
not used hint:
duplication hint:
error hint:

         QUERY PLAN         
----------------------------
 Append
   ->  Seq Scan on p1
         Filter: (val = 1)
   ->  Seq Scan on p1_c1
         Filter: (val = 1)
   ->  Seq Scan on p1_c2
         Filter: (val = 1)
   ->  Seq Scan on p1_c3
         Filter: (val = 1)
   ->  Seq Scan on p1_c4
         Filter: (val = 1)
   ->  Seq Scan on p1_c1_c1
         Filter: (val = 1)
   ->  Seq Scan on p1_c1_c2
         Filter: (val = 1)
   ->  Seq Scan on p1_c3_c1
         Filter: (val = 1)
   ->  Seq Scan on p1_c3_c2
         Filter: (val = 1)
(19 rows)

-- search from hint table
INSERT INTO hint_plan.hints (norm_query_string, application_name, hints) VALUES ('EXPLAIN (COSTS false) SELECT * FROM t1 WHERE t1.id = ?;', '', 'SeqScan(t1)');
INSERT INTO hint_plan.hints (norm_query_string, application_name, hints) VALUES ('EXPLAIN (COSTS false) SELECT id FROM t1 WHERE t1.id = ?;', '', 'IndexScan(t1)');
INSERT INTO hint_plan.hints (norm_query_string, application_name, hints) VALUES ('EXPLAIN SELECT * FROM t1 WHERE t1.id = ?;', '', 'BitmapScan(t1)');
SELECT * FROM hint_plan.hints ORDER BY id;
 id |                    norm_query_string                     | application_name |     hints      
----+----------------------------------------------------------+------------------+----------------
  1 | EXPLAIN (COSTS false) SELECT * FROM t1 WHERE t1.id = ?;  |                  | SeqScan(t1)
  2 | EXPLAIN (COSTS false) SELECT id FROM t1 WHERE t1.id = ?; |                  | IndexScan(t1)
  3 | EXPLAIN SELECT * FROM t1 WHERE t1.id = ?;                |                  | BitmapScan(t1)
(3 rows)

SET pg_hint_plan.enable_hint_table = on;
EXPLAIN (COSTS false) SELECT * FROM t1 WHERE t1.id = 1;
LOG:  pg_hint_plan:
used hint:
SeqScan(t1)
not used hint:
duplication hint:
error hint:

     QUERY PLAN     
--------------------
 Seq Scan on t1
   Filter: (id = 1)
(2 rows)

SET pg_hint_plan.enable_hint_table = off;
EXPLAIN (COSTS false) SELECT * FROM t1 WHERE t1.id = 1;
           QUERY PLAN           
--------------------------------
 Index Scan using t1_pkey on t1
   Index Cond: (id = 1)
(2 rows)

TRUNCATE hint_plan.hints;
VACUUM ANALYZE hint_plan.hints;
-- plpgsql test
EXPLAIN (COSTS false) SELECT id FROM t1 WHERE t1.id = 1;
             QUERY PLAN              
-------------------------------------
 Index Only Scan using t1_pkey on t1
   Index Cond: (id = 1)
(2 rows)

-- static function
CREATE FUNCTION testfunc() RETURNS RECORD AS $$
DECLARE
  ret record;
BEGIN
  SELECT /*+ SeqScan(t1) */ * INTO ret FROM t1 LIMIT 1;
  RETURN ret;
END;
$$ LANGUAGE plpgsql;
SELECT testfunc();
LOG:  pg_hint_plan:
used hint:
SeqScan(t1)
not used hint:
duplication hint:
error hint:

CONTEXT:  SQL statement "SELECT /*+ SeqScan(t1) */ *          FROM t1 LIMIT 1"
PL/pgSQL function testfunc() line 5 at SQL statement
 testfunc 
----------
 (1,1)
(1 row)

-- dynamic function
DROP FUNCTION testfunc();
CREATE FUNCTION testfunc() RETURNS void AS $$
BEGIN
  EXECUTE format('/*+ SeqScan(t1) */ SELECT * FROM t1');
END;
$$ LANGUAGE plpgsql;
SELECT testfunc();
LOG:  pg_hint_plan:
used hint:
SeqScan(t1)
not used hint:
duplication hint:
error hint:

CONTEXT:  SQL statement "/*+ SeqScan(t1) */ SELECT * FROM t1"
PL/pgSQL function testfunc() line 3 at EXECUTE statement
 testfunc 
----------
 
(1 row)

-- This should not use SeqScan(t1)
/*+ IndexScan(t1) */ SELECT * from t1 LIMIT 1;
LOG:  pg_hint_plan:
used hint:
IndexScan(t1)
not used hint:
duplication hint:
error hint:

 id | val 
----+-----
  1 |   1
(1 row)

-- Perform
DROP FUNCTION testfunc();
CREATE FUNCTION testfunc() RETURNS void AS $$
BEGIN
  PERFORM  1, /*+ SeqScan(t1) */ * from t1;
END;
$$ LANGUAGE plpgsql;
SELECT testfunc();
LOG:  pg_hint_plan:
used hint:
SeqScan(t1)
not used hint:
duplication hint:
error hint:

CONTEXT:  SQL statement "SELECT 1, /*+ SeqScan(t1) */ * from t1"
PL/pgSQL function testfunc() line 3 at PERFORM
 testfunc 
----------
 
(1 row)

-- FOR loop
DROP FUNCTION testfunc();
CREATE FUNCTION testfunc() RETURNS int AS $$
DECLARE
  sum int;
  v int;
BEGIN
  sum := 0;
  FOR v IN SELECT /*+ SeqScan(t1) */ v FROM t1 ORDER BY id LOOP
    sum := sum + v;
  END LOOP;
  RETURN v;
END;
$$ LANGUAGE plpgsql;
SELECT testfunc();
LOG:  pg_hint_plan:
used hint:
SeqScan(t1)
not used hint:
duplication hint:
error hint:

CONTEXT:  SQL statement "SELECT /*+ SeqScan(t1) */ v FROM t1 ORDER BY id"
PL/pgSQL function testfunc() line 7 at FOR over SELECT rows
 testfunc 
----------
         
(1 row)

-- Dynamic FOR loop
DROP FUNCTION testfunc();
CREATE FUNCTION testfunc() RETURNS int AS $$
DECLARE
  sum int;
  v int;
  i   int;
BEGIN
  sum := 0;
  FOR v IN EXECUTE 'SELECT /*+ SeqScan(t1) */ val FROM t1 ORDER BY id' LOOP
    sum := sum + v;
  END LOOP;
  RETURN v;
END;
$$ LANGUAGE plpgsql;
SELECT testfunc();
LOG:  pg_hint_plan:
used hint:
SeqScan(t1)
not used hint:
duplication hint:
error hint:

CONTEXT:  SQL statement "SELECT /*+ SeqScan(t1) */ val FROM t1 ORDER BY id"
PL/pgSQL function testfunc() line 8 at FOR over EXECUTE statement
 testfunc 
----------
        0
(1 row)

-- Cursor FOR loop
DROP FUNCTION testfunc();
CREATE FUNCTION testfunc() RETURNS int AS $$
DECLARE
  ref CURSOR FOR SELECT /*+ SeqScan(t1) */ * FROM t1 ORDER BY id;
  rec record;
  sum int := 0;
BEGIN
  FOR rec IN ref LOOP
    sum := sum + rec.val;
  END LOOP;
  RETURN sum;
END;
$$ LANGUAGE plpgsql;
SELECT testfunc();
LOG:  pg_hint_plan:
used hint:
SeqScan(t1)
not used hint:
duplication hint:
error hint:

CONTEXT:  SQL statement "SELECT /*+ SeqScan(t1) */ * FROM t1 ORDER BY id"
PL/pgSQL function testfunc() line 7 at FOR over cursor
 testfunc 
----------
   495000
(1 row)

-- RETURN QUERY
DROP FUNCTION testfunc();
CREATE FUNCTION testfunc() RETURNS SETOF t1 AS $$
BEGIN
  RETURN QUERY SELECT /*+ SeqScan(t1) */ * FROM t1 ORDER BY id;
END;
$$ LANGUAGE plpgsql;
SELECT * FROM testfunc() LIMIT 1;
LOG:  pg_hint_plan:
used hint:
SeqScan(t1)
not used hint:
duplication hint:
error hint:

CONTEXT:  SQL statement "SELECT /*+ SeqScan(t1) */ * FROM t1 ORDER BY id"
PL/pgSQL function testfunc() line 3 at RETURN QUERY
 id | val 
----+-----
  1 |   1
(1 row)

-- Test for error exit from inner SQL statement.
DROP FUNCTION testfunc();
CREATE FUNCTION testfunc() RETURNS SETOF t1 AS $$
BEGIN
  RETURN QUERY SELECT /*+ SeqScan(t1) */ * FROM ttx ORDER BY id;
END;
$$ LANGUAGE plpgsql;
SELECT * FROM testfunc() LIMIT 1;
ERROR:  relation "ttx" does not exist
LINE 1: SELECT /*+ SeqScan(t1) */ * FROM ttx ORDER BY id
                                         ^
QUERY:  SELECT /*+ SeqScan(t1) */ * FROM ttx ORDER BY id
CONTEXT:  PL/pgSQL function testfunc() line 3 at RETURN QUERY
-- this should not use SeqScan(t1) hint.
/*+ IndexScan(t1) */ SELECT * from t1 LIMIT 1;
LOG:  pg_hint_plan:
used hint:
IndexScan(t1)
not used hint:
duplication hint:
error hint:

 id | val 
----+-----
  1 |   1
(1 row)

DROP FUNCTION testfunc();
DROP EXTENSION pg_hint_plan;
--
-- Rows hint tests
--
-- Explain result includes "Planning time" if COSTS is enabled, but
-- this test needs it enabled for get rows count. So do tests via psql
-- and grep -v the mutable line.
-- value types
\o results/pg_hint_plan.tmpout
EXPLAIN SELECT * FROM t1 JOIN t2 ON (t1.id = t2.id);
\o
\! sql/maskout.sh results/pg_hint_plan.tmpout
                                  QUERY PLAN                                  
------------------------------------------------------------------------------
 Merge Join  (cost=xxx rows=1000 width=xxx)
   Merge Cond: (t1.id = t2.id)
   ->  Index Scan using t1_pkey on t1  (cost=xxx rows=10000 width=xxx)
   ->  Index Scan using t2_pkey on t2  (cost=xxx rows=1000 width=xxx)
(4 rows)

\o results/pg_hint_plan.tmpout
/*+ Rows(t1 t2 #99) */
EXPLAIN SELECT * FROM t1 JOIN t2 ON (t1.id = t2.id);
LOG:  pg_hint_plan:
used hint:
Rows(t1 t2 #99)
not used hint:
duplication hint:
error hint:

\o
\! sql/maskout.sh results/pg_hint_plan.tmpout
                                  QUERY PLAN                                  
------------------------------------------------------------------------------
 Merge Join  (cost=xxx rows=99 width=xxx)
   Merge Cond: (t1.id = t2.id)
   ->  Index Scan using t1_pkey on t1  (cost=xxx rows=10000 width=xxx)
   ->  Index Scan using t2_pkey on t2  (cost=xxx rows=1000 width=xxx)
(4 rows)

\o results/pg_hint_plan.tmpout
/*+ Rows(t1 t2 +99) */
EXPLAIN SELECT * FROM t1 JOIN t2 ON (t1.id = t2.id);
LOG:  pg_hint_plan:
used hint:
Rows(t1 t2 +99)
not used hint:
duplication hint:
error hint:

\o
\! sql/maskout.sh results/pg_hint_plan.tmpout
                                  QUERY PLAN                                  
------------------------------------------------------------------------------
 Merge Join  (cost=xxx rows=1099 width=xxx)
   Merge Cond: (t1.id = t2.id)
   ->  Index Scan using t1_pkey on t1  (cost=xxx rows=10000 width=xxx)
   ->  Index Scan using t2_pkey on t2  (cost=xxx rows=1000 width=xxx)
(4 rows)

\o results/pg_hint_plan.tmpout
/*+ Rows(t1 t2 -99) */
EXPLAIN SELECT * FROM t1 JOIN t2 ON (t1.id = t2.id);
LOG:  pg_hint_plan:
used hint:
Rows(t1 t2 -99)
not used hint:
duplication hint:
error hint:

\o
\! sql/maskout.sh results/pg_hint_plan.tmpout
                                  QUERY PLAN                                  
------------------------------------------------------------------------------
 Merge Join  (cost=xxx rows=901 width=xxx)
   Merge Cond: (t1.id = t2.id)
   ->  Index Scan using t1_pkey on t1  (cost=xxx rows=10000 width=xxx)
   ->  Index Scan using t2_pkey on t2  (cost=xxx rows=1000 width=xxx)
(4 rows)

\o results/pg_hint_plan.tmpout
/*+ Rows(t1 t2 *99) */
EXPLAIN SELECT * FROM t1 JOIN t2 ON (t1.id = t2.id);
LOG:  pg_hint_plan:
used hint:
Rows(t1 t2 *99)
not used hint:
duplication hint:
error hint:

\o
\! sql/maskout.sh results/pg_hint_plan.tmpout
                                  QUERY PLAN                                  
------------------------------------------------------------------------------
 Merge Join  (cost=xxx rows=99000 width=xxx)
   Merge Cond: (t1.id = t2.id)
   ->  Index Scan using t1_pkey on t1  (cost=xxx rows=10000 width=xxx)
   ->  Index Scan using t2_pkey on t2  (cost=xxx rows=1000 width=xxx)
(4 rows)

\o results/pg_hint_plan.tmpout
/*+ Rows(t1 t2 *0.01) */
EXPLAIN SELECT * FROM t1 JOIN t2 ON (t1.id = t2.id);
LOG:  pg_hint_plan:
used hint:
Rows(t1 t2 *0.01)
not used hint:
duplication hint:
error hint:

\o
\! sql/maskout.sh results/pg_hint_plan.tmpout
                                  QUERY PLAN                                  
------------------------------------------------------------------------------
 Merge Join  (cost=xxx rows=10 width=xxx)
   Merge Cond: (t1.id = t2.id)
   ->  Index Scan using t1_pkey on t1  (cost=xxx rows=10000 width=xxx)
   ->  Index Scan using t2_pkey on t2  (cost=xxx rows=1000 width=xxx)
(4 rows)

\o results/pg_hint_plan.tmpout
/*+ Rows(t1 t2 #aa) */
EXPLAIN SELECT * FROM t1 JOIN t2 ON (t1.id = t2.id); -- ERROR
INFO:  pg_hint_plan: hint syntax error at or near "aa"
DETAIL:  Rows hint requires valid number as rows estimation.
LOG:  pg_hint_plan:
used hint:
not used hint:
duplication hint:
error hint:
Rows(t1 t2 #aa)

\o
\! sql/maskout.sh results/pg_hint_plan.tmpout
                                  QUERY PLAN                                  
------------------------------------------------------------------------------
 Merge Join  (cost=xxx rows=1000 width=xxx)
   Merge Cond: (t1.id = t2.id)
   ->  Index Scan using t1_pkey on t1  (cost=xxx rows=10000 width=xxx)
   ->  Index Scan using t2_pkey on t2  (cost=xxx rows=1000 width=xxx)
(4 rows)

\o results/pg_hint_plan.tmpout
/*+ Rows(t1 t2 /99) */
EXPLAIN SELECT * FROM t1 JOIN t2 ON (t1.id = t2.id); -- ERROR
INFO:  pg_hint_plan: hint syntax error at or near "/99"
DETAIL:  Unrecognized rows value type notation.
LOG:  pg_hint_plan:
used hint:
not used hint:
duplication hint:
error hint:
Rows(t1 t2 /99)

\o
\! sql/maskout.sh results/pg_hint_plan.tmpout
                                  QUERY PLAN                                  
------------------------------------------------------------------------------
 Merge Join  (cost=xxx rows=1000 width=xxx)
   Merge Cond: (t1.id = t2.id)
   ->  Index Scan using t1_pkey on t1  (cost=xxx rows=10000 width=xxx)
   ->  Index Scan using t2_pkey on t2  (cost=xxx rows=1000 width=xxx)
(4 rows)

-- round up to 1
\o results/pg_hint_plan.tmpout
/*+ Rows(t1 t2 -99999) */
EXPLAIN SELECT * FROM t1 JOIN t2 ON (t1.id = t2.id);
WARNING:  Force estimate to be at least one row, to avoid possible divide-by-zero when interpolating costs : Rows(t1 t2 -99999) 
LOG:  pg_hint_plan:
used hint:
Rows(t1 t2 -99999)
not used hint:
duplication hint:
error hint:

\o
\! sql/maskout.sh results/pg_hint_plan.tmpout
                                  QUERY PLAN                                  
------------------------------------------------------------------------------
 Merge Join  (cost=xxx rows=1 width=xxx)
   Merge Cond: (t1.id = t2.id)
   ->  Index Scan using t1_pkey on t1  (cost=xxx rows=10000 width=xxx)
   ->  Index Scan using t2_pkey on t2  (cost=xxx rows=1000 width=xxx)
(4 rows)

-- complex join tree
\o results/pg_hint_plan.tmpout
EXPLAIN SELECT * FROM t1 JOIN t2 ON (t1.id = t2.id) JOIN t3 ON (t3.id = t2.id);
\o
\! sql/maskout.sh results/pg_hint_plan.tmpout
                                     QUERY PLAN                                     
------------------------------------------------------------------------------------
 Merge Join  (cost=xxx rows=10 width=xxx)
   Merge Cond: (t1.id = t3.id)
   ->  Merge Join  (cost=xxx rows=1000 width=xxx)
         Merge Cond: (t1.id = t2.id)
         ->  Index Scan using t1_pkey on t1  (cost=xxx rows=10000 width=xxx)
         ->  Index Scan using t2_pkey on t2  (cost=xxx rows=1000 width=xxx)
   ->  Sort  (cost=xxx rows=100 width=xxx)
         Sort Key: t3.id
         ->  Seq Scan on t3  (cost=xxx rows=100 width=xxx)
(9 rows)

\o results/pg_hint_plan.tmpout
/*+ Rows(t1 t2 #22) */
EXPLAIN SELECT * FROM t1 JOIN t2 ON (t1.id = t2.id) JOIN t3 ON (t3.id = t2.id);
LOG:  pg_hint_plan:
used hint:
Rows(t1 t2 #22)
not used hint:
duplication hint:
error hint:

\o
\! sql/maskout.sh results/pg_hint_plan.tmpout
                                     QUERY PLAN                                     
------------------------------------------------------------------------------------
 Merge Join  (cost=xxx rows=1 width=xxx)
   Merge Cond: (t1.id = t3.id)
   ->  Merge Join  (cost=xxx rows=22 width=xxx)
         Merge Cond: (t1.id = t2.id)
         ->  Index Scan using t1_pkey on t1  (cost=xxx rows=10000 width=xxx)
         ->  Index Scan using t2_pkey on t2  (cost=xxx rows=1000 width=xxx)
   ->  Sort  (cost=xxx rows=100 width=xxx)
         Sort Key: t3.id
         ->  Seq Scan on t3  (cost=xxx rows=100 width=xxx)
(9 rows)

\o results/pg_hint_plan.tmpout
/*+ Rows(t1 t3 *10) */
EXPLAIN SELECT * FROM t1 JOIN t2 ON (t1.id = t2.id) JOIN t3 ON (t3.id = t2.id);
LOG:  pg_hint_plan:
used hint:
Rows(t1 t3 *10)
not used hint:
duplication hint:
error hint:

\o
\! sql/maskout.sh results/pg_hint_plan.tmpout
                                     QUERY PLAN                                     
------------------------------------------------------------------------------------
 Merge Join  (cost=xxx rows=100 width=xxx)
   Merge Cond: (t1.id = t3.id)
   ->  Merge Join  (cost=xxx rows=1000 width=xxx)
         Merge Cond: (t1.id = t2.id)
         ->  Index Scan using t1_pkey on t1  (cost=xxx rows=10000 width=xxx)
         ->  Index Scan using t2_pkey on t2  (cost=xxx rows=1000 width=xxx)
   ->  Sort  (cost=xxx rows=100 width=xxx)
         Sort Key: t3.id
         ->  Seq Scan on t3  (cost=xxx rows=100 width=xxx)
(9 rows)

\! rm results/pg_hint_plan.tmpout
