</tr>
</thead>
<tbody>
-<tr><td rowspan="10" nowrap>スキャン方式</td>
+<tr><td rowspan="11" nowrap>スキャン方式</td>
<td nowrap>SeqScan(テーブル)</td>
<td>指定したテーブルについて、Seq Scanを選択します。</td></tr>
-<tr><td>TidScan(テーブル)</td>
+<tr><td nowrap>TidScan(テーブル)</td>
<td>指定したテーブルについて、Tid Scanを選択します。検索条件にctidを指定した場合にのみ有効です。</td></tr>
<tr><td nowrap>IndexScan(テーブル[ インデックス...])</td>
<td>指定したテーブルについて、Index Scanを選択します。インデックスも指定した場合は、指定したインデックスの中でコストが最小となるIndex Scanを選択します。ただし、インデックスが存在しない場合や指定したインデックスがWHERE句やJOIN条件などに関連しない場合はSeq Scanを選択します。</td></tr>
<td>指定したテーブルについて、Index Only ScanとIndex Scanのうちコストが最小となるスキャン方式を選択します。インデックスも指定した場合は、指定したインデックスの中でIndex Only ScanとIndex Scanのうちコストが最小となるスキャン方式を選択します。ただし、インデックスが存在しない場合や指定したインデックスがWHERE句やJOIN条件などに関連しない場合はSeq Scanを選択します。また、これらの場合以外にも、インデックスが持つ値だけでなくテーブルの値も必要な場合はIndex Scanを選択します。PostgreSQL 9.2以降で動作します。</td></tr>
<tr><td nowrap>BitmapScan(テーブル[ インデックス...])</td>
<td>指定したテーブルについて、Bitmap Scanを選択します。インデックスも指定した場合は、指定したインデックスの中でコストが最小となるインデックスを選択します。ただし、インデックスが存在しない場合や指定したインデックスがWHERE句やJOIN条件などに関連しない場合はSeq Scanを選択します。</td></tr>
+<tr><td nowrap>IndexScanRegexp(テーブル[ POSIX正規表現...])</br>IndexOnlyScanRegexp(テーブル[ POSIX正規表現...])</br>BitmapScanRegexp(テーブル[ POSIX正規表現...])</td>
+ <td>テーブルのみを指定した場合のスキャン方式の選択基準は、Regexpの付かないスキャン方式のヒントと同じです。POSIX正規表現も指定した場合は、指定したPOSIX正規表現パターンに一致するインデックスの中でコストが最小となるスキャン方式を選択します。指定したテーブルが継承テーブルの場合は、子テーブルについても同じ基準で、使用するインデックスとスキャン方式を選択します。IndexOnlyScanRegexpヒントはPostgreSQL 9.2以降で動作します。</td></tr>
<tr><td nowrap>NoSeqScan(テーブル)</td>
<td>指定したテーブルについて、Seq Scan以外でコストが最小となるスキャン方式を選択します。ただし、他のスキャン方式を選択できない場合は、Seq Scanを選択します。</td></tr>
<tr><td nowrap>NoTidScan(テーブル)</td>
CREATE INDEX t5_id2 ON t5 (id);
CREATE INDEX t5_id3 ON t5 (id);
CREATE INDEX t5_val ON t5 (val);
+CREATE INDEX t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ON t5 (id);
+CREATE INDEX p1_val1 ON p1 (val);
+CREATE INDEX p1_val2 ON p1 (val);
+CREATE INDEX p1_val3 ON p1 (val);
+CREATE INDEX p1_c1_val1 ON p1_c1 (val);
+CREATE INDEX p1_c1_val2 ON p1_c1 (val);
+CREATE INDEX p1_c1_val3 ON p1_c1 (val);
+CREATE INDEX p1_c1_c1_val1 ON p1_c1_c1 (val);
+CREATE INDEX p1_c1_c1_val2 ON p1_c1_c1 (val);
+CREATE INDEX p1_c1_c1_val3 ON p1_c1_c1 (val);
+CREATE INDEX p1_c1_c2_val1 ON p1_c1_c2 (val);
+CREATE INDEX p1_c1_c2_val2 ON p1_c1_c2 (val);
+CREATE INDEX p1_c1_c2_val3 ON p1_c1_c2 (val);
+CREATE INDEX p1_c2_val1 ON p1_c2 (val);
+CREATE INDEX p1_c2_val2 ON p1_c2 (val);
+CREATE INDEX p1_c2_val3 ON p1_c2 (val);
+CREATE INDEX p1_c3_val1 ON p1_c3 (val);
+CREATE INDEX p1_c3_val2 ON p1_c3 (val);
+CREATE INDEX p1_c3_val3 ON p1_c3 (val);
+CREATE INDEX p1_c3_c1_val1 ON p1_c3_c1 (val);
+CREATE INDEX p1_c3_c1_val2 ON p1_c3_c1 (val);
+CREATE INDEX p1_c3_c1_val3 ON p1_c3_c1 (val);
+CREATE INDEX p1_c3_c2_val1 ON p1_c3_c2 (val);
+CREATE INDEX p1_c3_c2_val2 ON p1_c3_c2 (val);
+CREATE INDEX p1_c3_c2_val3 ON p1_c3_c2 (val);
+CREATE INDEX p1_c4_val1 ON p1_c4 (val);
+CREATE INDEX p1_c4_val2 ON p1_c4 (val);
+CREATE INDEX p1_c4_val3 ON p1_c4 (val);
ANALYZE t1;
ANALYZE t2;
ANALYZE t3;
CREATE INDEX t5_id2 ON t5 (id);
CREATE INDEX t5_id3 ON t5 (id);
CREATE INDEX t5_val ON t5 (val);
+CREATE INDEX t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ON t5 (id);
+CREATE INDEX p1_val1 ON p1 (val);
+CREATE INDEX p1_val2 ON p1 (val);
+CREATE INDEX p1_val3 ON p1 (val);
+CREATE INDEX p1_c1_val1 ON p1_c1 (val);
+CREATE INDEX p1_c1_val2 ON p1_c1 (val);
+CREATE INDEX p1_c1_val3 ON p1_c1 (val);
+CREATE INDEX p1_c1_c1_val1 ON p1_c1_c1 (val);
+CREATE INDEX p1_c1_c1_val2 ON p1_c1_c1 (val);
+CREATE INDEX p1_c1_c1_val3 ON p1_c1_c1 (val);
+CREATE INDEX p1_c1_c2_val1 ON p1_c1_c2 (val);
+CREATE INDEX p1_c1_c2_val2 ON p1_c1_c2 (val);
+CREATE INDEX p1_c1_c2_val3 ON p1_c1_c2 (val);
+CREATE INDEX p1_c2_val1 ON p1_c2 (val);
+CREATE INDEX p1_c2_val2 ON p1_c2 (val);
+CREATE INDEX p1_c2_val3 ON p1_c2 (val);
+CREATE INDEX p1_c3_val1 ON p1_c3 (val);
+CREATE INDEX p1_c3_val2 ON p1_c3 (val);
+CREATE INDEX p1_c3_val3 ON p1_c3 (val);
+CREATE INDEX p1_c3_c1_val1 ON p1_c3_c1 (val);
+CREATE INDEX p1_c3_c1_val2 ON p1_c3_c1 (val);
+CREATE INDEX p1_c3_c1_val3 ON p1_c3_c1 (val);
+CREATE INDEX p1_c3_c2_val1 ON p1_c3_c2 (val);
+CREATE INDEX p1_c3_c2_val2 ON p1_c3_c2 (val);
+CREATE INDEX p1_c3_c2_val3 ON p1_c3_c2 (val);
+CREATE INDEX p1_c4_val1 ON p1_c4 (val);
+CREATE INDEX p1_c4_val2 ON p1_c4 (val);
+CREATE INDEX p1_c4_val3 ON p1_c4 (val);
ANALYZE t1;
ANALYZE t2;
ANALYZE t3;
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Seq Scan on p1_c3 p1
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
- -> Tid Scan on p1_c4 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c3_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c3_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
-(25 rows)
+ -> Seq Scan on p1_c4 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c3_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c3_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+(20 rows)
SET constraint_exclusion TO on;
EXPLAIN (COSTS false) SELECT * FROM p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Seq Scan on p1_c1 p1
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
- -> Tid Scan on p1_c1_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
-(12 rows)
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+(10 rows)
SET constraint_exclusion TO off;
/*+SeqScan(p1)*/
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Seq Scan on p1_c3 p1
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
- -> Tid Scan on p1_c4 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c3_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c3_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
+ -> Seq Scan on p1_c4 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c3_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c3_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Index Scan using t1_pkey on t1
Index Cond: (id < 10)
-(30 rows)
+(25 rows)
SET constraint_exclusion TO on;
EXPLAIN (COSTS false) SELECT * FROM p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Seq Scan on p1_c1 p1
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
- -> Tid Scan on p1_c1_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Index Scan using t1_pkey on t1
Index Cond: (id < 10)
-(17 rows)
+(15 rows)
SET constraint_exclusion TO off;
/*+SeqScan(p1)*/
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Seq Scan on p1_c3 p1
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
- -> Tid Scan on p1_c4 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c3_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c3_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
+ -> Seq Scan on p1_c4 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c3_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c3_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Index Scan using t1_pkey on t1
Index Cond: (id < 10)
-(30 rows)
+(25 rows)
/*+IndexScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Seq Scan on p1_c3 p1
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
- -> Tid Scan on p1_c4 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c3_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c3_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
+ -> Seq Scan on p1_c4 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c3_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c3_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Index Scan using t1_pkey on t1
Index Cond: (id < 10)
-(30 rows)
+(25 rows)
/*+BitmapScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Seq Scan on p1_c3 p1
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
- -> Tid Scan on p1_c4 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c3_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c3_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
+ -> Seq Scan on p1_c4 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c3_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c3_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Index Scan using t1_pkey on t1
Index Cond: (id < 10)
-(30 rows)
+(25 rows)
/*+TidScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Seq Scan on p1_c3 p1
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
- -> Tid Scan on p1_c4 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c3_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c3_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
+ -> Seq Scan on p1_c4 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c3_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c3_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Index Scan using t1_pkey on t1
Index Cond: (id < 10)
-(30 rows)
+(25 rows)
/*+NestLoop(p1 t1)*/
EXPLAIN (COSTS false) SELECT * FROM p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Seq Scan on p1_c3 p1
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
- -> Tid Scan on p1_c4 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c3_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c3_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
+ -> Seq Scan on p1_c4 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c3_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c3_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Materialize
-> Index Scan using t1_pkey on t1
Index Cond: (id < 10)
-(29 rows)
+(24 rows)
/*+MergeJoin(p1 t1)*/
EXPLAIN (COSTS false) SELECT * FROM p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Seq Scan on p1_c3 p1
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
- -> Tid Scan on p1_c4 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c3_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c3_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
+ -> Seq Scan on p1_c4 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c3_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c3_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Index Scan using t1_pkey on t1
Index Cond: (id < 10)
-(30 rows)
+(25 rows)
/*+HashJoin(p1 t1)*/
EXPLAIN (COSTS false) SELECT * FROM p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Seq Scan on p1_c3 p1
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
- -> Tid Scan on p1_c4 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c3_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c3_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
+ -> Seq Scan on p1_c4 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c3_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c3_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Hash
-> Index Scan using t1_pkey on t1
Index Cond: (id < 10)
-(29 rows)
+(24 rows)
SET constraint_exclusion TO on;
/*+SeqScan(p1)*/
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Seq Scan on p1_c1 p1
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
- -> Tid Scan on p1_c1_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Index Scan using t1_pkey on t1
Index Cond: (id < 10)
-(17 rows)
+(15 rows)
/*+IndexScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Seq Scan on p1_c1 p1
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
- -> Tid Scan on p1_c1_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Index Scan using t1_pkey on t1
Index Cond: (id < 10)
-(17 rows)
+(15 rows)
/*+BitmapScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Seq Scan on p1_c1 p1
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
- -> Tid Scan on p1_c1_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Index Scan using t1_pkey on t1
Index Cond: (id < 10)
-(17 rows)
+(15 rows)
/*+TidScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Seq Scan on p1_c1 p1
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
- -> Tid Scan on p1_c1_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Index Scan using t1_pkey on t1
Index Cond: (id < 10)
-(17 rows)
+(15 rows)
/*+NestLoop(p1 t1)*/
EXPLAIN (COSTS false) SELECT * FROM p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Seq Scan on p1_c1 p1
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
- -> Tid Scan on p1_c1_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
-(16 rows)
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+(14 rows)
/*+MergeJoin(p1 t1)*/
EXPLAIN (COSTS false) SELECT * FROM p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Seq Scan on p1_c1 p1
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
- -> Tid Scan on p1_c1_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Index Scan using t1_pkey on t1
Index Cond: (id < 10)
-(17 rows)
+(15 rows)
/*+HashJoin(p1 t1)*/
EXPLAIN (COSTS false) SELECT * FROM p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Seq Scan on p1_c1 p1
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
- -> Tid Scan on p1_c1_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
-(16 rows)
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+(14 rows)
SET constraint_exclusion TO off;
EXPLAIN (COSTS false) SELECT * FROM ONLY p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
-> Nested Loop
-> Nested Loop
-> Nested Loop
- -> Index Scan using t1_pkey on t1 t1_3
- Index Cond: (id = $2)
-> Index Scan using t2_pkey on t2 t2_3
Index Cond: (id = $2)
- -> Seq Scan on t3 t3_3
- Filter: (id = $2)
+ -> Seq Scan on t3 t3_3
+ Filter: (id = $2)
+ -> Index Scan using t1_pkey on t1 t1_3
+ Index Cond: (id = $2)
-> CTE Scan on c1_1
Filter: (id = $2)
-> Seq Scan on t3 t3_1
-- debug log of candidate index to use IndexScan
EXPLAIN (COSTS false) SELECT * FROM t5 WHERE t5.id = 1;
- QUERY PLAN
--------------------------------
- Index Scan using t5_id3 on t5
+ QUERY PLAN
+----------------------------------------------------------------------------------------
+ Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
Index Cond: (id = 1)
(2 rows)
duplication hint:
error hint:
- QUERY PLAN
---------------------------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------------------------------------------------------------------------------
Merge Join
Merge Cond: (t1.id = t2.id)
-> Index Scan using t1_pkey on t1
-> Merge Join
Merge Cond: (t4.id = t5.id)
-> Index Scan using t4_pkey on t4
- -> Index Scan using t5_id3 on t5
+ -> Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
(16 rows)
/*+Leading((t5(t4(t3(t2 t1)))))*/
duplication hint:
error hint:
- QUERY PLAN
---------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------------------------------------------
Nested Loop
-> Merge Join
Merge Cond: (t1.id = t4.id)
-> Sort
Sort Key: t4.id
-> Seq Scan on t4
- -> Index Scan using t5_id3 on t5
+ -> Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
Index Cond: (id = t1.id)
(15 rows)
duplication hint:
error hint:
- QUERY PLAN
--------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------------------------------------------------------------
Nested Loop
-> Merge Join
Merge Cond: (t3.id = t2.id)
Merge Cond: (t4.id = t3.id)
-> Merge Join
Merge Cond: (t5.id = t4.id)
- -> Index Scan using t5_id3 on t5
+ -> Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
-> Sort
Sort Key: t4.id
-> Seq Scan on t4
duplication hint:
error hint:
- QUERY PLAN
---------------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------------------------------------------------------------------
Merge Join
Merge Cond: (t1.id = t3.id)
-> Merge Join
-> Merge Join
Merge Cond: (t4.id = t5.id)
-> Index Scan using t4_pkey on t4
- -> Index Scan using t5_id3 on t5
+ -> Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
(15 rows)
/*+Leading(((t5 t4)(t3(t2 t1))))*/
duplication hint:
error hint:
- QUERY PLAN
---------------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------------------------------------------------
Merge Join
Merge Cond: (t4.id = t1.id)
-> Merge Join
Merge Cond: (t5.id = t4.id)
- -> Index Scan using t5_id3 on t5
+ -> Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
-> Sort
Sort Key: t4.id
-> Seq Scan on t4
duplication hint:
error hint:
- QUERY PLAN
---------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------------------------------------------------------
Merge Join
Merge Cond: (t1.id = t4.id)
-> Merge Join
-> Merge Join
Merge Cond: (t4.id = t5.id)
-> Index Scan using t4_pkey on t4
- -> Index Scan using t5_id3 on t5
+ -> Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
(14 rows)
/*+Leading((((t5 t4)t3)(t2 t1)))*/
duplication hint:
error hint:
- QUERY PLAN
---------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------------------------------------------------------
Merge Join
Merge Cond: (t3.id = t1.id)
-> Merge Join
Merge Cond: (t4.id = t3.id)
-> Merge Join
Merge Cond: (t5.id = t4.id)
- -> Index Scan using t5_id3 on t5
+ -> Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
-> Sort
Sort Key: t4.id
-> Seq Scan on t4
-> Index Scan using t1_pkey on t1
(16 rows)
+-- regular expression
+-- ordinary table
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+ QUERY PLAN
+----------------------------------------------------------------------------------------
+ Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
+ Index Cond: (id = 1)
+(2 rows)
+
+/*+ IndexScanRegexp(t5 t5_[^i].*)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+LOG: available indexes for IndexScanRegexp(t5): t5_val t5_pkey
+LOG: pg_hint_plan:
+used hint:
+IndexScanRegexp(t5 t5_[^i].*)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+--------------------------------
+ Index Scan using t5_pkey on t5
+ Index Cond: (id = 1)
+(2 rows)
+
+/*+ IndexScanRegexp(t5 t5_id[0-9].*)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+LOG: available indexes for IndexScanRegexp(t5): t5_id3 t5_id2 t5_id1
+LOG: pg_hint_plan:
+used hint:
+IndexScanRegexp(t5 t5_id[0-9].*)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+-------------------------------
+ Index Scan using t5_id3 on t5
+ Index Cond: (id = 1)
+(2 rows)
+
+/*+ IndexScanRegexp(t5 t5[^_].*)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+LOG: available indexes for IndexScanRegexp(t5):
+LOG: pg_hint_plan:
+used hint:
+IndexScanRegexp(t5 t5[^_].*)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+--------------------
+ Seq Scan on t5
+ Filter: (id = 1)
+(2 rows)
+
+/*+ IndexScanRegexp(t5 ^.*t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+LOG: available indexes for IndexScanRegexp(t5):
+LOG: pg_hint_plan:
+used hint:
+IndexScanRegexp(t5 ^.*t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+--------------------
+ Seq Scan on t5
+ Filter: (id = 1)
+(2 rows)
+
+/*+ IndexScan(t5 t5_id[0-9].*)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+LOG: available indexes for IndexScan(t5):
+LOG: pg_hint_plan:
+used hint:
+IndexScan(t5 t5_id[0-9].*)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+--------------------
+ Seq Scan on t5
+ Filter: (id = 1)
+(2 rows)
+
+/*+ IndexOnlyScanRegexp(t5 t5_[^i].*)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+INFO: hint syntax error at or near "IndexOnlyScanRegexp(t5 t5_[^i].*)"
+DETAIL: Unrecognized hint keyword "IndexOnlyScanRegexp".
+ QUERY PLAN
+----------------------------------------------------------------------------------------
+ Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
+ Index Cond: (id = 1)
+(2 rows)
+
+/*+ IndexOnlyScanRegexp(t5 t5_id[0-9].*)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+INFO: hint syntax error at or near "IndexOnlyScanRegexp(t5 t5_id[0-9].*)"
+DETAIL: Unrecognized hint keyword "IndexOnlyScanRegexp".
+ QUERY PLAN
+----------------------------------------------------------------------------------------
+ Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
+ Index Cond: (id = 1)
+(2 rows)
+
+/*+ IndexOnlyScanRegexp(t5 t5[^_].*)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+INFO: hint syntax error at or near "IndexOnlyScanRegexp(t5 t5[^_].*)"
+DETAIL: Unrecognized hint keyword "IndexOnlyScanRegexp".
+ QUERY PLAN
+----------------------------------------------------------------------------------------
+ Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
+ Index Cond: (id = 1)
+(2 rows)
+
+/*+ IndexOnlyScanRegexp(t5 ^.*t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+INFO: hint syntax error at or near "IndexOnlyScanRegexp(t5 ^.*t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab)"
+DETAIL: Unrecognized hint keyword "IndexOnlyScanRegexp".
+ QUERY PLAN
+----------------------------------------------------------------------------------------
+ Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
+ Index Cond: (id = 1)
+(2 rows)
+
+/*+ IndexOnlyScan(t5 t5_id[0-9].*)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+INFO: hint syntax error at or near "IndexOnlyScan(t5 t5_id[0-9].*)"
+DETAIL: Unrecognized hint keyword "IndexOnlyScan".
+ QUERY PLAN
+----------------------------------------------------------------------------------------
+ Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
+ Index Cond: (id = 1)
+(2 rows)
+
+/*+ BitmapScanRegexp(t5 t5_[^i].*)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+LOG: available indexes for BitmapScanRegexp(t5): t5_val t5_pkey
+LOG: pg_hint_plan:
+used hint:
+BitmapScanRegexp(t5 t5_[^i].*)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+------------------------------------
+ Bitmap Heap Scan on t5
+ Recheck Cond: (id = 1)
+ -> Bitmap Index Scan on t5_pkey
+ Index Cond: (id = 1)
+(4 rows)
+
+/*+ BitmapScanRegexp(t5 t5_id[0-9].*)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+LOG: available indexes for BitmapScanRegexp(t5): t5_id3 t5_id2 t5_id1
+LOG: pg_hint_plan:
+used hint:
+BitmapScanRegexp(t5 t5_id[0-9].*)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+-----------------------------------
+ Bitmap Heap Scan on t5
+ Recheck Cond: (id = 1)
+ -> Bitmap Index Scan on t5_id3
+ Index Cond: (id = 1)
+(4 rows)
+
+/*+ BitmapScanRegexp(t5 t5[^_].*)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+LOG: available indexes for BitmapScanRegexp(t5):
+LOG: pg_hint_plan:
+used hint:
+BitmapScanRegexp(t5 t5[^_].*)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+--------------------
+ Seq Scan on t5
+ Filter: (id = 1)
+(2 rows)
+
+/*+ BitmapScanRegexp(t5 ^.*t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+LOG: available indexes for BitmapScanRegexp(t5):
+LOG: pg_hint_plan:
+used hint:
+BitmapScanRegexp(t5 ^.*t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+--------------------
+ Seq Scan on t5
+ Filter: (id = 1)
+(2 rows)
+
+/*+ BitmapScan(t5 t5_id[0-9].*)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+LOG: available indexes for BitmapScan(t5):
+LOG: pg_hint_plan:
+used hint:
+BitmapScan(t5 t5_id[0-9].*)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+--------------------
+ Seq Scan on t5
+ Filter: (id = 1)
+(2 rows)
+
+-- Inheritance
+EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
+ QUERY PLAN
+-------------------------------------
+ Result
+ -> Append
+ -> Seq Scan on p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c2 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c4 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3_c2 p1
+ Filter: (val = 1)
+(20 rows)
+
+/*+ IndexScanRegexp(p1 p1_.*[^0-9]$)*/
+EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
+LOG: available indexes for IndexScanRegexp(p1): p1_pkey
+LOG: available indexes for IndexScanRegexp(p1_c1): p1_c1_pkey
+LOG: available indexes for IndexScanRegexp(p1_c2): p1_c2_pkey
+LOG: available indexes for IndexScanRegexp(p1_c3): p1_c3_pkey
+LOG: available indexes for IndexScanRegexp(p1_c4): p1_c4_pkey
+LOG: available indexes for IndexScanRegexp(p1_c1_c1): p1_c1_c1_pkey
+LOG: available indexes for IndexScanRegexp(p1_c1_c2): p1_c1_c2_pkey
+LOG: available indexes for IndexScanRegexp(p1_c3_c1): p1_c3_c1_pkey
+LOG: available indexes for IndexScanRegexp(p1_c3_c2): p1_c3_c2_pkey
+LOG: pg_hint_plan:
+used hint:
+IndexScanRegexp(p1 p1_.*[^0-9]$)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+-------------------------------------
+ Result
+ -> Append
+ -> Seq Scan on p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c2 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c4 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3_c2 p1
+ Filter: (val = 1)
+(20 rows)
+
+/*+ IndexScanRegexp(p1 p1_.*val2.*)*/
+EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
+LOG: available indexes for IndexScanRegexp(p1): p1_val2
+LOG: available indexes for IndexScanRegexp(p1_c1): p1_c1_val2
+LOG: available indexes for IndexScanRegexp(p1_c2): p1_c2_val2
+LOG: available indexes for IndexScanRegexp(p1_c3): p1_c3_val2
+LOG: available indexes for IndexScanRegexp(p1_c4): p1_c4_val2
+LOG: available indexes for IndexScanRegexp(p1_c1_c1): p1_c1_c1_val2
+LOG: available indexes for IndexScanRegexp(p1_c1_c2): p1_c1_c2_val2
+LOG: available indexes for IndexScanRegexp(p1_c3_c1): p1_c3_c1_val2
+LOG: available indexes for IndexScanRegexp(p1_c3_c2): p1_c3_c2_val2
+LOG: pg_hint_plan:
+used hint:
+IndexScanRegexp(p1 p1_.*val2.*)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+-----------------------------------------------------------
+ Result
+ -> Append
+ -> Index Scan using p1_val2 on p1
+ Index Cond: (val = 1)
+ -> Index Scan using p1_c1_val2 on p1_c1 p1
+ Index Cond: (val = 1)
+ -> Index Scan using p1_c2_val2 on p1_c2 p1
+ Index Cond: (val = 1)
+ -> Index Scan using p1_c3_val2 on p1_c3 p1
+ Index Cond: (val = 1)
+ -> Index Scan using p1_c4_val2 on p1_c4 p1
+ Index Cond: (val = 1)
+ -> Index Scan using p1_c1_c1_val2 on p1_c1_c1 p1
+ Index Cond: (val = 1)
+ -> Index Scan using p1_c1_c2_val2 on p1_c1_c2 p1
+ Index Cond: (val = 1)
+ -> Index Scan using p1_c3_c1_val2 on p1_c3_c1 p1
+ Index Cond: (val = 1)
+ -> Index Scan using p1_c3_c2_val2 on p1_c3_c2 p1
+ Index Cond: (val = 1)
+(20 rows)
+
+/*+ IndexScanRegexp(p1 p1[^_].*)*/
+EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
+LOG: available indexes for IndexScanRegexp(p1):
+LOG: available indexes for IndexScanRegexp(p1_c1):
+LOG: available indexes for IndexScanRegexp(p1_c2):
+LOG: available indexes for IndexScanRegexp(p1_c3):
+LOG: available indexes for IndexScanRegexp(p1_c4):
+LOG: available indexes for IndexScanRegexp(p1_c1_c1):
+LOG: available indexes for IndexScanRegexp(p1_c1_c2):
+LOG: available indexes for IndexScanRegexp(p1_c3_c1):
+LOG: available indexes for IndexScanRegexp(p1_c3_c2):
+LOG: pg_hint_plan:
+used hint:
+IndexScanRegexp(p1 p1[^_].*)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+-------------------------------------
+ Result
+ -> Append
+ -> Seq Scan on p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c2 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c4 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3_c2 p1
+ Filter: (val = 1)
+(20 rows)
+
+/*+ IndexScan(p1 p1_.*val2.*)*/
+EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
+LOG: available indexes for IndexScan(p1):
+LOG: available indexes for IndexScan(p1_c1):
+LOG: available indexes for IndexScan(p1_c2):
+LOG: available indexes for IndexScan(p1_c3):
+LOG: available indexes for IndexScan(p1_c4):
+LOG: available indexes for IndexScan(p1_c1_c1):
+LOG: available indexes for IndexScan(p1_c1_c2):
+LOG: available indexes for IndexScan(p1_c3_c1):
+LOG: available indexes for IndexScan(p1_c3_c2):
+LOG: pg_hint_plan:
+used hint:
+IndexScan(p1 p1_.*val2.*)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+-------------------------------------
+ Result
+ -> Append
+ -> Seq Scan on p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c2 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c4 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3_c2 p1
+ Filter: (val = 1)
+(20 rows)
+
+/*+ IndexOnlyScanRegexp(p1 p1_.*[^0-9]$)*/
+EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
+INFO: hint syntax error at or near "IndexOnlyScanRegexp(p1 p1_.*[^0-9]$)"
+DETAIL: Unrecognized hint keyword "IndexOnlyScanRegexp".
+ QUERY PLAN
+-------------------------------------
+ Result
+ -> Append
+ -> Seq Scan on p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c2 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c4 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3_c2 p1
+ Filter: (val = 1)
+(20 rows)
+
+/*+ IndexOnlyScanRegexp(p1 p1_.*val2.*)*/
+EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
+INFO: hint syntax error at or near "IndexOnlyScanRegexp(p1 p1_.*val2.*)"
+DETAIL: Unrecognized hint keyword "IndexOnlyScanRegexp".
+ QUERY PLAN
+-------------------------------------
+ Result
+ -> Append
+ -> Seq Scan on p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c2 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c4 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3_c2 p1
+ Filter: (val = 1)
+(20 rows)
+
+/*+ IndexOnlyScanRegexp(p1 p1[^_].*)*/
+EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
+INFO: hint syntax error at or near "IndexOnlyScanRegexp(p1 p1[^_].*)"
+DETAIL: Unrecognized hint keyword "IndexOnlyScanRegexp".
+ QUERY PLAN
+-------------------------------------
+ Result
+ -> Append
+ -> Seq Scan on p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c2 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c4 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3_c2 p1
+ Filter: (val = 1)
+(20 rows)
+
+/*+ IndexOnlyScan(p1 p1_.*val2.*)*/
+EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
+INFO: hint syntax error at or near "IndexOnlyScan(p1 p1_.*val2.*)"
+DETAIL: Unrecognized hint keyword "IndexOnlyScan".
+ QUERY PLAN
+-------------------------------------
+ Result
+ -> Append
+ -> Seq Scan on p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c2 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c4 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3_c2 p1
+ Filter: (val = 1)
+(20 rows)
+
+/*+ BitmapScanRegexp(p1 p1_.*[^0-9]$)*/
+EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
+LOG: available indexes for BitmapScanRegexp(p1): p1_pkey
+LOG: available indexes for BitmapScanRegexp(p1_c1): p1_c1_pkey
+LOG: available indexes for BitmapScanRegexp(p1_c2): p1_c2_pkey
+LOG: available indexes for BitmapScanRegexp(p1_c3): p1_c3_pkey
+LOG: available indexes for BitmapScanRegexp(p1_c4): p1_c4_pkey
+LOG: available indexes for BitmapScanRegexp(p1_c1_c1): p1_c1_c1_pkey
+LOG: available indexes for BitmapScanRegexp(p1_c1_c2): p1_c1_c2_pkey
+LOG: available indexes for BitmapScanRegexp(p1_c3_c1): p1_c3_c1_pkey
+LOG: available indexes for BitmapScanRegexp(p1_c3_c2): p1_c3_c2_pkey
+LOG: pg_hint_plan:
+used hint:
+BitmapScanRegexp(p1 p1_.*[^0-9]$)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+-------------------------------------
+ Result
+ -> Append
+ -> Seq Scan on p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c2 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c4 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3_c2 p1
+ Filter: (val = 1)
+(20 rows)
+
+/*+ BitmapScanRegexp(p1 p1_.*val2.*)*/
+EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
+LOG: available indexes for BitmapScanRegexp(p1): p1_val2
+LOG: available indexes for BitmapScanRegexp(p1_c1): p1_c1_val2
+LOG: available indexes for BitmapScanRegexp(p1_c2): p1_c2_val2
+LOG: available indexes for BitmapScanRegexp(p1_c3): p1_c3_val2
+LOG: available indexes for BitmapScanRegexp(p1_c4): p1_c4_val2
+LOG: available indexes for BitmapScanRegexp(p1_c1_c1): p1_c1_c1_val2
+LOG: available indexes for BitmapScanRegexp(p1_c1_c2): p1_c1_c2_val2
+LOG: available indexes for BitmapScanRegexp(p1_c3_c1): p1_c3_c1_val2
+LOG: available indexes for BitmapScanRegexp(p1_c3_c2): p1_c3_c2_val2
+LOG: pg_hint_plan:
+used hint:
+BitmapScanRegexp(p1 p1_.*val2.*)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+------------------------------------------------------
+ Result
+ -> Append
+ -> Bitmap Heap Scan on p1
+ Recheck Cond: (val = 1)
+ -> Bitmap Index Scan on p1_val2
+ Index Cond: (val = 1)
+ -> Bitmap Heap Scan on p1_c1 p1
+ Recheck Cond: (val = 1)
+ -> Bitmap Index Scan on p1_c1_val2
+ Index Cond: (val = 1)
+ -> Bitmap Heap Scan on p1_c2 p1
+ Recheck Cond: (val = 1)
+ -> Bitmap Index Scan on p1_c2_val2
+ Index Cond: (val = 1)
+ -> Bitmap Heap Scan on p1_c3 p1
+ Recheck Cond: (val = 1)
+ -> Bitmap Index Scan on p1_c3_val2
+ Index Cond: (val = 1)
+ -> Bitmap Heap Scan on p1_c4 p1
+ Recheck Cond: (val = 1)
+ -> Bitmap Index Scan on p1_c4_val2
+ Index Cond: (val = 1)
+ -> Bitmap Heap Scan on p1_c1_c1 p1
+ Recheck Cond: (val = 1)
+ -> Bitmap Index Scan on p1_c1_c1_val2
+ Index Cond: (val = 1)
+ -> Bitmap Heap Scan on p1_c1_c2 p1
+ Recheck Cond: (val = 1)
+ -> Bitmap Index Scan on p1_c1_c2_val2
+ Index Cond: (val = 1)
+ -> Bitmap Heap Scan on p1_c3_c1 p1
+ Recheck Cond: (val = 1)
+ -> Bitmap Index Scan on p1_c3_c1_val2
+ Index Cond: (val = 1)
+ -> Bitmap Heap Scan on p1_c3_c2 p1
+ Recheck Cond: (val = 1)
+ -> Bitmap Index Scan on p1_c3_c2_val2
+ Index Cond: (val = 1)
+(38 rows)
+
+/*+ BitmapScanRegexp(p1 p1[^_].*)*/
+EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
+LOG: available indexes for BitmapScanRegexp(p1):
+LOG: available indexes for BitmapScanRegexp(p1_c1):
+LOG: available indexes for BitmapScanRegexp(p1_c2):
+LOG: available indexes for BitmapScanRegexp(p1_c3):
+LOG: available indexes for BitmapScanRegexp(p1_c4):
+LOG: available indexes for BitmapScanRegexp(p1_c1_c1):
+LOG: available indexes for BitmapScanRegexp(p1_c1_c2):
+LOG: available indexes for BitmapScanRegexp(p1_c3_c1):
+LOG: available indexes for BitmapScanRegexp(p1_c3_c2):
+LOG: pg_hint_plan:
+used hint:
+BitmapScanRegexp(p1 p1[^_].*)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+-------------------------------------
+ Result
+ -> Append
+ -> Seq Scan on p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c2 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c4 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3_c2 p1
+ Filter: (val = 1)
+(20 rows)
+
+/*+ BitmapScan(p1 p1_.*val2.*)*/
+EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
+LOG: available indexes for BitmapScan(p1):
+LOG: available indexes for BitmapScan(p1_c1):
+LOG: available indexes for BitmapScan(p1_c2):
+LOG: available indexes for BitmapScan(p1_c3):
+LOG: available indexes for BitmapScan(p1_c4):
+LOG: available indexes for BitmapScan(p1_c1_c1):
+LOG: available indexes for BitmapScan(p1_c1_c2):
+LOG: available indexes for BitmapScan(p1_c3_c1):
+LOG: available indexes for BitmapScan(p1_c3_c2):
+LOG: pg_hint_plan:
+used hint:
+BitmapScan(p1 p1_.*val2.*)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+-------------------------------------
+ Result
+ -> Append
+ -> Seq Scan on p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c2 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c4 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3_c2 p1
+ Filter: (val = 1)
+(20 rows)
+
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Seq Scan on p1_c3 p1
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
- -> Tid Scan on p1_c4 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c3_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c3_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
-(25 rows)
+ -> Seq Scan on p1_c4 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c3_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c3_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+(20 rows)
SET constraint_exclusion TO on;
EXPLAIN (COSTS false) SELECT * FROM p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Seq Scan on p1_c1 p1
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
- -> Tid Scan on p1_c1_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
-(12 rows)
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+(10 rows)
SET constraint_exclusion TO off;
/*+SeqScan(p1)*/
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Seq Scan on p1_c3 p1
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
- -> Tid Scan on p1_c4 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c3_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c3_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
+ -> Seq Scan on p1_c4 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c3_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c3_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Index Scan using t1_pkey on t1
Index Cond: (id < 10)
-(30 rows)
+(25 rows)
SET constraint_exclusion TO on;
EXPLAIN (COSTS false) SELECT * FROM p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Seq Scan on p1_c1 p1
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
- -> Tid Scan on p1_c1_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Index Scan using t1_pkey on t1
Index Cond: (id < 10)
-(17 rows)
+(15 rows)
SET constraint_exclusion TO off;
/*+SeqScan(p1)*/
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Seq Scan on p1_c3 p1
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
- -> Tid Scan on p1_c4 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c3_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c3_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
+ -> Seq Scan on p1_c4 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c3_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c3_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Index Scan using t1_pkey on t1
Index Cond: (id < 10)
-(30 rows)
+(25 rows)
/*+IndexScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Seq Scan on p1_c3 p1
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
- -> Tid Scan on p1_c4 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c3_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c3_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
+ -> Seq Scan on p1_c4 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c3_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c3_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Index Scan using t1_pkey on t1
Index Cond: (id < 10)
-(30 rows)
+(25 rows)
/*+BitmapScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Seq Scan on p1_c3 p1
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
- -> Tid Scan on p1_c4 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c3_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c3_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
+ -> Seq Scan on p1_c4 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c3_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c3_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Index Scan using t1_pkey on t1
Index Cond: (id < 10)
-(30 rows)
+(25 rows)
/*+TidScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Seq Scan on p1_c3 p1
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
- -> Tid Scan on p1_c4 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c3_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c3_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
+ -> Seq Scan on p1_c4 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c3_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c3_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Index Scan using t1_pkey on t1
Index Cond: (id < 10)
-(30 rows)
+(25 rows)
/*+NestLoop(p1 t1)*/
EXPLAIN (COSTS false) SELECT * FROM p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Seq Scan on p1_c3 p1
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
- -> Tid Scan on p1_c4 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c3_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c3_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
+ -> Seq Scan on p1_c4 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c3_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c3_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Materialize
-> Index Scan using t1_pkey on t1
Index Cond: (id < 10)
-(29 rows)
+(24 rows)
/*+MergeJoin(p1 t1)*/
EXPLAIN (COSTS false) SELECT * FROM p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Seq Scan on p1_c3 p1
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
- -> Tid Scan on p1_c4 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c3_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c3_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
+ -> Seq Scan on p1_c4 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c3_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c3_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Index Scan using t1_pkey on t1
Index Cond: (id < 10)
-(30 rows)
+(25 rows)
/*+HashJoin(p1 t1)*/
EXPLAIN (COSTS false) SELECT * FROM p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Seq Scan on p1_c3 p1
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
- -> Tid Scan on p1_c4 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c3_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c3_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
+ -> Seq Scan on p1_c4 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c3_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c3_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Hash
-> Index Scan using t1_pkey on t1
Index Cond: (id < 10)
-(29 rows)
+(24 rows)
SET constraint_exclusion TO on;
/*+SeqScan(p1)*/
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Seq Scan on p1_c1 p1
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
- -> Tid Scan on p1_c1_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Index Scan using t1_pkey on t1
Index Cond: (id < 10)
-(17 rows)
+(15 rows)
/*+IndexScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Seq Scan on p1_c1 p1
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
- -> Tid Scan on p1_c1_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Index Scan using t1_pkey on t1
Index Cond: (id < 10)
-(17 rows)
+(15 rows)
/*+BitmapScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Seq Scan on p1_c1 p1
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
- -> Tid Scan on p1_c1_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Index Scan using t1_pkey on t1
Index Cond: (id < 10)
-(17 rows)
+(15 rows)
/*+TidScan(p1)*/
EXPLAIN (COSTS false) SELECT * FROM p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Seq Scan on p1_c1 p1
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
- -> Tid Scan on p1_c1_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Index Scan using t1_pkey on t1
Index Cond: (id < 10)
-(17 rows)
+(15 rows)
/*+NestLoop(p1 t1)*/
EXPLAIN (COSTS false) SELECT * FROM p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Seq Scan on p1_c1 p1
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
- -> Tid Scan on p1_c1_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
-(16 rows)
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+(14 rows)
/*+MergeJoin(p1 t1)*/
EXPLAIN (COSTS false) SELECT * FROM p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Seq Scan on p1_c1 p1
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
- -> Tid Scan on p1_c1_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Index Scan using t1_pkey on t1
Index Cond: (id < 10)
-(17 rows)
+(15 rows)
/*+HashJoin(p1 t1)*/
EXPLAIN (COSTS false) SELECT * FROM p1, t1 WHERE p1.id >= 50 AND p1.id <= 51 AND p1.ctid = '(1,1)' AND p1.id = t1.id AND t1.id < 10;
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
-> Seq Scan on p1_c1 p1
Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
- -> Tid Scan on p1_c1_c1 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
- -> Tid Scan on p1_c1_c2 p1
- TID Cond: (ctid = '(1,1)'::tid)
- Filter: ((id >= 50) AND (id <= 51))
-(16 rows)
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
+(14 rows)
SET constraint_exclusion TO off;
EXPLAIN (COSTS false) SELECT * FROM ONLY p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
-- debug log of candidate index to use IndexScan
EXPLAIN (COSTS false) SELECT * FROM t5 WHERE t5.id = 1;
- QUERY PLAN
--------------------------------
- Index Scan using t5_id3 on t5
+ QUERY PLAN
+----------------------------------------------------------------------------------------
+ Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
Index Cond: (id = 1)
(2 rows)
duplication hint:
error hint:
- QUERY PLAN
---------------------------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------------------------------------------------------------------------------
Merge Join
Merge Cond: (t1.id = t2.id)
-> Index Scan using t1_pkey on t1
-> Merge Join
Merge Cond: (t4.id = t5.id)
-> Index Scan using t4_pkey on t4
- -> Index Scan using t5_id3 on t5
+ -> Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
(16 rows)
/*+Leading((t5(t4(t3(t2 t1)))))*/
duplication hint:
error hint:
- QUERY PLAN
---------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------------------------------------------
Nested Loop
-> Merge Join
Merge Cond: (t1.id = t4.id)
-> Sort
Sort Key: t4.id
-> Seq Scan on t4
- -> Index Scan using t5_id3 on t5
+ -> Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
Index Cond: (id = t1.id)
(15 rows)
duplication hint:
error hint:
- QUERY PLAN
--------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------------------------------------------------------------
Nested Loop
Join Filter: (t2.id = t1.id)
-> Nested Loop
Merge Cond: (t4.id = t3.id)
-> Merge Join
Merge Cond: (t5.id = t4.id)
- -> Index Scan using t5_id3 on t5
+ -> Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
-> Sort
Sort Key: t4.id
-> Seq Scan on t4
duplication hint:
error hint:
- QUERY PLAN
---------------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------------------------------------------------------------------
Merge Join
Merge Cond: (t1.id = t3.id)
-> Merge Join
-> Merge Join
Merge Cond: (t4.id = t5.id)
-> Index Scan using t4_pkey on t4
- -> Index Scan using t5_id3 on t5
+ -> Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
(15 rows)
/*+Leading(((t5 t4)(t3(t2 t1))))*/
duplication hint:
error hint:
- QUERY PLAN
---------------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------------------------------------------------
Merge Join
Merge Cond: (t4.id = t1.id)
-> Merge Join
Merge Cond: (t5.id = t4.id)
- -> Index Scan using t5_id3 on t5
+ -> Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
-> Sort
Sort Key: t4.id
-> Seq Scan on t4
duplication hint:
error hint:
- QUERY PLAN
---------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------------------------------------------------------
Merge Join
Merge Cond: (t1.id = t4.id)
-> Merge Join
-> Merge Join
Merge Cond: (t4.id = t5.id)
-> Index Scan using t4_pkey on t4
- -> Index Scan using t5_id3 on t5
+ -> Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
(14 rows)
/*+Leading((((t5 t4)t3)(t2 t1)))*/
duplication hint:
error hint:
- QUERY PLAN
---------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------------------------------------------------------
Merge Join
Merge Cond: (t3.id = t1.id)
-> Merge Join
Merge Cond: (t4.id = t3.id)
-> Merge Join
Merge Cond: (t5.id = t4.id)
- -> Index Scan using t5_id3 on t5
+ -> Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
-> Sort
Sort Key: t4.id
-> Seq Scan on t4
-> Index Scan using t1_pkey on t1
(16 rows)
+-- regular expression
+-- ordinary table
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+ QUERY PLAN
+---------------------------------------------------------------------------------------------
+ Index Only Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
+ Index Cond: (id = 1)
+(2 rows)
+
+/*+ IndexScanRegexp(t5 t5_[^i].*)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+LOG: available indexes for IndexScanRegexp(t5): t5_val t5_pkey
+LOG: pg_hint_plan:
+used hint:
+IndexScanRegexp(t5 t5_[^i].*)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+--------------------------------
+ Index Scan using t5_pkey on t5
+ Index Cond: (id = 1)
+(2 rows)
+
+/*+ IndexScanRegexp(t5 t5_id[0-9].*)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+LOG: available indexes for IndexScanRegexp(t5): t5_id3 t5_id2 t5_id1
+LOG: pg_hint_plan:
+used hint:
+IndexScanRegexp(t5 t5_id[0-9].*)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+-------------------------------
+ Index Scan using t5_id3 on t5
+ Index Cond: (id = 1)
+(2 rows)
+
+/*+ IndexScanRegexp(t5 t5[^_].*)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+LOG: available indexes for IndexScanRegexp(t5):
+LOG: pg_hint_plan:
+used hint:
+IndexScanRegexp(t5 t5[^_].*)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+--------------------
+ Seq Scan on t5
+ Filter: (id = 1)
+(2 rows)
+
+/*+ IndexScanRegexp(t5 ^.*t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+LOG: available indexes for IndexScanRegexp(t5):
+LOG: pg_hint_plan:
+used hint:
+IndexScanRegexp(t5 ^.*t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+--------------------
+ Seq Scan on t5
+ Filter: (id = 1)
+(2 rows)
+
+/*+ IndexScan(t5 t5_id[0-9].*)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+LOG: available indexes for IndexScan(t5):
+LOG: pg_hint_plan:
+used hint:
+IndexScan(t5 t5_id[0-9].*)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+--------------------
+ Seq Scan on t5
+ Filter: (id = 1)
+(2 rows)
+
+/*+ IndexOnlyScanRegexp(t5 t5_[^i].*)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+LOG: available indexes for IndexOnlyScanRegexp(t5): t5_val t5_pkey
+LOG: pg_hint_plan:
+used hint:
+IndexOnlyScanRegexp(t5 t5_[^i].*)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+-------------------------------------
+ Index Only Scan using t5_pkey on t5
+ Index Cond: (id = 1)
+(2 rows)
+
+/*+ IndexOnlyScanRegexp(t5 t5_id[0-9].*)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+LOG: available indexes for IndexOnlyScanRegexp(t5): t5_id3 t5_id2 t5_id1
+LOG: pg_hint_plan:
+used hint:
+IndexOnlyScanRegexp(t5 t5_id[0-9].*)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+------------------------------------
+ Index Only Scan using t5_id3 on t5
+ Index Cond: (id = 1)
+(2 rows)
+
+/*+ IndexOnlyScanRegexp(t5 t5[^_].*)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+LOG: available indexes for IndexOnlyScanRegexp(t5):
+LOG: pg_hint_plan:
+used hint:
+IndexOnlyScanRegexp(t5 t5[^_].*)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+--------------------
+ Seq Scan on t5
+ Filter: (id = 1)
+(2 rows)
+
+/*+ IndexOnlyScanRegexp(t5 ^.*t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+LOG: available indexes for IndexOnlyScanRegexp(t5):
+LOG: pg_hint_plan:
+used hint:
+IndexOnlyScanRegexp(t5 ^.*t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+--------------------
+ Seq Scan on t5
+ Filter: (id = 1)
+(2 rows)
+
+/*+ IndexOnlyScan(t5 t5_id[0-9].*)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+LOG: available indexes for IndexOnlyScan(t5):
+LOG: pg_hint_plan:
+used hint:
+IndexOnlyScan(t5 t5_id[0-9].*)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+--------------------
+ Seq Scan on t5
+ Filter: (id = 1)
+(2 rows)
+
+/*+ BitmapScanRegexp(t5 t5_[^i].*)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+LOG: available indexes for BitmapScanRegexp(t5): t5_val t5_pkey
+LOG: pg_hint_plan:
+used hint:
+BitmapScanRegexp(t5 t5_[^i].*)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+------------------------------------
+ Bitmap Heap Scan on t5
+ Recheck Cond: (id = 1)
+ -> Bitmap Index Scan on t5_pkey
+ Index Cond: (id = 1)
+(4 rows)
+
+/*+ BitmapScanRegexp(t5 t5_id[0-9].*)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+LOG: available indexes for BitmapScanRegexp(t5): t5_id3 t5_id2 t5_id1
+LOG: pg_hint_plan:
+used hint:
+BitmapScanRegexp(t5 t5_id[0-9].*)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+-----------------------------------
+ Bitmap Heap Scan on t5
+ Recheck Cond: (id = 1)
+ -> Bitmap Index Scan on t5_id3
+ Index Cond: (id = 1)
+(4 rows)
+
+/*+ BitmapScanRegexp(t5 t5[^_].*)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+LOG: available indexes for BitmapScanRegexp(t5):
+LOG: pg_hint_plan:
+used hint:
+BitmapScanRegexp(t5 t5[^_].*)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+--------------------
+ Seq Scan on t5
+ Filter: (id = 1)
+(2 rows)
+
+/*+ BitmapScanRegexp(t5 ^.*t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+LOG: available indexes for BitmapScanRegexp(t5):
+LOG: pg_hint_plan:
+used hint:
+BitmapScanRegexp(t5 ^.*t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+--------------------
+ Seq Scan on t5
+ Filter: (id = 1)
+(2 rows)
+
+/*+ BitmapScan(t5 t5_id[0-9].*)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+LOG: available indexes for BitmapScan(t5):
+LOG: pg_hint_plan:
+used hint:
+BitmapScan(t5 t5_id[0-9].*)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+--------------------
+ Seq Scan on t5
+ Filter: (id = 1)
+(2 rows)
+
+-- Inheritance
+EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
+ QUERY PLAN
+-------------------------------------
+ Result
+ -> Append
+ -> Seq Scan on p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c2 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c4 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3_c2 p1
+ Filter: (val = 1)
+(20 rows)
+
+/*+ IndexScanRegexp(p1 p1_.*[^0-9]$)*/
+EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
+LOG: available indexes for IndexScanRegexp(p1): p1_pkey
+LOG: available indexes for IndexScanRegexp(p1_c1): p1_c1_pkey
+LOG: available indexes for IndexScanRegexp(p1_c2): p1_c2_pkey
+LOG: available indexes for IndexScanRegexp(p1_c3): p1_c3_pkey
+LOG: available indexes for IndexScanRegexp(p1_c4): p1_c4_pkey
+LOG: available indexes for IndexScanRegexp(p1_c1_c1): p1_c1_c1_pkey
+LOG: available indexes for IndexScanRegexp(p1_c1_c2): p1_c1_c2_pkey
+LOG: available indexes for IndexScanRegexp(p1_c3_c1): p1_c3_c1_pkey
+LOG: available indexes for IndexScanRegexp(p1_c3_c2): p1_c3_c2_pkey
+LOG: pg_hint_plan:
+used hint:
+IndexScanRegexp(p1 p1_.*[^0-9]$)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+-------------------------------------
+ Result
+ -> Append
+ -> Seq Scan on p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c2 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c4 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3_c2 p1
+ Filter: (val = 1)
+(20 rows)
+
+/*+ IndexScanRegexp(p1 p1_.*val2.*)*/
+EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
+LOG: available indexes for IndexScanRegexp(p1): p1_val2
+LOG: available indexes for IndexScanRegexp(p1_c1): p1_c1_val2
+LOG: available indexes for IndexScanRegexp(p1_c2): p1_c2_val2
+LOG: available indexes for IndexScanRegexp(p1_c3): p1_c3_val2
+LOG: available indexes for IndexScanRegexp(p1_c4): p1_c4_val2
+LOG: available indexes for IndexScanRegexp(p1_c1_c1): p1_c1_c1_val2
+LOG: available indexes for IndexScanRegexp(p1_c1_c2): p1_c1_c2_val2
+LOG: available indexes for IndexScanRegexp(p1_c3_c1): p1_c3_c1_val2
+LOG: available indexes for IndexScanRegexp(p1_c3_c2): p1_c3_c2_val2
+LOG: pg_hint_plan:
+used hint:
+IndexScanRegexp(p1 p1_.*val2.*)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+-----------------------------------------------------------
+ Result
+ -> Append
+ -> Index Scan using p1_val2 on p1
+ Index Cond: (val = 1)
+ -> Index Scan using p1_c1_val2 on p1_c1 p1
+ Index Cond: (val = 1)
+ -> Index Scan using p1_c2_val2 on p1_c2 p1
+ Index Cond: (val = 1)
+ -> Index Scan using p1_c3_val2 on p1_c3 p1
+ Index Cond: (val = 1)
+ -> Index Scan using p1_c4_val2 on p1_c4 p1
+ Index Cond: (val = 1)
+ -> Index Scan using p1_c1_c1_val2 on p1_c1_c1 p1
+ Index Cond: (val = 1)
+ -> Index Scan using p1_c1_c2_val2 on p1_c1_c2 p1
+ Index Cond: (val = 1)
+ -> Index Scan using p1_c3_c1_val2 on p1_c3_c1 p1
+ Index Cond: (val = 1)
+ -> Index Scan using p1_c3_c2_val2 on p1_c3_c2 p1
+ Index Cond: (val = 1)
+(20 rows)
+
+/*+ IndexScanRegexp(p1 p1[^_].*)*/
+EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
+LOG: available indexes for IndexScanRegexp(p1):
+LOG: available indexes for IndexScanRegexp(p1_c1):
+LOG: available indexes for IndexScanRegexp(p1_c2):
+LOG: available indexes for IndexScanRegexp(p1_c3):
+LOG: available indexes for IndexScanRegexp(p1_c4):
+LOG: available indexes for IndexScanRegexp(p1_c1_c1):
+LOG: available indexes for IndexScanRegexp(p1_c1_c2):
+LOG: available indexes for IndexScanRegexp(p1_c3_c1):
+LOG: available indexes for IndexScanRegexp(p1_c3_c2):
+LOG: pg_hint_plan:
+used hint:
+IndexScanRegexp(p1 p1[^_].*)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+-------------------------------------
+ Result
+ -> Append
+ -> Seq Scan on p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c2 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c4 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3_c2 p1
+ Filter: (val = 1)
+(20 rows)
+
+/*+ IndexScan(p1 p1_.*val2.*)*/
+EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
+LOG: available indexes for IndexScan(p1):
+LOG: available indexes for IndexScan(p1_c1):
+LOG: available indexes for IndexScan(p1_c2):
+LOG: available indexes for IndexScan(p1_c3):
+LOG: available indexes for IndexScan(p1_c4):
+LOG: available indexes for IndexScan(p1_c1_c1):
+LOG: available indexes for IndexScan(p1_c1_c2):
+LOG: available indexes for IndexScan(p1_c3_c1):
+LOG: available indexes for IndexScan(p1_c3_c2):
+LOG: pg_hint_plan:
+used hint:
+IndexScan(p1 p1_.*val2.*)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+-------------------------------------
+ Result
+ -> Append
+ -> Seq Scan on p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c2 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c4 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3_c2 p1
+ Filter: (val = 1)
+(20 rows)
+
+/*+ IndexOnlyScanRegexp(p1 p1_.*[^0-9]$)*/
+EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
+LOG: available indexes for IndexOnlyScanRegexp(p1): p1_pkey
+LOG: available indexes for IndexOnlyScanRegexp(p1_c1): p1_c1_pkey
+LOG: available indexes for IndexOnlyScanRegexp(p1_c2): p1_c2_pkey
+LOG: available indexes for IndexOnlyScanRegexp(p1_c3): p1_c3_pkey
+LOG: available indexes for IndexOnlyScanRegexp(p1_c4): p1_c4_pkey
+LOG: available indexes for IndexOnlyScanRegexp(p1_c1_c1): p1_c1_c1_pkey
+LOG: available indexes for IndexOnlyScanRegexp(p1_c1_c2): p1_c1_c2_pkey
+LOG: available indexes for IndexOnlyScanRegexp(p1_c3_c1): p1_c3_c1_pkey
+LOG: available indexes for IndexOnlyScanRegexp(p1_c3_c2): p1_c3_c2_pkey
+LOG: pg_hint_plan:
+used hint:
+IndexOnlyScanRegexp(p1 p1_.*[^0-9]$)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+-------------------------------------
+ Result
+ -> Append
+ -> Seq Scan on p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c2 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c4 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3_c2 p1
+ Filter: (val = 1)
+(20 rows)
+
+/*+ IndexOnlyScanRegexp(p1 p1_.*val2.*)*/
+EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
+LOG: available indexes for IndexOnlyScanRegexp(p1): p1_val2
+LOG: available indexes for IndexOnlyScanRegexp(p1_c1): p1_c1_val2
+LOG: available indexes for IndexOnlyScanRegexp(p1_c2): p1_c2_val2
+LOG: available indexes for IndexOnlyScanRegexp(p1_c3): p1_c3_val2
+LOG: available indexes for IndexOnlyScanRegexp(p1_c4): p1_c4_val2
+LOG: available indexes for IndexOnlyScanRegexp(p1_c1_c1): p1_c1_c1_val2
+LOG: available indexes for IndexOnlyScanRegexp(p1_c1_c2): p1_c1_c2_val2
+LOG: available indexes for IndexOnlyScanRegexp(p1_c3_c1): p1_c3_c1_val2
+LOG: available indexes for IndexOnlyScanRegexp(p1_c3_c2): p1_c3_c2_val2
+LOG: pg_hint_plan:
+used hint:
+IndexOnlyScanRegexp(p1 p1_.*val2.*)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+----------------------------------------------------------------
+ Result
+ -> Append
+ -> Index Only Scan using p1_val2 on p1
+ Index Cond: (val = 1)
+ -> Index Only Scan using p1_c1_val2 on p1_c1 p1
+ Index Cond: (val = 1)
+ -> Index Only Scan using p1_c2_val2 on p1_c2 p1
+ Index Cond: (val = 1)
+ -> Index Only Scan using p1_c3_val2 on p1_c3 p1
+ Index Cond: (val = 1)
+ -> Index Only Scan using p1_c4_val2 on p1_c4 p1
+ Index Cond: (val = 1)
+ -> Index Only Scan using p1_c1_c1_val2 on p1_c1_c1 p1
+ Index Cond: (val = 1)
+ -> Index Only Scan using p1_c1_c2_val2 on p1_c1_c2 p1
+ Index Cond: (val = 1)
+ -> Index Only Scan using p1_c3_c1_val2 on p1_c3_c1 p1
+ Index Cond: (val = 1)
+ -> Index Only Scan using p1_c3_c2_val2 on p1_c3_c2 p1
+ Index Cond: (val = 1)
+(20 rows)
+
+/*+ IndexOnlyScanRegexp(p1 p1[^_].*)*/
+EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
+LOG: available indexes for IndexOnlyScanRegexp(p1):
+LOG: available indexes for IndexOnlyScanRegexp(p1_c1):
+LOG: available indexes for IndexOnlyScanRegexp(p1_c2):
+LOG: available indexes for IndexOnlyScanRegexp(p1_c3):
+LOG: available indexes for IndexOnlyScanRegexp(p1_c4):
+LOG: available indexes for IndexOnlyScanRegexp(p1_c1_c1):
+LOG: available indexes for IndexOnlyScanRegexp(p1_c1_c2):
+LOG: available indexes for IndexOnlyScanRegexp(p1_c3_c1):
+LOG: available indexes for IndexOnlyScanRegexp(p1_c3_c2):
+LOG: pg_hint_plan:
+used hint:
+IndexOnlyScanRegexp(p1 p1[^_].*)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+-------------------------------------
+ Result
+ -> Append
+ -> Seq Scan on p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c2 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c4 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3_c2 p1
+ Filter: (val = 1)
+(20 rows)
+
+/*+ IndexOnlyScan(p1 p1_.*val2.*)*/
+EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
+LOG: available indexes for IndexOnlyScan(p1):
+LOG: available indexes for IndexOnlyScan(p1_c1):
+LOG: available indexes for IndexOnlyScan(p1_c2):
+LOG: available indexes for IndexOnlyScan(p1_c3):
+LOG: available indexes for IndexOnlyScan(p1_c4):
+LOG: available indexes for IndexOnlyScan(p1_c1_c1):
+LOG: available indexes for IndexOnlyScan(p1_c1_c2):
+LOG: available indexes for IndexOnlyScan(p1_c3_c1):
+LOG: available indexes for IndexOnlyScan(p1_c3_c2):
+LOG: pg_hint_plan:
+used hint:
+IndexOnlyScan(p1 p1_.*val2.*)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+-------------------------------------
+ Result
+ -> Append
+ -> Seq Scan on p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c2 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c4 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3_c2 p1
+ Filter: (val = 1)
+(20 rows)
+
+/*+ BitmapScanRegexp(p1 p1_.*[^0-9]$)*/
+EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
+LOG: available indexes for BitmapScanRegexp(p1): p1_pkey
+LOG: available indexes for BitmapScanRegexp(p1_c1): p1_c1_pkey
+LOG: available indexes for BitmapScanRegexp(p1_c2): p1_c2_pkey
+LOG: available indexes for BitmapScanRegexp(p1_c3): p1_c3_pkey
+LOG: available indexes for BitmapScanRegexp(p1_c4): p1_c4_pkey
+LOG: available indexes for BitmapScanRegexp(p1_c1_c1): p1_c1_c1_pkey
+LOG: available indexes for BitmapScanRegexp(p1_c1_c2): p1_c1_c2_pkey
+LOG: available indexes for BitmapScanRegexp(p1_c3_c1): p1_c3_c1_pkey
+LOG: available indexes for BitmapScanRegexp(p1_c3_c2): p1_c3_c2_pkey
+LOG: pg_hint_plan:
+used hint:
+BitmapScanRegexp(p1 p1_.*[^0-9]$)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+-------------------------------------
+ Result
+ -> Append
+ -> Seq Scan on p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c2 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c4 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3_c2 p1
+ Filter: (val = 1)
+(20 rows)
+
+/*+ BitmapScanRegexp(p1 p1_.*val2.*)*/
+EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
+LOG: available indexes for BitmapScanRegexp(p1): p1_val2
+LOG: available indexes for BitmapScanRegexp(p1_c1): p1_c1_val2
+LOG: available indexes for BitmapScanRegexp(p1_c2): p1_c2_val2
+LOG: available indexes for BitmapScanRegexp(p1_c3): p1_c3_val2
+LOG: available indexes for BitmapScanRegexp(p1_c4): p1_c4_val2
+LOG: available indexes for BitmapScanRegexp(p1_c1_c1): p1_c1_c1_val2
+LOG: available indexes for BitmapScanRegexp(p1_c1_c2): p1_c1_c2_val2
+LOG: available indexes for BitmapScanRegexp(p1_c3_c1): p1_c3_c1_val2
+LOG: available indexes for BitmapScanRegexp(p1_c3_c2): p1_c3_c2_val2
+LOG: pg_hint_plan:
+used hint:
+BitmapScanRegexp(p1 p1_.*val2.*)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+------------------------------------------------------
+ Result
+ -> Append
+ -> Bitmap Heap Scan on p1
+ Recheck Cond: (val = 1)
+ -> Bitmap Index Scan on p1_val2
+ Index Cond: (val = 1)
+ -> Bitmap Heap Scan on p1_c1 p1
+ Recheck Cond: (val = 1)
+ -> Bitmap Index Scan on p1_c1_val2
+ Index Cond: (val = 1)
+ -> Bitmap Heap Scan on p1_c2 p1
+ Recheck Cond: (val = 1)
+ -> Bitmap Index Scan on p1_c2_val2
+ Index Cond: (val = 1)
+ -> Bitmap Heap Scan on p1_c3 p1
+ Recheck Cond: (val = 1)
+ -> Bitmap Index Scan on p1_c3_val2
+ Index Cond: (val = 1)
+ -> Bitmap Heap Scan on p1_c4 p1
+ Recheck Cond: (val = 1)
+ -> Bitmap Index Scan on p1_c4_val2
+ Index Cond: (val = 1)
+ -> Bitmap Heap Scan on p1_c1_c1 p1
+ Recheck Cond: (val = 1)
+ -> Bitmap Index Scan on p1_c1_c1_val2
+ Index Cond: (val = 1)
+ -> Bitmap Heap Scan on p1_c1_c2 p1
+ Recheck Cond: (val = 1)
+ -> Bitmap Index Scan on p1_c1_c2_val2
+ Index Cond: (val = 1)
+ -> Bitmap Heap Scan on p1_c3_c1 p1
+ Recheck Cond: (val = 1)
+ -> Bitmap Index Scan on p1_c3_c1_val2
+ Index Cond: (val = 1)
+ -> Bitmap Heap Scan on p1_c3_c2 p1
+ Recheck Cond: (val = 1)
+ -> Bitmap Index Scan on p1_c3_c2_val2
+ Index Cond: (val = 1)
+(38 rows)
+
+/*+ BitmapScanRegexp(p1 p1[^_].*)*/
+EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
+LOG: available indexes for BitmapScanRegexp(p1):
+LOG: available indexes for BitmapScanRegexp(p1_c1):
+LOG: available indexes for BitmapScanRegexp(p1_c2):
+LOG: available indexes for BitmapScanRegexp(p1_c3):
+LOG: available indexes for BitmapScanRegexp(p1_c4):
+LOG: available indexes for BitmapScanRegexp(p1_c1_c1):
+LOG: available indexes for BitmapScanRegexp(p1_c1_c2):
+LOG: available indexes for BitmapScanRegexp(p1_c3_c1):
+LOG: available indexes for BitmapScanRegexp(p1_c3_c2):
+LOG: pg_hint_plan:
+used hint:
+BitmapScanRegexp(p1 p1[^_].*)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+-------------------------------------
+ Result
+ -> Append
+ -> Seq Scan on p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c2 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c4 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3_c2 p1
+ Filter: (val = 1)
+(20 rows)
+
+/*+ BitmapScan(p1 p1_.*val2.*)*/
+EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
+LOG: available indexes for BitmapScan(p1):
+LOG: available indexes for BitmapScan(p1_c1):
+LOG: available indexes for BitmapScan(p1_c2):
+LOG: available indexes for BitmapScan(p1_c3):
+LOG: available indexes for BitmapScan(p1_c4):
+LOG: available indexes for BitmapScan(p1_c1_c1):
+LOG: available indexes for BitmapScan(p1_c1_c2):
+LOG: available indexes for BitmapScan(p1_c3_c1):
+LOG: available indexes for BitmapScan(p1_c3_c2):
+LOG: pg_hint_plan:
+used hint:
+BitmapScan(p1 p1_.*val2.*)
+not used hint:
+duplication hint:
+error hint:
+
+ QUERY PLAN
+-------------------------------------
+ Result
+ -> Append
+ -> Seq Scan on p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c2 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c4 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c1_c2 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3_c1 p1
+ Filter: (val = 1)
+ -> Seq Scan on p1_c3_c2 p1
+ Filter: (val = 1)
+(20 rows)
+
*-------------------------------------------------------------------------
*/
#include "postgres.h"
+#include "catalog/pg_collation.h"
#include "catalog/pg_index.h"
#include "commands/prepare.h"
#include "mb/pg_wchar.h"
#include "optimizer/restrictinfo.h"
#include "parser/scansup.h"
#include "tcop/utility.h"
+#include "utils/builtins.h"
#include "utils/lsyscache.h"
#include "utils/memutils.h"
#include "utils/rel.h"
/* hint keywords */
#define HINT_SEQSCAN "SeqScan"
#define HINT_INDEXSCAN "IndexScan"
+#define HINT_INDEXSCANREGEXP "IndexScanRegexp"
#define HINT_BITMAPSCAN "BitmapScan"
+#define HINT_BITMAPSCANREGEXP "BitmapScanRegexp"
#define HINT_TIDSCAN "TidScan"
#define HINT_NOSEQSCAN "NoSeqScan"
#define HINT_NOINDEXSCAN "NoIndexScan"
#define HINT_NOTIDSCAN "NoTidScan"
#if PG_VERSION_NUM >= 90200
#define HINT_INDEXONLYSCAN "IndexOnlyScan"
+#define HINT_INDEXONLYSCANREGEXP "IndexOnlyScanRegexp"
#define HINT_NOINDEXONLYSCAN "NoIndexOnlyScan"
#endif
#define HINT_NESTLOOP "NestLoop"
{
HINT_KEYWORD_SEQSCAN,
HINT_KEYWORD_INDEXSCAN,
+ HINT_KEYWORD_INDEXSCANREGEXP,
HINT_KEYWORD_BITMAPSCAN,
+ HINT_KEYWORD_BITMAPSCANREGEXP,
HINT_KEYWORD_TIDSCAN,
HINT_KEYWORD_NOSEQSCAN,
HINT_KEYWORD_NOINDEXSCAN,
HINT_KEYWORD_NOTIDSCAN,
#if PG_VERSION_NUM >= 90200
HINT_KEYWORD_INDEXONLYSCAN,
+ HINT_KEYWORD_INDEXONLYSCANREGEXP,
HINT_KEYWORD_NOINDEXONLYSCAN,
#endif
HINT_KEYWORD_NESTLOOP,
Hint base;
char *relname;
List *indexnames;
+ bool regexp;
unsigned char enforce_mask;
} ScanMethodHint;
static const HintParser parsers[] = {
{HINT_SEQSCAN, ScanMethodHintCreate, HINT_KEYWORD_SEQSCAN},
{HINT_INDEXSCAN, ScanMethodHintCreate, HINT_KEYWORD_INDEXSCAN},
+ {HINT_INDEXSCANREGEXP, ScanMethodHintCreate, HINT_KEYWORD_INDEXSCANREGEXP},
{HINT_BITMAPSCAN, ScanMethodHintCreate, HINT_KEYWORD_BITMAPSCAN},
+ {HINT_BITMAPSCANREGEXP, ScanMethodHintCreate,
+ HINT_KEYWORD_BITMAPSCANREGEXP},
{HINT_TIDSCAN, ScanMethodHintCreate, HINT_KEYWORD_TIDSCAN},
{HINT_NOSEQSCAN, ScanMethodHintCreate, HINT_KEYWORD_NOSEQSCAN},
{HINT_NOINDEXSCAN, ScanMethodHintCreate, HINT_KEYWORD_NOINDEXSCAN},
{HINT_NOTIDSCAN, ScanMethodHintCreate, HINT_KEYWORD_NOTIDSCAN},
#if PG_VERSION_NUM >= 90200
{HINT_INDEXONLYSCAN, ScanMethodHintCreate, HINT_KEYWORD_INDEXONLYSCAN},
+ {HINT_INDEXONLYSCANREGEXP, ScanMethodHintCreate,
+ HINT_KEYWORD_INDEXONLYSCANREGEXP},
{HINT_NOINDEXONLYSCAN, ScanMethodHintCreate, HINT_KEYWORD_NOINDEXONLYSCAN},
#endif
{HINT_NESTLOOP, JoinMethodHintCreate, HINT_KEYWORD_NESTLOOP},
hint->base.parse_func = (HintParseFunction) ScanMethodHintParse;
hint->relname = NULL;
hint->indexnames = NIL;
+ hint->regexp = false;
hint->enforce_mask = 0;
return (Hint *) hint;
}
static const char *
-parse_parentheses(const char *str, List **name_list, HintType type)
+parse_parentheses(const char *str, List **name_list, HintKeyword keyword)
{
char *name;
bool truncate = true;
*name_list = lappend(*name_list, name);
skip_space(str);
- if (type == HINT_TYPE_SET)
+ if (keyword == HINT_KEYWORD_INDEXSCANREGEXP ||
+#if PG_VERSION_NUM >= 90200
+ keyword == HINT_KEYWORD_INDEXONLYSCANREGEXP ||
+#endif
+ keyword == HINT_KEYWORD_BITMAPSCANREGEXP ||
+ keyword == HINT_KEYWORD_SET)
{
truncate = false;
}
List *name_list = NIL;
int length;
- if ((str = parse_parentheses(str, &name_list, hint->base.type)) == NULL)
+ if ((str = parse_parentheses(str, &name_list, hint_keyword)) == NULL)
return NULL;
/* Parse relation name and index name(s) if given hint accepts. */
hint->indexnames = list_delete_first(name_list);
/* check whether the hint accepts index name(s). */
- if (hint_keyword != HINT_KEYWORD_INDEXSCAN &&
+ if (length != 1 &&
+ hint_keyword != HINT_KEYWORD_INDEXSCAN &&
+ hint_keyword != HINT_KEYWORD_INDEXSCANREGEXP &&
#if PG_VERSION_NUM >= 90200
hint_keyword != HINT_KEYWORD_INDEXONLYSCAN &&
+ hint_keyword != HINT_KEYWORD_INDEXONLYSCANREGEXP &&
#endif
hint_keyword != HINT_KEYWORD_BITMAPSCAN &&
- length != 1)
+ hint_keyword != HINT_KEYWORD_BITMAPSCANREGEXP)
{
hint_ereport(str,
("%s hint accepts only one relation.",
case HINT_KEYWORD_INDEXSCAN:
hint->enforce_mask = ENABLE_INDEXSCAN;
break;
+ case HINT_KEYWORD_INDEXSCANREGEXP:
+ hint->enforce_mask = ENABLE_INDEXSCAN;
+ hint->regexp = true;
+ break;
case HINT_KEYWORD_BITMAPSCAN:
hint->enforce_mask = ENABLE_BITMAPSCAN;
break;
+ case HINT_KEYWORD_BITMAPSCANREGEXP:
+ hint->enforce_mask = ENABLE_BITMAPSCAN;
+ hint->regexp = true;
+ break;
case HINT_KEYWORD_TIDSCAN:
hint->enforce_mask = ENABLE_TIDSCAN;
break;
case HINT_KEYWORD_INDEXONLYSCAN:
hint->enforce_mask = ENABLE_INDEXSCAN | ENABLE_INDEXONLYSCAN;
break;
+ case HINT_KEYWORD_INDEXONLYSCANREGEXP:
+ hint->enforce_mask = ENABLE_INDEXSCAN | ENABLE_INDEXONLYSCAN;
+ hint->regexp = true;
+ break;
case HINT_KEYWORD_NOINDEXONLYSCAN:
hint->enforce_mask = ENABLE_ALL_SCAN ^ ENABLE_INDEXONLYSCAN;
break;
HintKeyword hint_keyword = hint->base.hint_keyword;
List *name_list = NIL;
- if ((str = parse_parentheses(str, &name_list, hint->base.type)) == NULL)
+ if ((str = parse_parentheses(str, &name_list, hint_keyword)) == NULL)
return NULL;
hint->nrels = list_length(name_list);
{
List *name_list = NIL;
- if ((str = parse_parentheses(str, &name_list, hint->base.type)) == NULL)
+ if ((str = parse_parentheses(str, &name_list, hint->base.hint_keyword))
+ == NULL)
return NULL;
hint->words = name_list;
return NULL;
}
+/*
+ * regexeq
+ *
+ * Returns TRUE on match, FALSE on no match.
+ *
+ * s1 --- the data to match against
+ * s2 --- the pattern
+ *
+ * Because we copy s1 to NameData, make the size of s1 less than NAMEDATALEN.
+ */
+static bool
+regexpeq(const char *s1, const char *s2)
+{
+ NameData name;
+ text *regexp;
+ Datum result;
+
+ strcpy(name.data, s1);
+ regexp = cstring_to_text(s2);
+
+ result = DirectFunctionCall2Coll(nameregexeq,
+ DEFAULT_COLLATION_OID,
+ NameGetDatum(&name),
+ PointerGetDatum(regexp));
+ return DatumGetBool(result);
+}
+
static void
delete_indexes(ScanMethodHint *hint, RelOptInfo *rel, Oid relationObjectId)
{
foreach(l, hint->indexnames)
{
- if (RelnameCmp(&indexname, &lfirst(l)) == 0)
+ char *hintname = (char *) lfirst(l);
+ bool result;
+
+ if (hint->regexp)
+ result = regexpeq(indexname, hintname);
+ else
+ result = RelnameCmp(&indexname, &hintname) == 0;
+
+ if (result)
{
use_index = true;
if (pg_hint_plan_debug_print)
CREATE INDEX t5_id2 ON t5 (id);
CREATE INDEX t5_id3 ON t5 (id);
CREATE INDEX t5_val ON t5 (val);
+CREATE INDEX t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ON t5 (id);
+CREATE INDEX p1_val1 ON p1 (val);
+CREATE INDEX p1_val2 ON p1 (val);
+CREATE INDEX p1_val3 ON p1 (val);
+CREATE INDEX p1_c1_val1 ON p1_c1 (val);
+CREATE INDEX p1_c1_val2 ON p1_c1 (val);
+CREATE INDEX p1_c1_val3 ON p1_c1 (val);
+CREATE INDEX p1_c1_c1_val1 ON p1_c1_c1 (val);
+CREATE INDEX p1_c1_c1_val2 ON p1_c1_c1 (val);
+CREATE INDEX p1_c1_c1_val3 ON p1_c1_c1 (val);
+CREATE INDEX p1_c1_c2_val1 ON p1_c1_c2 (val);
+CREATE INDEX p1_c1_c2_val2 ON p1_c1_c2 (val);
+CREATE INDEX p1_c1_c2_val3 ON p1_c1_c2 (val);
+CREATE INDEX p1_c2_val1 ON p1_c2 (val);
+CREATE INDEX p1_c2_val2 ON p1_c2 (val);
+CREATE INDEX p1_c2_val3 ON p1_c2 (val);
+CREATE INDEX p1_c3_val1 ON p1_c3 (val);
+CREATE INDEX p1_c3_val2 ON p1_c3 (val);
+CREATE INDEX p1_c3_val3 ON p1_c3 (val);
+CREATE INDEX p1_c3_c1_val1 ON p1_c3_c1 (val);
+CREATE INDEX p1_c3_c1_val2 ON p1_c3_c1 (val);
+CREATE INDEX p1_c3_c1_val3 ON p1_c3_c1 (val);
+CREATE INDEX p1_c3_c2_val1 ON p1_c3_c2 (val);
+CREATE INDEX p1_c3_c2_val2 ON p1_c3_c2 (val);
+CREATE INDEX p1_c3_c2_val3 ON p1_c3_c2 (val);
+CREATE INDEX p1_c4_val1 ON p1_c4 (val);
+CREATE INDEX p1_c4_val2 ON p1_c4 (val);
+CREATE INDEX p1_c4_val3 ON p1_c4 (val);
ANALYZE t1;
ANALYZE t2;
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;
/*+Leading((((t5 t4)t3)(t2 t1)))*/
EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4, t5 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id AND t1.id = t5.id;
+
+-- regular expression
+-- ordinary table
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+/*+ IndexScanRegexp(t5 t5_[^i].*)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+/*+ IndexScanRegexp(t5 t5_id[0-9].*)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+/*+ IndexScanRegexp(t5 t5[^_].*)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+/*+ IndexScanRegexp(t5 ^.*t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+/*+ IndexScan(t5 t5_id[0-9].*)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+/*+ IndexOnlyScanRegexp(t5 t5_[^i].*)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+/*+ IndexOnlyScanRegexp(t5 t5_id[0-9].*)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+/*+ IndexOnlyScanRegexp(t5 t5[^_].*)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+/*+ IndexOnlyScanRegexp(t5 ^.*t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+/*+ IndexOnlyScan(t5 t5_id[0-9].*)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+/*+ BitmapScanRegexp(t5 t5_[^i].*)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+/*+ BitmapScanRegexp(t5 t5_id[0-9].*)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+/*+ BitmapScanRegexp(t5 t5[^_].*)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+/*+ BitmapScanRegexp(t5 ^.*t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+/*+ BitmapScan(t5 t5_id[0-9].*)*/
+EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
+
+-- Inheritance
+EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
+/*+ IndexScanRegexp(p1 p1_.*[^0-9]$)*/
+EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
+/*+ IndexScanRegexp(p1 p1_.*val2.*)*/
+EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
+/*+ IndexScanRegexp(p1 p1[^_].*)*/
+EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
+/*+ IndexScan(p1 p1_.*val2.*)*/
+EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
+/*+ IndexOnlyScanRegexp(p1 p1_.*[^0-9]$)*/
+EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
+/*+ IndexOnlyScanRegexp(p1 p1_.*val2.*)*/
+EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
+/*+ IndexOnlyScanRegexp(p1 p1[^_].*)*/
+EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
+/*+ IndexOnlyScan(p1 p1_.*val2.*)*/
+EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
+/*+ BitmapScanRegexp(p1 p1_.*[^0-9]$)*/
+EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
+/*+ BitmapScanRegexp(p1 p1_.*val2.*)*/
+EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
+/*+ BitmapScanRegexp(p1 p1[^_].*)*/
+EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
+/*+ BitmapScan(p1 p1_.*val2.*)*/
+EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
OSDN Git Service
