1 SET search_path TO public;
2 SET client_min_messages TO log;
3 \set SHOW_CONTEXT always
4 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
6 --------------------------------------
8 Merge Cond: (t1.id = t2.id)
9 -> Index Scan using t1_pkey on t1
10 -> Index Scan using t2_pkey on t2
13 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.val = t2.val;
15 -------------------------------------------
17 Merge Cond: (t2.val = t1.val)
18 -> Index Scan using t2_val on t2
20 -> Index Scan using t1_val on t1
24 SET pg_hint_plan.debug_print TO on;
25 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
27 --------------------------------------
29 Merge Cond: (t1.id = t2.id)
30 -> Index Scan using t1_pkey on t1
31 -> Index Scan using t2_pkey on t2
34 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.val = t2.val;
36 -------------------------------------------
38 Merge Cond: (t2.val = t1.val)
39 -> Index Scan using t2_val on t2
41 -> Index Scan using t1_val on t1
45 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
46 INFO: pg_hint_plan: hint syntax error at or near "Test (t1 t2) "
47 DETAIL: Unrecognized hint keyword "Test".
49 --------------------------------------
51 Merge Cond: (t1.id = t2.id)
52 -> Index Scan using t1_pkey on t1
53 -> Index Scan using t2_pkey on t2
56 SET pg_hint_plan.enable_hint TO off;
58 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
60 --------------------------------------
62 Merge Cond: (t1.id = t2.id)
63 -> Index Scan using t1_pkey on t1
64 -> Index Scan using t2_pkey on t2
67 SET pg_hint_plan.enable_hint TO on;
68 /*Set(enable_indexscan off)*/
69 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
71 --------------------------------------
73 Merge Cond: (t1.id = t2.id)
74 -> Index Scan using t1_pkey on t1
75 -> Index Scan using t2_pkey on t2
78 --+Set(enable_indexscan off)
79 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
81 --------------------------------------
83 Merge Cond: (t1.id = t2.id)
84 -> Index Scan using t1_pkey on t1
85 -> Index Scan using t2_pkey on t2
88 /*+Set(enable_indexscan off) /* nest comment */ */
89 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
90 INFO: pg_hint_plan: hint syntax error at or near "/* nest comment */ */
91 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;"
92 DETAIL: Nested block comments are not supported.
94 --------------------------------------
96 Merge Cond: (t1.id = t2.id)
97 -> Index Scan using t1_pkey on t1
98 -> Index Scan using t2_pkey on t2
101 /*+Set(enable_indexscan off)*/
102 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
105 Set(enable_indexscan off)
111 ------------------------------
113 Hash Cond: (t1.id = t2.id)
119 EXPLAIN (COSTS false) /*+Set(enable_indexscan off)*/
120 SELECT * FROM t1, t2 WHERE t1.id = t2.id;
123 Set(enable_indexscan off)
129 ------------------------------
131 Hash Cond: (t1.id = t2.id)
137 /*+ Set(enable_indexscan off) Set(enable_hashjoin off) */
138 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
141 Set(enable_hashjoin off)
142 Set(enable_indexscan off)
148 -------------------------------
150 Merge Cond: (t1.id = t2.id)
159 /*+ Set ( enable_indexscan off ) */
160 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
163 Set(enable_indexscan off)
169 ------------------------------
171 Hash Cond: (t1.id = t2.id)
184 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
187 Set(enable_indexscan off)
193 ------------------------------
195 Hash Cond: (t1.id = t2.id)
201 /*+ Set(enable_indexscan off)Set(enable_nestloop off)Set(enable_mergejoin off)
202 Set(enable_seqscan off)
204 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
207 Set(enable_indexscan off)
208 Set(enable_mergejoin off)
209 Set(enable_nestloop off)
210 Set(enable_seqscan off)
216 --------------------------------------------
218 Hash Cond: (t1.id = t2.id)
219 -> Index Scan using t1_pkey on t1
221 -> Index Scan using t2_pkey on t2
224 /*+Set(work_mem "1M")*/
225 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
226 INFO: invalid value for parameter "work_mem": "1M"
227 HINT: Valid units for this parameter are "kB", "MB", "GB", and "TB".
236 --------------------------------------
238 Merge Cond: (t1.id = t2.id)
239 -> Index Scan using t1_pkey on t1
240 -> Index Scan using t2_pkey on t2
243 /*+Set(work_mem "1MB")*/
244 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
253 --------------------------------------
255 Merge Cond: (t1.id = t2.id)
256 -> Index Scan using t1_pkey on t1
257 -> Index Scan using t2_pkey on t2
260 /*+Set(work_mem TO "1MB")*/
261 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
262 INFO: pg_hint_plan: hint syntax error at or near "Set(work_mem TO "1MB")"
263 DETAIL: Set hint requires name and value of GUC parameter.
272 --------------------------------------
274 Merge Cond: (t1.id = t2.id)
275 -> Index Scan using t1_pkey on t1
276 -> Index Scan using t2_pkey on t2
280 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
281 INFO: pg_hint_plan: hint syntax error at or near ""
282 DETAIL: SeqScan hint accepts only one relation.
291 --------------------------------------
293 Merge Cond: (t1.id = t2.id)
294 -> Index Scan using t1_pkey on t1
295 -> Index Scan using t2_pkey on t2
299 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
308 ------------------------------
310 Hash Cond: (t1.id = t2.id)
316 /*+SeqScan(t1)IndexScan(t2)*/
317 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
327 --------------------------------------------
329 Hash Cond: (t1.id = t2.id)
332 -> Index Scan using t2_pkey on t2
336 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
345 ------------------------------------------
348 -> Bitmap Heap Scan on t2
349 Recheck Cond: (id = t1.id)
350 -> Bitmap Index Scan on t2_pkey
351 Index Cond: (id = t1.id)
354 /*+BitmapScan(t2)NoSeqScan(t1)*/
355 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
365 ------------------------------------------
367 -> Index Scan using t1_pkey on t1
368 -> Bitmap Heap Scan on t2
369 Recheck Cond: (id = t1.id)
370 -> Bitmap Index Scan on t2_pkey
371 Index Cond: (id = t1.id)
375 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
384 ------------------------------
386 Hash Cond: (t1.id = t2.id)
392 /*+NoBitmapScan(t1)*/
393 EXPLAIN (COSTS false) SELECT * FROM t1, t4 WHERE t1.val < 10;
402 ----------------------------
411 EXPLAIN (COSTS false) SELECT * FROM t3, t4 WHERE t3.id = t4.id AND t4.ctid = '(1,1)';
420 -----------------------------------------------
422 Merge Cond: (t3.id = t4.id)
423 -> Index Scan using t3_pkey on t3
427 TID Cond: (ctid = '(1,1)'::tid)
431 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)';
440 ---------------------------------------
443 Filter: (ctid = '(1,1)'::tid)
444 -> Index Scan using t2_pkey on t2
445 Index Cond: (id = t1.id)
449 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
458 ------------------------------
460 Hash Cond: (t1.id = t2.id)
467 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
476 --------------------------------------
479 -> Index Scan using t1_pkey on t1
480 Index Cond: (id = t2.id)
483 /*+NoMergeJoin(t1 t2)*/
484 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
493 ------------------------------
495 Hash Cond: (t1.id = t2.id)
501 /*+MergeJoin(t1 t3)*/
502 EXPLAIN (COSTS false) SELECT * FROM t1, t3 WHERE t1.val = t3.val;
511 -------------------------------------
513 Merge Cond: (t1.val = t3.val)
514 -> Index Scan using t1_val on t1
521 EXPLAIN (COSTS false) SELECT * FROM t1, t3 WHERE t1.val = t3.val;
530 -------------------------------------
533 -> Index Scan using t1_val on t1
534 Index Cond: (val = t3.val)
537 /*+NoHashJoin(t1 t3)*/
538 EXPLAIN (COSTS false) SELECT * FROM t1, t3 WHERE t1.val = t3.val;
547 -------------------------------------
550 -> Index Scan using t1_val on t1
551 Index Cond: (val = t3.val)
554 /*+MergeJoin(t4 t1 t2 t3)*/
555 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id;
558 MergeJoin(t1 t2 t3 t4)
564 --------------------------------------------------
566 Merge Cond: (t1.id = t3.id)
568 Merge Cond: (t1.id = t2.id)
569 -> Index Scan using t1_pkey on t1
570 -> Index Scan using t2_pkey on t2
573 Merge Cond: (t3.id = t4.id)
574 -> Index Scan using t3_pkey on t3
580 /*+HashJoin(t3 t4 t1 t2)*/
581 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id;
584 HashJoin(t1 t2 t3 t4)
590 --------------------------------------------------------
592 Hash Cond: (t3.id = t1.id)
596 Merge Cond: (t1.id = t4.id)
598 Merge Cond: (t1.id = t2.id)
599 -> Index Scan using t1_pkey on t1
600 -> Index Scan using t2_pkey on t2
606 /*+NestLoop(t2 t3 t4 t1) IndexScan(t3)*/
607 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id;
611 NestLoop(t1 t2 t3 t4)
617 --------------------------------------------------
620 Merge Cond: (t1.id = t4.id)
622 Merge Cond: (t1.id = t2.id)
623 -> Index Scan using t1_pkey on t1
624 -> Index Scan using t2_pkey on t2
628 -> Index Scan using t3_pkey on t3
629 Index Cond: (id = t1.id)
632 /*+NoNestLoop(t4 t1 t3 t2)*/
633 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id;
636 NoNestLoop(t1 t2 t3 t4)
642 --------------------------------------------------
644 Merge Cond: (t1.id = t3.id)
646 Merge Cond: (t1.id = t2.id)
647 -> Index Scan using t1_pkey on t1
648 -> Index Scan using t2_pkey on t2
651 Merge Cond: (t3.id = t4.id)
652 -> Index Scan using t3_pkey on t3
659 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id;
660 INFO: pg_hint_plan: hint syntax error at or near ""
661 DETAIL: Closing parenthesis is necessary.
663 --------------------------------------------------
666 Merge Cond: (t1.id = t4.id)
668 Merge Cond: (t1.id = t2.id)
669 -> Index Scan using t1_pkey on t1
670 -> Index Scan using t2_pkey on t2
674 -> Index Scan using t3_pkey on t3
675 Index Cond: (id = t1.id)
679 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id;
680 INFO: pg_hint_plan: hint syntax error at or near "Leading( )"
681 DETAIL: Leading hint requires at least two relations.
690 --------------------------------------------------
693 Merge Cond: (t1.id = t4.id)
695 Merge Cond: (t1.id = t2.id)
696 -> Index Scan using t1_pkey on t1
697 -> Index Scan using t2_pkey on t2
701 -> Index Scan using t3_pkey on t3
702 Index Cond: (id = t1.id)
706 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id;
707 INFO: pg_hint_plan: hint syntax error at or near "Leading( t3 )"
708 DETAIL: Leading hint requires at least two relations.
717 --------------------------------------------------
720 Merge Cond: (t1.id = t4.id)
722 Merge Cond: (t1.id = t2.id)
723 -> Index Scan using t1_pkey on t1
724 -> Index Scan using t2_pkey on t2
728 -> Index Scan using t3_pkey on t3
729 Index Cond: (id = t1.id)
732 /*+Leading( t3 t4 )*/
733 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id;
742 --------------------------------------------------
746 Merge Cond: (t3.id = t4.id)
747 -> Index Scan using t3_pkey on t3
751 -> Index Scan using t2_pkey on t2
752 Index Cond: (id = t3.id)
753 -> Index Scan using t1_pkey on t1
754 Index Cond: (id = t2.id)
757 /*+Leading(t3 t4 t1)*/
758 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id;
767 --------------------------------------------------
770 Merge Cond: (t3.id = t1.id)
772 Merge Cond: (t3.id = t4.id)
773 -> Index Scan using t3_pkey on t3
777 -> Index Scan using t1_pkey on t1
778 -> Index Scan using t2_pkey on t2
779 Index Cond: (id = t1.id)
782 /*+Leading(t3 t4 t1 t2)*/
783 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id;
792 --------------------------------------------------
795 Merge Cond: (t3.id = t1.id)
797 Merge Cond: (t3.id = t4.id)
798 -> Index Scan using t3_pkey on t3
802 -> Index Scan using t1_pkey on t1
803 -> Index Scan using t2_pkey on t2
804 Index Cond: (id = t1.id)
807 /*+Leading(t3 t4 t1 t2 t1)*/
808 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id;
809 INFO: pg_hint_plan: hint syntax error at or near "Leading(t3 t4 t1 t2 t1)"
810 DETAIL: Relation name "t1" is duplicated.
816 Leading(t3 t4 t1 t2 t1)
819 --------------------------------------------------
822 Merge Cond: (t1.id = t4.id)
824 Merge Cond: (t1.id = t2.id)
825 -> Index Scan using t1_pkey on t1
826 -> Index Scan using t2_pkey on t2
830 -> Index Scan using t3_pkey on t3
831 Index Cond: (id = t1.id)
834 /*+Leading(t3 t4 t4)*/
835 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id;
836 INFO: pg_hint_plan: hint syntax error at or near "Leading(t3 t4 t4)"
837 DETAIL: Relation name "t4" is duplicated.
846 --------------------------------------------------
849 Merge Cond: (t1.id = t4.id)
851 Merge Cond: (t1.id = t2.id)
852 -> Index Scan using t1_pkey on t1
853 -> Index Scan using t2_pkey on t2
857 -> Index Scan using t3_pkey on t3
858 Index Cond: (id = t1.id)
861 EXPLAIN (COSTS false) SELECT * FROM t1, (VALUES(1,1),(2,2),(3,3)) AS t2(id,val) WHERE t1.id = t2.id;
863 -----------------------------------------------
865 -> Values Scan on "*VALUES*"
866 -> Index Scan using t1_pkey on t1
867 Index Cond: (id = "*VALUES*".column1)
871 EXPLAIN (COSTS false) SELECT * FROM t1, (VALUES(1,1),(2,2),(3,3)) AS t2(id,val) WHERE t1.id = t2.id;
880 -----------------------------------------------
882 -> Values Scan on "*VALUES*"
883 -> Index Scan using t1_pkey on t1
884 Index Cond: (id = "*VALUES*".column1)
887 /*+HashJoin(t1 *VALUES*)*/
888 EXPLAIN (COSTS false) SELECT * FROM t1, (VALUES(1,1),(2,2),(3,3)) AS t2(id,val) WHERE t1.id = t2.id;
891 HashJoin(*VALUES* t1)
897 -------------------------------------------
899 Hash Cond: (t1.id = "*VALUES*".column1)
902 -> Values Scan on "*VALUES*"
905 /*+HashJoin(t1 *VALUES*) IndexScan(t1) IndexScan(*VALUES*)*/
906 EXPLAIN (COSTS false) SELECT * FROM t1, (VALUES(1,1),(2,2),(3,3)) AS t2(id,val) WHERE t1.id = t2.id;
910 HashJoin(*VALUES* t1)
917 -------------------------------------------
919 Hash Cond: (t1.id = "*VALUES*".column1)
920 -> Index Scan using t1_pkey on t1
922 -> Values Scan on "*VALUES*"
925 -- single table scan hint test
926 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);
928 ------------------------------------------------------------------------
929 Index Only Scan using t1_pkey on t1
930 Index Cond: (id = $3)
931 InitPlan 2 (returns $1)
933 InitPlan 1 (returns $0)
935 -> Index Only Scan Backward using t1_pkey on t1 v_1
936 Index Cond: ((id IS NOT NULL) AND (id < 10))
937 InitPlan 4 (returns $3)
939 InitPlan 3 (returns $2)
941 -> Index Only Scan Backward using t1_pkey on t1 v_2
942 Index Cond: ((id IS NOT NULL) AND (id < 10))
946 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);
955 ------------------------------------------------------------------------
956 Index Only Scan using t1_pkey on t1
957 Index Cond: (id = $3)
958 InitPlan 1 (returns $1)
960 -> Bitmap Heap Scan on t1 v_1
961 Recheck Cond: (id < 10)
962 -> Bitmap Index Scan on t1_pkey
963 Index Cond: (id < 10)
964 InitPlan 3 (returns $3)
966 InitPlan 2 (returns $2)
968 -> Index Only Scan Backward using t1_pkey on t1 v_2
969 Index Cond: ((id IS NOT NULL) AND (id < 10))
973 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);
982 ------------------------------------------------------------------------
983 Index Only Scan using t1_pkey on t1
984 Index Cond: (id = $3)
985 InitPlan 2 (returns $1)
987 InitPlan 1 (returns $0)
989 -> Index Only Scan Backward using t1_pkey on t1 v_1
990 Index Cond: ((id IS NOT NULL) AND (id < 10))
991 InitPlan 3 (returns $3)
993 -> Bitmap Heap Scan on t1 v_2
994 Recheck Cond: (id < 10)
995 -> Bitmap Index Scan on t1_pkey
996 Index Cond: (id < 10)
1000 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);
1009 ------------------------------------------------------------------------
1010 Bitmap Heap Scan on t1
1011 Recheck Cond: (id = $3)
1012 InitPlan 2 (returns $1)
1014 InitPlan 1 (returns $0)
1016 -> Index Only Scan Backward using t1_pkey on t1 v_1
1017 Index Cond: ((id IS NOT NULL) AND (id < 10))
1018 InitPlan 4 (returns $3)
1020 InitPlan 3 (returns $2)
1022 -> Index Only Scan Backward using t1_pkey on t1 v_2
1023 Index Cond: ((id IS NOT NULL) AND (id < 10))
1024 -> Bitmap Index Scan on t1_pkey
1025 Index Cond: (id = $3)
1028 /*+BitmapScan(v_1)BitmapScan(v_2)*/
1029 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);
1039 --------------------------------------------------
1040 Index Only Scan using t1_pkey on t1
1041 Index Cond: (id = $3)
1042 InitPlan 1 (returns $1)
1044 -> Bitmap Heap Scan on t1 v_1
1045 Recheck Cond: (id < 10)
1046 -> Bitmap Index Scan on t1_pkey
1047 Index Cond: (id < 10)
1048 InitPlan 2 (returns $3)
1050 -> Bitmap Heap Scan on t1 v_2
1051 Recheck Cond: (id < 10)
1052 -> Bitmap Index Scan on t1_pkey
1053 Index Cond: (id < 10)
1056 /*+BitmapScan(v_1)BitmapScan(t1)*/
1057 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);
1067 ------------------------------------------------------------------------
1068 Bitmap Heap Scan on t1
1069 Recheck Cond: (id = $3)
1070 InitPlan 1 (returns $1)
1072 -> Bitmap Heap Scan on t1 v_1
1073 Recheck Cond: (id < 10)
1074 -> Bitmap Index Scan on t1_pkey
1075 Index Cond: (id < 10)
1076 InitPlan 3 (returns $3)
1078 InitPlan 2 (returns $2)
1080 -> Index Only Scan Backward using t1_pkey on t1 v_2
1081 Index Cond: ((id IS NOT NULL) AND (id < 10))
1082 -> Bitmap Index Scan on t1_pkey
1083 Index Cond: (id = $3)
1086 /*+BitmapScan(v_2)BitmapScan(t1)*/
1087 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);
1097 ------------------------------------------------------------------------
1098 Bitmap Heap Scan on t1
1099 Recheck Cond: (id = $3)
1100 InitPlan 2 (returns $1)
1102 InitPlan 1 (returns $0)
1104 -> Index Only Scan Backward using t1_pkey on t1 v_1
1105 Index Cond: ((id IS NOT NULL) AND (id < 10))
1106 InitPlan 3 (returns $3)
1108 -> Bitmap Heap Scan on t1 v_2
1109 Recheck Cond: (id < 10)
1110 -> Bitmap Index Scan on t1_pkey
1111 Index Cond: (id < 10)
1112 -> Bitmap Index Scan on t1_pkey
1113 Index Cond: (id = $3)
1116 /*+BitmapScan(v_1)BitmapScan(v_2)BitmapScan(t1)*/
1117 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);
1128 --------------------------------------------------
1129 Bitmap Heap Scan on t1
1130 Recheck Cond: (id = $3)
1131 InitPlan 1 (returns $1)
1133 -> Bitmap Heap Scan on t1 v_1
1134 Recheck Cond: (id < 10)
1135 -> Bitmap Index Scan on t1_pkey
1136 Index Cond: (id < 10)
1137 InitPlan 2 (returns $3)
1139 -> Bitmap Heap Scan on t1 v_2
1140 Recheck Cond: (id < 10)
1141 -> Bitmap Index Scan on t1_pkey
1142 Index Cond: (id < 10)
1143 -> Bitmap Index Scan on t1_pkey
1144 Index Cond: (id = $3)
1147 -- full scan hint pattern test
1148 EXPLAIN (COSTS false) SELECT * FROM t1 WHERE id < 10 AND ctid = '(1,1)';
1150 -----------------------------------
1152 TID Cond: (ctid = '(1,1)'::tid)
1157 EXPLAIN (COSTS false) SELECT * FROM t1 WHERE id < 10 AND ctid = '(1,1)';
1166 -------------------------------------------------
1168 Filter: ((id < 10) AND (ctid = '(1,1)'::tid))
1172 EXPLAIN (COSTS false) SELECT * FROM t1 WHERE id < 10 AND ctid = '(1,1)';
1181 ---------------------------------
1182 Index Scan using t1_pkey on t1
1183 Index Cond: (id < 10)
1184 Filter: (ctid = '(1,1)'::tid)
1188 EXPLAIN (COSTS false) SELECT * FROM t1 WHERE id < 10 AND ctid = '(1,1)';
1197 ------------------------------------
1198 Bitmap Heap Scan on t1
1199 Recheck Cond: (id < 10)
1200 Filter: (ctid = '(1,1)'::tid)
1201 -> Bitmap Index Scan on t1_pkey
1202 Index Cond: (id < 10)
1206 EXPLAIN (COSTS false) SELECT * FROM t1 WHERE id < 10 AND ctid = '(1,1)';
1215 -----------------------------------
1217 TID Cond: (ctid = '(1,1)'::tid)
1222 EXPLAIN (COSTS false) SELECT * FROM t1 WHERE id < 10 AND ctid = '(1,1)';
1231 -----------------------------------
1233 TID Cond: (ctid = '(1,1)'::tid)
1237 /*+NoIndexScan(t1)*/
1238 EXPLAIN (COSTS false) SELECT * FROM t1 WHERE id < 10 AND ctid = '(1,1)';
1247 -----------------------------------
1249 TID Cond: (ctid = '(1,1)'::tid)
1253 /*+NoBitmapScan(t1)*/
1254 EXPLAIN (COSTS false) SELECT * FROM t1 WHERE id < 10 AND ctid = '(1,1)';
1263 -----------------------------------
1265 TID Cond: (ctid = '(1,1)'::tid)
1270 EXPLAIN (COSTS false) SELECT * FROM t1 WHERE id < 10 AND ctid = '(1,1)';
1279 ---------------------------------
1280 Index Scan using t1_pkey on t1
1281 Index Cond: (id < 10)
1282 Filter: (ctid = '(1,1)'::tid)
1285 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1287 -----------------------------------------
1289 Join Filter: (t1.id = t2.id)
1291 TID Cond: (ctid = '(1,1)'::tid)
1293 TID Cond: (ctid = '(1,1)'::tid)
1297 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1306 -----------------------------------------
1308 Join Filter: (t1.id = t2.id)
1310 Filter: (ctid = '(1,1)'::tid)
1312 TID Cond: (ctid = '(1,1)'::tid)
1316 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1325 -----------------------------------------
1327 Join Filter: (t1.id = t2.id)
1329 TID Cond: (ctid = '(1,1)'::tid)
1331 Filter: (ctid = '(1,1)'::tid)
1334 /*+SeqScan(t1) SeqScan(t2)*/
1335 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1345 ---------------------------------------
1347 Join Filter: (t1.id = t2.id)
1349 Filter: (ctid = '(1,1)'::tid)
1351 Filter: (ctid = '(1,1)'::tid)
1354 /*+SeqScan(t1) IndexScan(t2)*/
1355 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1365 ---------------------------------------
1368 Filter: (ctid = '(1,1)'::tid)
1369 -> Index Scan using t2_pkey on t2
1370 Index Cond: (id = t1.id)
1371 Filter: (ctid = '(1,1)'::tid)
1374 /*+SeqScan(t1) BitmapScan(t2)*/
1375 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1385 ------------------------------------------
1388 Filter: (ctid = '(1,1)'::tid)
1389 -> Bitmap Heap Scan on t2
1390 Recheck Cond: (id = t1.id)
1391 Filter: (ctid = '(1,1)'::tid)
1392 -> Bitmap Index Scan on t2_pkey
1393 Index Cond: (id = t1.id)
1396 /*+SeqScan(t1) TidScan(t2)*/
1397 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1407 -----------------------------------------
1409 Join Filter: (t1.id = t2.id)
1411 Filter: (ctid = '(1,1)'::tid)
1413 TID Cond: (ctid = '(1,1)'::tid)
1416 /*+SeqScan(t1) NoSeqScan(t2)*/
1417 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1427 -----------------------------------------
1429 Join Filter: (t1.id = t2.id)
1431 Filter: (ctid = '(1,1)'::tid)
1433 TID Cond: (ctid = '(1,1)'::tid)
1436 /*+SeqScan(t1) NoIndexScan(t2)*/
1437 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1447 -----------------------------------------
1449 Join Filter: (t1.id = t2.id)
1451 Filter: (ctid = '(1,1)'::tid)
1453 TID Cond: (ctid = '(1,1)'::tid)
1456 /*+SeqScan(t1) NoBitmapScan(t2)*/
1457 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1467 -----------------------------------------
1469 Join Filter: (t1.id = t2.id)
1471 Filter: (ctid = '(1,1)'::tid)
1473 TID Cond: (ctid = '(1,1)'::tid)
1476 /*+SeqScan(t1) NoTidScan(t2)*/
1477 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1487 ---------------------------------------
1489 Join Filter: (t1.id = t2.id)
1491 Filter: (ctid = '(1,1)'::tid)
1493 Filter: (ctid = '(1,1)'::tid)
1497 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1506 -----------------------------------------
1509 TID Cond: (ctid = '(1,1)'::tid)
1510 -> Index Scan using t1_pkey on t1
1511 Index Cond: (id = t2.id)
1512 Filter: (ctid = '(1,1)'::tid)
1516 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1525 -----------------------------------------
1528 TID Cond: (ctid = '(1,1)'::tid)
1529 -> Index Scan using t2_pkey on t2
1530 Index Cond: (id = t1.id)
1531 Filter: (ctid = '(1,1)'::tid)
1534 /*+IndexScan(t1) SeqScan(t2)*/
1535 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1545 ---------------------------------------
1548 Filter: (ctid = '(1,1)'::tid)
1549 -> Index Scan using t1_pkey on t1
1550 Index Cond: (id = t2.id)
1551 Filter: (ctid = '(1,1)'::tid)
1554 /*+IndexScan(t1) IndexScan(t2)*/
1555 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1565 ---------------------------------------
1567 -> Index Scan using t2_pkey on t2
1568 Filter: (ctid = '(1,1)'::tid)
1569 -> Index Scan using t1_pkey on t1
1570 Index Cond: (id = t2.id)
1571 Filter: (ctid = '(1,1)'::tid)
1574 /*+IndexScan(t1) BitmapScan(t2)*/
1575 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1585 ------------------------------------------
1587 -> Index Scan using t1_pkey on t1
1588 Filter: (ctid = '(1,1)'::tid)
1589 -> Bitmap Heap Scan on t2
1590 Recheck Cond: (id = t1.id)
1591 Filter: (ctid = '(1,1)'::tid)
1592 -> Bitmap Index Scan on t2_pkey
1593 Index Cond: (id = t1.id)
1596 /*+IndexScan(t1) TidScan(t2)*/
1597 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1607 -----------------------------------------
1610 TID Cond: (ctid = '(1,1)'::tid)
1611 -> Index Scan using t1_pkey on t1
1612 Index Cond: (id = t2.id)
1613 Filter: (ctid = '(1,1)'::tid)
1616 /*+IndexScan(t1) NoSeqScan(t2)*/
1617 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1627 -----------------------------------------
1630 TID Cond: (ctid = '(1,1)'::tid)
1631 -> Index Scan using t1_pkey on t1
1632 Index Cond: (id = t2.id)
1633 Filter: (ctid = '(1,1)'::tid)
1636 /*+IndexScan(t1) NoIndexScan(t2)*/
1637 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1647 -----------------------------------------
1650 TID Cond: (ctid = '(1,1)'::tid)
1651 -> Index Scan using t1_pkey on t1
1652 Index Cond: (id = t2.id)
1653 Filter: (ctid = '(1,1)'::tid)
1656 /*+IndexScan(t1) NoBitmapScan(t2)*/
1657 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1667 -----------------------------------------
1670 TID Cond: (ctid = '(1,1)'::tid)
1671 -> Index Scan using t1_pkey on t1
1672 Index Cond: (id = t2.id)
1673 Filter: (ctid = '(1,1)'::tid)
1676 /*+IndexScan(t1) NoTidScan(t2)*/
1677 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1687 ---------------------------------------
1690 Filter: (ctid = '(1,1)'::tid)
1691 -> Index Scan using t1_pkey on t1
1692 Index Cond: (id = t2.id)
1693 Filter: (ctid = '(1,1)'::tid)
1697 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1706 ------------------------------------------
1709 TID Cond: (ctid = '(1,1)'::tid)
1710 -> Bitmap Heap Scan on t1
1711 Recheck Cond: (id = t2.id)
1712 Filter: (ctid = '(1,1)'::tid)
1713 -> Bitmap Index Scan on t1_pkey
1714 Index Cond: (id = t2.id)
1718 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1727 ------------------------------------------
1730 TID Cond: (ctid = '(1,1)'::tid)
1731 -> Bitmap Heap Scan on t2
1732 Recheck Cond: (id = t1.id)
1733 Filter: (ctid = '(1,1)'::tid)
1734 -> Bitmap Index Scan on t2_pkey
1735 Index Cond: (id = t1.id)
1739 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1748 ------------------------------------------
1751 TID Cond: (ctid = '(1,1)'::tid)
1752 -> Bitmap Heap Scan on t2
1753 Recheck Cond: (id = t1.id)
1754 Filter: (ctid = '(1,1)'::tid)
1755 -> Bitmap Index Scan on t2_pkey
1756 Index Cond: (id = t1.id)
1759 /*+BitmapScan(t1) SeqScan(t2)*/
1760 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1770 ------------------------------------------
1773 Filter: (ctid = '(1,1)'::tid)
1774 -> Bitmap Heap Scan on t1
1775 Recheck Cond: (id = t2.id)
1776 Filter: (ctid = '(1,1)'::tid)
1777 -> Bitmap Index Scan on t1_pkey
1778 Index Cond: (id = t2.id)
1781 /*+BitmapScan(t1) IndexScan(t2)*/
1782 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1792 ------------------------------------------
1794 -> Index Scan using t2_pkey on t2
1795 Filter: (ctid = '(1,1)'::tid)
1796 -> Bitmap Heap Scan on t1
1797 Recheck Cond: (id = t2.id)
1798 Filter: (ctid = '(1,1)'::tid)
1799 -> Bitmap Index Scan on t1_pkey
1800 Index Cond: (id = t2.id)
1803 /*+BitmapScan(t1) BitmapScan(t2)*/
1804 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1814 ------------------------------------------
1816 -> Index Scan using t2_pkey on t2
1817 Filter: (ctid = '(1,1)'::tid)
1818 -> Bitmap Heap Scan on t1
1819 Recheck Cond: (id = t2.id)
1820 Filter: (ctid = '(1,1)'::tid)
1821 -> Bitmap Index Scan on t1_pkey
1822 Index Cond: (id = t2.id)
1825 /*+BitmapScan(t1) TidScan(t2)*/
1826 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1836 ------------------------------------------
1839 TID Cond: (ctid = '(1,1)'::tid)
1840 -> Bitmap Heap Scan on t1
1841 Recheck Cond: (id = t2.id)
1842 Filter: (ctid = '(1,1)'::tid)
1843 -> Bitmap Index Scan on t1_pkey
1844 Index Cond: (id = t2.id)
1847 /*+BitmapScan(t1) NoSeqScan(t2)*/
1848 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1858 ------------------------------------------
1861 TID Cond: (ctid = '(1,1)'::tid)
1862 -> Bitmap Heap Scan on t1
1863 Recheck Cond: (id = t2.id)
1864 Filter: (ctid = '(1,1)'::tid)
1865 -> Bitmap Index Scan on t1_pkey
1866 Index Cond: (id = t2.id)
1869 /*+BitmapScan(t1) NoIndexScan(t2)*/
1870 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1880 ------------------------------------------
1883 TID Cond: (ctid = '(1,1)'::tid)
1884 -> Bitmap Heap Scan on t1
1885 Recheck Cond: (id = t2.id)
1886 Filter: (ctid = '(1,1)'::tid)
1887 -> Bitmap Index Scan on t1_pkey
1888 Index Cond: (id = t2.id)
1891 /*+BitmapScan(t1) NoBitmapScan(t2)*/
1892 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1902 ------------------------------------------
1905 TID Cond: (ctid = '(1,1)'::tid)
1906 -> Bitmap Heap Scan on t1
1907 Recheck Cond: (id = t2.id)
1908 Filter: (ctid = '(1,1)'::tid)
1909 -> Bitmap Index Scan on t1_pkey
1910 Index Cond: (id = t2.id)
1913 /*+BitmapScan(t1) NoTidScan(t2)*/
1914 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1924 ------------------------------------------
1927 Filter: (ctid = '(1,1)'::tid)
1928 -> Bitmap Heap Scan on t1
1929 Recheck Cond: (id = t2.id)
1930 Filter: (ctid = '(1,1)'::tid)
1931 -> Bitmap Index Scan on t1_pkey
1932 Index Cond: (id = t2.id)
1936 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1945 -----------------------------------------
1947 Join Filter: (t1.id = t2.id)
1949 TID Cond: (ctid = '(1,1)'::tid)
1951 TID Cond: (ctid = '(1,1)'::tid)
1955 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1964 -----------------------------------------
1966 Join Filter: (t1.id = t2.id)
1968 TID Cond: (ctid = '(1,1)'::tid)
1970 TID Cond: (ctid = '(1,1)'::tid)
1973 /*+TidScan(t1) SeqScan(t2)*/
1974 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1984 -----------------------------------------
1986 Join Filter: (t1.id = t2.id)
1988 TID Cond: (ctid = '(1,1)'::tid)
1990 Filter: (ctid = '(1,1)'::tid)
1993 /*+TidScan(t1) IndexScan(t2)*/
1994 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2004 -----------------------------------------
2007 TID Cond: (ctid = '(1,1)'::tid)
2008 -> Index Scan using t2_pkey on t2
2009 Index Cond: (id = t1.id)
2010 Filter: (ctid = '(1,1)'::tid)
2013 /*+TidScan(t1) BitmapScan(t2)*/
2014 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2024 ------------------------------------------
2027 TID Cond: (ctid = '(1,1)'::tid)
2028 -> Bitmap Heap Scan on t2
2029 Recheck Cond: (id = t1.id)
2030 Filter: (ctid = '(1,1)'::tid)
2031 -> Bitmap Index Scan on t2_pkey
2032 Index Cond: (id = t1.id)
2035 /*+TidScan(t1) TidScan(t2)*/
2036 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2046 -----------------------------------------
2048 Join Filter: (t1.id = t2.id)
2050 TID Cond: (ctid = '(1,1)'::tid)
2052 TID Cond: (ctid = '(1,1)'::tid)
2055 /*+TidScan(t1) NoSeqScan(t2)*/
2056 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2066 -----------------------------------------
2068 Join Filter: (t1.id = t2.id)
2070 TID Cond: (ctid = '(1,1)'::tid)
2072 TID Cond: (ctid = '(1,1)'::tid)
2075 /*+TidScan(t1) NoIndexScan(t2)*/
2076 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2086 -----------------------------------------
2088 Join Filter: (t1.id = t2.id)
2090 TID Cond: (ctid = '(1,1)'::tid)
2092 TID Cond: (ctid = '(1,1)'::tid)
2095 /*+TidScan(t1) NoBitmapScan(t2)*/
2096 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2106 -----------------------------------------
2108 Join Filter: (t1.id = t2.id)
2110 TID Cond: (ctid = '(1,1)'::tid)
2112 TID Cond: (ctid = '(1,1)'::tid)
2115 /*+TidScan(t1) NoTidScan(t2)*/
2116 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2126 -----------------------------------------
2129 TID Cond: (ctid = '(1,1)'::tid)
2130 -> Index Scan using t2_pkey on t2
2131 Index Cond: (id = t1.id)
2132 Filter: (ctid = '(1,1)'::tid)
2136 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2145 -----------------------------------------
2147 Join Filter: (t1.id = t2.id)
2149 TID Cond: (ctid = '(1,1)'::tid)
2151 TID Cond: (ctid = '(1,1)'::tid)
2155 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2164 -----------------------------------------
2166 Join Filter: (t1.id = t2.id)
2168 TID Cond: (ctid = '(1,1)'::tid)
2170 TID Cond: (ctid = '(1,1)'::tid)
2173 /*+NoSeqScan(t1) SeqScan(t2)*/
2174 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2184 -----------------------------------------
2186 Join Filter: (t1.id = t2.id)
2188 TID Cond: (ctid = '(1,1)'::tid)
2190 Filter: (ctid = '(1,1)'::tid)
2193 /*+NoSeqScan(t1) IndexScan(t2)*/
2194 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2204 -----------------------------------------
2207 TID Cond: (ctid = '(1,1)'::tid)
2208 -> Index Scan using t2_pkey on t2
2209 Index Cond: (id = t1.id)
2210 Filter: (ctid = '(1,1)'::tid)
2213 /*+NoSeqScan(t1) BitmapScan(t2)*/
2214 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2224 ------------------------------------------
2227 TID Cond: (ctid = '(1,1)'::tid)
2228 -> Bitmap Heap Scan on t2
2229 Recheck Cond: (id = t1.id)
2230 Filter: (ctid = '(1,1)'::tid)
2231 -> Bitmap Index Scan on t2_pkey
2232 Index Cond: (id = t1.id)
2235 /*+NoSeqScan(t1) TidScan(t2)*/
2236 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2246 -----------------------------------------
2248 Join Filter: (t1.id = t2.id)
2250 TID Cond: (ctid = '(1,1)'::tid)
2252 TID Cond: (ctid = '(1,1)'::tid)
2255 /*+NoSeqScan(t1) NoSeqScan(t2)*/
2256 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2266 -----------------------------------------
2268 Join Filter: (t1.id = t2.id)
2270 TID Cond: (ctid = '(1,1)'::tid)
2272 TID Cond: (ctid = '(1,1)'::tid)
2275 /*+NoSeqScan(t1) NoIndexScan(t2)*/
2276 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2286 -----------------------------------------
2288 Join Filter: (t1.id = t2.id)
2290 TID Cond: (ctid = '(1,1)'::tid)
2292 TID Cond: (ctid = '(1,1)'::tid)
2295 /*+NoSeqScan(t1) NoBitmapScan(t2)*/
2296 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2306 -----------------------------------------
2308 Join Filter: (t1.id = t2.id)
2310 TID Cond: (ctid = '(1,1)'::tid)
2312 TID Cond: (ctid = '(1,1)'::tid)
2315 /*+NoSeqScan(t1) NoTidScan(t2)*/
2316 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2326 -----------------------------------------
2329 TID Cond: (ctid = '(1,1)'::tid)
2330 -> Index Scan using t2_pkey on t2
2331 Index Cond: (id = t1.id)
2332 Filter: (ctid = '(1,1)'::tid)
2335 /*+NoIndexScan(t1)*/
2336 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2345 -----------------------------------------
2347 Join Filter: (t1.id = t2.id)
2349 TID Cond: (ctid = '(1,1)'::tid)
2351 TID Cond: (ctid = '(1,1)'::tid)
2354 /*+NoIndexScan(t2)*/
2355 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2364 -----------------------------------------
2366 Join Filter: (t1.id = t2.id)
2368 TID Cond: (ctid = '(1,1)'::tid)
2370 TID Cond: (ctid = '(1,1)'::tid)
2373 /*+NoIndexScan(t1) SeqScan(t2)*/
2374 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2384 -----------------------------------------
2386 Join Filter: (t1.id = t2.id)
2388 TID Cond: (ctid = '(1,1)'::tid)
2390 Filter: (ctid = '(1,1)'::tid)
2393 /*+NoIndexScan(t1) IndexScan(t2)*/
2394 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2404 -----------------------------------------
2407 TID Cond: (ctid = '(1,1)'::tid)
2408 -> Index Scan using t2_pkey on t2
2409 Index Cond: (id = t1.id)
2410 Filter: (ctid = '(1,1)'::tid)
2413 /*+NoIndexScan(t1) BitmapScan(t2)*/
2414 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2424 ------------------------------------------
2427 TID Cond: (ctid = '(1,1)'::tid)
2428 -> Bitmap Heap Scan on t2
2429 Recheck Cond: (id = t1.id)
2430 Filter: (ctid = '(1,1)'::tid)
2431 -> Bitmap Index Scan on t2_pkey
2432 Index Cond: (id = t1.id)
2435 /*+NoIndexScan(t1) TidScan(t2)*/
2436 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2446 -----------------------------------------
2448 Join Filter: (t1.id = t2.id)
2450 TID Cond: (ctid = '(1,1)'::tid)
2452 TID Cond: (ctid = '(1,1)'::tid)
2455 /*+NoIndexScan(t1) NoSeqScan(t2)*/
2456 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2466 -----------------------------------------
2468 Join Filter: (t1.id = t2.id)
2470 TID Cond: (ctid = '(1,1)'::tid)
2472 TID Cond: (ctid = '(1,1)'::tid)
2475 /*+NoIndexScan(t1) NoIndexScan(t2)*/
2476 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2486 -----------------------------------------
2488 Join Filter: (t1.id = t2.id)
2490 TID Cond: (ctid = '(1,1)'::tid)
2492 TID Cond: (ctid = '(1,1)'::tid)
2495 /*+NoIndexScan(t1) NoBitmapScan(t2)*/
2496 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2506 -----------------------------------------
2508 Join Filter: (t1.id = t2.id)
2510 TID Cond: (ctid = '(1,1)'::tid)
2512 TID Cond: (ctid = '(1,1)'::tid)
2515 /*+NoIndexScan(t1) NoTidScan(t2)*/
2516 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2526 -----------------------------------------
2529 TID Cond: (ctid = '(1,1)'::tid)
2530 -> Index Scan using t2_pkey on t2
2531 Index Cond: (id = t1.id)
2532 Filter: (ctid = '(1,1)'::tid)
2535 /*+NoBitmapScan(t1)*/
2536 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2545 -----------------------------------------
2547 Join Filter: (t1.id = t2.id)
2549 TID Cond: (ctid = '(1,1)'::tid)
2551 TID Cond: (ctid = '(1,1)'::tid)
2554 /*+NoBitmapScan(t2)*/
2555 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2564 -----------------------------------------
2566 Join Filter: (t1.id = t2.id)
2568 TID Cond: (ctid = '(1,1)'::tid)
2570 TID Cond: (ctid = '(1,1)'::tid)
2573 /*+NoBitmapScan(t1) SeqScan(t2)*/
2574 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2584 -----------------------------------------
2586 Join Filter: (t1.id = t2.id)
2588 TID Cond: (ctid = '(1,1)'::tid)
2590 Filter: (ctid = '(1,1)'::tid)
2593 /*+NoBitmapScan(t1) IndexScan(t2)*/
2594 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2604 -----------------------------------------
2607 TID Cond: (ctid = '(1,1)'::tid)
2608 -> Index Scan using t2_pkey on t2
2609 Index Cond: (id = t1.id)
2610 Filter: (ctid = '(1,1)'::tid)
2613 /*+NoBitmapScan(t1) BitmapScan(t2)*/
2614 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2624 ------------------------------------------
2627 TID Cond: (ctid = '(1,1)'::tid)
2628 -> Bitmap Heap Scan on t2
2629 Recheck Cond: (id = t1.id)
2630 Filter: (ctid = '(1,1)'::tid)
2631 -> Bitmap Index Scan on t2_pkey
2632 Index Cond: (id = t1.id)
2635 /*+NoBitmapScan(t1) TidScan(t2)*/
2636 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2646 -----------------------------------------
2648 Join Filter: (t1.id = t2.id)
2650 TID Cond: (ctid = '(1,1)'::tid)
2652 TID Cond: (ctid = '(1,1)'::tid)
2655 /*+NoBitmapScan(t1) NoSeqScan(t2)*/
2656 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2666 -----------------------------------------
2668 Join Filter: (t1.id = t2.id)
2670 TID Cond: (ctid = '(1,1)'::tid)
2672 TID Cond: (ctid = '(1,1)'::tid)
2675 /*+NoBitmapScan(t1) NoIndexScan(t2)*/
2676 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2686 -----------------------------------------
2688 Join Filter: (t1.id = t2.id)
2690 TID Cond: (ctid = '(1,1)'::tid)
2692 TID Cond: (ctid = '(1,1)'::tid)
2695 /*+NoBitmapScan(t1) NoBitmapScan(t2)*/
2696 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2706 -----------------------------------------
2708 Join Filter: (t1.id = t2.id)
2710 TID Cond: (ctid = '(1,1)'::tid)
2712 TID Cond: (ctid = '(1,1)'::tid)
2715 /*+NoBitmapScan(t1) NoTidScan(t2)*/
2716 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2726 -----------------------------------------
2729 TID Cond: (ctid = '(1,1)'::tid)
2730 -> Index Scan using t2_pkey on t2
2731 Index Cond: (id = t1.id)
2732 Filter: (ctid = '(1,1)'::tid)
2736 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2745 -----------------------------------------
2748 TID Cond: (ctid = '(1,1)'::tid)
2749 -> Index Scan using t1_pkey on t1
2750 Index Cond: (id = t2.id)
2751 Filter: (ctid = '(1,1)'::tid)
2755 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2764 -----------------------------------------
2767 TID Cond: (ctid = '(1,1)'::tid)
2768 -> Index Scan using t2_pkey on t2
2769 Index Cond: (id = t1.id)
2770 Filter: (ctid = '(1,1)'::tid)
2773 /*+NoTidScan(t1) SeqScan(t2)*/
2774 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2784 ---------------------------------------
2787 Filter: (ctid = '(1,1)'::tid)
2788 -> Index Scan using t1_pkey on t1
2789 Index Cond: (id = t2.id)
2790 Filter: (ctid = '(1,1)'::tid)
2793 /*+NoTidScan(t1) IndexScan(t2)*/
2794 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2804 ---------------------------------------
2806 -> Index Scan using t2_pkey on t2
2807 Filter: (ctid = '(1,1)'::tid)
2808 -> Index Scan using t1_pkey on t1
2809 Index Cond: (id = t2.id)
2810 Filter: (ctid = '(1,1)'::tid)
2813 /*+NoTidScan(t1) BitmapScan(t2)*/
2814 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2824 ------------------------------------------
2827 Filter: (ctid = '(1,1)'::tid)
2828 -> Bitmap Heap Scan on t2
2829 Recheck Cond: (id = t1.id)
2830 Filter: (ctid = '(1,1)'::tid)
2831 -> Bitmap Index Scan on t2_pkey
2832 Index Cond: (id = t1.id)
2835 /*+NoTidScan(t1) TidScan(t2)*/
2836 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2846 -----------------------------------------
2849 TID Cond: (ctid = '(1,1)'::tid)
2850 -> Index Scan using t1_pkey on t1
2851 Index Cond: (id = t2.id)
2852 Filter: (ctid = '(1,1)'::tid)
2855 /*+NoTidScan(t1) NoSeqScan(t2)*/
2856 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2866 -----------------------------------------
2869 TID Cond: (ctid = '(1,1)'::tid)
2870 -> Index Scan using t1_pkey on t1
2871 Index Cond: (id = t2.id)
2872 Filter: (ctid = '(1,1)'::tid)
2875 /*+NoTidScan(t1) NoIndexScan(t2)*/
2876 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2886 -----------------------------------------
2889 TID Cond: (ctid = '(1,1)'::tid)
2890 -> Index Scan using t1_pkey on t1
2891 Index Cond: (id = t2.id)
2892 Filter: (ctid = '(1,1)'::tid)
2895 /*+NoTidScan(t1) NoBitmapScan(t2)*/
2896 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2906 -----------------------------------------
2909 TID Cond: (ctid = '(1,1)'::tid)
2910 -> Index Scan using t1_pkey on t1
2911 Index Cond: (id = t2.id)
2912 Filter: (ctid = '(1,1)'::tid)
2915 /*+NoTidScan(t1) NoTidScan(t2)*/
2916 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2926 ---------------------------------------
2929 Filter: (ctid = '(1,1)'::tid)
2930 -> Index Scan using t1_pkey on t1
2931 Index Cond: (id = t2.id)
2932 Filter: (ctid = '(1,1)'::tid)
2936 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;
2938 -----------------------------------------
2940 Join Filter: (t1.id = t2.id)
2942 TID Cond: (ctid = '(1,1)'::tid)
2945 TID Cond: (ctid = '(1,1)'::tid)
2949 /*+BitmapScan(t1) BitmapScan(t2)*/
2950 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;
2960 --------------------------------------------------------
2962 -> Bitmap Heap Scan on t2
2963 Recheck Cond: (id < 10)
2964 Filter: (ctid = '(1,1)'::tid)
2965 -> Bitmap Index Scan on t2_pkey
2966 Index Cond: (id < 10)
2967 -> Bitmap Heap Scan on t1
2968 Recheck Cond: ((id = t2.id) AND (id < 10))
2969 Filter: (ctid = '(1,1)'::tid)
2970 -> Bitmap Index Scan on t1_pkey
2971 Index Cond: ((id = t2.id) AND (id < 10))
2975 EXPLAIN (COSTS false) SELECT * FROM t1 FULL OUTER JOIN t2 ON (t1.id = t2.id);
2977 ------------------------------
2979 Hash Cond: (t1.id = t2.id)
2985 /*+MergeJoin(t1 t2)*/
2986 EXPLAIN (COSTS false) SELECT * FROM t1 FULL OUTER JOIN t2 ON (t1.id = t2.id);
2995 --------------------------------------
2997 Merge Cond: (t1.id = t2.id)
2998 -> Index Scan using t1_pkey on t1
2999 -> Index Scan using t2_pkey on t2
3003 /*+NestLoop(t1 t2)*/
3004 EXPLAIN (COSTS false) SELECT * FROM t1 FULL OUTER JOIN t2 ON (t1.id = t2.id);
3013 ------------------------------
3015 Hash Cond: (t1.id = t2.id)
3021 -- inheritance tables test
3022 SET constraint_exclusion TO off;
3023 EXPLAIN (COSTS false) SELECT * FROM p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3025 -----------------------------------------------------------------------
3028 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3029 -> Seq Scan on p1_c1
3030 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3031 -> Seq Scan on p1_c2
3032 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3033 -> Seq Scan on p1_c3
3034 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3035 -> Seq Scan on p1_c4
3036 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3037 -> Seq Scan on p1_c1_c1
3038 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3039 -> Seq Scan on p1_c1_c2
3040 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3041 -> Seq Scan on p1_c3_c1
3042 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3043 -> Seq Scan on p1_c3_c2
3044 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3047 SET constraint_exclusion TO on;
3048 EXPLAIN (COSTS false) SELECT * FROM p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3050 -----------------------------------------------------------------------
3053 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3054 -> Seq Scan on p1_c1
3055 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3056 -> Seq Scan on p1_c1_c1
3057 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3058 -> Seq Scan on p1_c1_c2
3059 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3062 SET constraint_exclusion TO off;
3064 EXPLAIN (COSTS false) SELECT * FROM p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3073 -----------------------------------------------------------------------
3076 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3077 -> Seq Scan on p1_c1
3078 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3079 -> Seq Scan on p1_c2
3080 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3081 -> Seq Scan on p1_c3
3082 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3083 -> Seq Scan on p1_c4
3084 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3085 -> Seq Scan on p1_c1_c1
3086 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3087 -> Seq Scan on p1_c1_c2
3088 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3089 -> Seq Scan on p1_c3_c1
3090 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3091 -> Seq Scan on p1_c3_c2
3092 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3096 EXPLAIN (COSTS false) SELECT * FROM p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3105 --------------------------------------------------
3107 -> Index Scan using p1_pkey on p1
3108 Index Cond: ((id >= 50) AND (id <= 51))
3109 Filter: (ctid = '(1,1)'::tid)
3110 -> Index Scan using p1_c1_pkey on p1_c1
3111 Index Cond: ((id >= 50) AND (id <= 51))
3112 Filter: (ctid = '(1,1)'::tid)
3113 -> Index Scan using p1_c2_pkey on p1_c2
3114 Index Cond: ((id >= 50) AND (id <= 51))
3115 Filter: (ctid = '(1,1)'::tid)
3116 -> Index Scan using p1_c3_pkey on p1_c3
3117 Index Cond: ((id >= 50) AND (id <= 51))
3118 Filter: (ctid = '(1,1)'::tid)
3119 -> Index Scan using p1_c4_pkey on p1_c4
3120 Index Cond: ((id >= 50) AND (id <= 51))
3121 Filter: (ctid = '(1,1)'::tid)
3122 -> Index Scan using p1_c1_c1_pkey on p1_c1_c1
3123 Index Cond: ((id >= 50) AND (id <= 51))
3124 Filter: (ctid = '(1,1)'::tid)
3125 -> Index Scan using p1_c1_c2_pkey on p1_c1_c2
3126 Index Cond: ((id >= 50) AND (id <= 51))
3127 Filter: (ctid = '(1,1)'::tid)
3128 -> Index Scan using p1_c3_c1_pkey on p1_c3_c1
3129 Index Cond: ((id >= 50) AND (id <= 51))
3130 Filter: (ctid = '(1,1)'::tid)
3131 -> Index Scan using p1_c3_c2_pkey on p1_c3_c2
3132 Index Cond: ((id >= 50) AND (id <= 51))
3133 Filter: (ctid = '(1,1)'::tid)
3137 EXPLAIN (COSTS false) SELECT * FROM p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3146 -------------------------------------------------------
3148 -> Bitmap Heap Scan on p1
3149 Recheck Cond: ((id >= 50) AND (id <= 51))
3150 Filter: (ctid = '(1,1)'::tid)
3151 -> Bitmap Index Scan on p1_pkey
3152 Index Cond: ((id >= 50) AND (id <= 51))
3153 -> Bitmap Heap Scan on p1_c1
3154 Recheck Cond: ((id >= 50) AND (id <= 51))
3155 Filter: (ctid = '(1,1)'::tid)
3156 -> Bitmap Index Scan on p1_c1_pkey
3157 Index Cond: ((id >= 50) AND (id <= 51))
3158 -> Bitmap Heap Scan on p1_c2
3159 Recheck Cond: ((id >= 50) AND (id <= 51))
3160 Filter: (ctid = '(1,1)'::tid)
3161 -> Bitmap Index Scan on p1_c2_pkey
3162 Index Cond: ((id >= 50) AND (id <= 51))
3163 -> Bitmap Heap Scan on p1_c3
3164 Recheck Cond: ((id >= 50) AND (id <= 51))
3165 Filter: (ctid = '(1,1)'::tid)
3166 -> Bitmap Index Scan on p1_c3_pkey
3167 Index Cond: ((id >= 50) AND (id <= 51))
3168 -> Bitmap Heap Scan on p1_c4
3169 Recheck Cond: ((id >= 50) AND (id <= 51))
3170 Filter: (ctid = '(1,1)'::tid)
3171 -> Bitmap Index Scan on p1_c4_pkey
3172 Index Cond: ((id >= 50) AND (id <= 51))
3173 -> Bitmap Heap Scan on p1_c1_c1
3174 Recheck Cond: ((id >= 50) AND (id <= 51))
3175 Filter: (ctid = '(1,1)'::tid)
3176 -> Bitmap Index Scan on p1_c1_c1_pkey
3177 Index Cond: ((id >= 50) AND (id <= 51))
3178 -> Bitmap Heap Scan on p1_c1_c2
3179 Recheck Cond: ((id >= 50) AND (id <= 51))
3180 Filter: (ctid = '(1,1)'::tid)
3181 -> Bitmap Index Scan on p1_c1_c2_pkey
3182 Index Cond: ((id >= 50) AND (id <= 51))
3183 -> Bitmap Heap Scan on p1_c3_c1
3184 Recheck Cond: ((id >= 50) AND (id <= 51))
3185 Filter: (ctid = '(1,1)'::tid)
3186 -> Bitmap Index Scan on p1_c3_c1_pkey
3187 Index Cond: ((id >= 50) AND (id <= 51))
3188 -> Bitmap Heap Scan on p1_c3_c2
3189 Recheck Cond: ((id >= 50) AND (id <= 51))
3190 Filter: (ctid = '(1,1)'::tid)
3191 -> Bitmap Index Scan on p1_c3_c2_pkey
3192 Index Cond: ((id >= 50) AND (id <= 51))
3196 EXPLAIN (COSTS false) SELECT * FROM p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3205 ---------------------------------------------
3208 TID Cond: (ctid = '(1,1)'::tid)
3209 Filter: ((id >= 50) AND (id <= 51))
3210 -> Tid Scan on p1_c1
3211 TID Cond: (ctid = '(1,1)'::tid)
3212 Filter: ((id >= 50) AND (id <= 51))
3213 -> Tid Scan on p1_c2
3214 TID Cond: (ctid = '(1,1)'::tid)
3215 Filter: ((id >= 50) AND (id <= 51))
3216 -> Tid Scan on p1_c3
3217 TID Cond: (ctid = '(1,1)'::tid)
3218 Filter: ((id >= 50) AND (id <= 51))
3219 -> Tid Scan on p1_c4
3220 TID Cond: (ctid = '(1,1)'::tid)
3221 Filter: ((id >= 50) AND (id <= 51))
3222 -> Tid Scan on p1_c1_c1
3223 TID Cond: (ctid = '(1,1)'::tid)
3224 Filter: ((id >= 50) AND (id <= 51))
3225 -> Tid Scan on p1_c1_c2
3226 TID Cond: (ctid = '(1,1)'::tid)
3227 Filter: ((id >= 50) AND (id <= 51))
3228 -> Tid Scan on p1_c3_c1
3229 TID Cond: (ctid = '(1,1)'::tid)
3230 Filter: ((id >= 50) AND (id <= 51))
3231 -> Tid Scan on p1_c3_c2
3232 TID Cond: (ctid = '(1,1)'::tid)
3233 Filter: ((id >= 50) AND (id <= 51))
3236 SET constraint_exclusion TO on;
3238 EXPLAIN (COSTS false) SELECT * FROM p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3247 -----------------------------------------------------------------------
3250 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3251 -> Seq Scan on p1_c1
3252 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3253 -> Seq Scan on p1_c1_c1
3254 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3255 -> Seq Scan on p1_c1_c2
3256 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3260 EXPLAIN (COSTS false) SELECT * FROM p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3269 --------------------------------------------------
3271 -> Index Scan using p1_pkey on p1
3272 Index Cond: ((id >= 50) AND (id <= 51))
3273 Filter: (ctid = '(1,1)'::tid)
3274 -> Index Scan using p1_c1_pkey on p1_c1
3275 Index Cond: ((id >= 50) AND (id <= 51))
3276 Filter: (ctid = '(1,1)'::tid)
3277 -> Index Scan using p1_c1_c1_pkey on p1_c1_c1
3278 Index Cond: ((id >= 50) AND (id <= 51))
3279 Filter: (ctid = '(1,1)'::tid)
3280 -> Index Scan using p1_c1_c2_pkey on p1_c1_c2
3281 Index Cond: ((id >= 50) AND (id <= 51))
3282 Filter: (ctid = '(1,1)'::tid)
3286 EXPLAIN (COSTS false) SELECT * FROM p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3295 -------------------------------------------------------
3297 -> Bitmap Heap Scan on p1
3298 Recheck Cond: ((id >= 50) AND (id <= 51))
3299 Filter: (ctid = '(1,1)'::tid)
3300 -> Bitmap Index Scan on p1_pkey
3301 Index Cond: ((id >= 50) AND (id <= 51))
3302 -> Bitmap Heap Scan on p1_c1
3303 Recheck Cond: ((id >= 50) AND (id <= 51))
3304 Filter: (ctid = '(1,1)'::tid)
3305 -> Bitmap Index Scan on p1_c1_pkey
3306 Index Cond: ((id >= 50) AND (id <= 51))
3307 -> Bitmap Heap Scan on p1_c1_c1
3308 Recheck Cond: ((id >= 50) AND (id <= 51))
3309 Filter: (ctid = '(1,1)'::tid)
3310 -> Bitmap Index Scan on p1_c1_c1_pkey
3311 Index Cond: ((id >= 50) AND (id <= 51))
3312 -> Bitmap Heap Scan on p1_c1_c2
3313 Recheck Cond: ((id >= 50) AND (id <= 51))
3314 Filter: (ctid = '(1,1)'::tid)
3315 -> Bitmap Index Scan on p1_c1_c2_pkey
3316 Index Cond: ((id >= 50) AND (id <= 51))
3320 EXPLAIN (COSTS false) SELECT * FROM p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3329 ---------------------------------------------
3332 TID Cond: (ctid = '(1,1)'::tid)
3333 Filter: ((id >= 50) AND (id <= 51))
3334 -> Tid Scan on p1_c1
3335 TID Cond: (ctid = '(1,1)'::tid)
3336 Filter: ((id >= 50) AND (id <= 51))
3337 -> Tid Scan on p1_c1_c1
3338 TID Cond: (ctid = '(1,1)'::tid)
3339 Filter: ((id >= 50) AND (id <= 51))
3340 -> Tid Scan on p1_c1_c2
3341 TID Cond: (ctid = '(1,1)'::tid)
3342 Filter: ((id >= 50) AND (id <= 51))
3345 SET constraint_exclusion TO off;
3346 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;
3348 -----------------------------------------------------------------------------------
3350 Merge Cond: (p1.id = t1.id)
3355 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3356 -> Seq Scan on p1_c1
3357 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3358 -> Seq Scan on p1_c2
3359 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3360 -> Seq Scan on p1_c3
3361 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3362 -> Seq Scan on p1_c4
3363 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3364 -> Seq Scan on p1_c1_c1
3365 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3366 -> Seq Scan on p1_c1_c2
3367 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3368 -> Seq Scan on p1_c3_c1
3369 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3370 -> Seq Scan on p1_c3_c2
3371 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3372 -> Index Scan using t1_pkey on t1
3373 Index Cond: (id < 10)
3376 SET constraint_exclusion TO on;
3377 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;
3379 -----------------------------------------------------------------------------------
3381 Merge Cond: (p1.id = t1.id)
3386 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3387 -> Seq Scan on p1_c1
3388 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3389 -> Seq Scan on p1_c1_c1
3390 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3391 -> Seq Scan on p1_c1_c2
3392 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3393 -> Index Scan using t1_pkey on t1
3394 Index Cond: (id < 10)
3397 SET constraint_exclusion TO off;
3399 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;
3408 -----------------------------------------------------------------------------------
3410 Merge Cond: (p1.id = t1.id)
3415 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3416 -> Seq Scan on p1_c1
3417 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3418 -> Seq Scan on p1_c2
3419 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3420 -> Seq Scan on p1_c3
3421 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3422 -> Seq Scan on p1_c4
3423 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3424 -> Seq Scan on p1_c1_c1
3425 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3426 -> Seq Scan on p1_c1_c2
3427 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3428 -> Seq Scan on p1_c3_c1
3429 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3430 -> Seq Scan on p1_c3_c2
3431 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3432 -> Index Scan using t1_pkey on t1
3433 Index Cond: (id < 10)
3437 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;
3446 --------------------------------------------------------
3448 Merge Cond: (p1.id = t1.id)
3451 -> Index Scan using p1_pkey on p1
3452 Index Cond: ((id >= 50) AND (id <= 51))
3453 Filter: (ctid = '(1,1)'::tid)
3454 -> Index Scan using p1_c1_pkey on p1_c1
3455 Index Cond: ((id >= 50) AND (id <= 51))
3456 Filter: (ctid = '(1,1)'::tid)
3457 -> Index Scan using p1_c2_pkey on p1_c2
3458 Index Cond: ((id >= 50) AND (id <= 51))
3459 Filter: (ctid = '(1,1)'::tid)
3460 -> Index Scan using p1_c3_pkey on p1_c3
3461 Index Cond: ((id >= 50) AND (id <= 51))
3462 Filter: (ctid = '(1,1)'::tid)
3463 -> Index Scan using p1_c4_pkey on p1_c4
3464 Index Cond: ((id >= 50) AND (id <= 51))
3465 Filter: (ctid = '(1,1)'::tid)
3466 -> Index Scan using p1_c1_c1_pkey on p1_c1_c1
3467 Index Cond: ((id >= 50) AND (id <= 51))
3468 Filter: (ctid = '(1,1)'::tid)
3469 -> Index Scan using p1_c1_c2_pkey on p1_c1_c2
3470 Index Cond: ((id >= 50) AND (id <= 51))
3471 Filter: (ctid = '(1,1)'::tid)
3472 -> Index Scan using p1_c3_c1_pkey on p1_c3_c1
3473 Index Cond: ((id >= 50) AND (id <= 51))
3474 Filter: (ctid = '(1,1)'::tid)
3475 -> Index Scan using p1_c3_c2_pkey on p1_c3_c2
3476 Index Cond: ((id >= 50) AND (id <= 51))
3477 Filter: (ctid = '(1,1)'::tid)
3478 -> Index Scan using t1_pkey on t1
3479 Index Cond: (id < 10)
3483 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;
3492 -------------------------------------------------------------------
3494 Merge Cond: (p1.id = t1.id)
3498 -> Bitmap Heap Scan on p1
3499 Recheck Cond: ((id >= 50) AND (id <= 51))
3500 Filter: (ctid = '(1,1)'::tid)
3501 -> Bitmap Index Scan on p1_pkey
3502 Index Cond: ((id >= 50) AND (id <= 51))
3503 -> Bitmap Heap Scan on p1_c1
3504 Recheck Cond: ((id >= 50) AND (id <= 51))
3505 Filter: (ctid = '(1,1)'::tid)
3506 -> Bitmap Index Scan on p1_c1_pkey
3507 Index Cond: ((id >= 50) AND (id <= 51))
3508 -> Bitmap Heap Scan on p1_c2
3509 Recheck Cond: ((id >= 50) AND (id <= 51))
3510 Filter: (ctid = '(1,1)'::tid)
3511 -> Bitmap Index Scan on p1_c2_pkey
3512 Index Cond: ((id >= 50) AND (id <= 51))
3513 -> Bitmap Heap Scan on p1_c3
3514 Recheck Cond: ((id >= 50) AND (id <= 51))
3515 Filter: (ctid = '(1,1)'::tid)
3516 -> Bitmap Index Scan on p1_c3_pkey
3517 Index Cond: ((id >= 50) AND (id <= 51))
3518 -> Bitmap Heap Scan on p1_c4
3519 Recheck Cond: ((id >= 50) AND (id <= 51))
3520 Filter: (ctid = '(1,1)'::tid)
3521 -> Bitmap Index Scan on p1_c4_pkey
3522 Index Cond: ((id >= 50) AND (id <= 51))
3523 -> Bitmap Heap Scan on p1_c1_c1
3524 Recheck Cond: ((id >= 50) AND (id <= 51))
3525 Filter: (ctid = '(1,1)'::tid)
3526 -> Bitmap Index Scan on p1_c1_c1_pkey
3527 Index Cond: ((id >= 50) AND (id <= 51))
3528 -> Bitmap Heap Scan on p1_c1_c2
3529 Recheck Cond: ((id >= 50) AND (id <= 51))
3530 Filter: (ctid = '(1,1)'::tid)
3531 -> Bitmap Index Scan on p1_c1_c2_pkey
3532 Index Cond: ((id >= 50) AND (id <= 51))
3533 -> Bitmap Heap Scan on p1_c3_c1
3534 Recheck Cond: ((id >= 50) AND (id <= 51))
3535 Filter: (ctid = '(1,1)'::tid)
3536 -> Bitmap Index Scan on p1_c3_c1_pkey
3537 Index Cond: ((id >= 50) AND (id <= 51))
3538 -> Bitmap Heap Scan on p1_c3_c2
3539 Recheck Cond: ((id >= 50) AND (id <= 51))
3540 Filter: (ctid = '(1,1)'::tid)
3541 -> Bitmap Index Scan on p1_c3_c2_pkey
3542 Index Cond: ((id >= 50) AND (id <= 51))
3543 -> Index Scan using t1_pkey on t1
3544 Index Cond: (id < 10)
3548 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;
3557 ---------------------------------------------------------
3559 Merge Cond: (p1.id = t1.id)
3564 TID Cond: (ctid = '(1,1)'::tid)
3565 Filter: ((id >= 50) AND (id <= 51))
3566 -> Tid Scan on p1_c1
3567 TID Cond: (ctid = '(1,1)'::tid)
3568 Filter: ((id >= 50) AND (id <= 51))
3569 -> Tid Scan on p1_c2
3570 TID Cond: (ctid = '(1,1)'::tid)
3571 Filter: ((id >= 50) AND (id <= 51))
3572 -> Tid Scan on p1_c3
3573 TID Cond: (ctid = '(1,1)'::tid)
3574 Filter: ((id >= 50) AND (id <= 51))
3575 -> Tid Scan on p1_c4
3576 TID Cond: (ctid = '(1,1)'::tid)
3577 Filter: ((id >= 50) AND (id <= 51))
3578 -> Tid Scan on p1_c1_c1
3579 TID Cond: (ctid = '(1,1)'::tid)
3580 Filter: ((id >= 50) AND (id <= 51))
3581 -> Tid Scan on p1_c1_c2
3582 TID Cond: (ctid = '(1,1)'::tid)
3583 Filter: ((id >= 50) AND (id <= 51))
3584 -> Tid Scan on p1_c3_c1
3585 TID Cond: (ctid = '(1,1)'::tid)
3586 Filter: ((id >= 50) AND (id <= 51))
3587 -> Tid Scan on p1_c3_c2
3588 TID Cond: (ctid = '(1,1)'::tid)
3589 Filter: ((id >= 50) AND (id <= 51))
3590 -> Index Scan using t1_pkey on t1
3591 Index Cond: (id < 10)
3594 /*+NestLoop(p1 t1)*/
3595 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;
3604 -----------------------------------------------------------------------------
3606 Join Filter: (p1.id = t1.id)
3609 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3610 -> Seq Scan on p1_c1
3611 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3612 -> Seq Scan on p1_c2
3613 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3614 -> Seq Scan on p1_c3
3615 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3616 -> Seq Scan on p1_c4
3617 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3618 -> Seq Scan on p1_c1_c1
3619 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3620 -> Seq Scan on p1_c1_c2
3621 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3622 -> Seq Scan on p1_c3_c1
3623 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3624 -> Seq Scan on p1_c3_c2
3625 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3627 -> Index Scan using t1_pkey on t1
3628 Index Cond: (id < 10)
3631 /*+MergeJoin(p1 t1)*/
3632 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;
3641 -----------------------------------------------------------------------------------
3643 Merge Cond: (p1.id = t1.id)
3648 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3649 -> Seq Scan on p1_c1
3650 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3651 -> Seq Scan on p1_c2
3652 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3653 -> Seq Scan on p1_c3
3654 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3655 -> Seq Scan on p1_c4
3656 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3657 -> Seq Scan on p1_c1_c1
3658 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3659 -> Seq Scan on p1_c1_c2
3660 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3661 -> Seq Scan on p1_c3_c1
3662 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3663 -> Seq Scan on p1_c3_c2
3664 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3665 -> Index Scan using t1_pkey on t1
3666 Index Cond: (id < 10)
3669 /*+HashJoin(p1 t1)*/
3670 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;
3679 -----------------------------------------------------------------------------
3681 Hash Cond: (p1.id = t1.id)
3684 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3685 -> Seq Scan on p1_c1
3686 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3687 -> Seq Scan on p1_c2
3688 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3689 -> Seq Scan on p1_c3
3690 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3691 -> Seq Scan on p1_c4
3692 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3693 -> Seq Scan on p1_c1_c1
3694 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3695 -> Seq Scan on p1_c1_c2
3696 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3697 -> Seq Scan on p1_c3_c1
3698 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3699 -> Seq Scan on p1_c3_c2
3700 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3702 -> Index Scan using t1_pkey on t1
3703 Index Cond: (id < 10)
3706 SET constraint_exclusion TO on;
3708 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;
3717 -----------------------------------------------------------------------------------
3719 Merge Cond: (p1.id = t1.id)
3724 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3725 -> Seq Scan on p1_c1
3726 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3727 -> Seq Scan on p1_c1_c1
3728 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3729 -> Seq Scan on p1_c1_c2
3730 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3731 -> Index Scan using t1_pkey on t1
3732 Index Cond: (id < 10)
3736 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;
3745 --------------------------------------------------------
3747 Merge Cond: (p1.id = t1.id)
3750 -> Index Scan using p1_pkey on p1
3751 Index Cond: ((id >= 50) AND (id <= 51))
3752 Filter: (ctid = '(1,1)'::tid)
3753 -> Index Scan using p1_c1_pkey on p1_c1
3754 Index Cond: ((id >= 50) AND (id <= 51))
3755 Filter: (ctid = '(1,1)'::tid)
3756 -> Index Scan using p1_c1_c1_pkey on p1_c1_c1
3757 Index Cond: ((id >= 50) AND (id <= 51))
3758 Filter: (ctid = '(1,1)'::tid)
3759 -> Index Scan using p1_c1_c2_pkey on p1_c1_c2
3760 Index Cond: ((id >= 50) AND (id <= 51))
3761 Filter: (ctid = '(1,1)'::tid)
3762 -> Index Scan using t1_pkey on t1
3763 Index Cond: (id < 10)
3767 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;
3776 -------------------------------------------------------------------
3778 Merge Cond: (p1.id = t1.id)
3782 -> Bitmap Heap Scan on p1
3783 Recheck Cond: ((id >= 50) AND (id <= 51))
3784 Filter: (ctid = '(1,1)'::tid)
3785 -> Bitmap Index Scan on p1_pkey
3786 Index Cond: ((id >= 50) AND (id <= 51))
3787 -> Bitmap Heap Scan on p1_c1
3788 Recheck Cond: ((id >= 50) AND (id <= 51))
3789 Filter: (ctid = '(1,1)'::tid)
3790 -> Bitmap Index Scan on p1_c1_pkey
3791 Index Cond: ((id >= 50) AND (id <= 51))
3792 -> Bitmap Heap Scan on p1_c1_c1
3793 Recheck Cond: ((id >= 50) AND (id <= 51))
3794 Filter: (ctid = '(1,1)'::tid)
3795 -> Bitmap Index Scan on p1_c1_c1_pkey
3796 Index Cond: ((id >= 50) AND (id <= 51))
3797 -> Bitmap Heap Scan on p1_c1_c2
3798 Recheck Cond: ((id >= 50) AND (id <= 51))
3799 Filter: (ctid = '(1,1)'::tid)
3800 -> Bitmap Index Scan on p1_c1_c2_pkey
3801 Index Cond: ((id >= 50) AND (id <= 51))
3802 -> Index Scan using t1_pkey on t1
3803 Index Cond: (id < 10)
3807 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;
3816 ---------------------------------------------------------
3818 Merge Cond: (p1.id = t1.id)
3823 TID Cond: (ctid = '(1,1)'::tid)
3824 Filter: ((id >= 50) AND (id <= 51))
3825 -> Tid Scan on p1_c1
3826 TID Cond: (ctid = '(1,1)'::tid)
3827 Filter: ((id >= 50) AND (id <= 51))
3828 -> Tid Scan on p1_c1_c1
3829 TID Cond: (ctid = '(1,1)'::tid)
3830 Filter: ((id >= 50) AND (id <= 51))
3831 -> Tid Scan on p1_c1_c2
3832 TID Cond: (ctid = '(1,1)'::tid)
3833 Filter: ((id >= 50) AND (id <= 51))
3834 -> Index Scan using t1_pkey on t1
3835 Index Cond: (id < 10)
3838 /*+NestLoop(p1 t1)*/
3839 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;
3848 -----------------------------------------------------------------------------------
3850 Join Filter: (p1.id = t1.id)
3851 -> Index Scan using t1_pkey on t1
3852 Index Cond: (id < 10)
3856 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3857 -> Seq Scan on p1_c1
3858 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3859 -> Seq Scan on p1_c1_c1
3860 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3861 -> Seq Scan on p1_c1_c2
3862 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3865 /*+MergeJoin(p1 t1)*/
3866 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;
3875 -----------------------------------------------------------------------------------
3877 Merge Cond: (p1.id = t1.id)
3882 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3883 -> Seq Scan on p1_c1
3884 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3885 -> Seq Scan on p1_c1_c1
3886 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3887 -> Seq Scan on p1_c1_c2
3888 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3889 -> Index Scan using t1_pkey on t1
3890 Index Cond: (id < 10)
3893 /*+HashJoin(p1 t1)*/
3894 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;
3903 -----------------------------------------------------------------------------------
3905 Hash Cond: (t1.id = p1.id)
3906 -> Index Scan using t1_pkey on t1
3907 Index Cond: (id < 10)
3911 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3912 -> Seq Scan on p1_c1
3913 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3914 -> Seq Scan on p1_c1_c1
3915 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3916 -> Seq Scan on p1_c1_c2
3917 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3920 SET constraint_exclusion TO off;
3921 EXPLAIN (COSTS false) SELECT * FROM ONLY p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3923 -----------------------------------------------------------------
3925 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3928 SET constraint_exclusion TO on;
3929 EXPLAIN (COSTS false) SELECT * FROM ONLY p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3931 -----------------------------------------------------------------
3933 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3936 SET constraint_exclusion TO off;
3938 EXPLAIN (COSTS false) SELECT * FROM ONLY p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3947 -----------------------------------------------------------------
3949 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3953 EXPLAIN (COSTS false) SELECT * FROM ONLY p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3962 -------------------------------------------
3963 Index Scan using p1_pkey on p1
3964 Index Cond: ((id >= 50) AND (id <= 51))
3965 Filter: (ctid = '(1,1)'::tid)
3969 EXPLAIN (COSTS false) SELECT * FROM ONLY p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3978 -------------------------------------------------
3979 Bitmap Heap Scan on p1
3980 Recheck Cond: ((id >= 50) AND (id <= 51))
3981 Filter: (ctid = '(1,1)'::tid)
3982 -> Bitmap Index Scan on p1_pkey
3983 Index Cond: ((id >= 50) AND (id <= 51))
3987 EXPLAIN (COSTS false) SELECT * FROM ONLY p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3996 ---------------------------------------
3998 TID Cond: (ctid = '(1,1)'::tid)
3999 Filter: ((id >= 50) AND (id <= 51))
4002 /*+NestLoop(p1 t1)*/
4003 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;
4012 -----------------------------------------------------------------------
4014 Join Filter: (p1.id = t1.id)
4016 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
4017 -> Index Scan using t1_pkey on t1
4018 Index Cond: (id < 10)
4021 /*+MergeJoin(p1 t1)*/
4022 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;
4031 -----------------------------------------------------------------------------
4033 Merge Cond: (p1.id = t1.id)
4037 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
4038 -> Index Scan using t1_pkey on t1
4039 Index Cond: (id < 10)
4042 /*+HashJoin(p1 t1)*/
4043 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;
4052 -----------------------------------------------------------------------------
4054 Hash Cond: (t1.id = p1.id)
4055 -> Index Scan using t1_pkey on t1
4056 Index Cond: (id < 10)
4059 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
4062 SET constraint_exclusion TO on;
4064 EXPLAIN (COSTS false) SELECT * FROM ONLY p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
4073 -----------------------------------------------------------------
4075 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
4079 EXPLAIN (COSTS false) SELECT * FROM ONLY p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
4088 -------------------------------------------
4089 Index Scan using p1_pkey on p1
4090 Index Cond: ((id >= 50) AND (id <= 51))
4091 Filter: (ctid = '(1,1)'::tid)
4095 EXPLAIN (COSTS false) SELECT * FROM ONLY p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
4104 -------------------------------------------------
4105 Bitmap Heap Scan on p1
4106 Recheck Cond: ((id >= 50) AND (id <= 51))
4107 Filter: (ctid = '(1,1)'::tid)
4108 -> Bitmap Index Scan on p1_pkey
4109 Index Cond: ((id >= 50) AND (id <= 51))
4113 EXPLAIN (COSTS false) SELECT * FROM ONLY p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
4122 ---------------------------------------
4124 TID Cond: (ctid = '(1,1)'::tid)
4125 Filter: ((id >= 50) AND (id <= 51))
4128 /*+NestLoop(p1 t1)*/
4129 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;
4138 -----------------------------------------------------------------------
4140 Join Filter: (p1.id = t1.id)
4142 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
4143 -> Index Scan using t1_pkey on t1
4144 Index Cond: (id < 10)
4147 /*+MergeJoin(p1 t1)*/
4148 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;
4157 -----------------------------------------------------------------------------
4159 Merge Cond: (p1.id = t1.id)
4163 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
4164 -> Index Scan using t1_pkey on t1
4165 Index Cond: (id < 10)
4168 /*+HashJoin(p1 t1)*/
4169 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;
4178 -----------------------------------------------------------------------------
4180 Hash Cond: (t1.id = p1.id)
4181 -> Index Scan using t1_pkey on t1
4182 Index Cond: (id < 10)
4185 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
4188 SET constraint_exclusion TO off;
4189 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;
4191 -----------------------------------------------------------------------
4193 Join Filter: (p1.id = t1.id)
4195 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
4196 -> Index Scan using t1_pkey on t1
4197 Index Cond: (id < 10)
4200 SET constraint_exclusion TO on;
4201 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;
4203 -----------------------------------------------------------------------
4205 Join Filter: (p1.id = t1.id)
4207 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
4208 -> Index Scan using t1_pkey on t1
4209 Index Cond: (id < 10)
4212 SET constraint_exclusion TO off;
4214 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;
4223 -----------------------------------------------------------------------
4225 Join Filter: (p1.id = t1.id)
4227 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
4228 -> Index Scan using t1_pkey on t1
4229 Index Cond: (id < 10)
4233 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;
4242 -------------------------------------------------
4244 Merge Cond: (p1.id = t1.id)
4245 -> Index Scan using p1_pkey on p1
4246 Index Cond: ((id >= 50) AND (id <= 51))
4247 Filter: (ctid = '(1,1)'::tid)
4248 -> Index Scan using t1_pkey on t1
4249 Index Cond: (id < 10)
4253 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;
4262 -------------------------------------------------------
4264 Join Filter: (p1.id = t1.id)
4265 -> Bitmap Heap Scan on p1
4266 Recheck Cond: ((id >= 50) AND (id <= 51))
4267 Filter: (ctid = '(1,1)'::tid)
4268 -> Bitmap Index Scan on p1_pkey
4269 Index Cond: ((id >= 50) AND (id <= 51))
4270 -> Index Scan using t1_pkey on t1
4271 Index Cond: (id < 10)
4275 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;
4284 ---------------------------------------------
4286 Join Filter: (p1.id = t1.id)
4288 TID Cond: (ctid = '(1,1)'::tid)
4289 Filter: ((id >= 50) AND (id <= 51))
4290 -> Index Scan using t1_pkey on t1
4291 Index Cond: (id < 10)
4294 SET constraint_exclusion TO on;
4296 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;
4305 -----------------------------------------------------------------------
4307 Join Filter: (p1.id = t1.id)
4309 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
4310 -> Index Scan using t1_pkey on t1
4311 Index Cond: (id < 10)
4315 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;
4324 -------------------------------------------------
4326 Merge Cond: (p1.id = t1.id)
4327 -> Index Scan using p1_pkey on p1
4328 Index Cond: ((id >= 50) AND (id <= 51))
4329 Filter: (ctid = '(1,1)'::tid)
4330 -> Index Scan using t1_pkey on t1
4331 Index Cond: (id < 10)
4335 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;
4344 -------------------------------------------------------
4346 Join Filter: (p1.id = t1.id)
4347 -> Bitmap Heap Scan on p1
4348 Recheck Cond: ((id >= 50) AND (id <= 51))
4349 Filter: (ctid = '(1,1)'::tid)
4350 -> Bitmap Index Scan on p1_pkey
4351 Index Cond: ((id >= 50) AND (id <= 51))
4352 -> Index Scan using t1_pkey on t1
4353 Index Cond: (id < 10)
4357 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;
4366 ---------------------------------------------
4368 Join Filter: (p1.id = t1.id)
4370 TID Cond: (ctid = '(1,1)'::tid)
4371 Filter: ((id >= 50) AND (id <= 51))
4372 -> Index Scan using t1_pkey on t1
4373 Index Cond: (id < 10)
4377 /*+SeqScan("""t1 ) ")IndexScan("t 2 """)HashJoin("""t1 ) "T3"t 2 """)Leading("""t1 ) "T3"t 2 """)Set(application_name"a a a"" a A")*/
4378 EXPLAIN (COSTS false) SELECT * FROM t1 """t1 ) ", t2 "t 2 """, t3 "T3" WHERE """t1 ) ".id = "t 2 """.id AND """t1 ) ".id = "T3".id;
4383 HashJoin("""t1 ) " T3 "t 2 """)
4384 Leading("""t1 ) " T3 "t 2 """)
4385 Set(application_name "a a a"" a A")
4391 ---------------------------------------------------------
4393 Hash Cond: ("t 2 """.id = """t1 ) ".id)
4394 -> Index Scan using t2_pkey on t2 "t 2 """
4397 Hash Cond: ("""t1 ) ".id = "T3".id)
4398 -> Seq Scan on t1 """t1 ) "
4400 -> Seq Scan on t3 "T3"
4403 -- duplicate hint test
4404 /*+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)*/
4405 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
4406 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)"
4407 DETAIL: Conflict scan method hint.
4408 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)"
4409 DETAIL: Conflict scan method hint.
4410 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)"
4411 DETAIL: Conflict scan method hint.
4412 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)"
4413 DETAIL: Conflict scan method hint.
4414 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)"
4415 DETAIL: Conflict scan method hint.
4416 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)"
4417 DETAIL: Conflict scan method hint.
4418 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)"
4419 DETAIL: Conflict join method hint.
4420 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)"
4421 DETAIL: Conflict join method hint.
4422 INFO: pg_hint_plan: hint syntax error at or near "Set(enable_seqscan off)Set(enable_mergejoin on)Set(enable_seqscan on)"
4423 DETAIL: Conflict set hint.
4424 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)"
4425 DETAIL: Conflict leading hint.
4432 Set(enable_mergejoin on)
4433 Set(enable_seqscan on)
4445 Set(enable_seqscan off)
4449 -----------------------------------------------
4451 Merge Cond: (t1.id = t2.id)
4455 TID Cond: (ctid = '(1,1)'::tid)
4459 TID Cond: (ctid = '(1,1)'::tid)
4462 -- sub query Leading hint test
4463 SET from_collapse_limit TO 100;
4464 SET geqo_threshold TO 100;
4465 EXPLAIN (COSTS false)
4467 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
4470 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
4471 ) FROM t1 t1_1, t2 t2_1, t3 t3_1, (
4472 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
4473 ) 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 = (
4474 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
4477 ------------------------------------------------------------------------------
4482 Merge Cond: (t1_5.id = t3_5.id)
4484 Merge Cond: (t1_5.id = t2_5.id)
4485 -> Index Only Scan using t1_pkey on t1 t1_5
4486 -> Index Only Scan using t2_pkey on t2 t2_5
4489 -> Seq Scan on t3 t3_5
4490 InitPlan 2 (returns $1)
4493 Merge Cond: (t1_2.id = t3_2.id)
4495 Merge Cond: (t1_2.id = t2_2.id)
4496 -> Index Only Scan using t1_pkey on t1 t1_2
4497 -> Index Only Scan using t2_pkey on t2 t2_2
4500 -> Seq Scan on t3 t3_2
4501 InitPlan 3 (returns $2)
4504 Merge Cond: (t1_4.id = t3_4.id)
4506 Merge Cond: (t1_4.id = t2_4.id)
4507 -> Index Only Scan using t1_pkey on t1 t1_4
4508 -> Index Only Scan using t2_pkey on t2 t2_4
4511 -> Seq Scan on t3 t3_4
4517 -> Index Only Scan using t1_pkey on t1 t1_1
4518 Index Cond: (id = $2)
4519 -> Index Only Scan using t2_pkey on t2 t2_1
4520 Index Cond: (id = $2)
4521 -> Seq Scan on t3 t3_1
4523 -> Index Only Scan using t1_pkey on t1 t1_3
4524 Index Cond: (id = $2)
4525 -> Index Only Scan using t2_pkey on t2 t2_3
4526 Index Cond: (id = $2)
4527 -> Seq Scan on t3 t3_3
4533 /*+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)*/
4534 EXPLAIN (COSTS false)
4536 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
4539 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
4540 ) FROM t1 t1_1, t2 t2_1, t3 t3_1, (
4541 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
4542 ) 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 = (
4543 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
4549 MergeJoin(t1_3 t3_3)
4557 ------------------------------------------------------------------------------
4562 Merge Cond: (t1_5.id = t3_5.id)
4564 -> Index Only Scan using t2_pkey on t2 t2_5
4565 -> Index Only Scan using t1_pkey on t1 t1_5
4566 Index Cond: (id = t2_5.id)
4569 -> Seq Scan on t3 t3_5
4570 InitPlan 2 (returns $3)
4573 Merge Cond: (t1_2.id = t3_2.id)
4575 -> Index Only Scan using t2_pkey on t2 t2_2
4576 -> Index Only Scan using t1_pkey on t1 t1_2
4577 Index Cond: (id = t2_2.id)
4580 -> Seq Scan on t3 t3_2
4581 InitPlan 3 (returns $5)
4584 Merge Cond: (t1_4.id = t3_4.id)
4586 -> Index Only Scan using t2_pkey on t2 t2_4
4587 -> Index Only Scan using t1_pkey on t1 t1_4
4588 Index Cond: (id = t2_4.id)
4591 -> Seq Scan on t3 t3_4
4597 -> Index Only Scan using t1_pkey on t1 t1_1
4598 Index Cond: (id = $5)
4599 -> Index Only Scan using t2_pkey on t2 t2_1
4600 Index Cond: (id = $5)
4601 -> Seq Scan on t3 t3_1
4603 -> Index Only Scan using t1_pkey on t1 t1_3
4604 Index Cond: (id = $5)
4605 -> Index Only Scan using t2_pkey on t2 t2_3
4606 Index Cond: (id = $5)
4607 -> Seq Scan on t3 t3_3
4613 /*+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)*/
4614 EXPLAIN (COSTS false)
4616 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
4619 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
4620 ) FROM t1 t1_1, t2 t2_1, t3 t3_1, (
4621 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
4622 ) 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 = (
4623 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
4629 MergeJoin(t1_3 t3_3)
4633 Leading(a t1_1 t1_2 t1_4 t1_5)
4638 ------------------------------------------------------------------------------
4643 Merge Cond: (t1_5.id = t3_5.id)
4645 -> Index Only Scan using t2_pkey on t2 t2_5
4646 -> Index Only Scan using t1_pkey on t1 t1_5
4647 Index Cond: (id = t2_5.id)
4650 -> Seq Scan on t3 t3_5
4651 InitPlan 2 (returns $3)
4654 Merge Cond: (t1_2.id = t3_2.id)
4656 -> Index Only Scan using t2_pkey on t2 t2_2
4657 -> Index Only Scan using t1_pkey on t1 t1_2
4658 Index Cond: (id = t2_2.id)
4661 -> Seq Scan on t3 t3_2
4662 InitPlan 3 (returns $5)
4665 Merge Cond: (t1_4.id = t3_4.id)
4667 -> Index Only Scan using t2_pkey on t2 t2_4
4668 -> Index Only Scan using t1_pkey on t1 t1_4
4669 Index Cond: (id = t2_4.id)
4672 -> Seq Scan on t3 t3_4
4678 -> Index Only Scan using t1_pkey on t1 t1_1
4679 Index Cond: (id = $5)
4680 -> Index Only Scan using t2_pkey on t2 t2_1
4681 Index Cond: (id = $5)
4682 -> Seq Scan on t3 t3_1
4684 -> Index Only Scan using t1_pkey on t1 t1_3
4685 Index Cond: (id = $5)
4686 -> Index Only Scan using t2_pkey on t2 t2_3
4687 Index Cond: (id = $5)
4688 -> Seq Scan on t3 t3_3
4694 /*+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)*/
4695 EXPLAIN (COSTS false)
4697 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
4700 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
4701 ) FROM t1 t1_1, t2 t2_1, t3 t3_1, (
4702 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
4703 ) 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 = (
4704 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
4710 MergeJoin(t1_3 t3_3)
4714 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)
4719 ------------------------------------------------------------------------------
4724 Merge Cond: (t1_5.id = t3_5.id)
4726 -> Index Only Scan using t2_pkey on t2 t2_5
4727 -> Index Only Scan using t1_pkey on t1 t1_5
4728 Index Cond: (id = t2_5.id)
4731 -> Seq Scan on t3 t3_5
4732 InitPlan 2 (returns $3)
4735 Merge Cond: (t1_2.id = t3_2.id)
4737 -> Index Only Scan using t2_pkey on t2 t2_2
4738 -> Index Only Scan using t1_pkey on t1 t1_2
4739 Index Cond: (id = t2_2.id)
4742 -> Seq Scan on t3 t3_2
4743 InitPlan 3 (returns $5)
4746 Merge Cond: (t1_4.id = t3_4.id)
4748 -> Index Only Scan using t2_pkey on t2 t2_4
4749 -> Index Only Scan using t1_pkey on t1 t1_4
4750 Index Cond: (id = t2_4.id)
4753 -> Seq Scan on t3 t3_4
4759 -> Index Only Scan using t1_pkey on t1 t1_1
4760 Index Cond: (id = $5)
4761 -> Index Only Scan using t2_pkey on t2 t2_1
4762 Index Cond: (id = $5)
4763 -> Seq Scan on t3 t3_1
4765 -> Index Only Scan using t1_pkey on t1 t1_3
4766 Index Cond: (id = $5)
4767 -> Index Only Scan using t2_pkey on t2 t2_3
4768 Index Cond: (id = $5)
4769 -> Seq Scan on t3 t3_3
4775 /*+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)*/
4776 EXPLAIN (COSTS false)
4778 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
4781 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
4782 ) FROM t1 t1_1, t2 t2_1, t3 t3_1, (
4783 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
4784 ) 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 = (
4785 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
4789 Leading(t3_5 t2_5 t1_5)
4790 Leading(t3_2 t2_2 t1_2)
4791 Leading(t3_4 t2_4 t1_4)
4792 Leading(c1_1 t3_3 t2_3 t1_3 t3_1 t2_1 t1_1)
4796 MergeJoin(t1_3 t3_3)
4803 ------------------------------------------------------------------------
4808 Merge Cond: (t2_5.id = t1_5.id)
4810 Merge Cond: (t2_5.id = t3_5.id)
4811 -> Index Only Scan using t2_pkey on t2 t2_5
4814 -> Seq Scan on t3 t3_5
4815 -> Index Only Scan using t1_pkey on t1 t1_5
4816 InitPlan 2 (returns $1)
4819 Merge Cond: (t2_2.id = t1_2.id)
4821 Merge Cond: (t2_2.id = t3_2.id)
4822 -> Index Only Scan using t2_pkey on t2 t2_2
4825 -> Seq Scan on t3 t3_2
4826 -> Index Only Scan using t1_pkey on t1 t1_2
4827 InitPlan 3 (returns $2)
4830 Merge Cond: (t2_4.id = t1_4.id)
4832 Merge Cond: (t2_4.id = t3_4.id)
4833 -> Index Only Scan using t2_pkey on t2 t2_4
4836 -> Seq Scan on t3 t3_4
4837 -> Index Only Scan using t1_pkey on t1 t1_4
4843 -> Seq Scan on t3 t3_3
4847 -> Index Only Scan using t2_pkey on t2 t2_3
4848 Index Cond: (id = $2)
4849 -> Index Only Scan using t1_pkey on t1 t1_3
4850 Index Cond: (id = $2)
4851 -> Seq Scan on t3 t3_1
4853 -> Index Only Scan using t2_pkey on t2 t2_1
4854 Index Cond: (id = $2)
4855 -> Index Only Scan using t1_pkey on t1 t1_1
4856 Index Cond: (id = $2)
4859 SET from_collapse_limit TO 1;
4860 EXPLAIN (COSTS false)
4862 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
4865 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
4866 ) FROM t1 t1_1, t2 t2_1, t3 t3_1, (
4867 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
4868 ) 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 = (
4869 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
4872 --------------------------------------------------------------------
4877 Merge Cond: (t1_5.id = t3_5.id)
4879 Merge Cond: (t1_5.id = t2_5.id)
4880 -> Index Only Scan using t1_pkey on t1 t1_5
4881 -> Index Only Scan using t2_pkey on t2 t2_5
4884 -> Seq Scan on t3 t3_5
4885 InitPlan 2 (returns $1)
4888 Merge Cond: (t1_2.id = t3_2.id)
4890 Merge Cond: (t1_2.id = t2_2.id)
4891 -> Index Only Scan using t1_pkey on t1 t1_2
4892 -> Index Only Scan using t2_pkey on t2 t2_2
4895 -> Seq Scan on t3 t3_2
4896 InitPlan 3 (returns $2)
4899 Merge Cond: (t1_4.id = t3_4.id)
4901 Merge Cond: (t1_4.id = t2_4.id)
4902 -> Index Only Scan using t1_pkey on t1 t1_4
4903 -> Index Only Scan using t2_pkey on t2 t2_4
4906 -> Seq Scan on t3 t3_4
4910 -> Index Only Scan using t1_pkey on t1 t1_1
4911 Index Cond: (id = $2)
4912 -> Index Only Scan using t2_pkey on t2 t2_1
4913 Index Cond: (id = $2)
4914 -> Seq Scan on t3 t3_1
4918 -> Index Only Scan using t1_pkey on t1 t1_3
4919 Index Cond: (id = $2)
4920 -> Index Only Scan using t2_pkey on t2 t2_3
4921 Index Cond: (id = $2)
4922 -> Seq Scan on t3 t3_3
4928 /*+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)*/
4929 EXPLAIN (COSTS false)
4931 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
4934 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
4935 ) FROM t1 t1_1, t2 t2_1, t3 t3_1, (
4936 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
4937 ) 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 = (
4938 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
4944 MergeJoin(t1_3 t3_3)
4952 --------------------------------------------------------------------
4957 Merge Cond: (t1_5.id = t3_5.id)
4959 -> Index Only Scan using t2_pkey on t2 t2_5
4960 -> Index Only Scan using t1_pkey on t1 t1_5
4961 Index Cond: (id = t2_5.id)
4964 -> Seq Scan on t3 t3_5
4965 InitPlan 2 (returns $3)
4968 Merge Cond: (t1_2.id = t3_2.id)
4970 -> Index Only Scan using t2_pkey on t2 t2_2
4971 -> Index Only Scan using t1_pkey on t1 t1_2
4972 Index Cond: (id = t2_2.id)
4975 -> Seq Scan on t3 t3_2
4976 InitPlan 3 (returns $5)
4979 Merge Cond: (t1_4.id = t3_4.id)
4981 -> Index Only Scan using t2_pkey on t2 t2_4
4982 -> Index Only Scan using t1_pkey on t1 t1_4
4983 Index Cond: (id = t2_4.id)
4986 -> Seq Scan on t3 t3_4
4990 -> Index Only Scan using t1_pkey on t1 t1_1
4991 Index Cond: (id = $5)
4992 -> Index Only Scan using t2_pkey on t2 t2_1
4993 Index Cond: (id = $5)
4994 -> Seq Scan on t3 t3_1
4998 -> Index Only Scan using t1_pkey on t1 t1_3
4999 Index Cond: (id = $5)
5000 -> Index Only Scan using t2_pkey on t2 t2_3
5001 Index Cond: (id = $5)
5002 -> Seq Scan on t3 t3_3
5008 /*+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)*/
5009 EXPLAIN (COSTS false)
5011 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
5014 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
5015 ) FROM t1 t1_1, t2 t2_1, t3 t3_1, (
5016 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
5017 ) 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 = (
5018 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
5024 MergeJoin(t1_3 t3_3)
5028 Leading(a t1_1 t1_2 t1_4 t1_5)
5033 --------------------------------------------------------------------
5038 Merge Cond: (t1_5.id = t3_5.id)
5040 -> Index Only Scan using t2_pkey on t2 t2_5
5041 -> Index Only Scan using t1_pkey on t1 t1_5
5042 Index Cond: (id = t2_5.id)
5045 -> Seq Scan on t3 t3_5
5046 InitPlan 2 (returns $3)
5049 Merge Cond: (t1_2.id = t3_2.id)
5051 -> Index Only Scan using t2_pkey on t2 t2_2
5052 -> Index Only Scan using t1_pkey on t1 t1_2
5053 Index Cond: (id = t2_2.id)
5056 -> Seq Scan on t3 t3_2
5057 InitPlan 3 (returns $5)
5060 Merge Cond: (t1_4.id = t3_4.id)
5062 -> Index Only Scan using t2_pkey on t2 t2_4
5063 -> Index Only Scan using t1_pkey on t1 t1_4
5064 Index Cond: (id = t2_4.id)
5067 -> Seq Scan on t3 t3_4
5071 -> Index Only Scan using t1_pkey on t1 t1_1
5072 Index Cond: (id = $5)
5073 -> Index Only Scan using t2_pkey on t2 t2_1
5074 Index Cond: (id = $5)
5075 -> Seq Scan on t3 t3_1
5079 -> Index Only Scan using t1_pkey on t1 t1_3
5080 Index Cond: (id = $5)
5081 -> Index Only Scan using t2_pkey on t2 t2_3
5082 Index Cond: (id = $5)
5083 -> Seq Scan on t3 t3_3
5089 /*+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)*/
5090 EXPLAIN (COSTS false)
5092 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
5095 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
5096 ) FROM t1 t1_1, t2 t2_1, t3 t3_1, (
5097 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
5098 ) 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 = (
5099 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
5105 MergeJoin(t1_3 t3_3)
5109 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)
5114 --------------------------------------------------------------------
5119 Merge Cond: (t1_5.id = t3_5.id)
5121 -> Index Only Scan using t2_pkey on t2 t2_5
5122 -> Index Only Scan using t1_pkey on t1 t1_5
5123 Index Cond: (id = t2_5.id)
5126 -> Seq Scan on t3 t3_5
5127 InitPlan 2 (returns $3)
5130 Merge Cond: (t1_2.id = t3_2.id)
5132 -> Index Only Scan using t2_pkey on t2 t2_2
5133 -> Index Only Scan using t1_pkey on t1 t1_2
5134 Index Cond: (id = t2_2.id)
5137 -> Seq Scan on t3 t3_2
5138 InitPlan 3 (returns $5)
5141 Merge Cond: (t1_4.id = t3_4.id)
5143 -> Index Only Scan using t2_pkey on t2 t2_4
5144 -> Index Only Scan using t1_pkey on t1 t1_4
5145 Index Cond: (id = t2_4.id)
5148 -> Seq Scan on t3 t3_4
5152 -> Index Only Scan using t1_pkey on t1 t1_1
5153 Index Cond: (id = $5)
5154 -> Index Only Scan using t2_pkey on t2 t2_1
5155 Index Cond: (id = $5)
5156 -> Seq Scan on t3 t3_1
5160 -> Index Only Scan using t1_pkey on t1 t1_3
5161 Index Cond: (id = $5)
5162 -> Index Only Scan using t2_pkey on t2 t2_3
5163 Index Cond: (id = $5)
5164 -> Seq Scan on t3 t3_3
5170 /*+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)*/
5171 EXPLAIN (COSTS false)
5173 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
5176 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
5177 ) FROM t1 t1_1, t2 t2_1, t3 t3_1, (
5178 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
5179 ) 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 = (
5180 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
5184 MergeJoin(t1_3 t3_3)
5185 Leading(t3_5 t2_5 t1_5)
5186 Leading(t3_2 t2_2 t1_2)
5187 Leading(t3_4 t2_4 t1_4)
5188 Leading(c1_1 t3_3 t2_3 t1_3 t3_1 t2_1 t1_1)
5198 ------------------------------------------------------------------------------
5203 Merge Cond: (t2_5.id = t1_5.id)
5205 Merge Cond: (t2_5.id = t3_5.id)
5206 -> Index Only Scan using t2_pkey on t2 t2_5
5209 -> Seq Scan on t3 t3_5
5210 -> Index Only Scan using t1_pkey on t1 t1_5
5211 InitPlan 2 (returns $1)
5214 Merge Cond: (t2_2.id = t1_2.id)
5216 Merge Cond: (t2_2.id = t3_2.id)
5217 -> Index Only Scan using t2_pkey on t2 t2_2
5220 -> Seq Scan on t3 t3_2
5221 -> Index Only Scan using t1_pkey on t1 t1_2
5222 InitPlan 3 (returns $2)
5225 Merge Cond: (t2_4.id = t1_4.id)
5227 Merge Cond: (t2_4.id = t3_4.id)
5228 -> Index Only Scan using t2_pkey on t2 t2_4
5231 -> Seq Scan on t3 t3_4
5232 -> Index Only Scan using t1_pkey on t1 t1_4
5238 -> Index Only Scan using t1_pkey on t1 t1_3
5239 Index Cond: (id = $2)
5240 -> Index Only Scan using t2_pkey on t2 t2_3
5241 Index Cond: (id = $2)
5242 -> Seq Scan on t3 t3_3
5246 -> Seq Scan on t3 t3_1
5248 -> Index Only Scan using t2_pkey on t2 t2_1
5249 Index Cond: (id = $2)
5250 -> Index Only Scan using t1_pkey on t1 t1_1
5251 Index Cond: (id = $2)
5255 EXPLAIN (COSTS false) SELECT * FROM t1, s0.t1, t2 WHERE public.t1.id = s0.t1.id AND public.t1.id = t2.id;
5257 -------------------------------------------------
5259 Merge Cond: (t1.id = t2.id)
5261 Merge Cond: (t1.id = t1_1.id)
5262 -> Index Scan using t1_pkey on t1
5263 -> Index Scan using t1_pkey on t1 t1_1
5264 -> Index Scan using t2_pkey on t2
5267 /*+NestLoop(t1 t2)*/
5268 EXPLAIN (COSTS false) SELECT * FROM t1, s0.t1, t2 WHERE public.t1.id = s0.t1.id AND public.t1.id = t2.id;
5269 INFO: pg_hint_plan: hint syntax error at or near "NestLoop(t1 t2)"
5270 DETAIL: Relation name "t1" is ambiguous.
5279 -------------------------------------------------
5281 Merge Cond: (t1.id = t2.id)
5283 Merge Cond: (t1.id = t1_1.id)
5284 -> Index Scan using t1_pkey on t1
5285 -> Index Scan using t1_pkey on t1 t1_1
5286 -> Index Scan using t2_pkey on t2
5289 /*+Leading(t1 t2 t1)*/
5290 EXPLAIN (COSTS false) SELECT * FROM t1, s0.t1, t2 WHERE public.t1.id = s0.t1.id AND public.t1.id = t2.id;
5291 INFO: pg_hint_plan: hint syntax error at or near "Leading(t1 t2 t1)"
5292 DETAIL: Relation name "t1" is ambiguous.
5301 -------------------------------------------------
5303 Merge Cond: (t1.id = t2.id)
5305 Merge Cond: (t1.id = t1_1.id)
5306 -> Index Scan using t1_pkey on t1
5307 -> Index Scan using t1_pkey on t1 t1_1
5308 -> Index Scan using t2_pkey on t2
5311 -- identifier length test
5312 EXPLAIN (COSTS false) SELECT * FROM t1 "123456789012345678901234567890123456789012345678901234567890123" JOIN t2 ON ("123456789012345678901234567890123456789012345678901234567890123".id = t2.id) JOIN t3 ON (t2.id = t3.id);
5314 --------------------------------------------------------------------------------------------------------------
5316 Merge Cond: ("123456789012345678901234567890123456789012345678901234567890123".id = t3.id)
5318 Merge Cond: ("123456789012345678901234567890123456789012345678901234567890123".id = t2.id)
5319 -> Index Scan using t1_pkey on t1 "123456789012345678901234567890123456789012345678901234567890123"
5320 -> Index Scan using t2_pkey on t2
5327 Leading(123456789012345678901234567890123456789012345678901234567890123 t2 t3)
5328 SeqScan(123456789012345678901234567890123456789012345678901234567890123)
5329 MergeJoin(123456789012345678901234567890123456789012345678901234567890123 t2)
5330 Set(123456789012345678901234567890123456789012345678901234567890123 1)
5332 EXPLAIN (COSTS false) SELECT * FROM t1 "123456789012345678901234567890123456789012345678901234567890123" JOIN t2 ON ("123456789012345678901234567890123456789012345678901234567890123".id = t2.id) JOIN t3 ON (t2.id = t3.id);
5333 INFO: unrecognized configuration parameter "123456789012345678901234567890123456789012345678901234567890123"
5336 SeqScan(123456789012345678901234567890123456789012345678901234567890123)
5337 MergeJoin(123456789012345678901234567890123456789012345678901234567890123 t2)
5338 Leading(123456789012345678901234567890123456789012345678901234567890123 t2 t3)
5342 Set(123456789012345678901234567890123456789012345678901234567890123 1)
5345 ----------------------------------------------------------------------------------------------------
5347 Merge Cond: ("123456789012345678901234567890123456789012345678901234567890123".id = t3.id)
5349 Merge Cond: (t2.id = "123456789012345678901234567890123456789012345678901234567890123".id)
5350 -> Index Scan using t2_pkey on t2
5352 Sort Key: "123456789012345678901234567890123456789012345678901234567890123".id
5353 -> Seq Scan on t1 "123456789012345678901234567890123456789012345678901234567890123"
5360 Leading(1234567890123456789012345678901234567890123456789012345678901234 t2 t3)
5361 SeqScan(1234567890123456789012345678901234567890123456789012345678901234)
5362 MergeJoin(1234567890123456789012345678901234567890123456789012345678901234 t2)
5363 Set(1234567890123456789012345678901234567890123456789012345678901234 1)
5364 Set(cursor_tuple_fraction 0.1234567890123456789012345678901234567890123456789012345678901234)
5366 EXPLAIN (COSTS false) SELECT * FROM t1 "1234567890123456789012345678901234567890123456789012345678901234" JOIN t2 ON ("1234567890123456789012345678901234567890123456789012345678901234".id = t2.id) JOIN t3 ON (t2.id = t3.id);
5367 NOTICE: identifier "1234567890123456789012345678901234567890123456789012345678901234" will be truncated to "123456789012345678901234567890123456789012345678901234567890123"
5368 NOTICE: identifier "1234567890123456789012345678901234567890123456789012345678901234" will be truncated to "123456789012345678901234567890123456789012345678901234567890123"
5369 NOTICE: identifier "1234567890123456789012345678901234567890123456789012345678901234" will be truncated to "123456789012345678901234567890123456789012345678901234567890123"
5370 NOTICE: identifier "1234567890123456789012345678901234567890123456789012345678901234" will be truncated to "123456789012345678901234567890123456789012345678901234567890123"
5371 NOTICE: identifier "1234567890123456789012345678901234567890123456789012345678901234" will be truncated to "123456789012345678901234567890123456789012345678901234567890123"
5372 NOTICE: identifier "1234567890123456789012345678901234567890123456789012345678901234" will be truncated to "123456789012345678901234567890123456789012345678901234567890123"
5373 INFO: unrecognized configuration parameter "123456789012345678901234567890123456789012345678901234567890123"
5376 SeqScan(123456789012345678901234567890123456789012345678901234567890123)
5377 MergeJoin(123456789012345678901234567890123456789012345678901234567890123 t2)
5378 Leading(123456789012345678901234567890123456789012345678901234567890123 t2 t3)
5379 Set(cursor_tuple_fraction 0.1234567890123456789012345678901234567890123456789012345678901234)
5383 Set(123456789012345678901234567890123456789012345678901234567890123 1)
5386 ----------------------------------------------------------------------------------------------------
5388 Merge Cond: ("123456789012345678901234567890123456789012345678901234567890123".id = t3.id)
5390 Merge Cond: (t2.id = "123456789012345678901234567890123456789012345678901234567890123".id)
5391 -> Index Scan using t2_pkey on t2
5393 Sort Key: "123456789012345678901234567890123456789012345678901234567890123".id
5394 -> Seq Scan on t1 "123456789012345678901234567890123456789012345678901234567890123"
5400 SET "123456789012345678901234567890123456789012345678901234567890123" TO 1;
5401 ERROR: unrecognized configuration parameter "123456789012345678901234567890123456789012345678901234567890123"
5402 SET "1234567890123456789012345678901234567890123456789012345678901234" TO 1;
5403 NOTICE: identifier "1234567890123456789012345678901234567890123456789012345678901234" will be truncated to "123456789012345678901234567890123456789012345678901234567890123"
5404 ERROR: unrecognized configuration parameter "123456789012345678901234567890123456789012345678901234567890123"
5405 SET cursor_tuple_fraction TO 1234567890123456789012345678901234567890123456789012345678901234;
5406 ERROR: 1.23457e+63 is outside the valid range for parameter "cursor_tuple_fraction" (0 .. 1)
5408 /*+ Set(enable_seqscan 100)Set(seq_page_cost on)*/
5409 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
5410 INFO: parameter "enable_seqscan" requires a Boolean value
5411 INFO: parameter "seq_page_cost" requires a numeric value
5417 Set(enable_seqscan 100)
5418 Set(seq_page_cost on)
5421 --------------------------------------
5423 Merge Cond: (t1.id = t2.id)
5424 -> Index Scan using t1_pkey on t1
5425 -> Index Scan using t2_pkey on t2
5428 -- debug log of candidate index to use IndexScan
5429 EXPLAIN (COSTS false) SELECT * FROM t5 WHERE t5.id = 1;
5431 ----------------------------------------------------------------------------------------
5432 Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
5433 Index Cond: (id = 1)
5436 /*+IndexScan(t5 t5_id2)*/
5437 EXPLAIN (COSTS false) SELECT * FROM t5 WHERE t5.id = 1;
5438 LOG: available indexes for IndexScan(t5): t5_id2
5441 IndexScan(t5 t5_id2)
5447 -------------------------------
5448 Index Scan using t5_id2 on t5
5449 Index Cond: (id = 1)
5452 /*+IndexScan(t5 no_exist)*/
5453 EXPLAIN (COSTS false) SELECT * FROM t5 WHERE t5.id = 1;
5454 LOG: available indexes for IndexScan(t5):
5457 IndexScan(t5 no_exist)
5463 --------------------
5468 /*+IndexScan(t5 t5_id1 t5_id2)*/
5469 EXPLAIN (COSTS false) SELECT * FROM t5 WHERE t5.id = 1;
5470 LOG: available indexes for IndexScan(t5): t5_id2 t5_id1
5473 IndexScan(t5 t5_id1 t5_id2)
5479 -------------------------------
5480 Index Scan using t5_id2 on t5
5481 Index Cond: (id = 1)
5484 /*+IndexScan(t5 no_exist t5_id2)*/
5485 EXPLAIN (COSTS false) SELECT * FROM t5 WHERE t5.id = 1;
5486 LOG: available indexes for IndexScan(t5): t5_id2
5489 IndexScan(t5 no_exist t5_id2)
5495 -------------------------------
5496 Index Scan using t5_id2 on t5
5497 Index Cond: (id = 1)
5500 /*+IndexScan(t5 no_exist5 no_exist2)*/
5501 EXPLAIN (COSTS false) SELECT * FROM t5 WHERE t5.id = 1;
5502 LOG: available indexes for IndexScan(t5):
5505 IndexScan(t5 no_exist5 no_exist2)
5511 --------------------
5517 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
5519 --------------------------------------------------------
5521 Hash Cond: (t3.val = t2.val)
5525 Hash Cond: (t2.id = t1.id)
5528 -> Index Scan using t1_pkey on t1
5529 Index Cond: (id < 10)
5533 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
5534 INFO: pg_hint_plan: hint syntax error at or near "Leading((t1))"
5535 DETAIL: Leading hint requires two sets of relations when parentheses nests.
5544 --------------------------------------------------------
5546 Hash Cond: (t3.val = t2.val)
5550 Hash Cond: (t2.id = t1.id)
5553 -> Index Scan using t1_pkey on t1
5554 Index Cond: (id < 10)
5557 /*+Leading((t1 t2))*/
5558 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
5567 --------------------------------------------
5569 Join Filter: (t2.val = t3.val)
5571 Hash Cond: (t1.id = t2.id)
5572 -> Index Scan using t1_pkey on t1
5573 Index Cond: (id < 10)
5579 /*+Leading((t1 t2 t3))*/
5580 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
5581 INFO: pg_hint_plan: hint syntax error at or near "Leading((t1 t2 t3))"
5582 DETAIL: Leading hint requires two sets of relations when parentheses nests.
5591 --------------------------------------------------------
5593 Hash Cond: (t3.val = t2.val)
5597 Hash Cond: (t2.id = t1.id)
5600 -> Index Scan using t1_pkey on t1
5601 Index Cond: (id < 10)
5604 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.id < 10;
5606 --------------------------------------------
5608 Hash Cond: (t2.id = t1.id)
5611 -> Index Scan using t1_pkey on t1
5612 Index Cond: (id < 10)
5615 /*+Leading((t1 t2))*/
5616 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.id < 10;
5625 --------------------------------------
5627 Hash Cond: (t1.id = t2.id)
5628 -> Index Scan using t1_pkey on t1
5629 Index Cond: (id < 10)
5634 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
5636 --------------------------------------------------------
5638 Hash Cond: (t3.val = t2.val)
5642 Hash Cond: (t2.id = t1.id)
5645 -> Index Scan using t1_pkey on t1
5646 Index Cond: (id < 10)
5649 /*+Leading(((t1 t2) t3))*/
5650 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
5653 Leading(((t1 t2) t3))
5659 --------------------------------------------
5661 Join Filter: (t2.val = t3.val)
5663 Hash Cond: (t1.id = t2.id)
5664 -> Index Scan using t1_pkey on t1
5665 Index Cond: (id < 10)
5671 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;
5673 --------------------------------------------------------
5676 Merge Cond: (t3.id = t4.id)
5678 Join Filter: (t1.val = t3.val)
5679 -> Index Scan using t3_pkey on t3
5681 -> Index Scan using t1_pkey on t1
5682 Index Cond: (id < 10)
5686 -> Index Scan using t2_pkey on t2
5687 Index Cond: (id = t1.id)
5690 /*+Leading((((t1 t2) t3) t4))*/
5691 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;
5694 Leading((((t1 t2) t3) t4))
5700 --------------------------------------------------
5703 Join Filter: (t1.val = t3.val)
5705 Hash Cond: (t1.id = t2.id)
5706 -> Index Scan using t1_pkey on t1
5707 Index Cond: (id < 10)
5711 -> Index Scan using t4_pkey on t4
5712 Index Cond: (id = t3.id)
5715 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
5717 --------------------------------------------------------
5719 Hash Cond: (t3.val = t2.val)
5723 Hash Cond: (t2.id = t1.id)
5726 -> Index Scan using t1_pkey on t1
5727 Index Cond: (id < 10)
5730 /*+Leading(((t1 t2) t3))*/
5731 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
5734 Leading(((t1 t2) t3))
5740 --------------------------------------------
5742 Join Filter: (t2.val = t3.val)
5744 Hash Cond: (t1.id = t2.id)
5745 -> Index Scan using t1_pkey on t1
5746 Index Cond: (id < 10)
5752 /*+Leading((t1 (t2 t3)))*/
5753 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
5756 Leading((t1 (t2 t3)))
5762 --------------------------------------------
5764 Hash Cond: (t1.id = t2.id)
5765 -> Index Scan using t1_pkey on t1
5766 Index Cond: (id < 10)
5769 Hash Cond: (t2.val = t3.val)
5775 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;
5777 --------------------------------------------------------
5780 Merge Cond: (t3.id = t4.id)
5782 Join Filter: (t1.val = t3.val)
5783 -> Index Scan using t3_pkey on t3
5785 -> Index Scan using t1_pkey on t1
5786 Index Cond: (id < 10)
5790 -> Index Scan using t2_pkey on t2
5791 Index Cond: (id = t1.id)
5794 /*+Leading(((t1 t2) (t3 t4)))*/
5795 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;
5798 Leading(((t1 t2) (t3 t4)))
5804 --------------------------------------------
5806 Join Filter: (t1.val = t3.val)
5808 Hash Cond: (t1.id = t2.id)
5809 -> Index Scan using t1_pkey on t1
5810 Index Cond: (id < 10)
5814 Merge Cond: (t3.id = t4.id)
5815 -> Index Scan using t3_pkey on t3
5821 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);
5823 --------------------------------------------------------------------
5825 Hash Cond: (t2.val = t3.val)
5826 InitPlan 1 (returns $1)
5831 -> Index Scan using t2_val on t2 t2_2
5832 Index Cond: (val > 100)
5833 -> Index Only Scan using t1_pkey on t1 t1_2
5834 Index Cond: (id = t2_2.id)
5836 Merge Cond: (t1.id = t2.id)
5837 -> Index Scan using t1_pkey on t1
5838 Index Cond: (id < $1)
5839 -> Index Scan using t2_pkey on t2
5844 /*+Leading(((t1 t2) t3)) Leading(((t3 t1) t2))*/
5845 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);
5846 INFO: pg_hint_plan: hint syntax error at or near "Leading(((t1 t2) t3)) Leading(((t3 t1) t2))"
5847 DETAIL: Conflict leading hint.
5850 Leading(((t3 t1) t2))
5853 Leading(((t1 t2) t3))
5857 --------------------------------------------------------------------
5859 Hash Cond: (t1.id = t2.id)
5860 InitPlan 1 (returns $1)
5865 -> Index Scan using t2_val on t2 t2_2
5866 Index Cond: (val > 100)
5867 -> Index Only Scan using t1_pkey on t1 t1_2
5868 Index Cond: (id = t2_2.id)
5870 Hash Cond: (t3.val = t1.val)
5873 -> Index Scan using t1_pkey on t1
5874 Index Cond: (id < $1)
5879 /*+Leading(((t1 t2) t3)) Leading((t1_2 t2_2))*/
5880 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);
5883 Leading(((t1 t2) t3))
5884 Leading((t1_2 t2_2))
5890 --------------------------------------------------------------
5892 Hash Cond: (t2.val = t3.val)
5893 InitPlan 1 (returns $0)
5896 Merge Cond: (t1_2.id = t2_2.id)
5897 -> Index Only Scan using t1_pkey on t1 t1_2
5900 -> Index Scan using t2_val on t2 t2_2
5901 Index Cond: (val > 100)
5903 Merge Cond: (t1.id = t2.id)
5904 -> Index Scan using t1_pkey on t1
5905 Index Cond: (id < $0)
5906 -> Index Scan using t2_pkey on t2
5911 /*+Leading(((((t1 t2) t3) t1_2) t2_2))*/
5912 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);
5916 Leading(((((t1 t2) t3) t1_2) t2_2))
5921 --------------------------------------------------------------------
5923 Hash Cond: (t2.val = t3.val)
5924 InitPlan 1 (returns $1)
5929 -> Index Scan using t2_val on t2 t2_2
5930 Index Cond: (val > 100)
5931 -> Index Only Scan using t1_pkey on t1 t1_2
5932 Index Cond: (id = t2_2.id)
5934 Merge Cond: (t1.id = t2.id)
5935 -> Index Scan using t1_pkey on t1
5936 Index Cond: (id < $1)
5937 -> Index Scan using t2_pkey on t2
5942 -- Specified outer/inner leading hint and join method hint at the same time
5943 /*+Leading(((t1 t2) t3))*/
5944 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
5947 Leading(((t1 t2) t3))
5953 --------------------------------------------
5955 Join Filter: (t2.val = t3.val)
5957 Hash Cond: (t1.id = t2.id)
5958 -> Index Scan using t1_pkey on t1
5959 Index Cond: (id < 10)
5965 /*+Leading(((t1 t2) t3)) MergeJoin(t1 t2)*/
5966 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
5970 Leading(((t1 t2) t3))
5976 --------------------------------------------
5978 Join Filter: (t2.val = t3.val)
5980 Merge Cond: (t1.id = t2.id)
5981 -> Index Scan using t1_pkey on t1
5982 Index Cond: (id < 10)
5983 -> Index Scan using t2_pkey on t2
5987 /*+Leading(((t1 t2) t3)) MergeJoin(t1 t2 t3)*/
5988 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
5992 Leading(((t1 t2) t3))
5998 --------------------------------------------------
6000 Merge Cond: (t2.val = t3.val)
6004 Hash Cond: (t1.id = t2.id)
6005 -> Index Scan using t1_pkey on t1
6006 Index Cond: (id < 10)
6014 /*+Leading(((t1 t2) t3)) MergeJoin(t1 t3)*/
6015 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
6018 Leading(((t1 t2) t3))
6025 --------------------------------------------
6027 Join Filter: (t2.val = t3.val)
6029 Hash Cond: (t1.id = t2.id)
6030 -> Index Scan using t1_pkey on t1
6031 Index Cond: (id < 10)
6037 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;
6039 --------------------------------------------------------
6042 Merge Cond: (t3.id = t4.id)
6044 Join Filter: (t1.val = t3.val)
6045 -> Index Scan using t3_pkey on t3
6047 -> Index Scan using t1_pkey on t1
6048 Index Cond: (id < 10)
6052 -> Index Scan using t2_pkey on t2
6053 Index Cond: (id = t1.id)
6056 /*+Leading(((t1 t2) t3)) MergeJoin(t3 t4)*/
6057 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;
6060 Leading(((t1 t2) t3))
6067 --------------------------------------------------
6069 Join Filter: (t3.id = t4.id)
6071 Join Filter: (t1.val = t3.val)
6073 Hash Cond: (t1.id = t2.id)
6074 -> Index Scan using t1_pkey on t1
6075 Index Cond: (id < 10)
6082 /*+Leading(((t1 t2) t3)) MergeJoin(t1 t2 t3 t4)*/
6083 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;
6086 MergeJoin(t1 t2 t3 t4)
6087 Leading(((t1 t2) t3))
6093 --------------------------------------------------------
6095 Merge Cond: (t3.id = t4.id)
6099 Join Filter: (t1.val = t3.val)
6101 Hash Cond: (t1.id = t2.id)
6102 -> Index Scan using t1_pkey on t1
6103 Index Cond: (id < 10)
6112 /*+ Leading ( ( t1 ( t2 t3 ) ) ) */
6113 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
6116 Leading((t1 (t2 t3)))
6122 --------------------------------------------
6124 Hash Cond: (t1.id = t2.id)
6125 -> Index Scan using t1_pkey on t1
6126 Index Cond: (id < 10)
6129 Hash Cond: (t2.val = t3.val)
6135 /*+Leading((t1(t2 t3)))*/
6136 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
6139 Leading((t1 (t2 t3)))
6145 --------------------------------------------
6147 Hash Cond: (t1.id = t2.id)
6148 -> Index Scan using t1_pkey on t1
6149 Index Cond: (id < 10)
6152 Hash Cond: (t2.val = t3.val)
6158 /*+Leading(("t1(t2" "t3)"))*/
6159 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
6163 Leading(("t1(t2" "t3)"))
6168 --------------------------------------------------------
6170 Hash Cond: (t3.val = t2.val)
6174 Hash Cond: (t2.id = t1.id)
6177 -> Index Scan using t1_pkey on t1
6178 Index Cond: (id < 10)
6181 /*+ Leading ( ( ( t1 t2 ) t3 ) ) */
6182 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
6185 Leading(((t1 t2) t3))
6191 --------------------------------------------
6193 Join Filter: (t2.val = t3.val)
6195 Hash Cond: (t1.id = t2.id)
6196 -> Index Scan using t1_pkey on t1
6197 Index Cond: (id < 10)
6203 /*+Leading(((t1 t2)t3))*/
6204 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
6207 Leading(((t1 t2) t3))
6213 --------------------------------------------
6215 Join Filter: (t2.val = t3.val)
6217 Hash Cond: (t1.id = t2.id)
6218 -> Index Scan using t1_pkey on t1
6219 Index Cond: (id < 10)
6225 /*+Leading(("(t1" "t2)t3"))*/
6226 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
6230 Leading(("(t1" "t2)t3"))
6235 --------------------------------------------------------
6237 Hash Cond: (t3.val = t2.val)
6241 Hash Cond: (t2.id = t1.id)
6244 -> Index Scan using t1_pkey on t1
6245 Index Cond: (id < 10)
6248 /*+Leading((t1(t2(t3(t4 t5)))))*/
6249 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;
6252 Leading((t1 (t2 (t3 (t4 t5)))))
6258 ----------------------------------------------------------------------------------------------------------------------------------
6260 Merge Cond: (t1.id = t2.id)
6261 -> Index Scan using t1_pkey on t1
6264 Merge Cond: (t2.id = t3.id)
6265 -> Index Scan using t2_pkey on t2
6268 Merge Cond: (t3.id = t4.id)
6269 -> Index Scan using t3_pkey on t3
6272 Merge Cond: (t4.id = t5.id)
6273 -> Index Scan using t4_pkey on t4
6274 -> Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
6277 /*+Leading((t5(t4(t3(t2 t1)))))*/
6278 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;
6281 Leading((t5 (t4 (t3 (t2 t1)))))
6287 --------------------------------------------------------------------------
6289 Hash Cond: (t5.id = t1.id)
6293 Merge Cond: (t4.id = t1.id)
6299 Merge Cond: (t3.id = t1.id)
6305 Merge Cond: (t2.id = t1.id)
6306 -> Index Scan using t2_pkey on t2
6307 -> Index Scan using t1_pkey on t1
6310 /*+Leading(((((t1 t2)t3)t4)t5))*/
6311 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;
6314 Leading(((((t1 t2) t3) t4) t5))
6320 ----------------------------------------------------------------------------------------------
6323 Merge Cond: (t1.id = t4.id)
6325 Merge Cond: (t1.id = t3.id)
6327 Merge Cond: (t1.id = t2.id)
6328 -> Index Scan using t1_pkey on t1
6329 -> Index Scan using t2_pkey on t2
6336 -> Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
6337 Index Cond: (id = t1.id)
6340 /*+Leading(((((t5 t4)t3)t2)t1))*/
6341 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;
6344 Leading(((((t5 t4) t3) t2) t1))
6350 ----------------------------------------------------------------------------------------------------------------
6352 Join Filter: (t2.id = t1.id)
6354 Join Filter: (t3.id = t2.id)
6356 Merge Cond: (t4.id = t3.id)
6358 Merge Cond: (t5.id = t4.id)
6359 -> Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
6363 -> Index Scan using t3_pkey on t3
6364 -> Index Scan using t2_pkey on t2
6365 Index Cond: (id = t5.id)
6366 -> Index Scan using t1_pkey on t1
6367 Index Cond: (id = t5.id)
6370 /*+Leading(((t1 t2)(t3(t4 t5))))*/
6371 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;
6374 Leading(((t1 t2) (t3 (t4 t5))))
6380 ----------------------------------------------------------------------------------------------------------------------
6382 Merge Cond: (t1.id = t3.id)
6384 Merge Cond: (t1.id = t2.id)
6385 -> Index Scan using t1_pkey on t1
6386 -> Index Scan using t2_pkey on t2
6389 Merge Cond: (t3.id = t4.id)
6390 -> Index Scan using t3_pkey on t3
6393 Merge Cond: (t4.id = t5.id)
6394 -> Index Scan using t4_pkey on t4
6395 -> Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
6398 /*+Leading(((t5 t4)(t3(t2 t1))))*/
6399 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;
6402 Leading(((t5 t4) (t3 (t2 t1))))
6408 ----------------------------------------------------------------------------------------------------
6410 Merge Cond: (t4.id = t1.id)
6412 Merge Cond: (t5.id = t4.id)
6413 -> Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
6419 Merge Cond: (t3.id = t1.id)
6425 Merge Cond: (t2.id = t1.id)
6426 -> Index Scan using t2_pkey on t2
6427 -> Index Scan using t1_pkey on t1
6430 /*+Leading((((t1 t2)t3)(t4 t5)))*/
6431 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;
6434 Leading((((t1 t2) t3) (t4 t5)))
6440 ----------------------------------------------------------------------------------------------------------
6442 Merge Cond: (t1.id = t4.id)
6444 Merge Cond: (t1.id = t3.id)
6446 Merge Cond: (t1.id = t2.id)
6447 -> Index Scan using t1_pkey on t1
6448 -> Index Scan using t2_pkey on t2
6454 Merge Cond: (t4.id = t5.id)
6455 -> Index Scan using t4_pkey on t4
6456 -> Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
6459 /*+Leading((((t5 t4)t3)(t2 t1)))*/
6460 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;
6463 Leading((((t5 t4) t3) (t2 t1)))
6469 ----------------------------------------------------------------------------------------------------------
6471 Merge Cond: (t3.id = t1.id)
6473 Merge Cond: (t4.id = t3.id)
6475 Merge Cond: (t5.id = t4.id)
6476 -> Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
6480 -> Index Scan using t3_pkey on t3
6483 Merge Cond: (t2.id = t1.id)
6484 -> Index Scan using t2_pkey on t2
6485 -> Index Scan using t1_pkey on t1
6488 -- inherite table test to specify the index's name
6489 EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
6491 -----------------------------------------------------------------------
6494 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
6495 -> Seq Scan on p2_c1
6496 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
6497 -> Seq Scan on p2_c1_c1
6498 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
6499 -> Seq Scan on p2_c1_c2
6500 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
6503 /*+IndexScan(p2 p2_pkey)*/
6504 EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
6505 LOG: available indexes for IndexScan(p2): p2_pkey
6506 LOG: available indexes for IndexScan(p2_c1): p2_c1_pkey
6507 LOG: available indexes for IndexScan(p2_c1_c1): p2_c1_c1_pkey
6508 LOG: available indexes for IndexScan(p2_c1_c2): p2_c1_c2_pkey
6511 IndexScan(p2 p2_pkey)
6517 --------------------------------------------------
6519 -> Index Scan using p2_pkey on p2
6520 Index Cond: ((id >= 50) AND (id <= 51))
6521 Filter: (ctid = '(1,1)'::tid)
6522 -> Index Scan using p2_c1_pkey on p2_c1
6523 Index Cond: ((id >= 50) AND (id <= 51))
6524 Filter: (ctid = '(1,1)'::tid)
6525 -> Index Scan using p2_c1_c1_pkey on p2_c1_c1
6526 Index Cond: ((id >= 50) AND (id <= 51))
6527 Filter: (ctid = '(1,1)'::tid)
6528 -> Index Scan using p2_c1_c2_pkey on p2_c1_c2
6529 Index Cond: ((id >= 50) AND (id <= 51))
6530 Filter: (ctid = '(1,1)'::tid)
6533 /*+IndexScan(p2 p2_id_val_idx)*/
6534 EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
6535 LOG: available indexes for IndexScan(p2): p2_id_val_idx
6536 LOG: available indexes for IndexScan(p2_c1): p2_c1_id_val_idx
6537 LOG: available indexes for IndexScan(p2_c1_c1): p2_c1_c1_id_val_idx
6538 LOG: available indexes for IndexScan(p2_c1_c2): p2_c1_c2_id_val_idx
6541 IndexScan(p2 p2_id_val_idx)
6547 --------------------------------------------------------
6549 -> Index Scan using p2_id_val_idx on p2
6550 Index Cond: ((id >= 50) AND (id <= 51))
6551 Filter: (ctid = '(1,1)'::tid)
6552 -> Index Scan using p2_c1_id_val_idx on p2_c1
6553 Index Cond: ((id >= 50) AND (id <= 51))
6554 Filter: (ctid = '(1,1)'::tid)
6555 -> Index Scan using p2_c1_c1_id_val_idx on p2_c1_c1
6556 Index Cond: ((id >= 50) AND (id <= 51))
6557 Filter: (ctid = '(1,1)'::tid)
6558 -> Index Scan using p2_c1_c2_id_val_idx on p2_c1_c2
6559 Index Cond: ((id >= 50) AND (id <= 51))
6560 Filter: (ctid = '(1,1)'::tid)
6563 /*+IndexScan(p2 p2_val_id_idx)*/
6564 EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
6565 LOG: available indexes for IndexScan(p2): p2_val_id_idx
6566 LOG: available indexes for IndexScan(p2_c1): p2_c1_val_id_idx
6567 LOG: available indexes for IndexScan(p2_c1_c1): p2_c1_c1_val_id_idx
6568 LOG: available indexes for IndexScan(p2_c1_c2): p2_c1_c2_val_id_idx
6571 IndexScan(p2 p2_val_id_idx)
6577 --------------------------------------------------------
6579 -> Index Scan using p2_val_id_idx on p2
6580 Index Cond: ((id >= 50) AND (id <= 51))
6581 Filter: (ctid = '(1,1)'::tid)
6582 -> Index Scan using p2_c1_val_id_idx on p2_c1
6583 Index Cond: ((id >= 50) AND (id <= 51))
6584 Filter: (ctid = '(1,1)'::tid)
6585 -> Index Scan using p2_c1_c1_val_id_idx on p2_c1_c1
6586 Index Cond: ((id >= 50) AND (id <= 51))
6587 Filter: (ctid = '(1,1)'::tid)
6588 -> Index Scan using p2_c1_c2_val_id_idx on p2_c1_c2
6589 Index Cond: ((id >= 50) AND (id <= 51))
6590 Filter: (ctid = '(1,1)'::tid)
6593 EXPLAIN (COSTS false) SELECT val FROM p2 WHERE val >= '50' AND val <= '51' AND p2.ctid = '(1,1)';
6595 -----------------------------------------------------------------------------------------
6598 Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
6599 -> Seq Scan on p2_c1
6600 Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
6601 -> Seq Scan on p2_c2
6602 Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
6603 -> Seq Scan on p2_c3
6604 Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
6605 -> Seq Scan on p2_c4
6606 Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
6607 -> Seq Scan on p2_c1_c1
6608 Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
6609 -> Seq Scan on p2_c1_c2
6610 Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
6611 -> Seq Scan on p2_c3_c1
6612 Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
6613 -> Seq Scan on p2_c3_c2
6614 Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
6617 -- Inhibit parallel exection to avoid interfaring the hint
6618 set max_parallel_workers_per_gather to 0;
6619 /*+ IndexScan(p2 p2_val)*/
6620 EXPLAIN (COSTS false) SELECT val FROM p2 WHERE val >= '50' AND val <= '51' AND p2.ctid = '(1,1)';
6621 LOG: available indexes for IndexScan(p2):
6622 LOG: available indexes for IndexScan(p2_c1):
6623 LOG: available indexes for IndexScan(p2_c2):
6624 LOG: available indexes for IndexScan(p2_c3):
6625 LOG: available indexes for IndexScan(p2_c4):
6626 LOG: available indexes for IndexScan(p2_c1_c1):
6627 LOG: available indexes for IndexScan(p2_c1_c2):
6628 LOG: available indexes for IndexScan(p2_c3_c1):
6629 LOG: available indexes for IndexScan(p2_c3_c2):
6632 IndexScan(p2 p2_val)
6638 -----------------------------------------------------------------------------------------
6641 Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
6642 -> Seq Scan on p2_c1
6643 Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
6644 -> Seq Scan on p2_c2
6645 Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
6646 -> Seq Scan on p2_c3
6647 Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
6648 -> Seq Scan on p2_c4
6649 Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
6650 -> Seq Scan on p2_c1_c1
6651 Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
6652 -> Seq Scan on p2_c1_c2
6653 Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
6654 -> Seq Scan on p2_c3_c1
6655 Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
6656 -> Seq Scan on p2_c3_c2
6657 Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
6660 /*+IndexScan(p2 p2_pkey)*/
6661 EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
6662 LOG: available indexes for IndexScan(p2): p2_pkey
6663 LOG: available indexes for IndexScan(p2_c1): p2_c1_pkey
6664 LOG: available indexes for IndexScan(p2_c1_c1): p2_c1_c1_pkey
6665 LOG: available indexes for IndexScan(p2_c1_c2): p2_c1_c2_pkey
6668 IndexScan(p2 p2_pkey)
6674 --------------------------------------------------
6676 -> Index Scan using p2_pkey on p2
6677 Index Cond: ((id >= 50) AND (id <= 51))
6678 Filter: (ctid = '(1,1)'::tid)
6679 -> Index Scan using p2_c1_pkey on p2_c1
6680 Index Cond: ((id >= 50) AND (id <= 51))
6681 Filter: (ctid = '(1,1)'::tid)
6682 -> Index Scan using p2_c1_c1_pkey on p2_c1_c1
6683 Index Cond: ((id >= 50) AND (id <= 51))
6684 Filter: (ctid = '(1,1)'::tid)
6685 -> Index Scan using p2_c1_c2_pkey on p2_c1_c2
6686 Index Cond: ((id >= 50) AND (id <= 51))
6687 Filter: (ctid = '(1,1)'::tid)
6690 /*+IndexScan(p2 p2_id2_val)*/
6691 EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
6692 LOG: available indexes for IndexScan(p2): p2_id2_val
6693 LOG: available indexes for IndexScan(p2_c1): p2_c1_id2_val
6694 LOG: available indexes for IndexScan(p2_c1_c1):
6695 LOG: available indexes for IndexScan(p2_c1_c2):
6698 IndexScan(p2 p2_id2_val)
6704 -----------------------------------------------------------------------
6706 -> Index Scan using p2_id2_val on p2
6707 Index Cond: ((id >= 50) AND (id <= 51))
6708 Filter: (ctid = '(1,1)'::tid)
6709 -> Index Scan using p2_c1_id2_val on p2_c1
6710 Index Cond: ((id >= 50) AND (id <= 51))
6711 Filter: (ctid = '(1,1)'::tid)
6712 -> Seq Scan on p2_c1_c1
6713 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
6714 -> Seq Scan on p2_c1_c2
6715 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
6718 /*+IndexScan(p2 p2_val2_id)*/
6719 EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
6720 LOG: available indexes for IndexScan(p2): p2_val2_id
6721 LOG: available indexes for IndexScan(p2_c1):
6722 LOG: available indexes for IndexScan(p2_c1_c1):
6723 LOG: available indexes for IndexScan(p2_c1_c2):
6726 IndexScan(p2 p2_val2_id)
6732 -----------------------------------------------------------------------
6734 -> Index Scan using p2_val2_id on p2
6735 Index Cond: ((id >= 50) AND (id <= 51))
6736 Filter: (ctid = '(1,1)'::tid)
6737 -> Seq Scan on p2_c1
6738 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
6739 -> Seq Scan on p2_c1_c1
6740 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
6741 -> Seq Scan on p2_c1_c2
6742 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
6745 /*+IndexScan(p2 p2_pkey)*/
6746 EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
6747 LOG: available indexes for IndexScan(p2): p2_pkey
6748 LOG: available indexes for IndexScan(p2_c1): p2_c1_pkey
6749 LOG: available indexes for IndexScan(p2_c1_c1): p2_c1_c1_pkey
6750 LOG: available indexes for IndexScan(p2_c1_c2): p2_c1_c2_pkey
6753 IndexScan(p2 p2_pkey)
6759 --------------------------------------------------
6761 -> Index Scan using p2_pkey on p2
6762 Index Cond: ((id >= 50) AND (id <= 51))
6763 Filter: (ctid = '(1,1)'::tid)
6764 -> Index Scan using p2_c1_pkey on p2_c1
6765 Index Cond: ((id >= 50) AND (id <= 51))
6766 Filter: (ctid = '(1,1)'::tid)
6767 -> Index Scan using p2_c1_c1_pkey on p2_c1_c1
6768 Index Cond: ((id >= 50) AND (id <= 51))
6769 Filter: (ctid = '(1,1)'::tid)
6770 -> Index Scan using p2_c1_c2_pkey on p2_c1_c2
6771 Index Cond: ((id >= 50) AND (id <= 51))
6772 Filter: (ctid = '(1,1)'::tid)
6775 /*+IndexScan(p2 p2_c1_id_val_idx)*/
6776 EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
6777 LOG: available indexes for IndexScan(p2):
6778 LOG: available indexes for IndexScan(p2_c1): p2_c1_id_val_idx
6779 LOG: available indexes for IndexScan(p2_c1_c1):
6780 LOG: available indexes for IndexScan(p2_c1_c2):
6783 IndexScan(p2 p2_c1_id_val_idx)
6789 -----------------------------------------------------------------------
6792 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
6793 -> Index Scan using p2_c1_id_val_idx on p2_c1
6794 Index Cond: ((id >= 50) AND (id <= 51))
6795 Filter: (ctid = '(1,1)'::tid)
6796 -> Seq Scan on p2_c1_c1
6797 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
6798 -> Seq Scan on p2_c1_c2
6799 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
6802 /*+IndexScan(p2 no_exist)*/
6803 EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
6804 LOG: available indexes for IndexScan(p2):
6805 LOG: available indexes for IndexScan(p2_c1):
6806 LOG: available indexes for IndexScan(p2_c1_c1):
6807 LOG: available indexes for IndexScan(p2_c1_c2):
6810 IndexScan(p2 no_exist)
6816 -----------------------------------------------------------------------
6819 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
6820 -> Seq Scan on p2_c1
6821 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
6822 -> Seq Scan on p2_c1_c1
6823 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
6824 -> Seq Scan on p2_c1_c2
6825 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
6828 /*+IndexScan(p2 p2_pkey p2_c1_id_val_idx)*/
6829 EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
6830 LOG: available indexes for IndexScan(p2): p2_pkey
6831 LOG: available indexes for IndexScan(p2_c1): p2_c1_id_val_idx p2_c1_pkey
6832 LOG: available indexes for IndexScan(p2_c1_c1): p2_c1_c1_pkey
6833 LOG: available indexes for IndexScan(p2_c1_c2): p2_c1_c2_pkey
6836 IndexScan(p2 p2_pkey p2_c1_id_val_idx)
6842 --------------------------------------------------
6844 -> Index Scan using p2_pkey on p2
6845 Index Cond: ((id >= 50) AND (id <= 51))
6846 Filter: (ctid = '(1,1)'::tid)
6847 -> Index Scan using p2_c1_id_val_idx on p2_c1
6848 Index Cond: ((id >= 50) AND (id <= 51))
6849 Filter: (ctid = '(1,1)'::tid)
6850 -> Index Scan using p2_c1_c1_pkey on p2_c1_c1
6851 Index Cond: ((id >= 50) AND (id <= 51))
6852 Filter: (ctid = '(1,1)'::tid)
6853 -> Index Scan using p2_c1_c2_pkey on p2_c1_c2
6854 Index Cond: ((id >= 50) AND (id <= 51))
6855 Filter: (ctid = '(1,1)'::tid)
6858 /*+IndexScan(p2 p2_pkey no_exist)*/
6859 EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
6860 LOG: available indexes for IndexScan(p2): p2_pkey
6861 LOG: available indexes for IndexScan(p2_c1): p2_c1_pkey
6862 LOG: available indexes for IndexScan(p2_c1_c1): p2_c1_c1_pkey
6863 LOG: available indexes for IndexScan(p2_c1_c2): p2_c1_c2_pkey
6866 IndexScan(p2 p2_pkey no_exist)
6872 --------------------------------------------------
6874 -> Index Scan using p2_pkey on p2
6875 Index Cond: ((id >= 50) AND (id <= 51))
6876 Filter: (ctid = '(1,1)'::tid)
6877 -> Index Scan using p2_c1_pkey on p2_c1
6878 Index Cond: ((id >= 50) AND (id <= 51))
6879 Filter: (ctid = '(1,1)'::tid)
6880 -> Index Scan using p2_c1_c1_pkey on p2_c1_c1
6881 Index Cond: ((id >= 50) AND (id <= 51))
6882 Filter: (ctid = '(1,1)'::tid)
6883 -> Index Scan using p2_c1_c2_pkey on p2_c1_c2
6884 Index Cond: ((id >= 50) AND (id <= 51))
6885 Filter: (ctid = '(1,1)'::tid)
6888 /*+IndexScan(p2 p2_c1_id_val_idx no_exist)*/
6889 EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
6890 LOG: available indexes for IndexScan(p2):
6891 LOG: available indexes for IndexScan(p2_c1): p2_c1_id_val_idx
6892 LOG: available indexes for IndexScan(p2_c1_c1):
6893 LOG: available indexes for IndexScan(p2_c1_c2):
6896 IndexScan(p2 p2_c1_id_val_idx no_exist)
6902 -----------------------------------------------------------------------
6905 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
6906 -> Index Scan using p2_c1_id_val_idx on p2_c1
6907 Index Cond: ((id >= 50) AND (id <= 51))
6908 Filter: (ctid = '(1,1)'::tid)
6909 -> Seq Scan on p2_c1_c1
6910 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
6911 -> Seq Scan on p2_c1_c2
6912 Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
6915 /*+IndexScan(p2 p2_pkey p2_c1_id_val_idx no_exist)*/
6916 EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
6917 LOG: available indexes for IndexScan(p2): p2_pkey
6918 LOG: available indexes for IndexScan(p2_c1): p2_c1_id_val_idx p2_c1_pkey
6919 LOG: available indexes for IndexScan(p2_c1_c1): p2_c1_c1_pkey
6920 LOG: available indexes for IndexScan(p2_c1_c2): p2_c1_c2_pkey
6923 IndexScan(p2 p2_pkey p2_c1_id_val_idx no_exist)
6929 --------------------------------------------------
6931 -> Index Scan using p2_pkey on p2
6932 Index Cond: ((id >= 50) AND (id <= 51))
6933 Filter: (ctid = '(1,1)'::tid)
6934 -> Index Scan using p2_c1_id_val_idx on p2_c1
6935 Index Cond: ((id >= 50) AND (id <= 51))
6936 Filter: (ctid = '(1,1)'::tid)
6937 -> Index Scan using p2_c1_c1_pkey on p2_c1_c1
6938 Index Cond: ((id >= 50) AND (id <= 51))
6939 Filter: (ctid = '(1,1)'::tid)
6940 -> Index Scan using p2_c1_c2_pkey on p2_c1_c2
6941 Index Cond: ((id >= 50) AND (id <= 51))
6942 Filter: (ctid = '(1,1)'::tid)
6945 /*+IndexScan(p2 p2_val_idx)*/
6946 EXPLAIN (COSTS false) SELECT val FROM p2 WHERE val >= '50' AND val <= '51' AND p2.ctid = '(1,1)';
6947 LOG: available indexes for IndexScan(p2): p2_val_idx
6948 LOG: available indexes for IndexScan(p2_c1): p2_c1_val_idx
6949 LOG: available indexes for IndexScan(p2_c2): p2_c2_val_idx
6950 LOG: available indexes for IndexScan(p2_c3): p2_c3_val_idx
6951 LOG: available indexes for IndexScan(p2_c4): p2_c4_val_idx
6952 LOG: available indexes for IndexScan(p2_c1_c1): p2_c1_c1_val_idx
6953 LOG: available indexes for IndexScan(p2_c1_c2): p2_c1_c2_val_idx
6954 LOG: available indexes for IndexScan(p2_c3_c1): p2_c3_c1_val_idx
6955 LOG: available indexes for IndexScan(p2_c3_c2): p2_c3_c2_val_idx
6958 IndexScan(p2 p2_val_idx)
6964 -------------------------------------------------------------------
6966 -> Index Scan using p2_val_idx on p2
6967 Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
6968 Filter: (ctid = '(1,1)'::tid)
6969 -> Index Scan using p2_c1_val_idx on p2_c1
6970 Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
6971 Filter: (ctid = '(1,1)'::tid)
6972 -> Index Scan using p2_c2_val_idx on p2_c2
6973 Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
6974 Filter: (ctid = '(1,1)'::tid)
6975 -> Index Scan using p2_c3_val_idx on p2_c3
6976 Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
6977 Filter: (ctid = '(1,1)'::tid)
6978 -> Index Scan using p2_c4_val_idx on p2_c4
6979 Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
6980 Filter: (ctid = '(1,1)'::tid)
6981 -> Index Scan using p2_c1_c1_val_idx on p2_c1_c1
6982 Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
6983 Filter: (ctid = '(1,1)'::tid)
6984 -> Index Scan using p2_c1_c2_val_idx on p2_c1_c2
6985 Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
6986 Filter: (ctid = '(1,1)'::tid)
6987 -> Index Scan using p2_c3_c1_val_idx on p2_c3_c1
6988 Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
6989 Filter: (ctid = '(1,1)'::tid)
6990 -> Index Scan using p2_c3_c2_val_idx on p2_c3_c2
6991 Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
6992 Filter: (ctid = '(1,1)'::tid)
6995 /*+IndexScan(p2 p2_expr)*/
6996 EXPLAIN (COSTS false) SELECT val FROM p2 WHERE val >= '50' AND val <= '51' AND p2.ctid = '(1,1)';
6997 LOG: available indexes for IndexScan(p2): p2_expr
6998 LOG: available indexes for IndexScan(p2_c1): p2_c1_expr_idx
6999 LOG: available indexes for IndexScan(p2_c2): p2_c2_expr_idx
7000 LOG: available indexes for IndexScan(p2_c3): p2_c3_expr_idx
7001 LOG: available indexes for IndexScan(p2_c4): p2_c4_expr_idx
7002 LOG: available indexes for IndexScan(p2_c1_c1): p2_c1_c1_expr_idx
7003 LOG: available indexes for IndexScan(p2_c1_c2): p2_c1_c2_expr_idx
7004 LOG: available indexes for IndexScan(p2_c3_c1): p2_c3_c1_expr_idx
7005 LOG: available indexes for IndexScan(p2_c3_c2): p2_c3_c2_expr_idx
7008 IndexScan(p2 p2_expr)
7014 -----------------------------------------------------------------------------------------
7017 Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
7018 -> Seq Scan on p2_c1
7019 Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
7020 -> Seq Scan on p2_c2
7021 Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
7022 -> Seq Scan on p2_c3
7023 Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
7024 -> Seq Scan on p2_c4
7025 Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
7026 -> Seq Scan on p2_c1_c1
7027 Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
7028 -> Seq Scan on p2_c1_c2
7029 Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
7030 -> Seq Scan on p2_c3_c1
7031 Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
7032 -> Seq Scan on p2_c3_c2
7033 Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
7036 /*+IndexScan(p2 p2_val_idx6)*/
7037 EXPLAIN (COSTS false) SELECT val FROM p2 WHERE val >= '50' AND val <= '51' AND p2.ctid = '(1,1)';
7038 LOG: available indexes for IndexScan(p2): p2_val_idx6
7039 LOG: available indexes for IndexScan(p2_c1): p2_c1_val_idx6
7040 LOG: available indexes for IndexScan(p2_c2): p2_c2_val_idx6
7041 LOG: available indexes for IndexScan(p2_c3): p2_c3_val_idx6
7042 LOG: available indexes for IndexScan(p2_c4): p2_c4_val_idx6
7043 LOG: available indexes for IndexScan(p2_c1_c1): p2_c1_c1_val_idx6
7044 LOG: available indexes for IndexScan(p2_c1_c2): p2_c1_c2_val_idx6
7045 LOG: available indexes for IndexScan(p2_c3_c1): p2_c3_c1_val_idx6
7046 LOG: available indexes for IndexScan(p2_c3_c2): p2_c3_c2_val_idx6
7049 IndexScan(p2 p2_val_idx6)
7055 -----------------------------------------------------------------------------------------
7058 Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
7059 -> Seq Scan on p2_c1
7060 Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
7061 -> Seq Scan on p2_c2
7062 Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
7063 -> Seq Scan on p2_c3
7064 Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
7065 -> Seq Scan on p2_c4
7066 Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
7067 -> Seq Scan on p2_c1_c1
7068 Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
7069 -> Seq Scan on p2_c1_c2
7070 Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
7071 -> Seq Scan on p2_c3_c1
7072 Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
7073 -> Seq Scan on p2_c3_c2
7074 Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
7077 /*+IndexScan(p2 p2_val_idx p2_val_idx6)*/
7078 EXPLAIN (COSTS false) SELECT val FROM p2 WHERE val >= '50' AND val <= '51' AND p2.ctid = '(1,1)';
7079 LOG: available indexes for IndexScan(p2): p2_val_idx6 p2_val_idx
7080 LOG: available indexes for IndexScan(p2_c1): p2_c1_val_idx6 p2_c1_val_idx
7081 LOG: available indexes for IndexScan(p2_c2): p2_c2_val_idx6 p2_c2_val_idx
7082 LOG: available indexes for IndexScan(p2_c3): p2_c3_val_idx6 p2_c3_val_idx
7083 LOG: available indexes for IndexScan(p2_c4): p2_c4_val_idx6 p2_c4_val_idx
7084 LOG: available indexes for IndexScan(p2_c1_c1): p2_c1_c1_val_idx6 p2_c1_c1_val_idx
7085 LOG: available indexes for IndexScan(p2_c1_c2): p2_c1_c2_val_idx6 p2_c1_c2_val_idx
7086 LOG: available indexes for IndexScan(p2_c3_c1): p2_c3_c1_val_idx6 p2_c3_c1_val_idx
7087 LOG: available indexes for IndexScan(p2_c3_c2): p2_c3_c2_val_idx6 p2_c3_c2_val_idx
7090 IndexScan(p2 p2_val_idx p2_val_idx6)
7096 -------------------------------------------------------------------
7098 -> Index Scan using p2_val_idx on p2
7099 Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
7100 Filter: (ctid = '(1,1)'::tid)
7101 -> Index Scan using p2_c1_val_idx on p2_c1
7102 Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
7103 Filter: (ctid = '(1,1)'::tid)
7104 -> Index Scan using p2_c2_val_idx on p2_c2
7105 Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
7106 Filter: (ctid = '(1,1)'::tid)
7107 -> Index Scan using p2_c3_val_idx on p2_c3
7108 Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
7109 Filter: (ctid = '(1,1)'::tid)
7110 -> Index Scan using p2_c4_val_idx on p2_c4
7111 Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
7112 Filter: (ctid = '(1,1)'::tid)
7113 -> Index Scan using p2_c1_c1_val_idx on p2_c1_c1
7114 Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
7115 Filter: (ctid = '(1,1)'::tid)
7116 -> Index Scan using p2_c1_c2_val_idx on p2_c1_c2
7117 Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
7118 Filter: (ctid = '(1,1)'::tid)
7119 -> Index Scan using p2_c3_c1_val_idx on p2_c3_c1
7120 Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
7121 Filter: (ctid = '(1,1)'::tid)
7122 -> Index Scan using p2_c3_c2_val_idx on p2_c3_c2
7123 Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
7124 Filter: (ctid = '(1,1)'::tid)
7127 -- regular expression
7129 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7131 ---------------------------------------------------------------------------------------------
7132 Index Only Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
7133 Index Cond: (id = 1)
7136 /*+ IndexScanRegexp(t5 t5_[^i].*)*/
7137 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7138 LOG: available indexes for IndexScanRegexp(t5): t5_val t5_pkey
7141 IndexScanRegexp(t5 t5_[^i].*)
7147 --------------------------------
7148 Index Scan using t5_pkey on t5
7149 Index Cond: (id = 1)
7152 /*+ IndexScanRegexp(t5 t5_id[0-9].*)*/
7153 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7154 LOG: available indexes for IndexScanRegexp(t5): t5_id3 t5_id2 t5_id1
7157 IndexScanRegexp(t5 t5_id[0-9].*)
7163 -------------------------------
7164 Index Scan using t5_id3 on t5
7165 Index Cond: (id = 1)
7168 /*+ IndexScanRegexp(t5 t5[^_].*)*/
7169 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7170 LOG: available indexes for IndexScanRegexp(t5):
7173 IndexScanRegexp(t5 t5[^_].*)
7179 --------------------
7184 /*+ IndexScanRegexp(t5 ^.*t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab)*/
7185 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7186 LOG: available indexes for IndexScanRegexp(t5):
7189 IndexScanRegexp(t5 ^.*t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab)
7195 --------------------
7200 /*+ IndexScan(t5 t5_id[0-9].*)*/
7201 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7202 LOG: available indexes for IndexScan(t5):
7205 IndexScan(t5 t5_id[0-9].*)
7211 --------------------
7216 /*+ IndexOnlyScanRegexp(t5 t5_[^i].*)*/
7217 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7218 LOG: available indexes for IndexOnlyScanRegexp(t5): t5_val t5_pkey
7221 IndexOnlyScanRegexp(t5 t5_[^i].*)
7227 -------------------------------------
7228 Index Only Scan using t5_pkey on t5
7229 Index Cond: (id = 1)
7232 /*+ IndexOnlyScanRegexp(t5 t5_id[0-9].*)*/
7233 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7234 LOG: available indexes for IndexOnlyScanRegexp(t5): t5_id3 t5_id2 t5_id1
7237 IndexOnlyScanRegexp(t5 t5_id[0-9].*)
7243 ------------------------------------
7244 Index Only Scan using t5_id3 on t5
7245 Index Cond: (id = 1)
7248 /*+ IndexOnlyScanRegexp(t5 t5[^_].*)*/
7249 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7250 LOG: available indexes for IndexOnlyScanRegexp(t5):
7253 IndexOnlyScanRegexp(t5 t5[^_].*)
7259 --------------------
7264 /*+ IndexOnlyScanRegexp(t5 ^.*t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab)*/
7265 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7266 LOG: available indexes for IndexOnlyScanRegexp(t5):
7269 IndexOnlyScanRegexp(t5 ^.*t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab)
7275 --------------------
7280 /*+ IndexOnlyScan(t5 t5_id[0-9].*)*/
7281 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7282 LOG: available indexes for IndexOnlyScan(t5):
7285 IndexOnlyScan(t5 t5_id[0-9].*)
7291 --------------------
7296 /*+ BitmapScanRegexp(t5 t5_[^i].*)*/
7297 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7298 LOG: available indexes for BitmapScanRegexp(t5): t5_val t5_pkey
7301 BitmapScanRegexp(t5 t5_[^i].*)
7307 ------------------------------------
7308 Bitmap Heap Scan on t5
7309 Recheck Cond: (id = 1)
7310 -> Bitmap Index Scan on t5_pkey
7311 Index Cond: (id = 1)
7314 /*+ BitmapScanRegexp(t5 t5_id[0-9].*)*/
7315 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7316 LOG: available indexes for BitmapScanRegexp(t5): t5_id3 t5_id2 t5_id1
7319 BitmapScanRegexp(t5 t5_id[0-9].*)
7325 -----------------------------------
7326 Bitmap Heap Scan on t5
7327 Recheck Cond: (id = 1)
7328 -> Bitmap Index Scan on t5_id3
7329 Index Cond: (id = 1)
7332 /*+ BitmapScanRegexp(t5 t5[^_].*)*/
7333 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7334 LOG: available indexes for BitmapScanRegexp(t5):
7337 BitmapScanRegexp(t5 t5[^_].*)
7343 --------------------
7348 /*+ BitmapScanRegexp(t5 ^.*t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab)*/
7349 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7350 LOG: available indexes for BitmapScanRegexp(t5):
7353 BitmapScanRegexp(t5 ^.*t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab)
7359 --------------------
7364 /*+ BitmapScan(t5 t5_id[0-9].*)*/
7365 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7366 LOG: available indexes for BitmapScan(t5):
7369 BitmapScan(t5 t5_id[0-9].*)
7375 --------------------
7381 EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
7383 ----------------------------
7387 -> Seq Scan on p1_c1
7389 -> Seq Scan on p1_c2
7391 -> Seq Scan on p1_c3
7393 -> Seq Scan on p1_c4
7395 -> Seq Scan on p1_c1_c1
7397 -> Seq Scan on p1_c1_c2
7399 -> Seq Scan on p1_c3_c1
7401 -> Seq Scan on p1_c3_c2
7405 /*+ IndexScanRegexp(p1 p1_.*[^0-9]$)*/
7406 EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
7407 LOG: available indexes for IndexScanRegexp(p1): p1_pkey
7408 LOG: available indexes for IndexScanRegexp(p1_c1): p1_c1_pkey
7409 LOG: available indexes for IndexScanRegexp(p1_c2): p1_c2_pkey
7410 LOG: available indexes for IndexScanRegexp(p1_c3): p1_c3_pkey
7411 LOG: available indexes for IndexScanRegexp(p1_c4): p1_c4_pkey
7412 LOG: available indexes for IndexScanRegexp(p1_c1_c1): p1_c1_c1_pkey
7413 LOG: available indexes for IndexScanRegexp(p1_c1_c2): p1_c1_c2_pkey
7414 LOG: available indexes for IndexScanRegexp(p1_c3_c1): p1_c3_c1_pkey
7415 LOG: available indexes for IndexScanRegexp(p1_c3_c2): p1_c3_c2_pkey
7418 IndexScanRegexp(p1 p1_.*[^0-9]$)
7424 ----------------------------
7428 -> Seq Scan on p1_c1
7430 -> Seq Scan on p1_c2
7432 -> Seq Scan on p1_c3
7434 -> Seq Scan on p1_c4
7436 -> Seq Scan on p1_c1_c1
7438 -> Seq Scan on p1_c1_c2
7440 -> Seq Scan on p1_c3_c1
7442 -> Seq Scan on p1_c3_c2
7446 /*+ IndexScanRegexp(p1 p1_.*val2.*)*/
7447 EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
7448 LOG: available indexes for IndexScanRegexp(p1): p1_val2
7449 LOG: available indexes for IndexScanRegexp(p1_c1): p1_c1_val2
7450 LOG: available indexes for IndexScanRegexp(p1_c2): p1_c2_val2
7451 LOG: available indexes for IndexScanRegexp(p1_c3): p1_c3_val2
7452 LOG: available indexes for IndexScanRegexp(p1_c4): p1_c4_val2
7453 LOG: available indexes for IndexScanRegexp(p1_c1_c1): p1_c1_c1_val2
7454 LOG: available indexes for IndexScanRegexp(p1_c1_c2): p1_c1_c2_val2
7455 LOG: available indexes for IndexScanRegexp(p1_c3_c1): p1_c3_c1_val2
7456 LOG: available indexes for IndexScanRegexp(p1_c3_c2): p1_c3_c2_val2
7459 IndexScanRegexp(p1 p1_.*val2.*)
7465 --------------------------------------------------
7467 -> Index Scan using p1_val2 on p1
7468 Index Cond: (val = 1)
7469 -> Index Scan using p1_c1_val2 on p1_c1
7470 Index Cond: (val = 1)
7471 -> Index Scan using p1_c2_val2 on p1_c2
7472 Index Cond: (val = 1)
7473 -> Index Scan using p1_c3_val2 on p1_c3
7474 Index Cond: (val = 1)
7475 -> Index Scan using p1_c4_val2 on p1_c4
7476 Index Cond: (val = 1)
7477 -> Index Scan using p1_c1_c1_val2 on p1_c1_c1
7478 Index Cond: (val = 1)
7479 -> Index Scan using p1_c1_c2_val2 on p1_c1_c2
7480 Index Cond: (val = 1)
7481 -> Index Scan using p1_c3_c1_val2 on p1_c3_c1
7482 Index Cond: (val = 1)
7483 -> Index Scan using p1_c3_c2_val2 on p1_c3_c2
7484 Index Cond: (val = 1)
7487 /*+ IndexScanRegexp(p1 p1[^_].*)*/
7488 EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
7489 LOG: available indexes for IndexScanRegexp(p1):
7490 LOG: available indexes for IndexScanRegexp(p1_c1):
7491 LOG: available indexes for IndexScanRegexp(p1_c2):
7492 LOG: available indexes for IndexScanRegexp(p1_c3):
7493 LOG: available indexes for IndexScanRegexp(p1_c4):
7494 LOG: available indexes for IndexScanRegexp(p1_c1_c1):
7495 LOG: available indexes for IndexScanRegexp(p1_c1_c2):
7496 LOG: available indexes for IndexScanRegexp(p1_c3_c1):
7497 LOG: available indexes for IndexScanRegexp(p1_c3_c2):
7500 IndexScanRegexp(p1 p1[^_].*)
7506 ----------------------------
7510 -> Seq Scan on p1_c1
7512 -> Seq Scan on p1_c2
7514 -> Seq Scan on p1_c3
7516 -> Seq Scan on p1_c4
7518 -> Seq Scan on p1_c1_c1
7520 -> Seq Scan on p1_c1_c2
7522 -> Seq Scan on p1_c3_c1
7524 -> Seq Scan on p1_c3_c2
7528 /*+ IndexScan(p1 p1_.*val2.*)*/
7529 EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
7530 LOG: available indexes for IndexScan(p1):
7531 LOG: available indexes for IndexScan(p1_c1):
7532 LOG: available indexes for IndexScan(p1_c2):
7533 LOG: available indexes for IndexScan(p1_c3):
7534 LOG: available indexes for IndexScan(p1_c4):
7535 LOG: available indexes for IndexScan(p1_c1_c1):
7536 LOG: available indexes for IndexScan(p1_c1_c2):
7537 LOG: available indexes for IndexScan(p1_c3_c1):
7538 LOG: available indexes for IndexScan(p1_c3_c2):
7541 IndexScan(p1 p1_.*val2.*)
7547 ----------------------------
7551 -> Seq Scan on p1_c1
7553 -> Seq Scan on p1_c2
7555 -> Seq Scan on p1_c3
7557 -> Seq Scan on p1_c4
7559 -> Seq Scan on p1_c1_c1
7561 -> Seq Scan on p1_c1_c2
7563 -> Seq Scan on p1_c3_c1
7565 -> Seq Scan on p1_c3_c2
7569 /*+ IndexOnlyScanRegexp(p1 p1_.*[^0-9]$)*/
7570 EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
7571 LOG: available indexes for IndexOnlyScanRegexp(p1): p1_pkey
7572 LOG: available indexes for IndexOnlyScanRegexp(p1_c1): p1_c1_pkey
7573 LOG: available indexes for IndexOnlyScanRegexp(p1_c2): p1_c2_pkey
7574 LOG: available indexes for IndexOnlyScanRegexp(p1_c3): p1_c3_pkey
7575 LOG: available indexes for IndexOnlyScanRegexp(p1_c4): p1_c4_pkey
7576 LOG: available indexes for IndexOnlyScanRegexp(p1_c1_c1): p1_c1_c1_pkey
7577 LOG: available indexes for IndexOnlyScanRegexp(p1_c1_c2): p1_c1_c2_pkey
7578 LOG: available indexes for IndexOnlyScanRegexp(p1_c3_c1): p1_c3_c1_pkey
7579 LOG: available indexes for IndexOnlyScanRegexp(p1_c3_c2): p1_c3_c2_pkey
7582 IndexOnlyScanRegexp(p1 p1_.*[^0-9]$)
7588 ----------------------------
7592 -> Seq Scan on p1_c1
7594 -> Seq Scan on p1_c2
7596 -> Seq Scan on p1_c3
7598 -> Seq Scan on p1_c4
7600 -> Seq Scan on p1_c1_c1
7602 -> Seq Scan on p1_c1_c2
7604 -> Seq Scan on p1_c3_c1
7606 -> Seq Scan on p1_c3_c2
7610 /*+ IndexOnlyScanRegexp(p1 p1_.*val2.*)*/
7611 EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
7612 LOG: available indexes for IndexOnlyScanRegexp(p1): p1_val2
7613 LOG: available indexes for IndexOnlyScanRegexp(p1_c1): p1_c1_val2
7614 LOG: available indexes for IndexOnlyScanRegexp(p1_c2): p1_c2_val2
7615 LOG: available indexes for IndexOnlyScanRegexp(p1_c3): p1_c3_val2
7616 LOG: available indexes for IndexOnlyScanRegexp(p1_c4): p1_c4_val2
7617 LOG: available indexes for IndexOnlyScanRegexp(p1_c1_c1): p1_c1_c1_val2
7618 LOG: available indexes for IndexOnlyScanRegexp(p1_c1_c2): p1_c1_c2_val2
7619 LOG: available indexes for IndexOnlyScanRegexp(p1_c3_c1): p1_c3_c1_val2
7620 LOG: available indexes for IndexOnlyScanRegexp(p1_c3_c2): p1_c3_c2_val2
7623 IndexOnlyScanRegexp(p1 p1_.*val2.*)
7629 -------------------------------------------------------
7631 -> Index Only Scan using p1_val2 on p1
7632 Index Cond: (val = 1)
7633 -> Index Only Scan using p1_c1_val2 on p1_c1
7634 Index Cond: (val = 1)
7635 -> Index Only Scan using p1_c2_val2 on p1_c2
7636 Index Cond: (val = 1)
7637 -> Index Only Scan using p1_c3_val2 on p1_c3
7638 Index Cond: (val = 1)
7639 -> Index Only Scan using p1_c4_val2 on p1_c4
7640 Index Cond: (val = 1)
7641 -> Index Only Scan using p1_c1_c1_val2 on p1_c1_c1
7642 Index Cond: (val = 1)
7643 -> Index Only Scan using p1_c1_c2_val2 on p1_c1_c2
7644 Index Cond: (val = 1)
7645 -> Index Only Scan using p1_c3_c1_val2 on p1_c3_c1
7646 Index Cond: (val = 1)
7647 -> Index Only Scan using p1_c3_c2_val2 on p1_c3_c2
7648 Index Cond: (val = 1)
7651 /*+ IndexOnlyScanRegexp(p1 p1[^_].*)*/
7652 EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
7653 LOG: available indexes for IndexOnlyScanRegexp(p1):
7654 LOG: available indexes for IndexOnlyScanRegexp(p1_c1):
7655 LOG: available indexes for IndexOnlyScanRegexp(p1_c2):
7656 LOG: available indexes for IndexOnlyScanRegexp(p1_c3):
7657 LOG: available indexes for IndexOnlyScanRegexp(p1_c4):
7658 LOG: available indexes for IndexOnlyScanRegexp(p1_c1_c1):
7659 LOG: available indexes for IndexOnlyScanRegexp(p1_c1_c2):
7660 LOG: available indexes for IndexOnlyScanRegexp(p1_c3_c1):
7661 LOG: available indexes for IndexOnlyScanRegexp(p1_c3_c2):
7664 IndexOnlyScanRegexp(p1 p1[^_].*)
7670 ----------------------------
7674 -> Seq Scan on p1_c1
7676 -> Seq Scan on p1_c2
7678 -> Seq Scan on p1_c3
7680 -> Seq Scan on p1_c4
7682 -> Seq Scan on p1_c1_c1
7684 -> Seq Scan on p1_c1_c2
7686 -> Seq Scan on p1_c3_c1
7688 -> Seq Scan on p1_c3_c2
7692 /*+ IndexOnlyScan(p1 p1_.*val2.*)*/
7693 EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
7694 LOG: available indexes for IndexOnlyScan(p1):
7695 LOG: available indexes for IndexOnlyScan(p1_c1):
7696 LOG: available indexes for IndexOnlyScan(p1_c2):
7697 LOG: available indexes for IndexOnlyScan(p1_c3):
7698 LOG: available indexes for IndexOnlyScan(p1_c4):
7699 LOG: available indexes for IndexOnlyScan(p1_c1_c1):
7700 LOG: available indexes for IndexOnlyScan(p1_c1_c2):
7701 LOG: available indexes for IndexOnlyScan(p1_c3_c1):
7702 LOG: available indexes for IndexOnlyScan(p1_c3_c2):
7705 IndexOnlyScan(p1 p1_.*val2.*)
7711 ----------------------------
7715 -> Seq Scan on p1_c1
7717 -> Seq Scan on p1_c2
7719 -> Seq Scan on p1_c3
7721 -> Seq Scan on p1_c4
7723 -> Seq Scan on p1_c1_c1
7725 -> Seq Scan on p1_c1_c2
7727 -> Seq Scan on p1_c3_c1
7729 -> Seq Scan on p1_c3_c2
7733 /*+ BitmapScanRegexp(p1 p1_.*[^0-9]$)*/
7734 EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
7735 LOG: available indexes for BitmapScanRegexp(p1): p1_pkey
7736 LOG: available indexes for BitmapScanRegexp(p1_c1): p1_c1_pkey
7737 LOG: available indexes for BitmapScanRegexp(p1_c2): p1_c2_pkey
7738 LOG: available indexes for BitmapScanRegexp(p1_c3): p1_c3_pkey
7739 LOG: available indexes for BitmapScanRegexp(p1_c4): p1_c4_pkey
7740 LOG: available indexes for BitmapScanRegexp(p1_c1_c1): p1_c1_c1_pkey
7741 LOG: available indexes for BitmapScanRegexp(p1_c1_c2): p1_c1_c2_pkey
7742 LOG: available indexes for BitmapScanRegexp(p1_c3_c1): p1_c3_c1_pkey
7743 LOG: available indexes for BitmapScanRegexp(p1_c3_c2): p1_c3_c2_pkey
7746 BitmapScanRegexp(p1 p1_.*[^0-9]$)
7752 ----------------------------
7756 -> Seq Scan on p1_c1
7758 -> Seq Scan on p1_c2
7760 -> Seq Scan on p1_c3
7762 -> Seq Scan on p1_c4
7764 -> Seq Scan on p1_c1_c1
7766 -> Seq Scan on p1_c1_c2
7768 -> Seq Scan on p1_c3_c1
7770 -> Seq Scan on p1_c3_c2
7774 /*+ BitmapScanRegexp(p1 p1_.*val2.*)*/
7775 EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
7776 LOG: available indexes for BitmapScanRegexp(p1): p1_val2
7777 LOG: available indexes for BitmapScanRegexp(p1_c1): p1_c1_val2
7778 LOG: available indexes for BitmapScanRegexp(p1_c2): p1_c2_val2
7779 LOG: available indexes for BitmapScanRegexp(p1_c3): p1_c3_val2
7780 LOG: available indexes for BitmapScanRegexp(p1_c4): p1_c4_val2
7781 LOG: available indexes for BitmapScanRegexp(p1_c1_c1): p1_c1_c1_val2
7782 LOG: available indexes for BitmapScanRegexp(p1_c1_c2): p1_c1_c2_val2
7783 LOG: available indexes for BitmapScanRegexp(p1_c3_c1): p1_c3_c1_val2
7784 LOG: available indexes for BitmapScanRegexp(p1_c3_c2): p1_c3_c2_val2
7787 BitmapScanRegexp(p1 p1_.*val2.*)
7793 ------------------------------------------------
7795 -> Bitmap Heap Scan on p1
7796 Recheck Cond: (val = 1)
7797 -> Bitmap Index Scan on p1_val2
7798 Index Cond: (val = 1)
7799 -> Bitmap Heap Scan on p1_c1
7800 Recheck Cond: (val = 1)
7801 -> Bitmap Index Scan on p1_c1_val2
7802 Index Cond: (val = 1)
7803 -> Bitmap Heap Scan on p1_c2
7804 Recheck Cond: (val = 1)
7805 -> Bitmap Index Scan on p1_c2_val2
7806 Index Cond: (val = 1)
7807 -> Bitmap Heap Scan on p1_c3
7808 Recheck Cond: (val = 1)
7809 -> Bitmap Index Scan on p1_c3_val2
7810 Index Cond: (val = 1)
7811 -> Bitmap Heap Scan on p1_c4
7812 Recheck Cond: (val = 1)
7813 -> Bitmap Index Scan on p1_c4_val2
7814 Index Cond: (val = 1)
7815 -> Bitmap Heap Scan on p1_c1_c1
7816 Recheck Cond: (val = 1)
7817 -> Bitmap Index Scan on p1_c1_c1_val2
7818 Index Cond: (val = 1)
7819 -> Bitmap Heap Scan on p1_c1_c2
7820 Recheck Cond: (val = 1)
7821 -> Bitmap Index Scan on p1_c1_c2_val2
7822 Index Cond: (val = 1)
7823 -> Bitmap Heap Scan on p1_c3_c1
7824 Recheck Cond: (val = 1)
7825 -> Bitmap Index Scan on p1_c3_c1_val2
7826 Index Cond: (val = 1)
7827 -> Bitmap Heap Scan on p1_c3_c2
7828 Recheck Cond: (val = 1)
7829 -> Bitmap Index Scan on p1_c3_c2_val2
7830 Index Cond: (val = 1)
7833 /*+ BitmapScanRegexp(p1 p1[^_].*)*/
7834 EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
7835 LOG: available indexes for BitmapScanRegexp(p1):
7836 LOG: available indexes for BitmapScanRegexp(p1_c1):
7837 LOG: available indexes for BitmapScanRegexp(p1_c2):
7838 LOG: available indexes for BitmapScanRegexp(p1_c3):
7839 LOG: available indexes for BitmapScanRegexp(p1_c4):
7840 LOG: available indexes for BitmapScanRegexp(p1_c1_c1):
7841 LOG: available indexes for BitmapScanRegexp(p1_c1_c2):
7842 LOG: available indexes for BitmapScanRegexp(p1_c3_c1):
7843 LOG: available indexes for BitmapScanRegexp(p1_c3_c2):
7846 BitmapScanRegexp(p1 p1[^_].*)
7852 ----------------------------
7856 -> Seq Scan on p1_c1
7858 -> Seq Scan on p1_c2
7860 -> Seq Scan on p1_c3
7862 -> Seq Scan on p1_c4
7864 -> Seq Scan on p1_c1_c1
7866 -> Seq Scan on p1_c1_c2
7868 -> Seq Scan on p1_c3_c1
7870 -> Seq Scan on p1_c3_c2
7874 /*+ BitmapScan(p1 p1_.*val2.*)*/
7875 EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
7876 LOG: available indexes for BitmapScan(p1):
7877 LOG: available indexes for BitmapScan(p1_c1):
7878 LOG: available indexes for BitmapScan(p1_c2):
7879 LOG: available indexes for BitmapScan(p1_c3):
7880 LOG: available indexes for BitmapScan(p1_c4):
7881 LOG: available indexes for BitmapScan(p1_c1_c1):
7882 LOG: available indexes for BitmapScan(p1_c1_c2):
7883 LOG: available indexes for BitmapScan(p1_c3_c1):
7884 LOG: available indexes for BitmapScan(p1_c3_c2):
7887 BitmapScan(p1 p1_.*val2.*)
7893 ----------------------------
7897 -> Seq Scan on p1_c1
7899 -> Seq Scan on p1_c2
7901 -> Seq Scan on p1_c3
7903 -> Seq Scan on p1_c4
7905 -> Seq Scan on p1_c1_c1
7907 -> Seq Scan on p1_c1_c2
7909 -> Seq Scan on p1_c3_c1
7911 -> Seq Scan on p1_c3_c2
7915 -- search from hint table
7916 INSERT INTO hint_plan.hints (norm_query_string, application_name, hints) VALUES ('EXPLAIN (COSTS false) SELECT * FROM t1 WHERE t1.id = ?;', '', 'SeqScan(t1)');
7917 INSERT INTO hint_plan.hints (norm_query_string, application_name, hints) VALUES ('EXPLAIN (COSTS false) SELECT id FROM t1 WHERE t1.id = ?;', '', 'IndexScan(t1)');
7918 INSERT INTO hint_plan.hints (norm_query_string, application_name, hints) VALUES ('EXPLAIN SELECT * FROM t1 WHERE t1.id = ?;', '', 'BitmapScan(t1)');
7919 SELECT * FROM hint_plan.hints ORDER BY id;
7920 id | norm_query_string | application_name | hints
7921 ----+----------------------------------------------------------+------------------+----------------
7922 1 | EXPLAIN (COSTS false) SELECT * FROM t1 WHERE t1.id = ?; | | SeqScan(t1)
7923 2 | EXPLAIN (COSTS false) SELECT id FROM t1 WHERE t1.id = ?; | | IndexScan(t1)
7924 3 | EXPLAIN SELECT * FROM t1 WHERE t1.id = ?; | | BitmapScan(t1)
7927 SET pg_hint_plan.enable_hint_table = on;
7928 EXPLAIN (COSTS false) SELECT * FROM t1 WHERE t1.id = 1;
7937 --------------------
7942 SET pg_hint_plan.enable_hint_table = off;
7943 EXPLAIN (COSTS false) SELECT * FROM t1 WHERE t1.id = 1;
7945 --------------------------------
7946 Index Scan using t1_pkey on t1
7947 Index Cond: (id = 1)
7950 TRUNCATE hint_plan.hints;
7951 VACUUM ANALYZE hint_plan.hints;
7953 EXPLAIN (COSTS false) SELECT id FROM t1 WHERE t1.id = 1;
7955 -------------------------------------
7956 Index Only Scan using t1_pkey on t1
7957 Index Cond: (id = 1)
7961 CREATE FUNCTION testfunc() RETURNS RECORD AS $$
7965 SELECT /*+ SeqScan(t1) */ * INTO ret FROM t1 LIMIT 1;
7968 $$ LANGUAGE plpgsql;
7977 CONTEXT: SQL statement "SELECT /*+ SeqScan(t1) */ * FROM t1 LIMIT 1"
7978 PL/pgSQL function testfunc() line 5 at SQL statement
7985 DROP FUNCTION testfunc();
7986 CREATE FUNCTION testfunc() RETURNS void AS $$
7988 EXECUTE format('/*+ SeqScan(t1) */ SELECT * FROM t1');
7990 $$ LANGUAGE plpgsql;
7999 CONTEXT: SQL statement "/*+ SeqScan(t1) */ SELECT * FROM t1"
8000 PL/pgSQL function testfunc() line 3 at EXECUTE
8006 -- This should not use SeqScan(t1)
8007 /*+ IndexScan(t1) */ SELECT * from t1 LIMIT 1;
8021 DROP FUNCTION testfunc();
8022 CREATE FUNCTION testfunc() RETURNS void AS $$
8024 PERFORM 1, /*+ SeqScan(t1) */ * from t1;
8026 $$ LANGUAGE plpgsql;
8035 CONTEXT: SQL statement "SELECT 1, /*+ SeqScan(t1) */ * from t1"
8036 PL/pgSQL function testfunc() line 3 at PERFORM
8043 DROP FUNCTION testfunc();
8044 CREATE FUNCTION testfunc() RETURNS int AS $$
8050 FOR v IN SELECT /*+ SeqScan(t1) */ v FROM t1 ORDER BY id LOOP
8055 $$ LANGUAGE plpgsql;
8064 CONTEXT: SQL statement "SELECT /*+ SeqScan(t1) */ v FROM t1 ORDER BY id"
8065 PL/pgSQL function testfunc() line 7 at FOR over SELECT rows
8072 DROP FUNCTION testfunc();
8073 CREATE FUNCTION testfunc() RETURNS int AS $$
8080 FOR v IN EXECUTE 'SELECT /*+ SeqScan(t1) */ val FROM t1 ORDER BY id' LOOP
8085 $$ LANGUAGE plpgsql;
8094 CONTEXT: SQL statement "SELECT /*+ SeqScan(t1) */ val FROM t1 ORDER BY id"
8095 PL/pgSQL function testfunc() line 8 at FOR over EXECUTE statement
8102 DROP FUNCTION testfunc();
8103 CREATE FUNCTION testfunc() RETURNS int AS $$
8105 ref CURSOR FOR SELECT /*+ SeqScan(t1) */ * FROM t1 ORDER BY id;
8110 sum := sum + rec.val;
8114 $$ LANGUAGE plpgsql;
8123 CONTEXT: SQL statement "SELECT /*+ SeqScan(t1) */ * FROM t1 ORDER BY id"
8124 PL/pgSQL function testfunc() line 7 at FOR over cursor
8131 DROP FUNCTION testfunc();
8132 CREATE FUNCTION testfunc() RETURNS SETOF t1 AS $$
8134 RETURN QUERY SELECT /*+ SeqScan(t1) */ * FROM t1 ORDER BY id;
8136 $$ LANGUAGE plpgsql;
8137 SELECT * FROM testfunc() LIMIT 1;
8145 CONTEXT: SQL statement "SELECT /*+ SeqScan(t1) */ * FROM t1 ORDER BY id"
8146 PL/pgSQL function testfunc() line 3 at RETURN QUERY
8152 -- Test for error exit from inner SQL statement.
8153 DROP FUNCTION testfunc();
8154 CREATE FUNCTION testfunc() RETURNS SETOF t1 AS $$
8156 RETURN QUERY SELECT /*+ SeqScan(t1) */ * FROM ttx ORDER BY id;
8158 $$ LANGUAGE plpgsql;
8159 SELECT * FROM testfunc() LIMIT 1;
8160 ERROR: relation "ttx" does not exist
8161 LINE 1: SELECT /*+ SeqScan(t1) */ * FROM ttx ORDER BY id
8163 QUERY: SELECT /*+ SeqScan(t1) */ * FROM ttx ORDER BY id
8164 CONTEXT: PL/pgSQL function testfunc() line 3 at RETURN QUERY
8165 -- this should not use SeqScan(t1) hint.
8166 /*+ IndexScan(t1) */ SELECT * from t1 LIMIT 1;
8179 DROP FUNCTION testfunc();
8180 DROP EXTENSION pg_hint_plan;
8181 CREATE FUNCTION reset_stats_and_wait() RETURNS void AS $$
8187 PERFORM pg_stat_reset();
8188 PERFORM pg_sleep(0.5);
8189 SELECT sum(seq_scan + idx_scan) from pg_stat_user_tables into rows;
8192 $$ LANGUAGE plpgsql;
8193 -- Dynamic query in pl/pgsql
8194 CREATE OR REPLACE FUNCTION dynsql1(x int) RETURNS int AS $$
8197 EXECUTE '/*+ IndexScan(t1) */ SELECT count(*) FROM t1 WHERE id < $1'
8201 $$ VOLATILE LANGUAGE plpgsql;
8203 SET pg_hint_plan.enable_hint = false;
8204 SELECT reset_stats_and_wait();
8205 reset_stats_and_wait
8206 ----------------------
8210 SELECT dynsql1(9000);
8222 SELECT relname, seq_scan > 0 as seq_scan, idx_scan > 0 as idx_scan FROM pg_stat_user_tables WHERE schemaname = 'public' AND relname = 't1';
8223 relname | seq_scan | idx_scan
8224 ---------+----------+----------
8228 SET pg_hint_plan.enable_hint = true;
8229 SELECT reset_stats_and_wait();
8230 reset_stats_and_wait
8231 ----------------------
8235 SELECT dynsql1(9000);
8243 CONTEXT: SQL statement "/*+ IndexScan(t1) */ SELECT count(*) FROM t1 WHERE id < $1"
8244 PL/pgSQL function dynsql1(integer) line 4 at EXECUTE
8256 SELECT relname, seq_scan > 0 as seq_scan, idx_scan > 0 as idx_scan FROM pg_stat_user_tables WHERE schemaname = 'public' AND relname = 't1';
8257 relname | seq_scan | idx_scan
8258 ---------+----------+----------
8262 -- Looped dynamic query in pl/pgsql
8263 CREATE OR REPLACE FUNCTION dynsql2(x int, OUT r int) AS $$
8269 FOR c IN SELECT f.f FROM (VALUES ('p1_c1'), ('p1_c2')) f(f) LOOP
8270 FOR s IN EXECUTE '/*+ IndexScan(' || c || ' ' || c || '_pkey) */ SELECT sum(val) FROM ' || c || ' WHERE id < ' || x LOOP
8275 $$ VOLATILE LANGUAGE plpgsql;
8276 SET pg_hint_plan.enable_hint = false;
8277 SELECT reset_stats_and_wait();
8278 reset_stats_and_wait
8279 ----------------------
8283 SELECT dynsql2(9000);
8295 -- one of the index scans happened while planning.
8296 SELECT relname, seq_scan, idx_scan FROM pg_stat_user_tables WHERE schemaname = 'public' AND (relname = 'p1_c1' OR relname = 'p1_c2');
8297 relname | seq_scan | idx_scan
8298 ---------+----------+----------
8303 SET pg_hint_plan.enable_hint = true;
8304 SELECT reset_stats_and_wait();
8305 reset_stats_and_wait
8306 ----------------------
8310 SELECT dynsql2(9000);
8311 LOG: available indexes for IndexScan(p1_c1): p1_c1_pkey
8312 CONTEXT: SQL statement "/*+ IndexScan(p1_c1 p1_c1_pkey) */ SELECT sum(val) FROM p1_c1 WHERE id < 9000"
8313 PL/pgSQL function dynsql2(integer) line 8 at FOR over EXECUTE statement
8314 LOG: available indexes for IndexScan(p1_c1_c1): p1_c1_c1_pkey
8315 CONTEXT: SQL statement "/*+ IndexScan(p1_c1 p1_c1_pkey) */ SELECT sum(val) FROM p1_c1 WHERE id < 9000"
8316 PL/pgSQL function dynsql2(integer) line 8 at FOR over EXECUTE statement
8317 LOG: available indexes for IndexScan(p1_c1_c2): p1_c1_c2_pkey
8318 CONTEXT: SQL statement "/*+ IndexScan(p1_c1 p1_c1_pkey) */ SELECT sum(val) FROM p1_c1 WHERE id < 9000"
8319 PL/pgSQL function dynsql2(integer) line 8 at FOR over EXECUTE statement
8322 IndexScan(p1_c1 p1_c1_pkey)
8327 CONTEXT: SQL statement "/*+ IndexScan(p1_c1 p1_c1_pkey) */ SELECT sum(val) FROM p1_c1 WHERE id < 9000"
8328 PL/pgSQL function dynsql2(integer) line 8 at FOR over EXECUTE statement
8329 LOG: available indexes for IndexScan(p1_c2): p1_c2_pkey
8330 CONTEXT: SQL statement "/*+ IndexScan(p1_c2 p1_c2_pkey) */ SELECT sum(val) FROM p1_c2 WHERE id < 9000"
8331 PL/pgSQL function dynsql2(integer) line 8 at FOR over EXECUTE statement
8334 IndexScan(p1_c2 p1_c2_pkey)
8339 CONTEXT: SQL statement "/*+ IndexScan(p1_c2 p1_c2_pkey) */ SELECT sum(val) FROM p1_c2 WHERE id < 9000"
8340 PL/pgSQL function dynsql2(integer) line 8 at FOR over EXECUTE statement
8352 -- the index scan happened while planning.
8353 SELECT relname, seq_scan, idx_scan FROM pg_stat_user_tables WHERE schemaname = 'public' AND (relname = 'p1_c1' OR relname = 'p1_c2');
8354 relname | seq_scan | idx_scan
8355 ---------+----------+----------
8360 -- Subqueries on inheritance tables under UNION
8361 EXPLAIN (COSTS off) SELECT val FROM p1 WHERE val < 1000
8363 SELECT val::int FROM p2 WHERE id < 1000;
8365 -----------------------------------------
8369 Filter: (val < 1000)
8370 -> Seq Scan on p1_c1
8371 Filter: (val < 1000)
8372 -> Seq Scan on p1_c2
8373 Filter: (val < 1000)
8374 -> Seq Scan on p1_c3
8375 Filter: (val < 1000)
8376 -> Seq Scan on p1_c4
8377 Filter: (val < 1000)
8378 -> Seq Scan on p1_c1_c1
8379 Filter: (val < 1000)
8380 -> Seq Scan on p1_c1_c2
8381 Filter: (val < 1000)
8382 -> Seq Scan on p1_c3_c1
8383 Filter: (val < 1000)
8384 -> Seq Scan on p1_c3_c2
8385 Filter: (val < 1000)
8390 -> Seq Scan on p2_c1
8392 -> Seq Scan on p2_c2
8394 -> Seq Scan on p2_c3
8396 -> Seq Scan on p2_c4
8398 -> Seq Scan on p2_c1_c1
8400 -> Seq Scan on p2_c1_c2
8402 -> Seq Scan on p2_c3_c1
8404 -> Seq Scan on p2_c3_c2
8408 /*+ IndexScan(p1 p1_val2) */
8409 EXPLAIN (COSTS off) SELECT val FROM p1 WHERE val < 1000
8411 SELECT val::int FROM p2 WHERE id < 1000;
8412 LOG: available indexes for IndexScan(p1): p1_val3 p1_val2 p1_val1
8413 LOG: available indexes for IndexScan(p1_c1): p1_c1_val3 p1_c1_val2 p1_c1_val1
8414 LOG: available indexes for IndexScan(p1_c2): p1_c2_val3 p1_c2_val2 p1_c2_val1
8415 LOG: available indexes for IndexScan(p1_c3): p1_c3_val3 p1_c3_val2 p1_c3_val1
8416 LOG: available indexes for IndexScan(p1_c4): p1_c4_val3 p1_c4_val2 p1_c4_val1
8417 LOG: available indexes for IndexScan(p1_c1_c1): p1_c1_c1_val3 p1_c1_c1_val2 p1_c1_c1_val1
8418 LOG: available indexes for IndexScan(p1_c1_c2): p1_c1_c2_val3 p1_c1_c2_val2 p1_c1_c2_val1
8419 LOG: available indexes for IndexScan(p1_c3_c1): p1_c3_c1_val3 p1_c3_c1_val2 p1_c3_c1_val1
8420 LOG: available indexes for IndexScan(p1_c3_c2): p1_c3_c2_val3 p1_c3_c2_val2 p1_c3_c2_val1
8423 IndexScan(p1 p1_val2)
8429 --------------------------------------------------------
8432 -> Index Scan using p1_val3 on p1
8433 Index Cond: (val < 1000)
8434 -> Index Scan using p1_c1_val3 on p1_c1
8435 Index Cond: (val < 1000)
8436 -> Index Scan using p1_c2_val3 on p1_c2
8437 Index Cond: (val < 1000)
8438 -> Index Scan using p1_c3_val3 on p1_c3
8439 Index Cond: (val < 1000)
8440 -> Index Scan using p1_c4_val3 on p1_c4
8441 Index Cond: (val < 1000)
8442 -> Index Scan using p1_c1_c1_val3 on p1_c1_c1
8443 Index Cond: (val < 1000)
8444 -> Index Scan using p1_c1_c2_val3 on p1_c1_c2
8445 Index Cond: (val < 1000)
8446 -> Index Scan using p1_c3_c1_val3 on p1_c3_c1
8447 Index Cond: (val < 1000)
8448 -> Index Scan using p1_c3_c2_val3 on p1_c3_c2
8449 Index Cond: (val < 1000)
8454 -> Seq Scan on p2_c1
8456 -> Seq Scan on p2_c2
8458 -> Seq Scan on p2_c3
8460 -> Seq Scan on p2_c4
8462 -> Seq Scan on p2_c1_c1
8464 -> Seq Scan on p2_c1_c2
8466 -> Seq Scan on p2_c3_c1
8468 -> Seq Scan on p2_c3_c2
8472 /*+ IndexScan(p1 p1_val2) IndexScan(p2 p2_id_val_idx) */
8473 EXPLAIN (COSTS off) SELECT val FROM p1 WHERE val < 1000
8475 SELECT val::int FROM p2 WHERE id < 1000;
8476 LOG: available indexes for IndexScan(p1): p1_val3 p1_val2 p1_val1
8477 LOG: available indexes for IndexScan(p1_c1): p1_c1_val3 p1_c1_val2 p1_c1_val1
8478 LOG: available indexes for IndexScan(p1_c2): p1_c2_val3 p1_c2_val2 p1_c2_val1
8479 LOG: available indexes for IndexScan(p1_c3): p1_c3_val3 p1_c3_val2 p1_c3_val1
8480 LOG: available indexes for IndexScan(p1_c4): p1_c4_val3 p1_c4_val2 p1_c4_val1
8481 LOG: available indexes for IndexScan(p1_c1_c1): p1_c1_c1_val3 p1_c1_c1_val2 p1_c1_c1_val1
8482 LOG: available indexes for IndexScan(p1_c1_c2): p1_c1_c2_val3 p1_c1_c2_val2 p1_c1_c2_val1
8483 LOG: available indexes for IndexScan(p1_c3_c1): p1_c3_c1_val3 p1_c3_c1_val2 p1_c3_c1_val1
8484 LOG: available indexes for IndexScan(p1_c3_c2): p1_c3_c2_val3 p1_c3_c2_val2 p1_c3_c2_val1
8485 LOG: available indexes for IndexScan(p2): p2_id_val_idx
8486 LOG: available indexes for IndexScan(p2_c1): p2_c1_id_val_idx
8487 LOG: available indexes for IndexScan(p2_c2): p2_c2_id_val_idx
8488 LOG: available indexes for IndexScan(p2_c3): p2_c3_id_val_idx
8489 LOG: available indexes for IndexScan(p2_c4): p2_c4_id_val_idx
8490 LOG: available indexes for IndexScan(p2_c1_c1): p2_c1_c1_id_val_idx
8491 LOG: available indexes for IndexScan(p2_c1_c2): p2_c1_c2_id_val_idx
8492 LOG: available indexes for IndexScan(p2_c3_c1): p2_c3_c1_id_val_idx
8493 LOG: available indexes for IndexScan(p2_c3_c2): p2_c3_c2_id_val_idx
8496 IndexScan(p1 p1_val2)
8497 IndexScan(p2 p2_id_val_idx)
8503 --------------------------------------------------------------------
8506 -> Index Scan using p1_val3 on p1
8507 Index Cond: (val < 1000)
8508 -> Index Scan using p1_c1_val3 on p1_c1
8509 Index Cond: (val < 1000)
8510 -> Index Scan using p1_c2_val3 on p1_c2
8511 Index Cond: (val < 1000)
8512 -> Index Scan using p1_c3_val3 on p1_c3
8513 Index Cond: (val < 1000)
8514 -> Index Scan using p1_c4_val3 on p1_c4
8515 Index Cond: (val < 1000)
8516 -> Index Scan using p1_c1_c1_val3 on p1_c1_c1
8517 Index Cond: (val < 1000)
8518 -> Index Scan using p1_c1_c2_val3 on p1_c1_c2
8519 Index Cond: (val < 1000)
8520 -> Index Scan using p1_c3_c1_val3 on p1_c3_c1
8521 Index Cond: (val < 1000)
8522 -> Index Scan using p1_c3_c2_val3 on p1_c3_c2
8523 Index Cond: (val < 1000)
8526 -> Index Scan using p2_id_val_idx on p2
8527 Index Cond: (id < 1000)
8528 -> Index Scan using p2_c1_id_val_idx on p2_c1
8529 Index Cond: (id < 1000)
8530 -> Index Scan using p2_c2_id_val_idx on p2_c2
8531 Index Cond: (id < 1000)
8532 -> Index Scan using p2_c3_id_val_idx on p2_c3
8533 Index Cond: (id < 1000)
8534 -> Index Scan using p2_c4_id_val_idx on p2_c4
8535 Index Cond: (id < 1000)
8536 -> Index Scan using p2_c1_c1_id_val_idx on p2_c1_c1
8537 Index Cond: (id < 1000)
8538 -> Index Scan using p2_c1_c2_id_val_idx on p2_c1_c2
8539 Index Cond: (id < 1000)
8540 -> Index Scan using p2_c3_c1_id_val_idx on p2_c3_c1
8541 Index Cond: (id < 1000)
8542 -> Index Scan using p2_c3_c2_id_val_idx on p2_c3_c2
8543 Index Cond: (id < 1000)
8547 EXPLAIN (COSTS off) SELECT val FROM p1 WHERE val < 1000
8549 SELECT val::int FROM p2 WHERE id < 1000;
8551 -----------------------------------------------
8557 Filter: (val < 1000)
8558 -> Seq Scan on p1_c1
8559 Filter: (val < 1000)
8560 -> Seq Scan on p1_c2
8561 Filter: (val < 1000)
8562 -> Seq Scan on p1_c3
8563 Filter: (val < 1000)
8564 -> Seq Scan on p1_c4
8565 Filter: (val < 1000)
8566 -> Seq Scan on p1_c1_c1
8567 Filter: (val < 1000)
8568 -> Seq Scan on p1_c1_c2
8569 Filter: (val < 1000)
8570 -> Seq Scan on p1_c3_c1
8571 Filter: (val < 1000)
8572 -> Seq Scan on p1_c3_c2
8573 Filter: (val < 1000)
8578 -> Seq Scan on p2_c1
8580 -> Seq Scan on p2_c2
8582 -> Seq Scan on p2_c3
8584 -> Seq Scan on p2_c4
8586 -> Seq Scan on p2_c1_c1
8588 -> Seq Scan on p2_c1_c2
8590 -> Seq Scan on p2_c3_c1
8592 -> Seq Scan on p2_c3_c2
8596 /*+ IndexScan(p2 p2_id_val_idx) */
8597 EXPLAIN (COSTS off) SELECT val FROM p1 WHERE val < 1000
8599 SELECT val::int FROM p2 WHERE id < 1000;
8600 LOG: available indexes for IndexScan(p2): p2_id_val_idx
8601 LOG: available indexes for IndexScan(p2_c1): p2_c1_id_val_idx
8602 LOG: available indexes for IndexScan(p2_c2): p2_c2_id_val_idx
8603 LOG: available indexes for IndexScan(p2_c3): p2_c3_id_val_idx
8604 LOG: available indexes for IndexScan(p2_c4): p2_c4_id_val_idx
8605 LOG: available indexes for IndexScan(p2_c1_c1): p2_c1_c1_id_val_idx
8606 LOG: available indexes for IndexScan(p2_c1_c2): p2_c1_c2_id_val_idx
8607 LOG: available indexes for IndexScan(p2_c3_c1): p2_c3_c1_id_val_idx
8608 LOG: available indexes for IndexScan(p2_c3_c2): p2_c3_c2_id_val_idx
8611 IndexScan(p2 p2_id_val_idx)
8617 --------------------------------------------------------------------------
8623 Filter: (val < 1000)
8624 -> Seq Scan on p1_c1
8625 Filter: (val < 1000)
8626 -> Seq Scan on p1_c2
8627 Filter: (val < 1000)
8628 -> Seq Scan on p1_c3
8629 Filter: (val < 1000)
8630 -> Seq Scan on p1_c4
8631 Filter: (val < 1000)
8632 -> Seq Scan on p1_c1_c1
8633 Filter: (val < 1000)
8634 -> Seq Scan on p1_c1_c2
8635 Filter: (val < 1000)
8636 -> Seq Scan on p1_c3_c1
8637 Filter: (val < 1000)
8638 -> Seq Scan on p1_c3_c2
8639 Filter: (val < 1000)
8642 -> Index Scan using p2_id_val_idx on p2
8643 Index Cond: (id < 1000)
8644 -> Index Scan using p2_c1_id_val_idx on p2_c1
8645 Index Cond: (id < 1000)
8646 -> Index Scan using p2_c2_id_val_idx on p2_c2
8647 Index Cond: (id < 1000)
8648 -> Index Scan using p2_c3_id_val_idx on p2_c3
8649 Index Cond: (id < 1000)
8650 -> Index Scan using p2_c4_id_val_idx on p2_c4
8651 Index Cond: (id < 1000)
8652 -> Index Scan using p2_c1_c1_id_val_idx on p2_c1_c1
8653 Index Cond: (id < 1000)
8654 -> Index Scan using p2_c1_c2_id_val_idx on p2_c1_c2
8655 Index Cond: (id < 1000)
8656 -> Index Scan using p2_c3_c1_id_val_idx on p2_c3_c1
8657 Index Cond: (id < 1000)
8658 -> Index Scan using p2_c3_c2_id_val_idx on p2_c3_c2
8659 Index Cond: (id < 1000)
8662 /*+ IndexScan(p1 p1_val2) IndexScan(p2 p2_id_val_idx) */
8663 EXPLAIN (COSTS off) SELECT val FROM p1 WHERE val < 1000
8665 SELECT val::int FROM p2 WHERE id < 1000;
8666 LOG: available indexes for IndexScan(p2): p2_id_val_idx
8667 LOG: available indexes for IndexScan(p2_c1): p2_c1_id_val_idx
8668 LOG: available indexes for IndexScan(p2_c2): p2_c2_id_val_idx
8669 LOG: available indexes for IndexScan(p2_c3): p2_c3_id_val_idx
8670 LOG: available indexes for IndexScan(p2_c4): p2_c4_id_val_idx
8671 LOG: available indexes for IndexScan(p2_c1_c1): p2_c1_c1_id_val_idx
8672 LOG: available indexes for IndexScan(p2_c1_c2): p2_c1_c2_id_val_idx
8673 LOG: available indexes for IndexScan(p2_c3_c1): p2_c3_c1_id_val_idx
8674 LOG: available indexes for IndexScan(p2_c3_c2): p2_c3_c2_id_val_idx
8675 LOG: available indexes for IndexScan(p1): p1_val3 p1_val2 p1_val1
8676 LOG: available indexes for IndexScan(p1_c1): p1_c1_val3 p1_c1_val2 p1_c1_val1
8677 LOG: available indexes for IndexScan(p1_c2): p1_c2_val3 p1_c2_val2 p1_c2_val1
8678 LOG: available indexes for IndexScan(p1_c3): p1_c3_val3 p1_c3_val2 p1_c3_val1
8679 LOG: available indexes for IndexScan(p1_c4): p1_c4_val3 p1_c4_val2 p1_c4_val1
8680 LOG: available indexes for IndexScan(p1_c1_c1): p1_c1_c1_val3 p1_c1_c1_val2 p1_c1_c1_val1
8681 LOG: available indexes for IndexScan(p1_c1_c2): p1_c1_c2_val3 p1_c1_c2_val2 p1_c1_c2_val1
8682 LOG: available indexes for IndexScan(p1_c3_c1): p1_c3_c1_val3 p1_c3_c1_val2 p1_c3_c1_val1
8683 LOG: available indexes for IndexScan(p1_c3_c2): p1_c3_c2_val3 p1_c3_c2_val2 p1_c3_c2_val1
8686 IndexScan(p1 p1_val2)
8687 IndexScan(p2 p2_id_val_idx)
8693 --------------------------------------------------------------------------
8698 -> Index Scan using p1_val3 on p1
8699 Index Cond: (val < 1000)
8700 -> Index Scan using p1_c1_val3 on p1_c1
8701 Index Cond: (val < 1000)
8702 -> Index Scan using p1_c2_val3 on p1_c2
8703 Index Cond: (val < 1000)
8704 -> Index Scan using p1_c3_val3 on p1_c3
8705 Index Cond: (val < 1000)
8706 -> Index Scan using p1_c4_val3 on p1_c4
8707 Index Cond: (val < 1000)
8708 -> Index Scan using p1_c1_c1_val3 on p1_c1_c1
8709 Index Cond: (val < 1000)
8710 -> Index Scan using p1_c1_c2_val3 on p1_c1_c2
8711 Index Cond: (val < 1000)
8712 -> Index Scan using p1_c3_c1_val3 on p1_c3_c1
8713 Index Cond: (val < 1000)
8714 -> Index Scan using p1_c3_c2_val3 on p1_c3_c2
8715 Index Cond: (val < 1000)
8718 -> Index Scan using p2_id_val_idx on p2
8719 Index Cond: (id < 1000)
8720 -> Index Scan using p2_c1_id_val_idx on p2_c1
8721 Index Cond: (id < 1000)
8722 -> Index Scan using p2_c2_id_val_idx on p2_c2
8723 Index Cond: (id < 1000)
8724 -> Index Scan using p2_c3_id_val_idx on p2_c3
8725 Index Cond: (id < 1000)
8726 -> Index Scan using p2_c4_id_val_idx on p2_c4
8727 Index Cond: (id < 1000)
8728 -> Index Scan using p2_c1_c1_id_val_idx on p2_c1_c1
8729 Index Cond: (id < 1000)
8730 -> Index Scan using p2_c1_c2_id_val_idx on p2_c1_c2
8731 Index Cond: (id < 1000)
8732 -> Index Scan using p2_c3_c1_id_val_idx on p2_c3_c1
8733 Index Cond: (id < 1000)
8734 -> Index Scan using p2_c3_c2_id_val_idx on p2_c3_c2
8735 Index Cond: (id < 1000)
8741 -- Explain result includes "Planning time" if COSTS is enabled, but
8742 -- this test needs it enabled for get rows count. So do tests via psql
8743 -- and grep -v the mutable line.
8745 \o results/pg_hint_plan.tmpout
8746 EXPLAIN SELECT * FROM t1 JOIN t2 ON (t1.id = t2.id);
8748 \! sql/maskout.sh results/pg_hint_plan.tmpout
8750 ------------------------------------------------------------------------------
8751 Merge Join (cost=xxx rows=1000 width=xxx)
8752 Merge Cond: (t1.id = t2.id)
8753 -> Index Scan using t1_pkey on t1 (cost=xxx rows=10000 width=xxx)
8754 -> Index Scan using t2_pkey on t2 (cost=xxx rows=1000 width=xxx)
8757 \o results/pg_hint_plan.tmpout
8758 /*+ Rows(t1 t2 #99) */
8759 EXPLAIN SELECT * FROM t1 JOIN t2 ON (t1.id = t2.id);
8768 \! sql/maskout.sh results/pg_hint_plan.tmpout
8770 ------------------------------------------------------------------------------
8771 Merge Join (cost=xxx rows=99 width=xxx)
8772 Merge Cond: (t1.id = t2.id)
8773 -> Index Scan using t1_pkey on t1 (cost=xxx rows=10000 width=xxx)
8774 -> Index Scan using t2_pkey on t2 (cost=xxx rows=1000 width=xxx)
8777 \o results/pg_hint_plan.tmpout
8778 /*+ Rows(t1 t2 +99) */
8779 EXPLAIN SELECT * FROM t1 JOIN t2 ON (t1.id = t2.id);
8788 \! sql/maskout.sh results/pg_hint_plan.tmpout
8790 ------------------------------------------------------------------------------
8791 Merge Join (cost=xxx rows=1099 width=xxx)
8792 Merge Cond: (t1.id = t2.id)
8793 -> Index Scan using t1_pkey on t1 (cost=xxx rows=10000 width=xxx)
8794 -> Index Scan using t2_pkey on t2 (cost=xxx rows=1000 width=xxx)
8797 \o results/pg_hint_plan.tmpout
8798 /*+ Rows(t1 t2 -99) */
8799 EXPLAIN SELECT * FROM t1 JOIN t2 ON (t1.id = t2.id);
8808 \! sql/maskout.sh results/pg_hint_plan.tmpout
8810 ------------------------------------------------------------------------------
8811 Merge Join (cost=xxx rows=901 width=xxx)
8812 Merge Cond: (t1.id = t2.id)
8813 -> Index Scan using t1_pkey on t1 (cost=xxx rows=10000 width=xxx)
8814 -> Index Scan using t2_pkey on t2 (cost=xxx rows=1000 width=xxx)
8817 \o results/pg_hint_plan.tmpout
8818 /*+ Rows(t1 t2 *99) */
8819 EXPLAIN SELECT * FROM t1 JOIN t2 ON (t1.id = t2.id);
8828 \! sql/maskout.sh results/pg_hint_plan.tmpout
8830 ------------------------------------------------------------------------------
8831 Merge Join (cost=xxx rows=99000 width=xxx)
8832 Merge Cond: (t1.id = t2.id)
8833 -> Index Scan using t1_pkey on t1 (cost=xxx rows=10000 width=xxx)
8834 -> Index Scan using t2_pkey on t2 (cost=xxx rows=1000 width=xxx)
8837 \o results/pg_hint_plan.tmpout
8838 /*+ Rows(t1 t2 *0.01) */
8839 EXPLAIN SELECT * FROM t1 JOIN t2 ON (t1.id = t2.id);
8848 \! sql/maskout.sh results/pg_hint_plan.tmpout
8850 ------------------------------------------------------------------------------
8851 Merge Join (cost=xxx rows=10 width=xxx)
8852 Merge Cond: (t1.id = t2.id)
8853 -> Index Scan using t1_pkey on t1 (cost=xxx rows=10000 width=xxx)
8854 -> Index Scan using t2_pkey on t2 (cost=xxx rows=1000 width=xxx)
8857 \o results/pg_hint_plan.tmpout
8858 /*+ Rows(t1 t2 #aa) */
8859 EXPLAIN SELECT * FROM t1 JOIN t2 ON (t1.id = t2.id); -- ERROR
8860 INFO: pg_hint_plan: hint syntax error at or near "aa"
8861 DETAIL: Rows hint requires valid number as rows estimation.
8870 \! sql/maskout.sh results/pg_hint_plan.tmpout
8872 ------------------------------------------------------------------------------
8873 Merge Join (cost=xxx rows=1000 width=xxx)
8874 Merge Cond: (t1.id = t2.id)
8875 -> Index Scan using t1_pkey on t1 (cost=xxx rows=10000 width=xxx)
8876 -> Index Scan using t2_pkey on t2 (cost=xxx rows=1000 width=xxx)
8879 \o results/pg_hint_plan.tmpout
8880 /*+ Rows(t1 t2 /99) */
8881 EXPLAIN SELECT * FROM t1 JOIN t2 ON (t1.id = t2.id); -- ERROR
8882 INFO: pg_hint_plan: hint syntax error at or near "/99"
8883 DETAIL: Unrecognized rows value type notation.
8892 \! sql/maskout.sh results/pg_hint_plan.tmpout
8894 ------------------------------------------------------------------------------
8895 Merge Join (cost=xxx rows=1000 width=xxx)
8896 Merge Cond: (t1.id = t2.id)
8897 -> Index Scan using t1_pkey on t1 (cost=xxx rows=10000 width=xxx)
8898 -> Index Scan using t2_pkey on t2 (cost=xxx rows=1000 width=xxx)
8902 \o results/pg_hint_plan.tmpout
8903 /*+ Rows(t1 t2 -99999) */
8904 EXPLAIN SELECT * FROM t1 JOIN t2 ON (t1.id = t2.id);
8905 WARNING: Force estimate to be at least one row, to avoid possible divide-by-zero when interpolating costs : Rows(t1 t2 -99999)
8914 \! sql/maskout.sh results/pg_hint_plan.tmpout
8916 ------------------------------------------------------------------------------
8917 Merge Join (cost=xxx rows=1 width=xxx)
8918 Merge Cond: (t1.id = t2.id)
8919 -> Index Scan using t1_pkey on t1 (cost=xxx rows=10000 width=xxx)
8920 -> Index Scan using t2_pkey on t2 (cost=xxx rows=1000 width=xxx)
8923 -- complex join tree
8924 \o results/pg_hint_plan.tmpout
8925 EXPLAIN SELECT * FROM t1 JOIN t2 ON (t1.id = t2.id) JOIN t3 ON (t3.id = t2.id);
8927 \! sql/maskout.sh results/pg_hint_plan.tmpout
8929 ------------------------------------------------------------------------------------
8930 Merge Join (cost=xxx rows=10 width=xxx)
8931 Merge Cond: (t1.id = t3.id)
8932 -> Merge Join (cost=xxx rows=1000 width=xxx)
8933 Merge Cond: (t1.id = t2.id)
8934 -> Index Scan using t1_pkey on t1 (cost=xxx rows=10000 width=xxx)
8935 -> Index Scan using t2_pkey on t2 (cost=xxx rows=1000 width=xxx)
8936 -> Sort (cost=xxx rows=100 width=xxx)
8938 -> Seq Scan on t3 (cost=xxx rows=100 width=xxx)
8941 \o results/pg_hint_plan.tmpout
8942 /*+ Rows(t1 t2 #22) */
8943 EXPLAIN SELECT * FROM t1 JOIN t2 ON (t1.id = t2.id) JOIN t3 ON (t3.id = t2.id);
8952 \! sql/maskout.sh results/pg_hint_plan.tmpout
8954 ------------------------------------------------------------------------------------
8955 Merge Join (cost=xxx rows=1 width=xxx)
8956 Merge Cond: (t1.id = t3.id)
8957 -> Merge Join (cost=xxx rows=22 width=xxx)
8958 Merge Cond: (t1.id = t2.id)
8959 -> Index Scan using t1_pkey on t1 (cost=xxx rows=10000 width=xxx)
8960 -> Index Scan using t2_pkey on t2 (cost=xxx rows=1000 width=xxx)
8961 -> Sort (cost=xxx rows=100 width=xxx)
8963 -> Seq Scan on t3 (cost=xxx rows=100 width=xxx)
8966 \o results/pg_hint_plan.tmpout
8967 /*+ Rows(t1 t3 *10) */
8968 EXPLAIN SELECT * FROM t1 JOIN t2 ON (t1.id = t2.id) JOIN t3 ON (t3.id = t2.id);
8977 set max_parallel_workers_per_gather to DEFAULT;
8978 \! sql/maskout.sh results/pg_hint_plan.tmpout
8980 ------------------------------------------------------------------------------------
8981 Merge Join (cost=xxx rows=100 width=xxx)
8982 Merge Cond: (t1.id = t3.id)
8983 -> Merge Join (cost=xxx rows=1000 width=xxx)
8984 Merge Cond: (t1.id = t2.id)
8985 -> Index Scan using t1_pkey on t1 (cost=xxx rows=10000 width=xxx)
8986 -> Index Scan using t2_pkey on t2 (cost=xxx rows=1000 width=xxx)
8987 -> Sort (cost=xxx rows=100 width=xxx)
8989 -> Seq Scan on t3 (cost=xxx rows=100 width=xxx)
8992 \! rm results/pg_hint_plan.tmpout
8994 set client_min_messages to 'DEBUG1';
8995 set pg_hint_plan.debug_level to 'verbose';
8996 /*+ SeqScan( */ SELECT 1;
8997 INFO: pg_hint_plan: hint syntax error at or near ""
8998 DETAIL: Closing parenthesis is necessary.
9004 /*+ SeqScan(t1) */ SELECT * FROM t1 LIMIT 0;
9016 set pg_hint_plan.message_level to 'DEBUG1';
9017 set pg_hint_plan.parse_messages to 'NOTICE';
9018 /*+ SeqScan( */ SELECT 1;
9019 NOTICE: pg_hint_plan: hint syntax error at or near ""
9020 DETAIL: Closing parenthesis is necessary.
9026 /*+ SeqScan(t1) */ SELECT * FROM t1 LIMIT 0;
9027 DEBUG: pg_hint_plan: