(1 row)
EXPLAIN (ANALYZE, COSTS OFF, SUMMARY OFF, TIMING OFF, BUFFERS OFF) SELECT 100;
- QUERY PLAN
---------------------------------
- Result (actual rows=1 loops=1)
+ QUERY PLAN
+-----------------------------------
+ Result (actual rows=1.00 loops=1)
(1 row)
EXPLAIN (ANALYZE, COSTS OFF, SUMMARY OFF, TIMING OFF, BUFFERS OFF)
DECLARE foocur CURSOR FOR SELECT * FROM stats_track_tab;
- QUERY PLAN
------------------------------------------------------
- Seq Scan on stats_track_tab (actual rows=0 loops=1)
+ QUERY PLAN
+--------------------------------------------------------
+ Seq Scan on stats_track_tab (actual rows=0.00 loops=1)
(1 row)
SELECT toplevel, calls, query FROM pg_stat_statements
(1 row)
EXPLAIN (ANALYZE, COSTS OFF, SUMMARY OFF, TIMING OFF, BUFFERS OFF) SELECT 100;
- QUERY PLAN
---------------------------------
- Result (actual rows=1 loops=1)
+ QUERY PLAN
+-----------------------------------
+ Result (actual rows=1.00 loops=1)
(1 row)
EXPLAIN (ANALYZE, COSTS OFF, SUMMARY OFF, TIMING OFF, BUFFERS OFF)
DECLARE foocur CURSOR FOR SELECT * FROM stats_track_tab;
- QUERY PLAN
------------------------------------------------------
- Seq Scan on stats_track_tab (actual rows=0 loops=1)
+ QUERY PLAN
+--------------------------------------------------------
+ Seq Scan on stats_track_tab (actual rows=0.00 loops=1)
(1 row)
SELECT toplevel, calls, query FROM pg_stat_statements
EXPLAIN (ANALYZE, COSTS OFF, SUMMARY OFF, TIMING OFF, BUFFERS OFF)
SELECT * FROM local_tbl, async_pt WHERE local_tbl.a = async_pt.a AND local_tbl.c = 'bar';
- QUERY PLAN
--------------------------------------------------------------------------------
- Nested Loop (actual rows=1 loops=1)
- -> Seq Scan on local_tbl (actual rows=1 loops=1)
+ QUERY PLAN
+----------------------------------------------------------------------------------
+ Nested Loop (actual rows=1.00 loops=1)
+ -> Seq Scan on local_tbl (actual rows=1.00 loops=1)
Filter: (c = 'bar'::text)
Rows Removed by Filter: 1
- -> Append (actual rows=1 loops=1)
+ -> Append (actual rows=1.00 loops=1)
-> Async Foreign Scan on async_p1 async_pt_1 (never executed)
- -> Async Foreign Scan on async_p2 async_pt_2 (actual rows=1 loops=1)
+ -> Async Foreign Scan on async_p2 async_pt_2 (actual rows=1.00 loops=1)
-> Seq Scan on async_p3 async_pt_3 (never executed)
Filter: (a = local_tbl.a)
(9 rows)
EXPLAIN (ANALYZE, COSTS OFF, SUMMARY OFF, TIMING OFF, BUFFERS OFF)
SELECT * FROM local_tbl t1 LEFT JOIN (SELECT *, (SELECT count(*) FROM async_pt WHERE a < 3000) FROM async_pt WHERE a < 3000) t2 ON t1.a = t2.a;
- QUERY PLAN
------------------------------------------------------------------------------------------
- Nested Loop Left Join (actual rows=1 loops=1)
+ QUERY PLAN
+--------------------------------------------------------------------------------------------
+ Nested Loop Left Join (actual rows=1.00 loops=1)
Join Filter: (t1.a = async_pt.a)
Rows Removed by Join Filter: 399
InitPlan 1
- -> Aggregate (actual rows=1 loops=1)
- -> Append (actual rows=400 loops=1)
- -> Async Foreign Scan on async_p1 async_pt_4 (actual rows=200 loops=1)
- -> Async Foreign Scan on async_p2 async_pt_5 (actual rows=200 loops=1)
- -> Seq Scan on local_tbl t1 (actual rows=1 loops=1)
- -> Append (actual rows=400 loops=1)
- -> Async Foreign Scan on async_p1 async_pt_1 (actual rows=200 loops=1)
- -> Async Foreign Scan on async_p2 async_pt_2 (actual rows=200 loops=1)
+ -> Aggregate (actual rows=1.00 loops=1)
+ -> Append (actual rows=400.00 loops=1)
+ -> Async Foreign Scan on async_p1 async_pt_4 (actual rows=200.00 loops=1)
+ -> Async Foreign Scan on async_p2 async_pt_5 (actual rows=200.00 loops=1)
+ -> Seq Scan on local_tbl t1 (actual rows=1.00 loops=1)
+ -> Append (actual rows=400.00 loops=1)
+ -> Async Foreign Scan on async_p1 async_pt_1 (actual rows=200.00 loops=1)
+ -> Async Foreign Scan on async_p2 async_pt_2 (actual rows=200.00 loops=1)
(12 rows)
SELECT * FROM local_tbl t1 LEFT JOIN (SELECT *, (SELECT count(*) FROM async_pt WHERE a < 3000) FROM async_pt WHERE a < 3000) t2 ON t1.a = t2.a;
EXPLAIN (ANALYZE, COSTS OFF, SUMMARY OFF, TIMING OFF, BUFFERS OFF)
SELECT * FROM async_pt t1 WHERE t1.b === 505 LIMIT 1;
- QUERY PLAN
--------------------------------------------------------------------------
- Limit (actual rows=1 loops=1)
- -> Append (actual rows=1 loops=1)
- -> Async Foreign Scan on async_p1 t1_1 (actual rows=0 loops=1)
+ QUERY PLAN
+----------------------------------------------------------------------------
+ Limit (actual rows=1.00 loops=1)
+ -> Append (actual rows=1.00 loops=1)
+ -> Async Foreign Scan on async_p1 t1_1 (actual rows=0.00 loops=1)
Filter: (b === 505)
- -> Async Foreign Scan on async_p2 t1_2 (actual rows=0 loops=1)
+ -> Async Foreign Scan on async_p2 t1_2 (actual rows=0.00 loops=1)
Filter: (b === 505)
- -> Seq Scan on async_p3 t1_3 (actual rows=1 loops=1)
+ -> Seq Scan on async_p3 t1_3 (actual rows=1.00 loops=1)
Filter: (b === 505)
Rows Removed by Filter: 101
(9 rows)
DELETE FROM async_p3;
EXPLAIN (ANALYZE, COSTS OFF, SUMMARY OFF, TIMING OFF, BUFFERS OFF)
SELECT * FROM async_pt;
- QUERY PLAN
--------------------------------------------------------------------------
- Append (actual rows=0 loops=1)
- -> Async Foreign Scan on async_p1 async_pt_1 (actual rows=0 loops=1)
- -> Async Foreign Scan on async_p2 async_pt_2 (actual rows=0 loops=1)
- -> Seq Scan on async_p3 async_pt_3 (actual rows=0 loops=1)
+ QUERY PLAN
+----------------------------------------------------------------------------
+ Append (actual rows=0.00 loops=1)
+ -> Async Foreign Scan on async_p1 async_pt_1 (actual rows=0.00 loops=1)
+ -> Async Foreign Scan on async_p2 async_pt_2 (actual rows=0.00 loops=1)
+ -> Seq Scan on async_p3 async_pt_3 (actual rows=0.00 loops=1)
(4 rows)
-- Clean up
Query Text: SELECT count(*)
FROM pg_class, pg_index
WHERE oid = indrelid AND indisunique;
- Aggregate (cost=16.79..16.80 rows=1 width=0) (actual time=3.626..3.627 rows=1 loops=1)
- -> Hash Join (cost=4.17..16.55 rows=92 width=0) (actual time=3.349..3.594 rows=92 loops=1)
+ Aggregate (cost=16.79..16.80 rows=1 width=0) (actual time=3.626..3.627 rows=1.00 loops=1)
+ -> Hash Join (cost=4.17..16.55 rows=92 width=0) (actual time=3.349..3.594 rows=92.00 loops=1)
Hash Cond: (pg_class.oid = pg_index.indrelid)
- -> Seq Scan on pg_class (cost=0.00..9.55 rows=255 width=4) (actual time=0.016..0.140 rows=255 loops=1)
- -> Hash (cost=3.02..3.02 rows=92 width=4) (actual time=3.238..3.238 rows=92 loops=1)
+ -> Seq Scan on pg_class (cost=0.00..9.55 rows=255 width=4) (actual time=0.016..0.140 rows=255.00 loops=1)
+ -> Hash (cost=3.02..3.02 rows=92 width=4) (actual time=3.238..3.238 rows=92.00 loops=1)
Buckets: 1024 Batches: 1 Memory Usage: 4kB
- -> Seq Scan on pg_index (cost=0.00..3.02 rows=92 width=4) (actual time=0.008..3.187 rows=92 loops=1)
+ -> Seq Scan on pg_index (cost=0.00..3.02 rows=92 width=4) (actual time=0.008..3.187 rows=92.00 loops=1)
Filter: indisunique
]]></screen>
</sect2>
=# EXPLAIN ANALYZE SELECT * FROM tbloom WHERE i2 = 898732 AND i5 = 123451;
QUERY PLAN
-------------------------------------------------------------------&zwsp;-----------------------------------
- Seq Scan on tbloom (cost=0.00..213744.00 rows=250 width=24) (actual time=357.059..357.059 rows=0 loops=1)
+ Seq Scan on tbloom (cost=0.00..213744.00 rows=250 width=24) (actual time=357.059..357.059 rows=0.00 loops=1)
Filter: ((i2 = 898732) AND (i5 = 123451))
Rows Removed by Filter: 10000000
Buffers: shared hit=63744
=# EXPLAIN ANALYZE SELECT * FROM tbloom WHERE i2 = 898732 AND i5 = 123451;
QUERY PLAN
-------------------------------------------------------------------&zwsp;-----------------------------------
- Seq Scan on tbloom (cost=0.00..213744.00 rows=2 width=24) (actual time=351.016..351.017 rows=0 loops=1)
+ Seq Scan on tbloom (cost=0.00..213744.00 rows=2 width=24) (actual time=351.016..351.017 rows=0.00 loops=1)
Filter: ((i2 = 898732) AND (i5 = 123451))
Rows Removed by Filter: 10000000
Buffers: shared hit=63744
=# EXPLAIN ANALYZE SELECT * FROM tbloom WHERE i2 = 898732 AND i5 = 123451;
QUERY PLAN
-------------------------------------------------------------------&zwsp;--------------------------------------------------
- Bitmap Heap Scan on tbloom (cost=1792.00..1799.69 rows=2 width=24) (actual time=22.605..22.606 rows=0 loops=1)
+ Bitmap Heap Scan on tbloom (cost=1792.00..1799.69 rows=2 width=24) (actual time=22.605..22.606 rows=0.00 loops=1)
Recheck Cond: ((i2 = 898732) AND (i5 = 123451))
Rows Removed by Index Recheck: 2300
Heap Blocks: exact=2256
Buffers: shared hit=21864
- -> Bitmap Index Scan on bloomidx (cost=0.00..178436.00 rows=1 width=0) (actual time=20.005..20.005 rows=2300 loops=1)
+ -> Bitmap Index Scan on bloomidx (cost=0.00..178436.00 rows=1 width=0) (actual time=20.005..20.005 rows=2300.00 loops=1)
Index Cond: ((i2 = 898732) AND (i5 = 123451))
Buffers: shared hit=19608
Planning Time: 0.099 ms
=# EXPLAIN ANALYZE SELECT * FROM tbloom WHERE i2 = 898732 AND i5 = 123451;
QUERY PLAN
-------------------------------------------------------------------&zwsp;--------------------------------------------------------
- Bitmap Heap Scan on tbloom (cost=9.29..13.30 rows=1 width=24) (actual time=0.032..0.033 rows=0 loops=1)
+ Bitmap Heap Scan on tbloom (cost=9.29..13.30 rows=1 width=24) (actual time=0.032..0.033 rows=0.00 loops=1)
Recheck Cond: ((i5 = 123451) AND (i2 = 898732))
Buffers: shared read=6
- -> BitmapAnd (cost=9.29..9.29 rows=1 width=0) (actual time=0.047..0.047 rows=0 loops=1)
+ -> BitmapAnd (cost=9.29..9.29 rows=1 width=0) (actual time=0.047..0.047 rows=0.00 loops=1)
Buffers: shared hit=6
- -> Bitmap Index Scan on btreeidx5 (cost=0.00..4.52 rows=11 width=0) (actual time=0.026..0.026 rows=7 loops=1)
+ -> Bitmap Index Scan on btreeidx5 (cost=0.00..4.52 rows=11 width=0) (actual time=0.026..0.026 rows=7.00 loops=1)
Index Cond: (i5 = 123451)
Buffers: shared hit=3
- -> Bitmap Index Scan on btreeidx2 (cost=0.00..4.52 rows=11 width=0) (actual time=0.007..0.007 rows=8 loops=1)
+ -> Bitmap Index Scan on btreeidx2 (cost=0.00..4.52 rows=11 width=0) (actual time=0.007..0.007 rows=8.00 loops=1)
Index Cond: (i2 = 898732)
Buffers: shared hit=3
Planning Time: 0.264 ms
=# EXPLAIN ANALYZE SELECT SUM(relpages) FROM pg_class;
QUERY PLAN
-------------------------------------------------------------------&zwsp;------------------------------------------
- Aggregate (cost=16.27..16.29 rows=1 width=8) (actual time=0.303..0.303 rows=1 loops=1)
+ Aggregate (cost=16.27..16.29 rows=1 width=8) (actual time=0.303..0.303 rows=1.00 loops=1)
Buffers: shared hit=14
- -> Seq Scan on pg_class (cost=0.00..15.42 rows=342 width=4) (actual time=0.017..0.111 rows=356 loops=1)
+ -> Seq Scan on pg_class (cost=0.00..15.42 rows=342 width=4) (actual time=0.017..0.111 rows=356.00 loops=1)
Buffers: shared hit=14
Planning Time: 0.116 ms
Execution Time: 0.365 ms
=# EXPLAIN ANALYZE SELECT SUM(relpages) FROM pg_class;
QUERY PLAN
-------------------------------------------------------------------&zwsp;------------------------------------------
- Aggregate (cost=16.27..16.29 rows=1 width=8) (actual time=6.049..6.049 rows=1 loops=1)
+ Aggregate (cost=16.27..16.29 rows=1 width=8) (actual time=6.049..6.049 rows=1.00 loops=1)
Buffers: shared hit=14
- -> Seq Scan on pg_class (cost=0.00..15.42 rows=342 width=4) (actual time=0.019..0.052 rows=356 loops=1)
+ -> Seq Scan on pg_class (cost=0.00..15.42 rows=342 width=4) (actual time=0.019..0.052 rows=356.00 loops=1)
Buffers: shared hit=14
Planning Time: 0.133 ms
JIT:
QUERY PLAN
-------------------------------------------------------------------&zwsp;--------------------------------------------------------------
- Nested Loop (cost=4.65..118.50 rows=10 width=488) (actual time=0.017..0.051 rows=10 loops=1)
+ Nested Loop (cost=4.65..118.50 rows=10 width=488) (actual time=0.017..0.051 rows=10.00 loops=1)
Buffers: shared hit=36 read=6
- -> Bitmap Heap Scan on tenk1 t1 (cost=4.36..39.38 rows=10 width=244) (actual time=0.009..0.017 rows=10 loops=1)
+ -> Bitmap Heap Scan on tenk1 t1 (cost=4.36..39.38 rows=10 width=244) (actual time=0.009..0.017 rows=10.00 loops=1)
Recheck Cond: (unique1 < 10)
Heap Blocks: exact=10
Buffers: shared hit=3 read=5 written=4
- -> Bitmap Index Scan on tenk1_unique1 (cost=0.00..4.36 rows=10 width=0) (actual time=0.004..0.004 rows=10 loops=1)
+ -> Bitmap Index Scan on tenk1_unique1 (cost=0.00..4.36 rows=10 width=0) (actual time=0.004..0.004 rows=10.00 loops=1)
Index Cond: (unique1 < 10)
Buffers: shared hit=2
-> Index Scan using tenk2_unique2 on tenk2 t2 (cost=0.29..7.90 rows=1 width=244) (actual time=0.003..0.003 rows=1 loops=10)
QUERY PLAN
-------------------------------------------------------------------&zwsp;-------------------------------------------------------------------&zwsp;------
- Sort (cost=713.05..713.30 rows=100 width=488) (actual time=2.995..3.002 rows=100 loops=1)
+ Sort (cost=713.05..713.30 rows=100 width=488) (actual time=2.995..3.002 rows=100.00 loops=1)
Sort Key: t1.fivethous
Sort Method: quicksort Memory: 74kB
Buffers: shared hit=440
- -> Hash Join (cost=226.23..709.73 rows=100 width=488) (actual time=0.515..2.920 rows=100 loops=1)
+ -> Hash Join (cost=226.23..709.73 rows=100 width=488) (actual time=0.515..2.920 rows=100.00 loops=1)
Hash Cond: (t2.unique2 = t1.unique2)
Buffers: shared hit=437
- -> Seq Scan on tenk2 t2 (cost=0.00..445.00 rows=10000 width=244) (actual time=0.026..1.790 rows=10000 loops=1)
+ -> Seq Scan on tenk2 t2 (cost=0.00..445.00 rows=10000 width=244) (actual time=0.026..1.790 rows=10000.00 loops=1)
Buffers: shared hit=345
- -> Hash (cost=224.98..224.98 rows=100 width=244) (actual time=0.476..0.477 rows=100 loops=1)
+ -> Hash (cost=224.98..224.98 rows=100 width=244) (actual time=0.476..0.477 rows=100.00 loops=1)
Buckets: 1024 Batches: 1 Memory Usage: 35kB
Buffers: shared hit=92
- -> Bitmap Heap Scan on tenk1 t1 (cost=5.06..224.98 rows=100 width=244) (actual time=0.030..0.450 rows=100 loops=1)
+ -> Bitmap Heap Scan on tenk1 t1 (cost=5.06..224.98 rows=100 width=244) (actual time=0.030..0.450 rows=100.00 loops=1)
Recheck Cond: (unique1 < 100)
Heap Blocks: exact=90
Buffers: shared hit=92
- -> Bitmap Index Scan on tenk1_unique1 (cost=0.00..5.04 rows=100 width=0) (actual time=0.013..0.013 rows=100 loops=1)
+ -> Bitmap Index Scan on tenk1_unique1 (cost=0.00..5.04 rows=100 width=0) (actual time=0.013..0.013 rows=100.00 loops=1)
Index Cond: (unique1 < 100)
Buffers: shared hit=2
Planning:
QUERY PLAN
-------------------------------------------------------------------&zwsp;--------------------------------------
- Seq Scan on tenk1 (cost=0.00..470.00 rows=7000 width=244) (actual time=0.030..1.995 rows=7000 loops=1)
+ Seq Scan on tenk1 (cost=0.00..470.00 rows=7000 width=244) (actual time=0.030..1.995 rows=7000.00 loops=1)
Filter: (ten < 7)
Rows Removed by Filter: 3000
Buffers: shared hit=345
QUERY PLAN
-------------------------------------------------------------------&zwsp;-----------------------------------
- Seq Scan on polygon_tbl (cost=0.00..1.09 rows=1 width=85) (actual time=0.023..0.023 rows=0 loops=1)
+ Seq Scan on polygon_tbl (cost=0.00..1.09 rows=1 width=85) (actual time=0.023..0.023 rows=0.00 loops=1)
Filter: (f1 @> '((0.5,2))'::polygon)
Rows Removed by Filter: 7
Buffers: shared hit=1
QUERY PLAN
-------------------------------------------------------------------&zwsp;-------------------------------------------------------
- Index Scan using gpolygonind on polygon_tbl (cost=0.13..8.15 rows=1 width=85) (actual time=0.074..0.074 rows=0 loops=1)
+ Index Scan using gpolygonind on polygon_tbl (cost=0.13..8.15 rows=1 width=85) (actual time=0.074..0.074 rows=0.00 loops=1)
Index Cond: (f1 @> '((0.5,2))'::polygon)
Rows Removed by Index Recheck: 1
Buffers: shared hit=1
QUERY PLAN
-------------------------------------------------------------------&zwsp;--------------------------------------------------------------
- Bitmap Heap Scan on tenk1 (cost=25.07..60.11 rows=10 width=244) (actual time=0.105..0.114 rows=10 loops=1)
+ Bitmap Heap Scan on tenk1 (cost=25.07..60.11 rows=10 width=244) (actual time=0.105..0.114 rows=10.00 loops=1)
Recheck Cond: ((unique1 < 100) AND (unique2 > 9000))
Heap Blocks: exact=10
- -> BitmapAnd (cost=25.07..25.07 rows=10 width=0) (actual time=0.100..0.101 rows=0 loops=1)
- -> Bitmap Index Scan on tenk1_unique1 (cost=0.00..5.04 rows=100 width=0) (actual time=0.027..0.027 rows=100 loops=1)
+ -> BitmapAnd (cost=25.07..25.07 rows=10 width=0) (actual time=0.100..0.101 rows=0.00 loops=1)
+ -> Bitmap Index Scan on tenk1_unique1 (cost=0.00..5.04 rows=100 width=0) (actual time=0.027..0.027 rows=100.00 loops=1)
Index Cond: (unique1 < 100)
- -> Bitmap Index Scan on tenk1_unique2 (cost=0.00..19.78 rows=999 width=0) (actual time=0.070..0.070 rows=999 loops=1)
+ -> Bitmap Index Scan on tenk1_unique2 (cost=0.00..19.78 rows=999 width=0) (actual time=0.070..0.070 rows=999.00 loops=1)
Index Cond: (unique2 > 9000)
Planning Time: 0.162 ms
Execution Time: 0.143 ms
QUERY PLAN
-------------------------------------------------------------------&zwsp;-------------------------------------------------------------
- Update on tenk1 (cost=5.06..225.23 rows=0 width=0) (actual time=1.634..1.635 rows=0 loops=1)
- -> Bitmap Heap Scan on tenk1 (cost=5.06..225.23 rows=100 width=10) (actual time=0.065..0.141 rows=100 loops=1)
+ Update on tenk1 (cost=5.06..225.23 rows=0 width=0) (actual time=1.634..1.635 rows=0.00 loops=1)
+ -> Bitmap Heap Scan on tenk1 (cost=5.06..225.23 rows=100 width=10) (actual time=0.065..0.141 rows=100.00 loops=1)
Recheck Cond: (unique1 < 100)
Heap Blocks: exact=90
Buffers: shared hit=4 read=2
- -> Bitmap Index Scan on tenk1_unique1 (cost=0.00..5.04 rows=100 width=0) (actual time=0.031..0.031 rows=100 loops=1)
+ -> Bitmap Index Scan on tenk1_unique1 (cost=0.00..5.04 rows=100 width=0) (actual time=0.031..0.031 rows=100.00 loops=1)
Index Cond: (unique1 < 100)
Buffers: shared read=2
Planning Time: 0.151 ms
QUERY PLAN
-------------------------------------------------------------------&zwsp;------------------------------------------------------------
- Limit (cost=0.29..14.33 rows=2 width=244) (actual time=0.051..0.071 rows=2 loops=1)
+ Limit (cost=0.29..14.33 rows=2 width=244) (actual time=0.051..0.071 rows=2.00 loops=1)
Buffers: shared hit=16
- -> Index Scan using tenk1_unique2 on tenk1 (cost=0.29..70.50 rows=10 width=244) (actual time=0.051..0.070 rows=2 loops=1)
+ -> Index Scan using tenk1_unique2 on tenk1 (cost=0.29..70.50 rows=10 width=244) (actual time=0.051..0.070 rows=2.00 loops=1)
Index Cond: (unique2 > 9000)
Filter: (unique1 < 100)
Rows Removed by Filter: 287
EXPLAIN (ANALYZE, TIMING OFF, BUFFERS OFF) SELECT * FROM t WHERE a = 1;
QUERY PLAN
-------------------------------------------------------------------&zwsp;------------
- Seq Scan on t (cost=0.00..170.00 rows=100 width=8) (actual rows=100 loops=1)
+ Seq Scan on t (cost=0.00..170.00 rows=100 width=8) (actual rows=100.00 loops=1)
Filter: (a = 1)
Rows Removed by Filter: 9900
</programlisting>
EXPLAIN (ANALYZE, TIMING OFF, BUFFERS OFF) SELECT * FROM t WHERE a = 1 AND b = 1;
QUERY PLAN
-------------------------------------------------------------------&zwsp;----------
- Seq Scan on t (cost=0.00..195.00 rows=1 width=8) (actual rows=100 loops=1)
+ Seq Scan on t (cost=0.00..195.00 rows=1 width=8) (actual rows=100.00 loops=1)
Filter: ((a = 1) AND (b = 1))
Rows Removed by Filter: 9900
</programlisting>
EXPLAIN (ANALYZE, TIMING OFF, BUFFERS OFF) SELECT * FROM t WHERE a = 1 AND b = 1;
QUERY PLAN
-------------------------------------------------------------------&zwsp;------------
- Seq Scan on t (cost=0.00..195.00 rows=100 width=8) (actual rows=100 loops=1)
+ Seq Scan on t (cost=0.00..195.00 rows=100 width=8) (actual rows=100.00 loops=1)
Filter: ((a = 1) AND (b = 1))
Rows Removed by Filter: 9900
</programlisting>
EXPLAIN (ANALYZE, TIMING OFF, BUFFERS OFF) SELECT COUNT(*) FROM t GROUP BY a;
QUERY PLAN
-------------------------------------------------------------------&zwsp;----------------------
- HashAggregate (cost=195.00..196.00 rows=100 width=12) (actual rows=100 loops=1)
+ HashAggregate (cost=195.00..196.00 rows=100 width=12) (actual rows=100.00 loops=1)
Group Key: a
- -> Seq Scan on t (cost=0.00..145.00 rows=10000 width=4) (actual rows=10000 loops=1)
+ -> Seq Scan on t (cost=0.00..145.00 rows=10000 width=4) (actual rows=10000.00 loops=1)
</programlisting>
But without multivariate statistics, the estimate for the number of
groups in a query with two columns in <command>GROUP BY</command>, as
EXPLAIN (ANALYZE, TIMING OFF, BUFFERS OFF) SELECT COUNT(*) FROM t GROUP BY a, b;
QUERY PLAN
-------------------------------------------------------------------&zwsp;-------------------------
- HashAggregate (cost=220.00..230.00 rows=1000 width=16) (actual rows=100 loops=1)
+ HashAggregate (cost=220.00..230.00 rows=1000 width=16) (actual rows=100.00 loops=1)
Group Key: a, b
- -> Seq Scan on t (cost=0.00..145.00 rows=10000 width=8) (actual rows=10000 loops=1)
+ -> Seq Scan on t (cost=0.00..145.00 rows=10000 width=8) (actual rows=10000.00 loops=1)
</programlisting>
By redefining the statistics object to include n-distinct counts for the
two columns, the estimate is much improved:
EXPLAIN (ANALYZE, TIMING OFF, BUFFERS OFF) SELECT COUNT(*) FROM t GROUP BY a, b;
QUERY PLAN
-------------------------------------------------------------------&zwsp;-------------------------
- HashAggregate (cost=220.00..221.00 rows=100 width=16) (actual rows=100 loops=1)
+ HashAggregate (cost=220.00..221.00 rows=100 width=16) (actual rows=100.00 loops=1)
Group Key: a, b
- -> Seq Scan on t (cost=0.00..145.00 rows=10000 width=8) (actual rows=10000 loops=1)
+ -> Seq Scan on t (cost=0.00..145.00 rows=10000 width=8) (actual rows=10000.00 loops=1)
</programlisting>
</para>
EXPLAIN (ANALYZE, TIMING OFF, BUFFERS OFF) SELECT * FROM t WHERE a = 1 AND b = 1;
QUERY PLAN
-------------------------------------------------------------------&zwsp;------------
- Seq Scan on t (cost=0.00..195.00 rows=100 width=8) (actual rows=100 loops=1)
+ Seq Scan on t (cost=0.00..195.00 rows=100 width=8) (actual rows=100.00 loops=1)
Filter: ((a = 1) AND (b = 1))
Rows Removed by Filter: 9900
</programlisting>
EXPLAIN (ANALYZE, TIMING OFF, BUFFERS OFF) SELECT * FROM t WHERE a = 1 AND b = 10;
QUERY PLAN
-------------------------------------------------------------------&zwsp;--------
- Seq Scan on t (cost=0.00..195.00 rows=1 width=8) (actual rows=0 loops=1)
+ Seq Scan on t (cost=0.00..195.00 rows=1 width=8) (actual rows=0.00 loops=1)
Filter: ((a = 1) AND (b = 10))
Rows Removed by Filter: 10000
</programlisting>
EXPLAIN (ANALYZE, TIMING OFF, BUFFERS OFF) SELECT * FROM t WHERE a <= 49 AND b > 49;
QUERY PLAN
-------------------------------------------------------------------&zwsp;--------
- Seq Scan on t (cost=0.00..195.00 rows=1 width=8) (actual rows=0 loops=1)
+ Seq Scan on t (cost=0.00..195.00 rows=1 width=8) (actual rows=0.00 loops=1)
Filter: ((a <= 49) AND (b > 49))
Rows Removed by Filter: 10000
</programlisting>
QUERY PLAN
-------------------------------------------------------------------&zwsp;------------------------------------------------------
- HashAggregate (cost=10.77..10.87 rows=10 width=12) (actual time=0.043..0.044 rows=10 loops=1)
+ HashAggregate (cost=10.77..10.87 rows=10 width=12) (actual time=0.043..0.044 rows=10.00 loops=1)
Group Key: foo
Batches: 1 Memory Usage: 24kB
Buffers: shared hit=4
- -> Index Scan using test_pkey on test (cost=0.29..10.27 rows=99 width=8) (actual time=0.009..0.025 rows=99 loops=1)
+ -> Index Scan using test_pkey on test (cost=0.29..10.27 rows=99 width=8) (actual time=0.009..0.025 rows=99.00 loops=1)
Index Cond: ((id > 100) AND (id < 200))
Buffers: shared hit=4
Planning Time: 0.244 ms
With <command>EXPLAIN ANALYZE</command>, we see:
<programlisting>
- Aggregate (cost=21763.99..21764.00 rows=1 width=0) (actual time=188.180..188.181 rows=1 loops=1)
- -> Foreign Scan on words (cost=0.00..21761.41 rows=1032 width=0) (actual time=188.177..188.177 rows=0 loops=1)
+ Aggregate (cost=21763.99..21764.00 rows=1 width=0) (actual time=188.180..188.181 rows=1.00 loops=1)
+ -> Foreign Scan on words (cost=0.00..21761.41 rows=1032 width=0) (actual time=188.177..188.177 rows=0.00 loops=1)
Filter: (word = 'caterpiler'::text)
Rows Removed by Filter: 479829
Foreign File: /usr/share/dict/words
If the materialized view is used instead, the query is much faster:
<programlisting>
- Aggregate (cost=4.44..4.45 rows=1 width=0) (actual time=0.042..0.042 rows=1 loops=1)
- -> Index Only Scan using wrd_word on wrd (cost=0.42..4.44 rows=1 width=0) (actual time=0.039..0.039 rows=0 loops=1)
+ Aggregate (cost=4.44..4.45 rows=1 width=0) (actual time=0.042..0.042 rows=1.00 loops=1)
+ -> Index Only Scan using wrd_word on wrd (cost=0.42..4.44 rows=1 width=0) (actual time=0.039..0.039 rows=0.00 loops=1)
Index Cond: (word = 'caterpiler'::text)
Heap Fetches: 0
Planning time: 0.164 ms
</programlisting>
<programlisting>
- Limit (cost=11583.61..11583.64 rows=10 width=32) (actual time=1431.591..1431.594 rows=10 loops=1)
- -> Sort (cost=11583.61..11804.76 rows=88459 width=32) (actual time=1431.589..1431.591 rows=10 loops=1)
+ Limit (cost=11583.61..11583.64 rows=10 width=32) (actual time=1431.591..1431.594 rows=10.00 loops=1)
+ -> Sort (cost=11583.61..11804.76 rows=88459 width=32) (actual time=1431.589..1431.591 rows=10.00 loops=1)
Sort Key: ((word <-> 'caterpiler'::text))
Sort Method: top-N heapsort Memory: 25kB
- -> Foreign Scan on words (cost=0.00..9672.05 rows=88459 width=32) (actual time=0.057..1286.455 rows=479829 loops=1)
+ -> Foreign Scan on words (cost=0.00..9672.05 rows=88459 width=32) (actual time=0.057..1286.455 rows=479829.00 loops=1)
Foreign File: /usr/share/dict/words
Foreign File Size: 4953699
Planning time: 0.128 ms
Using the materialized view:
<programlisting>
- Limit (cost=0.29..1.06 rows=10 width=10) (actual time=187.222..188.257 rows=10 loops=1)
- -> Index Scan using wrd_trgm on wrd (cost=0.29..37020.87 rows=479829 width=10) (actual time=187.219..188.252 rows=10 loops=1)
+ Limit (cost=0.29..1.06 rows=10 width=10) (actual time=187.222..188.257 rows=10.00 loops=1)
+ -> Index Scan using wrd_trgm on wrd (cost=0.29..37020.87 rows=479829 width=10) (actual time=187.219..188.252 rows=10.00 loops=1)
Order By: (word <-> 'caterpiler'::text)
Planning time: 0.196 ms
Execution time: 198.640 ms
if (es->timing)
appendStringInfo(es->str, "time=%.3f..%.3f ", startup_ms, total_ms);
- if (nloops > 1)
- appendStringInfo(es->str, "rows=%.2f loops=%.0f)", rows, nloops);
- else
- appendStringInfo(es->str, "rows=%.0f loops=%.0f)", rows, nloops);
+ appendStringInfo(es->str, "rows=%.2f loops=%.0f)", rows, nloops);
}
else
{
ExplainPropertyFloat("Actual Total Time", "ms", total_ms,
3, es);
}
- if (nloops > 1)
- {
- ExplainPropertyFloat("Actual Rows", NULL, rows, 2, es);
- ExplainPropertyFloat("Actual Loops", NULL, nloops, 0, es);
- }
- else
- {
- ExplainPropertyFloat("Actual Rows", NULL, rows, 0, es);
- ExplainPropertyFloat("Actual Loops", NULL, nloops, 0, es);
- }
+ ExplainPropertyFloat("Actual Rows", NULL, rows, 2, es);
+ ExplainPropertyFloat("Actual Loops", NULL, nloops, 0, es);
}
}
else if (es->analyze)
if (es->timing)
appendStringInfo(es->str, "time=%.3f..%.3f", startup_ms, total_ms);
- if (nloops > 1)
- appendStringInfo(es->str, "rows=%.2f loops=%.0f\n", rows, nloops);
- else
- appendStringInfo(es->str, "rows=%.0f loops=%.0f\n", rows, nloops);
+ appendStringInfo(es->str, "rows=%.2f loops=%.0f\n", rows, nloops);
}
else
{
total_ms, 3, es);
}
- if (nloops > 1)
- {
- ExplainPropertyFloat("Actual Rows", NULL, rows, 2, es);
- ExplainPropertyFloat("Actual Loops", NULL, nloops, 0, es);
- }
- else
- {
- ExplainPropertyFloat("Actual Rows", NULL, rows, 0, es);
- ExplainPropertyFloat("Actual Loops", NULL, nloops, 0, es);
- }
+ ExplainPropertyFloat("Actual Rows", NULL, rows, 2, es);
+ ExplainPropertyFloat("Actual Loops", NULL, nloops, 0, es);
}
ExplainCloseWorker(n, es);
-- make sure the ranges were built correctly and 2023-01-01 eliminates all
EXPLAIN (ANALYZE, TIMING OFF, COSTS OFF, SUMMARY OFF, BUFFERS OFF)
SELECT * FROM brin_date_test WHERE a = '2023-01-01'::date;
- QUERY PLAN
--------------------------------------------------------------------------
- Bitmap Heap Scan on brin_date_test (actual rows=0 loops=1)
+ QUERY PLAN
+----------------------------------------------------------------------------
+ Bitmap Heap Scan on brin_date_test (actual rows=0.00 loops=1)
Recheck Cond: (a = '2023-01-01'::date)
- -> Bitmap Index Scan on brin_date_test_a_idx (actual rows=0 loops=1)
+ -> Bitmap Index Scan on brin_date_test_a_idx (actual rows=0.00 loops=1)
Index Cond: (a = '2023-01-01'::date)
(4 rows)
SET enable_seqscan = off;
EXPLAIN (ANALYZE, TIMING OFF, COSTS OFF, SUMMARY OFF, BUFFERS OFF)
SELECT * FROM brin_timestamp_test WHERE a = '2023-01-01'::timestamp;
- QUERY PLAN
-------------------------------------------------------------------------------
- Bitmap Heap Scan on brin_timestamp_test (actual rows=0 loops=1)
+ QUERY PLAN
+---------------------------------------------------------------------------------
+ Bitmap Heap Scan on brin_timestamp_test (actual rows=0.00 loops=1)
Recheck Cond: (a = '2023-01-01 00:00:00'::timestamp without time zone)
- -> Bitmap Index Scan on brin_timestamp_test_a_idx (actual rows=0 loops=1)
+ -> Bitmap Index Scan on brin_timestamp_test_a_idx (actual rows=0.00 loops=1)
Index Cond: (a = '2023-01-01 00:00:00'::timestamp without time zone)
(4 rows)
EXPLAIN (ANALYZE, TIMING OFF, COSTS OFF, SUMMARY OFF, BUFFERS OFF)
SELECT * FROM brin_timestamp_test WHERE a = '1900-01-01'::timestamp;
- QUERY PLAN
-------------------------------------------------------------------------------
- Bitmap Heap Scan on brin_timestamp_test (actual rows=0 loops=1)
+ QUERY PLAN
+---------------------------------------------------------------------------------
+ Bitmap Heap Scan on brin_timestamp_test (actual rows=0.00 loops=1)
Recheck Cond: (a = '1900-01-01 00:00:00'::timestamp without time zone)
- -> Bitmap Index Scan on brin_timestamp_test_a_idx (actual rows=0 loops=1)
+ -> Bitmap Index Scan on brin_timestamp_test_a_idx (actual rows=0.00 loops=1)
Index Cond: (a = '1900-01-01 00:00:00'::timestamp without time zone)
(4 rows)
SET enable_seqscan = off;
EXPLAIN (ANALYZE, TIMING OFF, COSTS OFF, SUMMARY OFF, BUFFERS OFF)
SELECT * FROM brin_date_test WHERE a = '2023-01-01'::date;
- QUERY PLAN
--------------------------------------------------------------------------
- Bitmap Heap Scan on brin_date_test (actual rows=0 loops=1)
+ QUERY PLAN
+----------------------------------------------------------------------------
+ Bitmap Heap Scan on brin_date_test (actual rows=0.00 loops=1)
Recheck Cond: (a = '2023-01-01'::date)
- -> Bitmap Index Scan on brin_date_test_a_idx (actual rows=0 loops=1)
+ -> Bitmap Index Scan on brin_date_test_a_idx (actual rows=0.00 loops=1)
Index Cond: (a = '2023-01-01'::date)
(4 rows)
EXPLAIN (ANALYZE, TIMING OFF, COSTS OFF, SUMMARY OFF, BUFFERS OFF)
SELECT * FROM brin_date_test WHERE a = '1900-01-01'::date;
- QUERY PLAN
--------------------------------------------------------------------------
- Bitmap Heap Scan on brin_date_test (actual rows=0 loops=1)
+ QUERY PLAN
+----------------------------------------------------------------------------
+ Bitmap Heap Scan on brin_date_test (actual rows=0.00 loops=1)
Recheck Cond: (a = '1900-01-01'::date)
- -> Bitmap Index Scan on brin_date_test_a_idx (actual rows=0 loops=1)
+ -> Bitmap Index Scan on brin_date_test_a_idx (actual rows=0.00 loops=1)
Index Cond: (a = '1900-01-01'::date)
(4 rows)
SET enable_seqscan = off;
EXPLAIN (ANALYZE, TIMING OFF, COSTS OFF, SUMMARY OFF, BUFFERS OFF)
SELECT * FROM brin_interval_test WHERE a = '-30 years'::interval;
- QUERY PLAN
------------------------------------------------------------------------------
- Bitmap Heap Scan on brin_interval_test (actual rows=0 loops=1)
+ QUERY PLAN
+--------------------------------------------------------------------------------
+ Bitmap Heap Scan on brin_interval_test (actual rows=0.00 loops=1)
Recheck Cond: (a = '@ 30 years ago'::interval)
- -> Bitmap Index Scan on brin_interval_test_a_idx (actual rows=0 loops=1)
+ -> Bitmap Index Scan on brin_interval_test_a_idx (actual rows=0.00 loops=1)
Index Cond: (a = '@ 30 years ago'::interval)
(4 rows)
EXPLAIN (ANALYZE, TIMING OFF, COSTS OFF, SUMMARY OFF, BUFFERS OFF)
SELECT * FROM brin_interval_test WHERE a = '30 years'::interval;
- QUERY PLAN
------------------------------------------------------------------------------
- Bitmap Heap Scan on brin_interval_test (actual rows=0 loops=1)
+ QUERY PLAN
+--------------------------------------------------------------------------------
+ Bitmap Heap Scan on brin_interval_test (actual rows=0.00 loops=1)
Recheck Cond: (a = '@ 30 years'::interval)
- -> Bitmap Index Scan on brin_interval_test_a_idx (actual rows=0 loops=1)
+ -> Bitmap Index Scan on brin_interval_test_a_idx (actual rows=0.00 loops=1)
Index Cond: (a = '@ 30 years'::interval)
(4 rows)
SET enable_seqscan = off;
EXPLAIN (ANALYZE, TIMING OFF, COSTS OFF, SUMMARY OFF, BUFFERS OFF)
SELECT * FROM brin_interval_test WHERE a = '-30 years'::interval;
- QUERY PLAN
------------------------------------------------------------------------------
- Bitmap Heap Scan on brin_interval_test (actual rows=0 loops=1)
+ QUERY PLAN
+--------------------------------------------------------------------------------
+ Bitmap Heap Scan on brin_interval_test (actual rows=0.00 loops=1)
Recheck Cond: (a = '@ 30 years ago'::interval)
- -> Bitmap Index Scan on brin_interval_test_a_idx (actual rows=0 loops=1)
+ -> Bitmap Index Scan on brin_interval_test_a_idx (actual rows=0.00 loops=1)
Index Cond: (a = '@ 30 years ago'::interval)
(4 rows)
EXPLAIN (ANALYZE, TIMING OFF, COSTS OFF, SUMMARY OFF, BUFFERS OFF)
SELECT * FROM brin_interval_test WHERE a = '30 years'::interval;
- QUERY PLAN
------------------------------------------------------------------------------
- Bitmap Heap Scan on brin_interval_test (actual rows=0 loops=1)
+ QUERY PLAN
+--------------------------------------------------------------------------------
+ Bitmap Heap Scan on brin_interval_test (actual rows=0.00 loops=1)
Recheck Cond: (a = '@ 30 years'::interval)
- -> Bitmap Index Scan on brin_interval_test_a_idx (actual rows=0 loops=1)
+ -> Bitmap Index Scan on brin_interval_test_a_idx (actual rows=0.00 loops=1)
Index Cond: (a = '@ 30 years'::interval)
(4 rows)
(1 row)
select explain_filter('explain (analyze, buffers off) select * from int8_tbl i8');
- explain_filter
------------------------------------------------------------------------------------------------
- Seq Scan on int8_tbl i8 (cost=N.N..N.N rows=N width=N) (actual time=N.N..N.N rows=N loops=N)
+ explain_filter
+-------------------------------------------------------------------------------------------------
+ Seq Scan on int8_tbl i8 (cost=N.N..N.N rows=N width=N) (actual time=N.N..N.N rows=N.N loops=N)
Planning Time: N.N ms
Execution Time: N.N ms
(3 rows)
select explain_filter('explain (analyze, buffers off, verbose) select * from int8_tbl i8');
- explain_filter
-------------------------------------------------------------------------------------------------------
- Seq Scan on public.int8_tbl i8 (cost=N.N..N.N rows=N width=N) (actual time=N.N..N.N rows=N loops=N)
+ explain_filter
+--------------------------------------------------------------------------------------------------------
+ Seq Scan on public.int8_tbl i8 (cost=N.N..N.N rows=N width=N) (actual time=N.N..N.N rows=N.N loops=N)
Output: q1, q2
Planning Time: N.N ms
Execution Time: N.N ms
(4 rows)
select explain_filter('explain (analyze, buffers, format text) select * from int8_tbl i8');
- explain_filter
------------------------------------------------------------------------------------------------
- Seq Scan on int8_tbl i8 (cost=N.N..N.N rows=N width=N) (actual time=N.N..N.N rows=N loops=N)
+ explain_filter
+-------------------------------------------------------------------------------------------------
+ Seq Scan on int8_tbl i8 (cost=N.N..N.N rows=N width=N) (actual time=N.N..N.N rows=N.N loops=N)
Planning Time: N.N ms
Execution Time: N.N ms
(3 rows)
<Plan-Width>N</Plan-Width> +
<Actual-Startup-Time>N.N</Actual-Startup-Time> +
<Actual-Total-Time>N.N</Actual-Total-Time> +
- <Actual-Rows>N</Actual-Rows> +
+ <Actual-Rows>N.N</Actual-Rows> +
<Actual-Loops>N</Actual-Loops> +
<Disabled>false</Disabled> +
<Shared-Hit-Blocks>N</Shared-Hit-Blocks> +
Plan Width: N +
Actual Startup Time: N.N +
Actual Total Time: N.N +
- Actual Rows: N +
+ Actual Rows: N.N +
Actual Loops: N +
Disabled: false +
Shared Hit Blocks: N +
"Plan Width": N, +
"Actual Startup Time": N.N, +
"Actual Total Time": N.N, +
- "Actual Rows": N, +
+ "Actual Rows": N.N, +
"Actual Loops": N, +
"Disabled": false, +
"Shared Hit Blocks": N, +
(2 rows)
select explain_filter('explain (memory, analyze, buffers off) select * from int8_tbl i8');
- explain_filter
------------------------------------------------------------------------------------------------
- Seq Scan on int8_tbl i8 (cost=N.N..N.N rows=N width=N) (actual time=N.N..N.N rows=N loops=N)
+ explain_filter
+-------------------------------------------------------------------------------------------------
+ Seq Scan on int8_tbl i8 (cost=N.N..N.N rows=N width=N) (actual time=N.N..N.N rows=N.N loops=N)
Memory: used=NkB allocated=NkB
Planning Time: N.N ms
Execution Time: N.N ms
"Plan Width": N, +
"Actual Startup Time": N.N, +
"Actual Total Time": N.N, +
- "Actual Rows": N, +
+ "Actual Rows": N.N, +
"Actual Loops": N, +
"Disabled": false, +
"Shared Hit Blocks": N, +
-- Also remove its sort-type fields, as those aren't 100% stable
#- '{0,Plan,Plans,0,Sort Method}'
#- '{0,Plan,Plans,0,Sort Space Type}'
- -- Actual Rows can be 0 or 0.0 depending on whether loops>1
- #- '{0,Plan,Plans,0,Actual Rows}'
- #- '{0,Plan,Plans,0,Plans,0,Actual Rows}'
);
jsonb_pretty
-------------------------------------------------------------
"Plan Rows": 0, +
"Plan Width": 0, +
"Total Cost": 0.0, +
+ "Actual Rows": 0.0, +
"Actual Loops": 0, +
"Startup Cost": 0.0, +
"Async Capable": false, +
"Plan Rows": 0, +
"Plan Width": 0, +
"Total Cost": 0.0, +
+ "Actual Rows": 0.0, +
"Actual Loops": 0, +
"Startup Cost": 0.0, +
"Async Capable": false, +
"Plan Rows": 0, +
"Plan Width": 0, +
"Total Cost": 0.0, +
- "Actual Rows": 0, +
+ "Actual Rows": 0.0, +
"Actual Loops": 0, +
"Startup Cost": 0.0, +
"Async Capable": false, +
-- Test SERIALIZE option
select explain_filter('explain (analyze,buffers off,serialize) select * from int8_tbl i8');
- explain_filter
------------------------------------------------------------------------------------------------
- Seq Scan on int8_tbl i8 (cost=N.N..N.N rows=N width=N) (actual time=N.N..N.N rows=N loops=N)
+ explain_filter
+-------------------------------------------------------------------------------------------------
+ Seq Scan on int8_tbl i8 (cost=N.N..N.N rows=N width=N) (actual time=N.N..N.N rows=N.N loops=N)
Planning Time: N.N ms
Serialization: time=N.N ms output=NkB format=text
Execution Time: N.N ms
(4 rows)
select explain_filter('explain (analyze,serialize text,buffers,timing off) select * from int8_tbl i8');
- explain_filter
----------------------------------------------------------------------------------
- Seq Scan on int8_tbl i8 (cost=N.N..N.N rows=N width=N) (actual rows=N loops=N)
+ explain_filter
+-----------------------------------------------------------------------------------
+ Seq Scan on int8_tbl i8 (cost=N.N..N.N rows=N width=N) (actual rows=N.N loops=N)
Planning Time: N.N ms
Serialization: output=NkB format=text
Execution Time: N.N ms
(4 rows)
select explain_filter('explain (analyze,serialize binary,buffers,timing) select * from int8_tbl i8');
- explain_filter
------------------------------------------------------------------------------------------------
- Seq Scan on int8_tbl i8 (cost=N.N..N.N rows=N width=N) (actual time=N.N..N.N rows=N loops=N)
+ explain_filter
+-------------------------------------------------------------------------------------------------
+ Seq Scan on int8_tbl i8 (cost=N.N..N.N rows=N width=N) (actual time=N.N..N.N rows=N.N loops=N)
Planning Time: N.N ms
Serialization: time=N.N ms output=NkB format=binary
Execution Time: N.N ms
-- this tests an edge case where we have no data to return
select explain_filter('explain (analyze,buffers off,serialize) create temp table explain_temp as select * from int8_tbl i8');
- explain_filter
------------------------------------------------------------------------------------------------
- Seq Scan on int8_tbl i8 (cost=N.N..N.N rows=N width=N) (actual time=N.N..N.N rows=N loops=N)
+ explain_filter
+-------------------------------------------------------------------------------------------------
+ Seq Scan on int8_tbl i8 (cost=N.N..N.N rows=N width=N) (actual time=N.N..N.N rows=N.N loops=N)
Planning Time: N.N ms
Serialization: time=N.N ms output=NkB format=text
Execution Time: N.N ms
-- Test tuplestore storage usage in Window aggregate (memory case)
select explain_filter('explain (analyze,buffers off,costs off) select sum(n) over() from generate_series(1,10) a(n)');
- explain_filter
---------------------------------------------------------------------------------
- WindowAgg (actual time=N.N..N.N rows=N loops=N)
+ explain_filter
+----------------------------------------------------------------------------------
+ WindowAgg (actual time=N.N..N.N rows=N.N loops=N)
Storage: Memory Maximum Storage: NkB
- -> Function Scan on generate_series a (actual time=N.N..N.N rows=N loops=N)
+ -> Function Scan on generate_series a (actual time=N.N..N.N rows=N.N loops=N)
Planning Time: N.N ms
Execution Time: N.N ms
(5 rows)
-- Test tuplestore storage usage in Window aggregate (disk case)
set work_mem to 64;
select explain_filter('explain (analyze,buffers off,costs off) select sum(n) over() from generate_series(1,2000) a(n)');
- explain_filter
---------------------------------------------------------------------------------
- WindowAgg (actual time=N.N..N.N rows=N loops=N)
+ explain_filter
+----------------------------------------------------------------------------------
+ WindowAgg (actual time=N.N..N.N rows=N.N loops=N)
Storage: Disk Maximum Storage: NkB
- -> Function Scan on generate_series a (actual time=N.N..N.N rows=N loops=N)
+ -> Function Scan on generate_series a (actual time=N.N..N.N rows=N.N loops=N)
Planning Time: N.N ms
Execution Time: N.N ms
(5 rows)
-- Test tuplestore storage usage in Window aggregate (memory and disk case, final result is disk)
select explain_filter('explain (analyze,buffers off,costs off) select sum(n) over(partition by m) from (SELECT n < 3 as m, n from generate_series(1,2000) a(n))');
- explain_filter
---------------------------------------------------------------------------------------
- WindowAgg (actual time=N.N..N.N rows=N loops=N)
+ explain_filter
+----------------------------------------------------------------------------------------
+ WindowAgg (actual time=N.N..N.N rows=N.N loops=N)
Storage: Disk Maximum Storage: NkB
- -> Sort (actual time=N.N..N.N rows=N loops=N)
+ -> Sort (actual time=N.N..N.N rows=N.N loops=N)
Sort Key: ((a.n < N))
Sort Method: external merge Disk: NkB
- -> Function Scan on generate_series a (actual time=N.N..N.N rows=N loops=N)
+ -> Function Scan on generate_series a (actual time=N.N..N.N rows=N.N loops=N)
Planning Time: N.N ms
Execution Time: N.N ms
(8 rows)
lateral execute_text_query_heap($$select string_agg((i, j)::text, ' ') from t_gin_test_tbl where $$ || query) res_heap;
query | return by index | removed by recheck | match
-------------------------------------------+-----------------+--------------------+-------
- i @> '{}' | 7 | 0 | t
- j @> '{}' | 6 | 0 | t
- i @> '{}' and j @> '{}' | 4 | 0 | t
- i @> '{1}' | 5 | 0 | t
- i @> '{1}' and j @> '{}' | 3 | 0 | t
- i @> '{1}' and i @> '{}' and j @> '{}' | 3 | 0 | t
- j @> '{10}' | 4 | 0 | t
- j @> '{10}' and i @> '{}' | 3 | 0 | t
- j @> '{10}' and j @> '{}' and i @> '{}' | 3 | 0 | t
- i @> '{1}' and j @> '{10}' | 2 | 0 | t
+ i @> '{}' | 7.00 | 0 | t
+ j @> '{}' | 6.00 | 0 | t
+ i @> '{}' and j @> '{}' | 4.00 | 0 | t
+ i @> '{1}' | 5.00 | 0 | t
+ i @> '{1}' and j @> '{}' | 3.00 | 0 | t
+ i @> '{1}' and i @> '{}' and j @> '{}' | 3.00 | 0 | t
+ j @> '{10}' | 4.00 | 0 | t
+ j @> '{10}' and i @> '{}' | 3.00 | 0 | t
+ j @> '{10}' and j @> '{}' and i @> '{}' | 3.00 | 0 | t
+ i @> '{1}' and j @> '{10}' | 2.00 | 0 | t
(10 rows)
reset enable_seqscan;
select explain_analyze_without_memory('select * from (select * from t order by a) s order by a, b limit 55');
explain_analyze_without_memory
---------------------------------------------------------------------------------------------------------------
- Limit (actual rows=55 loops=1)
- -> Incremental Sort (actual rows=55 loops=1)
+ Limit (actual rows=55.00 loops=1)
+ -> Incremental Sort (actual rows=55.00 loops=1)
Sort Key: t.a, t.b
Presorted Key: t.a
Full-sort Groups: 2 Sort Methods: top-N heapsort, quicksort Average Memory: NNkB Peak Memory: NNkB
- -> Sort (actual rows=101 loops=1)
+ -> Sort (actual rows=101.00 loops=1)
Sort Key: t.a
Sort Method: quicksort Memory: NNkB
- -> Seq Scan on t (actual rows=1000 loops=1)
+ -> Seq Scan on t (actual rows=1000.00 loops=1)
(9 rows)
select jsonb_pretty(explain_analyze_inc_sort_nodes_without_memory('select * from (select * from t order by a) s order by a, b limit 55'));
"t.b" +
], +
"Node Type": "Incremental Sort", +
- "Actual Rows": 55, +
+ "Actual Rows": 55.00, +
"Actual Loops": 1, +
"Async Capable": false, +
"Presorted Key": [ +
select explain_analyze_without_memory('select * from (select * from t order by a) s order by a, b limit 70');
explain_analyze_without_memory
----------------------------------------------------------------------------------------------------------------
- Limit (actual rows=70 loops=1)
- -> Incremental Sort (actual rows=70 loops=1)
+ Limit (actual rows=70.00 loops=1)
+ -> Incremental Sort (actual rows=70.00 loops=1)
Sort Key: t.a, t.b
Presorted Key: t.a
Full-sort Groups: 1 Sort Method: quicksort Average Memory: NNkB Peak Memory: NNkB
Pre-sorted Groups: 5 Sort Methods: top-N heapsort, quicksort Average Memory: NNkB Peak Memory: NNkB
- -> Sort (actual rows=1000 loops=1)
+ -> Sort (actual rows=1000.00 loops=1)
Sort Key: t.a
Sort Method: quicksort Memory: NNkB
- -> Seq Scan on t (actual rows=1000 loops=1)
+ -> Seq Scan on t (actual rows=1000.00 loops=1)
(10 rows)
select jsonb_pretty(explain_analyze_inc_sort_nodes_without_memory('select * from (select * from t order by a) s order by a, b limit 70'));
"t.b" +
], +
"Node Type": "Incremental Sort", +
- "Actual Rows": 70, +
+ "Actual Rows": 70.00, +
"Actual Loops": 1, +
"Async Capable": false, +
"Presorted Key": [ +
EXPLAIN (ANALYZE, COSTS OFF, SUMMARY OFF, TIMING OFF, BUFFERS OFF)
CREATE MATERIALIZED VIEW matview_schema.mv_withdata2 (a) AS
SELECT generate_series(1, 10) WITH DATA;
- QUERY PLAN
---------------------------------------
- ProjectSet (actual rows=10 loops=1)
- -> Result (actual rows=1 loops=1)
+ QUERY PLAN
+-----------------------------------------
+ ProjectSet (actual rows=10.00 loops=1)
+ -> Result (actual rows=1.00 loops=1)
(2 rows)
REFRESH MATERIALIZED VIEW matview_schema.mv_withdata2;
WHERE t2.unique1 < 1000;', false);
explain_memoize
----------------------------------------------------------------------------------------------
- Aggregate (actual rows=1 loops=N)
- -> Nested Loop (actual rows=1000 loops=N)
- -> Seq Scan on tenk1 t2 (actual rows=1000 loops=N)
+ Aggregate (actual rows=1.00 loops=N)
+ -> Nested Loop (actual rows=1000.00 loops=N)
+ -> Seq Scan on tenk1 t2 (actual rows=1000.00 loops=N)
Filter: (unique1 < 1000)
Rows Removed by Filter: 9000
-> Memoize (actual rows=1.00 loops=N)
WHERE t1.unique1 < 1000;', false);
explain_memoize
----------------------------------------------------------------------------------------------
- Aggregate (actual rows=1 loops=N)
- -> Nested Loop (actual rows=1000 loops=N)
- -> Seq Scan on tenk1 t1 (actual rows=1000 loops=N)
+ Aggregate (actual rows=1.00 loops=N)
+ -> Nested Loop (actual rows=1000.00 loops=N)
+ -> Seq Scan on tenk1 t1 (actual rows=1000.00 loops=N)
Filter: (unique1 < 1000)
Rows Removed by Filter: 9000
-> Memoize (actual rows=1.00 loops=N)
WHERE t1.unique1 < 10;', false);
explain_memoize
-------------------------------------------------------------------------------------------------
- Aggregate (actual rows=1 loops=N)
- -> Nested Loop Left Join (actual rows=20 loops=N)
- -> Index Scan using tenk1_unique1 on tenk1 t1 (actual rows=10 loops=N)
+ Aggregate (actual rows=1.00 loops=N)
+ -> Nested Loop Left Join (actual rows=20.00 loops=N)
+ -> Index Scan using tenk1_unique1 on tenk1 t1 (actual rows=10.00 loops=N)
Index Cond: (unique1 < 10)
-> Memoize (actual rows=2.00 loops=N)
Cache Key: t1.two
WHERE s.c1 = s.c2 AND t1.unique1 < 1000;', false);
explain_memoize
----------------------------------------------------------------------------------------------
- Aggregate (actual rows=1 loops=N)
- -> Nested Loop (actual rows=1000 loops=N)
- -> Seq Scan on tenk1 t1 (actual rows=1000 loops=N)
+ Aggregate (actual rows=1.00 loops=N)
+ -> Nested Loop (actual rows=1000.00 loops=N)
+ -> Seq Scan on tenk1 t1 (actual rows=1000.00 loops=N)
Filter: (unique1 < 1000)
Rows Removed by Filter: 9000
-> Memoize (actual rows=1.00 loops=N)
WHERE s.c1 = s.c2 AND t1.unique1 < 1000;', false);
explain_memoize
---------------------------------------------------------------------------------------
- Aggregate (actual rows=1 loops=N)
- -> Nested Loop (actual rows=1000 loops=N)
- -> Seq Scan on tenk1 t1 (actual rows=1000 loops=N)
+ Aggregate (actual rows=1.00 loops=N)
+ -> Nested Loop (actual rows=1000.00 loops=N)
+ -> Seq Scan on tenk1 t1 (actual rows=1000.00 loops=N)
Filter: (unique1 < 1000)
Rows Removed by Filter: 9000
-> Memoize (actual rows=1.00 loops=N)
ON t1.x = t2.t::numeric AND t1.t::numeric = t2.x;', false);
explain_memoize
----------------------------------------------------------------------------------------------
- Nested Loop (actual rows=80 loops=N)
- -> Seq Scan on expr_key t1 (actual rows=40 loops=N)
+ Nested Loop (actual rows=80.00 loops=N)
+ -> Seq Scan on expr_key t1 (actual rows=40.00 loops=N)
-> Memoize (actual rows=2.00 loops=N)
Cache Key: t1.x, (t1.t)::numeric
Cache Mode: logical
WHERE t2.unique1 < 1200;', true);
explain_memoize
----------------------------------------------------------------------------------------------
- Aggregate (actual rows=1 loops=N)
- -> Nested Loop (actual rows=1200 loops=N)
- -> Seq Scan on tenk1 t2 (actual rows=1200 loops=N)
+ Aggregate (actual rows=1.00 loops=N)
+ -> Nested Loop (actual rows=1200.00 loops=N)
+ -> Seq Scan on tenk1 t2 (actual rows=1200.00 loops=N)
Filter: (unique1 < 1200)
Rows Removed by Filter: 8800
-> Memoize (actual rows=1.00 loops=N)
-- Ensure memoize operates in logical mode
SELECT explain_memoize('
SELECT * FROM flt f1 INNER JOIN flt f2 ON f1.f = f2.f;', false);
- explain_memoize
--------------------------------------------------------------------------------
- Nested Loop (actual rows=4 loops=N)
- -> Index Only Scan using flt_f_idx on flt f1 (actual rows=2 loops=N)
+ explain_memoize
+----------------------------------------------------------------------------------
+ Nested Loop (actual rows=4.00 loops=N)
+ -> Index Only Scan using flt_f_idx on flt f1 (actual rows=2.00 loops=N)
Heap Fetches: N
-> Memoize (actual rows=2.00 loops=N)
Cache Key: f1.f
Cache Mode: logical
Hits: 1 Misses: 1 Evictions: Zero Overflows: 0 Memory Usage: NkB
- -> Index Only Scan using flt_f_idx on flt f2 (actual rows=2 loops=N)
+ -> Index Only Scan using flt_f_idx on flt f2 (actual rows=2.00 loops=N)
Index Cond: (f = f1.f)
Heap Fetches: N
(10 rows)
SELECT * FROM flt f1 INNER JOIN flt f2 ON f1.f >= f2.f;', false);
explain_memoize
----------------------------------------------------------------------------------
- Nested Loop (actual rows=4 loops=N)
- -> Index Only Scan using flt_f_idx on flt f1 (actual rows=2 loops=N)
+ Nested Loop (actual rows=4.00 loops=N)
+ -> Index Only Scan using flt_f_idx on flt f1 (actual rows=2.00 loops=N)
Heap Fetches: N
-> Memoize (actual rows=2.00 loops=N)
Cache Key: f1.f
SELECT * FROM strtest s1 INNER JOIN strtest s2 ON s1.n >= s2.n;', false);
explain_memoize
-------------------------------------------------------------------------------------
- Nested Loop (actual rows=24 loops=N)
- -> Seq Scan on strtest s1 (actual rows=6 loops=N)
+ Nested Loop (actual rows=24.00 loops=N)
+ -> Seq Scan on strtest s1 (actual rows=6.00 loops=N)
Disabled: true
-> Memoize (actual rows=4.00 loops=N)
Cache Key: s1.n
SELECT * FROM strtest s1 INNER JOIN strtest s2 ON s1.t >= s2.t;', false);
explain_memoize
-------------------------------------------------------------------------------------
- Nested Loop (actual rows=24 loops=N)
- -> Seq Scan on strtest s1 (actual rows=6 loops=N)
+ Nested Loop (actual rows=24.00 loops=N)
+ -> Seq Scan on strtest s1 (actual rows=6.00 loops=N)
Disabled: true
-> Memoize (actual rows=4.00 loops=N)
Cache Key: s1.t
ANALYZE prt;
SELECT explain_memoize('
SELECT * FROM prt t1 INNER JOIN prt t2 ON t1.a = t2.a;', false);
- explain_memoize
-------------------------------------------------------------------------------------------
- Append (actual rows=32 loops=N)
- -> Nested Loop (actual rows=16 loops=N)
- -> Index Only Scan using iprt_p1_a on prt_p1 t1_1 (actual rows=4 loops=N)
+ explain_memoize
+---------------------------------------------------------------------------------------------
+ Append (actual rows=32.00 loops=N)
+ -> Nested Loop (actual rows=16.00 loops=N)
+ -> Index Only Scan using iprt_p1_a on prt_p1 t1_1 (actual rows=4.00 loops=N)
Heap Fetches: N
-> Memoize (actual rows=4.00 loops=N)
Cache Key: t1_1.a
Cache Mode: logical
Hits: 3 Misses: 1 Evictions: Zero Overflows: 0 Memory Usage: NkB
- -> Index Only Scan using iprt_p1_a on prt_p1 t2_1 (actual rows=4 loops=N)
+ -> Index Only Scan using iprt_p1_a on prt_p1 t2_1 (actual rows=4.00 loops=N)
Index Cond: (a = t1_1.a)
Heap Fetches: N
- -> Nested Loop (actual rows=16 loops=N)
- -> Index Only Scan using iprt_p2_a on prt_p2 t1_2 (actual rows=4 loops=N)
+ -> Nested Loop (actual rows=16.00 loops=N)
+ -> Index Only Scan using iprt_p2_a on prt_p2 t1_2 (actual rows=4.00 loops=N)
Heap Fetches: N
-> Memoize (actual rows=4.00 loops=N)
Cache Key: t1_2.a
Cache Mode: logical
Hits: 3 Misses: 1 Evictions: Zero Overflows: 0 Memory Usage: NkB
- -> Index Only Scan using iprt_p2_a on prt_p2 t2_2 (actual rows=4 loops=N)
+ -> Index Only Scan using iprt_p2_a on prt_p2 t2_2 (actual rows=4.00 loops=N)
Index Cond: (a = t1_2.a)
Heap Fetches: N
(21 rows)
SELECT * FROM prt_p1 t1 INNER JOIN
(SELECT * FROM prt_p1 UNION ALL SELECT * FROM prt_p2) t2
ON t1.a = t2.a;', false);
- explain_memoize
--------------------------------------------------------------------------------------
- Nested Loop (actual rows=16 loops=N)
- -> Index Only Scan using iprt_p1_a on prt_p1 t1 (actual rows=4 loops=N)
+ explain_memoize
+----------------------------------------------------------------------------------------
+ Nested Loop (actual rows=16.00 loops=N)
+ -> Index Only Scan using iprt_p1_a on prt_p1 t1 (actual rows=4.00 loops=N)
Heap Fetches: N
-> Memoize (actual rows=4.00 loops=N)
Cache Key: t1.a
Cache Mode: logical
Hits: 3 Misses: 1 Evictions: Zero Overflows: 0 Memory Usage: NkB
- -> Append (actual rows=4 loops=N)
- -> Index Only Scan using iprt_p1_a on prt_p1 (actual rows=4 loops=N)
+ -> Append (actual rows=4.00 loops=N)
+ -> Index Only Scan using iprt_p1_a on prt_p1 (actual rows=4.00 loops=N)
Index Cond: (a = t1.a)
Heap Fetches: N
- -> Index Only Scan using iprt_p2_a on prt_p2 (actual rows=0 loops=N)
+ -> Index Only Scan using iprt_p2_a on prt_p2 (actual rows=0.00 loops=N)
Index Cond: (a = t1.a)
Heap Fetches: N
(14 rows)
MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a
WHEN MATCHED THEN
UPDATE SET b = t.b + 1');
- explain_merge
-----------------------------------------------------------------------
- Merge on ex_mtarget t (actual rows=0 loops=1)
+ explain_merge
+-------------------------------------------------------------------------
+ Merge on ex_mtarget t (actual rows=0.00 loops=1)
Tuples: updated=50
- -> Merge Join (actual rows=50 loops=1)
+ -> Merge Join (actual rows=50.00 loops=1)
Merge Cond: (t.a = s.a)
- -> Sort (actual rows=50 loops=1)
+ -> Sort (actual rows=50.00 loops=1)
Sort Key: t.a
Sort Method: quicksort Memory: xxx
- -> Seq Scan on ex_mtarget t (actual rows=50 loops=1)
- -> Sort (actual rows=100 loops=1)
+ -> Seq Scan on ex_mtarget t (actual rows=50.00 loops=1)
+ -> Sort (actual rows=100.00 loops=1)
Sort Key: s.a
Sort Method: quicksort Memory: xxx
- -> Seq Scan on ex_msource s (actual rows=100 loops=1)
+ -> Seq Scan on ex_msource s (actual rows=100.00 loops=1)
(12 rows)
-- only updates to selected tuples
MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a
WHEN MATCHED AND t.a < 10 THEN
UPDATE SET b = t.b + 1');
- explain_merge
-----------------------------------------------------------------------
- Merge on ex_mtarget t (actual rows=0 loops=1)
+ explain_merge
+-------------------------------------------------------------------------
+ Merge on ex_mtarget t (actual rows=0.00 loops=1)
Tuples: updated=5 skipped=45
- -> Merge Join (actual rows=50 loops=1)
+ -> Merge Join (actual rows=50.00 loops=1)
Merge Cond: (t.a = s.a)
- -> Sort (actual rows=50 loops=1)
+ -> Sort (actual rows=50.00 loops=1)
Sort Key: t.a
Sort Method: quicksort Memory: xxx
- -> Seq Scan on ex_mtarget t (actual rows=50 loops=1)
- -> Sort (actual rows=100 loops=1)
+ -> Seq Scan on ex_mtarget t (actual rows=50.00 loops=1)
+ -> Sort (actual rows=100.00 loops=1)
Sort Key: s.a
Sort Method: quicksort Memory: xxx
- -> Seq Scan on ex_msource s (actual rows=100 loops=1)
+ -> Seq Scan on ex_msource s (actual rows=100.00 loops=1)
(12 rows)
-- updates + deletes
UPDATE SET b = t.b + 1
WHEN MATCHED AND t.a >= 10 AND t.a <= 20 THEN
DELETE');
- explain_merge
-----------------------------------------------------------------------
- Merge on ex_mtarget t (actual rows=0 loops=1)
+ explain_merge
+-------------------------------------------------------------------------
+ Merge on ex_mtarget t (actual rows=0.00 loops=1)
Tuples: updated=5 deleted=5 skipped=40
- -> Merge Join (actual rows=50 loops=1)
+ -> Merge Join (actual rows=50.00 loops=1)
Merge Cond: (t.a = s.a)
- -> Sort (actual rows=50 loops=1)
+ -> Sort (actual rows=50.00 loops=1)
Sort Key: t.a
Sort Method: quicksort Memory: xxx
- -> Seq Scan on ex_mtarget t (actual rows=50 loops=1)
- -> Sort (actual rows=100 loops=1)
+ -> Seq Scan on ex_mtarget t (actual rows=50.00 loops=1)
+ -> Sort (actual rows=100.00 loops=1)
Sort Key: s.a
Sort Method: quicksort Memory: xxx
- -> Seq Scan on ex_msource s (actual rows=100 loops=1)
+ -> Seq Scan on ex_msource s (actual rows=100.00 loops=1)
(12 rows)
-- only inserts
MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a
WHEN NOT MATCHED AND s.a < 10 THEN
INSERT VALUES (a, b)');
- explain_merge
-----------------------------------------------------------------------
- Merge on ex_mtarget t (actual rows=0 loops=1)
+ explain_merge
+-------------------------------------------------------------------------
+ Merge on ex_mtarget t (actual rows=0.00 loops=1)
Tuples: inserted=4 skipped=96
- -> Merge Left Join (actual rows=100 loops=1)
+ -> Merge Left Join (actual rows=100.00 loops=1)
Merge Cond: (s.a = t.a)
- -> Sort (actual rows=100 loops=1)
+ -> Sort (actual rows=100.00 loops=1)
Sort Key: s.a
Sort Method: quicksort Memory: xxx
- -> Seq Scan on ex_msource s (actual rows=100 loops=1)
- -> Sort (actual rows=45 loops=1)
+ -> Seq Scan on ex_msource s (actual rows=100.00 loops=1)
+ -> Sort (actual rows=45.00 loops=1)
Sort Key: t.a
Sort Method: quicksort Memory: xxx
- -> Seq Scan on ex_mtarget t (actual rows=45 loops=1)
+ -> Seq Scan on ex_mtarget t (actual rows=45.00 loops=1)
(12 rows)
-- all three
DELETE
WHEN NOT MATCHED AND s.a < 20 THEN
INSERT VALUES (a, b)');
- explain_merge
-----------------------------------------------------------------------
- Merge on ex_mtarget t (actual rows=0 loops=1)
+ explain_merge
+-------------------------------------------------------------------------
+ Merge on ex_mtarget t (actual rows=0.00 loops=1)
Tuples: inserted=10 updated=9 deleted=5 skipped=76
- -> Merge Left Join (actual rows=100 loops=1)
+ -> Merge Left Join (actual rows=100.00 loops=1)
Merge Cond: (s.a = t.a)
- -> Sort (actual rows=100 loops=1)
+ -> Sort (actual rows=100.00 loops=1)
Sort Key: s.a
Sort Method: quicksort Memory: xxx
- -> Seq Scan on ex_msource s (actual rows=100 loops=1)
- -> Sort (actual rows=49 loops=1)
+ -> Seq Scan on ex_msource s (actual rows=100.00 loops=1)
+ -> Sort (actual rows=49.00 loops=1)
Sort Key: t.a
Sort Method: quicksort Memory: xxx
- -> Seq Scan on ex_mtarget t (actual rows=49 loops=1)
+ -> Seq Scan on ex_mtarget t (actual rows=49.00 loops=1)
(12 rows)
-- not matched by source
MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a
WHEN NOT MATCHED BY SOURCE and t.a < 10 THEN
DELETE');
- explain_merge
-----------------------------------------------------------------------
- Merge on ex_mtarget t (actual rows=0 loops=1)
+ explain_merge
+-------------------------------------------------------------------------
+ Merge on ex_mtarget t (actual rows=0.00 loops=1)
Tuples: skipped=54
- -> Merge Left Join (actual rows=54 loops=1)
+ -> Merge Left Join (actual rows=54.00 loops=1)
Merge Cond: (t.a = s.a)
- -> Sort (actual rows=54 loops=1)
+ -> Sort (actual rows=54.00 loops=1)
Sort Key: t.a
Sort Method: quicksort Memory: xxx
- -> Seq Scan on ex_mtarget t (actual rows=54 loops=1)
- -> Sort (actual rows=100 loops=1)
+ -> Seq Scan on ex_mtarget t (actual rows=54.00 loops=1)
+ -> Sort (actual rows=100.00 loops=1)
Sort Key: s.a
Sort Method: quicksort Memory: xxx
- -> Seq Scan on ex_msource s (actual rows=100 loops=1)
+ -> Seq Scan on ex_msource s (actual rows=100.00 loops=1)
(12 rows)
-- not matched by source and target
DELETE
WHEN NOT MATCHED BY TARGET AND s.a < 20 THEN
INSERT VALUES (a, b)');
- explain_merge
-----------------------------------------------------------------------
- Merge on ex_mtarget t (actual rows=0 loops=1)
+ explain_merge
+-------------------------------------------------------------------------
+ Merge on ex_mtarget t (actual rows=0.00 loops=1)
Tuples: skipped=100
- -> Merge Full Join (actual rows=100 loops=1)
+ -> Merge Full Join (actual rows=100.00 loops=1)
Merge Cond: (t.a = s.a)
- -> Sort (actual rows=54 loops=1)
+ -> Sort (actual rows=54.00 loops=1)
Sort Key: t.a
Sort Method: quicksort Memory: xxx
- -> Seq Scan on ex_mtarget t (actual rows=54 loops=1)
- -> Sort (actual rows=100 loops=1)
+ -> Seq Scan on ex_mtarget t (actual rows=54.00 loops=1)
+ -> Sort (actual rows=100.00 loops=1)
Sort Key: s.a
Sort Method: quicksort Memory: xxx
- -> Seq Scan on ex_msource s (actual rows=100 loops=1)
+ -> Seq Scan on ex_msource s (actual rows=100.00 loops=1)
(12 rows)
-- nothing
MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a AND t.a < -1000
WHEN MATCHED AND t.a < 10 THEN
DO NOTHING');
- explain_merge
---------------------------------------------------------------------
- Merge on ex_mtarget t (actual rows=0 loops=1)
- -> Merge Join (actual rows=0 loops=1)
+ explain_merge
+-----------------------------------------------------------------------
+ Merge on ex_mtarget t (actual rows=0.00 loops=1)
+ -> Merge Join (actual rows=0.00 loops=1)
Merge Cond: (t.a = s.a)
- -> Sort (actual rows=0 loops=1)
+ -> Sort (actual rows=0.00 loops=1)
Sort Key: t.a
Sort Method: quicksort Memory: xxx
- -> Seq Scan on ex_mtarget t (actual rows=0 loops=1)
+ -> Seq Scan on ex_mtarget t (actual rows=0.00 loops=1)
Filter: (a < '-1000'::integer)
Rows Removed by Filter: 54
-> Sort (never executed)
SELECT explain_mask_costs($$
SELECT * FROM generate_series(TIMESTAMPTZ '2024-02-01', TIMESTAMPTZ '2024-03-01', INTERVAL '1 day') g(s);$$,
true, true, false, true);
- explain_mask_costs
-------------------------------------------------------------------------------------------
- Function Scan on generate_series g (cost=N..N rows=30 width=N) (actual rows=30 loops=1)
+ explain_mask_costs
+---------------------------------------------------------------------------------------------
+ Function Scan on generate_series g (cost=N..N rows=30 width=N) (actual rows=30.00 loops=1)
(1 row)
-- As above but with generate_series_timestamp
SELECT explain_mask_costs($$
SELECT * FROM generate_series(TIMESTAMP '2024-02-01', TIMESTAMP '2024-03-01', INTERVAL '1 day') g(s);$$,
true, true, false, true);
- explain_mask_costs
-------------------------------------------------------------------------------------------
- Function Scan on generate_series g (cost=N..N rows=30 width=N) (actual rows=30 loops=1)
+ explain_mask_costs
+---------------------------------------------------------------------------------------------
+ Function Scan on generate_series g (cost=N..N rows=30 width=N) (actual rows=30.00 loops=1)
(1 row)
-- As above but with generate_series_timestamptz_at_zone()
SELECT explain_mask_costs($$
SELECT * FROM generate_series(TIMESTAMPTZ '2024-02-01', TIMESTAMPTZ '2024-03-01', INTERVAL '1 day', 'UTC') g(s);$$,
true, true, false, true);
- explain_mask_costs
-------------------------------------------------------------------------------------------
- Function Scan on generate_series g (cost=N..N rows=30 width=N) (actual rows=30 loops=1)
+ explain_mask_costs
+---------------------------------------------------------------------------------------------
+ Function Scan on generate_series g (cost=N..N rows=30 width=N) (actual rows=30.00 loops=1)
(1 row)
-- Ensure the estimated and actual row counts match when the range isn't
SELECT explain_mask_costs($$
SELECT * FROM generate_series(TIMESTAMPTZ '2024-02-01', TIMESTAMPTZ '2024-03-01', INTERVAL '7 day') g(s);$$,
true, true, false, true);
- explain_mask_costs
-----------------------------------------------------------------------------------------
- Function Scan on generate_series g (cost=N..N rows=5 width=N) (actual rows=5 loops=1)
+ explain_mask_costs
+-------------------------------------------------------------------------------------------
+ Function Scan on generate_series g (cost=N..N rows=5 width=N) (actual rows=5.00 loops=1)
(1 row)
-- Ensure the estimates match when step is decreasing
SELECT explain_mask_costs($$
SELECT * FROM generate_series(TIMESTAMPTZ '2024-03-01', TIMESTAMPTZ '2024-02-01', INTERVAL '-1 day') g(s);$$,
true, true, false, true);
- explain_mask_costs
-------------------------------------------------------------------------------------------
- Function Scan on generate_series g (cost=N..N rows=30 width=N) (actual rows=30 loops=1)
+ explain_mask_costs
+---------------------------------------------------------------------------------------------
+ Function Scan on generate_series g (cost=N..N rows=30 width=N) (actual rows=30.00 loops=1)
(1 row)
-- Ensure an empty range estimates 1 row
SELECT explain_mask_costs($$
SELECT * FROM generate_series(TIMESTAMPTZ '2024-03-01', TIMESTAMPTZ '2024-02-01', INTERVAL '1 day') g(s);$$,
true, true, false, true);
- explain_mask_costs
-----------------------------------------------------------------------------------------
- Function Scan on generate_series g (cost=N..N rows=1 width=N) (actual rows=0 loops=1)
+ explain_mask_costs
+-------------------------------------------------------------------------------------------
+ Function Scan on generate_series g (cost=N..N rows=1 width=N) (actual rows=0.00 loops=1)
(1 row)
-- Ensure we get the default row estimate for infinity values
SELECT explain_mask_costs($$
SELECT * FROM generate_series(1.0, 25.0) g(s);$$,
true, true, false, true);
- explain_mask_costs
-------------------------------------------------------------------------------------------
- Function Scan on generate_series g (cost=N..N rows=25 width=N) (actual rows=25 loops=1)
+ explain_mask_costs
+---------------------------------------------------------------------------------------------
+ Function Scan on generate_series g (cost=N..N rows=25 width=N) (actual rows=25.00 loops=1)
(1 row)
-- As above but with non-default step
SELECT explain_mask_costs($$
SELECT * FROM generate_series(1.0, 25.0, 2.0) g(s);$$,
true, true, false, true);
- explain_mask_costs
-------------------------------------------------------------------------------------------
- Function Scan on generate_series g (cost=N..N rows=13 width=N) (actual rows=13 loops=1)
+ explain_mask_costs
+---------------------------------------------------------------------------------------------
+ Function Scan on generate_series g (cost=N..N rows=13 width=N) (actual rows=13.00 loops=1)
(1 row)
-- Ensure the estimates match when step is decreasing
SELECT explain_mask_costs($$
SELECT * FROM generate_series(25.0, 1.0, -1.0) g(s);$$,
true, true, false, true);
- explain_mask_costs
-------------------------------------------------------------------------------------------
- Function Scan on generate_series g (cost=N..N rows=25 width=N) (actual rows=25 loops=1)
+ explain_mask_costs
+---------------------------------------------------------------------------------------------
+ Function Scan on generate_series g (cost=N..N rows=25 width=N) (actual rows=25.00 loops=1)
(1 row)
-- Ensure an empty range estimates 1 row
SELECT explain_mask_costs($$
SELECT * FROM generate_series(25.0, 1.0, 1.0) g(s);$$,
true, true, false, true);
- explain_mask_costs
-----------------------------------------------------------------------------------------
- Function Scan on generate_series g (cost=N..N rows=1 width=N) (actual rows=0 loops=1)
+ explain_mask_costs
+-------------------------------------------------------------------------------------------
+ Function Scan on generate_series g (cost=N..N rows=1 width=N) (actual rows=0.00 loops=1)
(1 row)
-- Ensure we get the default row estimate for error cases (infinity/NaN values
prepare ab_q1 (int, int, int) as
select * from ab where a between $1 and $2 and b <= $3;
explain (analyze, costs off, summary off, timing off, buffers off) execute ab_q1 (2, 2, 3);
- QUERY PLAN
----------------------------------------------------------
- Append (actual rows=0 loops=1)
+ QUERY PLAN
+------------------------------------------------------------
+ Append (actual rows=0.00 loops=1)
Subplans Removed: 6
- -> Seq Scan on ab_a2_b1 ab_1 (actual rows=0 loops=1)
+ -> Seq Scan on ab_a2_b1 ab_1 (actual rows=0.00 loops=1)
Filter: ((a >= $1) AND (a <= $2) AND (b <= $3))
- -> Seq Scan on ab_a2_b2 ab_2 (actual rows=0 loops=1)
+ -> Seq Scan on ab_a2_b2 ab_2 (actual rows=0.00 loops=1)
Filter: ((a >= $1) AND (a <= $2) AND (b <= $3))
- -> Seq Scan on ab_a2_b3 ab_3 (actual rows=0 loops=1)
+ -> Seq Scan on ab_a2_b3 ab_3 (actual rows=0.00 loops=1)
Filter: ((a >= $1) AND (a <= $2) AND (b <= $3))
(8 rows)
explain (analyze, costs off, summary off, timing off, buffers off) execute ab_q1 (1, 2, 3);
- QUERY PLAN
----------------------------------------------------------
- Append (actual rows=0 loops=1)
+ QUERY PLAN
+------------------------------------------------------------
+ Append (actual rows=0.00 loops=1)
Subplans Removed: 3
- -> Seq Scan on ab_a1_b1 ab_1 (actual rows=0 loops=1)
+ -> Seq Scan on ab_a1_b1 ab_1 (actual rows=0.00 loops=1)
Filter: ((a >= $1) AND (a <= $2) AND (b <= $3))
- -> Seq Scan on ab_a1_b2 ab_2 (actual rows=0 loops=1)
+ -> Seq Scan on ab_a1_b2 ab_2 (actual rows=0.00 loops=1)
Filter: ((a >= $1) AND (a <= $2) AND (b <= $3))
- -> Seq Scan on ab_a1_b3 ab_3 (actual rows=0 loops=1)
+ -> Seq Scan on ab_a1_b3 ab_3 (actual rows=0.00 loops=1)
Filter: ((a >= $1) AND (a <= $2) AND (b <= $3))
- -> Seq Scan on ab_a2_b1 ab_4 (actual rows=0 loops=1)
+ -> Seq Scan on ab_a2_b1 ab_4 (actual rows=0.00 loops=1)
Filter: ((a >= $1) AND (a <= $2) AND (b <= $3))
- -> Seq Scan on ab_a2_b2 ab_5 (actual rows=0 loops=1)
+ -> Seq Scan on ab_a2_b2 ab_5 (actual rows=0.00 loops=1)
Filter: ((a >= $1) AND (a <= $2) AND (b <= $3))
- -> Seq Scan on ab_a2_b3 ab_6 (actual rows=0 loops=1)
+ -> Seq Scan on ab_a2_b3 ab_6 (actual rows=0.00 loops=1)
Filter: ((a >= $1) AND (a <= $2) AND (b <= $3))
(14 rows)
prepare ab_q1 (int, int) as
select a from ab where a between $1 and $2 and b < 3;
explain (analyze, costs off, summary off, timing off, buffers off) execute ab_q1 (2, 2);
- QUERY PLAN
----------------------------------------------------------
- Append (actual rows=0 loops=1)
+ QUERY PLAN
+------------------------------------------------------------
+ Append (actual rows=0.00 loops=1)
Subplans Removed: 4
- -> Seq Scan on ab_a2_b1 ab_1 (actual rows=0 loops=1)
+ -> Seq Scan on ab_a2_b1 ab_1 (actual rows=0.00 loops=1)
Filter: ((a >= $1) AND (a <= $2) AND (b < 3))
- -> Seq Scan on ab_a2_b2 ab_2 (actual rows=0 loops=1)
+ -> Seq Scan on ab_a2_b2 ab_2 (actual rows=0.00 loops=1)
Filter: ((a >= $1) AND (a <= $2) AND (b < 3))
(6 rows)
explain (analyze, costs off, summary off, timing off, buffers off) execute ab_q1 (2, 4);
- QUERY PLAN
----------------------------------------------------------
- Append (actual rows=0 loops=1)
+ QUERY PLAN
+------------------------------------------------------------
+ Append (actual rows=0.00 loops=1)
Subplans Removed: 2
- -> Seq Scan on ab_a2_b1 ab_1 (actual rows=0 loops=1)
+ -> Seq Scan on ab_a2_b1 ab_1 (actual rows=0.00 loops=1)
Filter: ((a >= $1) AND (a <= $2) AND (b < 3))
- -> Seq Scan on ab_a2_b2 ab_2 (actual rows=0 loops=1)
+ -> Seq Scan on ab_a2_b2 ab_2 (actual rows=0.00 loops=1)
Filter: ((a >= $1) AND (a <= $2) AND (b < 3))
- -> Seq Scan on ab_a3_b1 ab_3 (actual rows=0 loops=1)
+ -> Seq Scan on ab_a3_b1 ab_3 (actual rows=0.00 loops=1)
Filter: ((a >= $1) AND (a <= $2) AND (b < 3))
- -> Seq Scan on ab_a3_b2 ab_4 (actual rows=0 loops=1)
+ -> Seq Scan on ab_a3_b2 ab_4 (actual rows=0.00 loops=1)
Filter: ((a >= $1) AND (a <= $2) AND (b < 3))
(10 rows)
explain (analyze, costs off, summary off, timing off, buffers off) execute ab_q2 (2, 2);
QUERY PLAN
-----------------------------------------------------------------------
- Append (actual rows=0 loops=1)
+ Append (actual rows=0.00 loops=1)
Subplans Removed: 6
InitPlan 1
- -> Result (actual rows=1 loops=1)
- -> Seq Scan on ab_a2_b1 ab_1 (actual rows=0 loops=1)
+ -> Result (actual rows=1.00 loops=1)
+ -> Seq Scan on ab_a2_b1 ab_1 (actual rows=0.00 loops=1)
Filter: ((a >= $1) AND (a <= $2) AND (b < (InitPlan 1).col1))
- -> Seq Scan on ab_a2_b2 ab_2 (actual rows=0 loops=1)
+ -> Seq Scan on ab_a2_b2 ab_2 (actual rows=0.00 loops=1)
Filter: ((a >= $1) AND (a <= $2) AND (b < (InitPlan 1).col1))
-> Seq Scan on ab_a2_b3 ab_3 (never executed)
Filter: ((a >= $1) AND (a <= $2) AND (b < (InitPlan 1).col1))
explain (analyze, costs off, summary off, timing off, buffers off) execute ab_q3 (2, 2);
QUERY PLAN
-----------------------------------------------------------------------
- Append (actual rows=0 loops=1)
+ Append (actual rows=0.00 loops=1)
Subplans Removed: 6
InitPlan 1
- -> Result (actual rows=1 loops=1)
- -> Seq Scan on ab_a1_b2 ab_1 (actual rows=0 loops=1)
+ -> Result (actual rows=1.00 loops=1)
+ -> Seq Scan on ab_a1_b2 ab_1 (actual rows=0.00 loops=1)
Filter: ((b >= $1) AND (b <= $2) AND (a < (InitPlan 1).col1))
- -> Seq Scan on ab_a2_b2 ab_2 (actual rows=0 loops=1)
+ -> Seq Scan on ab_a2_b2 ab_2 (actual rows=0.00 loops=1)
Filter: ((b >= $1) AND (b <= $2) AND (a < (InitPlan 1).col1))
-> Seq Scan on ab_a3_b2 ab_3 (never executed)
Filter: ((b >= $1) AND (b <= $2) AND (a < (InitPlan 1).col1))
create function list_part_fn(int) returns int as $$ begin return $1; end;$$ language plpgsql stable;
-- Ensure pruning works using a stable function containing no Vars
explain (analyze, costs off, summary off, timing off, buffers off) select * from list_part where a = list_part_fn(1);
- QUERY PLAN
-------------------------------------------------------------------
- Append (actual rows=1 loops=1)
+ QUERY PLAN
+---------------------------------------------------------------------
+ Append (actual rows=1.00 loops=1)
Subplans Removed: 3
- -> Seq Scan on list_part1 list_part_1 (actual rows=1 loops=1)
+ -> Seq Scan on list_part1 list_part_1 (actual rows=1.00 loops=1)
Filter: (a = list_part_fn(1))
(4 rows)
-- Ensure pruning does not take place when the function has a Var parameter
explain (analyze, costs off, summary off, timing off, buffers off) select * from list_part where a = list_part_fn(a);
- QUERY PLAN
-------------------------------------------------------------------
- Append (actual rows=4 loops=1)
- -> Seq Scan on list_part1 list_part_1 (actual rows=1 loops=1)
+ QUERY PLAN
+---------------------------------------------------------------------
+ Append (actual rows=4.00 loops=1)
+ -> Seq Scan on list_part1 list_part_1 (actual rows=1.00 loops=1)
Filter: (a = list_part_fn(a))
- -> Seq Scan on list_part2 list_part_2 (actual rows=1 loops=1)
+ -> Seq Scan on list_part2 list_part_2 (actual rows=1.00 loops=1)
Filter: (a = list_part_fn(a))
- -> Seq Scan on list_part3 list_part_3 (actual rows=1 loops=1)
+ -> Seq Scan on list_part3 list_part_3 (actual rows=1.00 loops=1)
Filter: (a = list_part_fn(a))
- -> Seq Scan on list_part4 list_part_4 (actual rows=1 loops=1)
+ -> Seq Scan on list_part4 list_part_4 (actual rows=1.00 loops=1)
Filter: (a = list_part_fn(a))
(9 rows)
-- Ensure pruning does not take place when the expression contains a Var.
explain (analyze, costs off, summary off, timing off, buffers off) select * from list_part where a = list_part_fn(1) + a;
- QUERY PLAN
-------------------------------------------------------------------
- Append (actual rows=0 loops=1)
- -> Seq Scan on list_part1 list_part_1 (actual rows=0 loops=1)
+ QUERY PLAN
+---------------------------------------------------------------------
+ Append (actual rows=0.00 loops=1)
+ -> Seq Scan on list_part1 list_part_1 (actual rows=0.00 loops=1)
Filter: (a = (list_part_fn(1) + a))
Rows Removed by Filter: 1
- -> Seq Scan on list_part2 list_part_2 (actual rows=0 loops=1)
+ -> Seq Scan on list_part2 list_part_2 (actual rows=0.00 loops=1)
Filter: (a = (list_part_fn(1) + a))
Rows Removed by Filter: 1
- -> Seq Scan on list_part3 list_part_3 (actual rows=0 loops=1)
+ -> Seq Scan on list_part3 list_part_3 (actual rows=0.00 loops=1)
Filter: (a = (list_part_fn(1) + a))
Rows Removed by Filter: 1
- -> Seq Scan on list_part4 list_part_4 (actual rows=0 loops=1)
+ -> Seq Scan on list_part4 list_part_4 (actual rows=0.00 loops=1)
Filter: (a = (list_part_fn(1) + a))
Rows Removed by Filter: 1
(13 rows)
-- Test run-time partition pruning with an initplan
explain (analyze, costs off, summary off, timing off, buffers off)
select * from ab where a = (select max(a) from lprt_a) and b = (select max(a)-1 from lprt_a);
- QUERY PLAN
--------------------------------------------------------------------------
- Append (actual rows=0 loops=1)
+ QUERY PLAN
+----------------------------------------------------------------------------
+ Append (actual rows=0.00 loops=1)
InitPlan 1
- -> Aggregate (actual rows=1 loops=1)
- -> Seq Scan on lprt_a (actual rows=102 loops=1)
+ -> Aggregate (actual rows=1.00 loops=1)
+ -> Seq Scan on lprt_a (actual rows=102.00 loops=1)
InitPlan 2
- -> Aggregate (actual rows=1 loops=1)
- -> Seq Scan on lprt_a lprt_a_1 (actual rows=102 loops=1)
+ -> Aggregate (actual rows=1.00 loops=1)
+ -> Seq Scan on lprt_a lprt_a_1 (actual rows=102.00 loops=1)
-> Bitmap Heap Scan on ab_a1_b1 ab_1 (never executed)
Recheck Cond: (a = (InitPlan 1).col1)
Filter: (b = (InitPlan 2).col1)
Filter: (b = (InitPlan 2).col1)
-> Bitmap Index Scan on ab_a3_b1_a_idx (never executed)
Index Cond: (a = (InitPlan 1).col1)
- -> Bitmap Heap Scan on ab_a3_b2 ab_8 (actual rows=0 loops=1)
+ -> Bitmap Heap Scan on ab_a3_b2 ab_8 (actual rows=0.00 loops=1)
Recheck Cond: (a = (InitPlan 1).col1)
Filter: (b = (InitPlan 2).col1)
- -> Bitmap Index Scan on ab_a3_b2_a_idx (actual rows=0 loops=1)
+ -> Bitmap Index Scan on ab_a3_b2_a_idx (actual rows=0.00 loops=1)
Index Cond: (a = (InitPlan 1).col1)
-> Bitmap Heap Scan on ab_a3_b3 ab_9 (never executed)
Recheck Cond: (a = (InitPlan 1).col1)
-- Test run-time partition pruning with UNION ALL parents
explain (analyze, costs off, summary off, timing off, buffers off)
select * from (select * from ab where a = 1 union all select * from ab) ab where b = (select 1);
- QUERY PLAN
--------------------------------------------------------------------------------
- Append (actual rows=0 loops=1)
+ QUERY PLAN
+----------------------------------------------------------------------------------
+ Append (actual rows=0.00 loops=1)
InitPlan 1
- -> Result (actual rows=1 loops=1)
- -> Append (actual rows=0 loops=1)
- -> Bitmap Heap Scan on ab_a1_b1 ab_11 (actual rows=0 loops=1)
+ -> Result (actual rows=1.00 loops=1)
+ -> Append (actual rows=0.00 loops=1)
+ -> Bitmap Heap Scan on ab_a1_b1 ab_11 (actual rows=0.00 loops=1)
Recheck Cond: (a = 1)
Filter: (b = (InitPlan 1).col1)
- -> Bitmap Index Scan on ab_a1_b1_a_idx (actual rows=0 loops=1)
+ -> Bitmap Index Scan on ab_a1_b1_a_idx (actual rows=0.00 loops=1)
Index Cond: (a = 1)
-> Bitmap Heap Scan on ab_a1_b2 ab_12 (never executed)
Recheck Cond: (a = 1)
Filter: (b = (InitPlan 1).col1)
-> Bitmap Index Scan on ab_a1_b3_a_idx (never executed)
Index Cond: (a = 1)
- -> Seq Scan on ab_a1_b1 ab_1 (actual rows=0 loops=1)
+ -> Seq Scan on ab_a1_b1 ab_1 (actual rows=0.00 loops=1)
Filter: (b = (InitPlan 1).col1)
-> Seq Scan on ab_a1_b2 ab_2 (never executed)
Filter: (b = (InitPlan 1).col1)
-> Seq Scan on ab_a1_b3 ab_3 (never executed)
Filter: (b = (InitPlan 1).col1)
- -> Seq Scan on ab_a2_b1 ab_4 (actual rows=0 loops=1)
+ -> Seq Scan on ab_a2_b1 ab_4 (actual rows=0.00 loops=1)
Filter: (b = (InitPlan 1).col1)
-> Seq Scan on ab_a2_b2 ab_5 (never executed)
Filter: (b = (InitPlan 1).col1)
-> Seq Scan on ab_a2_b3 ab_6 (never executed)
Filter: (b = (InitPlan 1).col1)
- -> Seq Scan on ab_a3_b1 ab_7 (actual rows=0 loops=1)
+ -> Seq Scan on ab_a3_b1 ab_7 (actual rows=0.00 loops=1)
Filter: (b = (InitPlan 1).col1)
-> Seq Scan on ab_a3_b2 ab_8 (never executed)
Filter: (b = (InitPlan 1).col1)
-- A case containing a UNION ALL with a non-partitioned child.
explain (analyze, costs off, summary off, timing off, buffers off)
select * from (select * from ab where a = 1 union all (values(10,5)) union all select * from ab) ab where b = (select 1);
- QUERY PLAN
--------------------------------------------------------------------------------
- Append (actual rows=0 loops=1)
+ QUERY PLAN
+----------------------------------------------------------------------------------
+ Append (actual rows=0.00 loops=1)
InitPlan 1
- -> Result (actual rows=1 loops=1)
- -> Append (actual rows=0 loops=1)
- -> Bitmap Heap Scan on ab_a1_b1 ab_11 (actual rows=0 loops=1)
+ -> Result (actual rows=1.00 loops=1)
+ -> Append (actual rows=0.00 loops=1)
+ -> Bitmap Heap Scan on ab_a1_b1 ab_11 (actual rows=0.00 loops=1)
Recheck Cond: (a = 1)
Filter: (b = (InitPlan 1).col1)
- -> Bitmap Index Scan on ab_a1_b1_a_idx (actual rows=0 loops=1)
+ -> Bitmap Index Scan on ab_a1_b1_a_idx (actual rows=0.00 loops=1)
Index Cond: (a = 1)
-> Bitmap Heap Scan on ab_a1_b2 ab_12 (never executed)
Recheck Cond: (a = 1)
Filter: (b = (InitPlan 1).col1)
-> Bitmap Index Scan on ab_a1_b3_a_idx (never executed)
Index Cond: (a = 1)
- -> Result (actual rows=0 loops=1)
+ -> Result (actual rows=0.00 loops=1)
One-Time Filter: (5 = (InitPlan 1).col1)
- -> Seq Scan on ab_a1_b1 ab_1 (actual rows=0 loops=1)
+ -> Seq Scan on ab_a1_b1 ab_1 (actual rows=0.00 loops=1)
Filter: (b = (InitPlan 1).col1)
-> Seq Scan on ab_a1_b2 ab_2 (never executed)
Filter: (b = (InitPlan 1).col1)
-> Seq Scan on ab_a1_b3 ab_3 (never executed)
Filter: (b = (InitPlan 1).col1)
- -> Seq Scan on ab_a2_b1 ab_4 (actual rows=0 loops=1)
+ -> Seq Scan on ab_a2_b1 ab_4 (actual rows=0.00 loops=1)
Filter: (b = (InitPlan 1).col1)
-> Seq Scan on ab_a2_b2 ab_5 (never executed)
Filter: (b = (InitPlan 1).col1)
-> Seq Scan on ab_a2_b3 ab_6 (never executed)
Filter: (b = (InitPlan 1).col1)
- -> Seq Scan on ab_a3_b1 ab_7 (actual rows=0 loops=1)
+ -> Seq Scan on ab_a3_b1 ab_7 (actual rows=0.00 loops=1)
Filter: (b = (InitPlan 1).col1)
-> Seq Scan on ab_a3_b2 ab_8 (never executed)
Filter: (b = (InitPlan 1).col1)
explain (analyze, costs off, summary off, timing off, buffers off) execute ab_q6(1);
QUERY PLAN
--------------------------------------------------------
- Append (actual rows=0 loops=1)
+ Append (actual rows=0.00 loops=1)
Subplans Removed: 12
InitPlan 1
- -> Result (actual rows=1 loops=1)
+ -> Result (actual rows=1.00 loops=1)
-> Seq Scan on ab_a1_b1 ab_1 (never executed)
Filter: ((a = $1) AND (b = (InitPlan 1).col1))
-> Seq Scan on ab_a1_b2 ab_2 (never executed)
Filter: ((a = $1) AND (b = (InitPlan 1).col1))
-> Seq Scan on ab_a1_b3 ab_3 (never executed)
Filter: ((a = $1) AND (b = (InitPlan 1).col1))
- -> Seq Scan on xy_1 (actual rows=0 loops=1)
+ -> Seq Scan on xy_1 (actual rows=0.00 loops=1)
Filter: ((x = $1) AND (y = (InitPlan 1).col1))
Rows Removed by Filter: 1
-> Seq Scan on ab_a1_b1 ab_4 (never executed)
insert into ab values (1,2);
select explain_analyze('
update ab_a1 set b = 3 from ab where ab.a = 1 and ab.a = ab_a1.a;');
- explain_analyze
--------------------------------------------------------------------------------------------
- Update on ab_a1 (actual rows=0 loops=1)
+ explain_analyze
+----------------------------------------------------------------------------------------------
+ Update on ab_a1 (actual rows=0.00 loops=1)
Update on ab_a1_b1 ab_a1_1
Update on ab_a1_b2 ab_a1_2
Update on ab_a1_b3 ab_a1_3
- -> Nested Loop (actual rows=1 loops=1)
- -> Append (actual rows=1 loops=1)
- -> Bitmap Heap Scan on ab_a1_b1 ab_a1_1 (actual rows=0 loops=1)
+ -> Nested Loop (actual rows=1.00 loops=1)
+ -> Append (actual rows=1.00 loops=1)
+ -> Bitmap Heap Scan on ab_a1_b1 ab_a1_1 (actual rows=0.00 loops=1)
Recheck Cond: (a = 1)
- -> Bitmap Index Scan on ab_a1_b1_a_idx (actual rows=0 loops=1)
+ -> Bitmap Index Scan on ab_a1_b1_a_idx (actual rows=0.00 loops=1)
Index Cond: (a = 1)
- -> Bitmap Heap Scan on ab_a1_b2 ab_a1_2 (actual rows=1 loops=1)
+ -> Bitmap Heap Scan on ab_a1_b2 ab_a1_2 (actual rows=1.00 loops=1)
Recheck Cond: (a = 1)
Heap Blocks: exact=1
- -> Bitmap Index Scan on ab_a1_b2_a_idx (actual rows=1 loops=1)
+ -> Bitmap Index Scan on ab_a1_b2_a_idx (actual rows=1.00 loops=1)
Index Cond: (a = 1)
- -> Bitmap Heap Scan on ab_a1_b3 ab_a1_3 (actual rows=0 loops=1)
+ -> Bitmap Heap Scan on ab_a1_b3 ab_a1_3 (actual rows=0.00 loops=1)
Recheck Cond: (a = 1)
Heap Blocks: exact=1
- -> Bitmap Index Scan on ab_a1_b3_a_idx (actual rows=1 loops=1)
+ -> Bitmap Index Scan on ab_a1_b3_a_idx (actual rows=1.00 loops=1)
Index Cond: (a = 1)
- -> Materialize (actual rows=1 loops=1)
+ -> Materialize (actual rows=1.00 loops=1)
Storage: Memory Maximum Storage: NkB
- -> Append (actual rows=1 loops=1)
- -> Bitmap Heap Scan on ab_a1_b1 ab_1 (actual rows=0 loops=1)
+ -> Append (actual rows=1.00 loops=1)
+ -> Bitmap Heap Scan on ab_a1_b1 ab_1 (actual rows=0.00 loops=1)
Recheck Cond: (a = 1)
- -> Bitmap Index Scan on ab_a1_b1_a_idx (actual rows=0 loops=1)
+ -> Bitmap Index Scan on ab_a1_b1_a_idx (actual rows=0.00 loops=1)
Index Cond: (a = 1)
- -> Bitmap Heap Scan on ab_a1_b2 ab_2 (actual rows=1 loops=1)
+ -> Bitmap Heap Scan on ab_a1_b2 ab_2 (actual rows=1.00 loops=1)
Recheck Cond: (a = 1)
Heap Blocks: exact=1
- -> Bitmap Index Scan on ab_a1_b2_a_idx (actual rows=1 loops=1)
+ -> Bitmap Index Scan on ab_a1_b2_a_idx (actual rows=1.00 loops=1)
Index Cond: (a = 1)
- -> Bitmap Heap Scan on ab_a1_b3 ab_3 (actual rows=0 loops=1)
+ -> Bitmap Heap Scan on ab_a1_b3 ab_3 (actual rows=0.00 loops=1)
Recheck Cond: (a = 1)
Heap Blocks: exact=1
- -> Bitmap Index Scan on ab_a1_b3_a_idx (actual rows=1 loops=1)
+ -> Bitmap Index Scan on ab_a1_b3_a_idx (actual rows=1.00 loops=1)
Index Cond: (a = 1)
(37 rows)
insert into ab values (1, 1), (1, 2), (1, 3), (2, 1);
select explain_analyze('
update ab_a1 set b = 3 from ab_a2 where ab_a2.b = (select 1);');
- explain_analyze
-------------------------------------------------------------------------------
- Update on ab_a1 (actual rows=0 loops=1)
+ explain_analyze
+---------------------------------------------------------------------------------
+ Update on ab_a1 (actual rows=0.00 loops=1)
Update on ab_a1_b1 ab_a1_1
Update on ab_a1_b2 ab_a1_2
Update on ab_a1_b3 ab_a1_3
InitPlan 1
- -> Result (actual rows=1 loops=1)
- -> Nested Loop (actual rows=3 loops=1)
- -> Append (actual rows=3 loops=1)
- -> Seq Scan on ab_a1_b1 ab_a1_1 (actual rows=1 loops=1)
- -> Seq Scan on ab_a1_b2 ab_a1_2 (actual rows=1 loops=1)
- -> Seq Scan on ab_a1_b3 ab_a1_3 (actual rows=1 loops=1)
+ -> Result (actual rows=1.00 loops=1)
+ -> Nested Loop (actual rows=3.00 loops=1)
+ -> Append (actual rows=3.00 loops=1)
+ -> Seq Scan on ab_a1_b1 ab_a1_1 (actual rows=1.00 loops=1)
+ -> Seq Scan on ab_a1_b2 ab_a1_2 (actual rows=1.00 loops=1)
+ -> Seq Scan on ab_a1_b3 ab_a1_3 (actual rows=1.00 loops=1)
-> Materialize (actual rows=1.00 loops=3)
Storage: Memory Maximum Storage: NkB
- -> Append (actual rows=1 loops=1)
- -> Seq Scan on ab_a2_b1 ab_a2_1 (actual rows=1 loops=1)
+ -> Append (actual rows=1.00 loops=1)
+ -> Seq Scan on ab_a2_b1 ab_a2_1 (actual rows=1.00 loops=1)
Filter: (b = (InitPlan 1).col1)
-> Seq Scan on ab_a2_b2 ab_a2_2 (never executed)
Filter: (b = (InitPlan 1).col1)
select * from tbl1 join tprt on tbl1.col1 > tprt.col1;
QUERY PLAN
-----------------------------------------------------------------------------
- Nested Loop (actual rows=6 loops=1)
- -> Seq Scan on tbl1 (actual rows=2 loops=1)
+ Nested Loop (actual rows=6.00 loops=1)
+ -> Seq Scan on tbl1 (actual rows=2.00 loops=1)
-> Append (actual rows=3.00 loops=2)
-> Index Scan using tprt1_idx on tprt_1 (actual rows=2.00 loops=2)
Index Cond: (col1 < tbl1.col1)
- -> Index Scan using tprt2_idx on tprt_2 (actual rows=2 loops=1)
+ -> Index Scan using tprt2_idx on tprt_2 (actual rows=2.00 loops=1)
Index Cond: (col1 < tbl1.col1)
-> Index Scan using tprt3_idx on tprt_3 (never executed)
Index Cond: (col1 < tbl1.col1)
select * from tbl1 join tprt on tbl1.col1 = tprt.col1;
QUERY PLAN
-----------------------------------------------------------------------------
- Nested Loop (actual rows=2 loops=1)
- -> Seq Scan on tbl1 (actual rows=2 loops=1)
+ Nested Loop (actual rows=2.00 loops=1)
+ -> Seq Scan on tbl1 (actual rows=2.00 loops=1)
-> Append (actual rows=1.00 loops=2)
-> Index Scan using tprt1_idx on tprt_1 (never executed)
Index Cond: (col1 = tbl1.col1)
select * from tbl1 inner join tprt on tbl1.col1 > tprt.col1;
QUERY PLAN
-----------------------------------------------------------------------------
- Nested Loop (actual rows=23 loops=1)
- -> Seq Scan on tbl1 (actual rows=5 loops=1)
+ Nested Loop (actual rows=23.00 loops=1)
+ -> Seq Scan on tbl1 (actual rows=5.00 loops=1)
-> Append (actual rows=4.60 loops=5)
-> Index Scan using tprt1_idx on tprt_1 (actual rows=2.00 loops=5)
Index Cond: (col1 < tbl1.col1)
select * from tbl1 inner join tprt on tbl1.col1 = tprt.col1;
QUERY PLAN
-----------------------------------------------------------------------------
- Nested Loop (actual rows=3 loops=1)
- -> Seq Scan on tbl1 (actual rows=5 loops=1)
+ Nested Loop (actual rows=3.00 loops=1)
+ -> Seq Scan on tbl1 (actual rows=5.00 loops=1)
-> Append (actual rows=0.60 loops=5)
-> Index Scan using tprt1_idx on tprt_1 (never executed)
Index Cond: (col1 = tbl1.col1)
insert into tbl1 values (4400);
explain (analyze, costs off, summary off, timing off, buffers off)
select * from tbl1 join tprt on tbl1.col1 < tprt.col1;
- QUERY PLAN
---------------------------------------------------------------------------
- Nested Loop (actual rows=1 loops=1)
- -> Seq Scan on tbl1 (actual rows=1 loops=1)
- -> Append (actual rows=1 loops=1)
+ QUERY PLAN
+-----------------------------------------------------------------------------
+ Nested Loop (actual rows=1.00 loops=1)
+ -> Seq Scan on tbl1 (actual rows=1.00 loops=1)
+ -> Append (actual rows=1.00 loops=1)
-> Index Scan using tprt1_idx on tprt_1 (never executed)
Index Cond: (col1 > tbl1.col1)
-> Index Scan using tprt2_idx on tprt_2 (never executed)
Index Cond: (col1 > tbl1.col1)
-> Index Scan using tprt5_idx on tprt_5 (never executed)
Index Cond: (col1 > tbl1.col1)
- -> Index Scan using tprt6_idx on tprt_6 (actual rows=1 loops=1)
+ -> Index Scan using tprt6_idx on tprt_6 (actual rows=1.00 loops=1)
Index Cond: (col1 > tbl1.col1)
(15 rows)
select * from tbl1 join tprt on tbl1.col1 = tprt.col1;
QUERY PLAN
-------------------------------------------------------------------
- Nested Loop (actual rows=0 loops=1)
- -> Seq Scan on tbl1 (actual rows=1 loops=1)
- -> Append (actual rows=0 loops=1)
+ Nested Loop (actual rows=0.00 loops=1)
+ -> Seq Scan on tbl1 (actual rows=1.00 loops=1)
+ -> Append (actual rows=0.00 loops=1)
-> Index Scan using tprt1_idx on tprt_1 (never executed)
Index Cond: (col1 = tbl1.col1)
-> Index Scan using tprt2_idx on tprt_2 (never executed)
select * from part_abc where a = $1 and b = $2 and c = $3;
-- Single partition should be scanned.
explain (analyze, costs off, summary off, timing off, buffers off) execute part_abc_q1 (1, 2, 3);
- QUERY PLAN
-----------------------------------------------------------
- Seq Scan on part_abc_p1 part_abc (actual rows=0 loops=1)
+ QUERY PLAN
+-------------------------------------------------------------
+ Seq Scan on part_abc_p1 part_abc (actual rows=0.00 loops=1)
Filter: ((a = $1) AND (b = $2) AND (c = $3))
(2 rows)
-- which match the given parameter.
prepare q1 (int,int) as select * from listp where b in ($1,$2);
explain (analyze, costs off, summary off, timing off, buffers off) execute q1 (1,1);
- QUERY PLAN
--------------------------------------------------------------
- Append (actual rows=0 loops=1)
+ QUERY PLAN
+----------------------------------------------------------------
+ Append (actual rows=0.00 loops=1)
Subplans Removed: 1
- -> Seq Scan on listp_1_1 listp_1 (actual rows=0 loops=1)
+ -> Seq Scan on listp_1_1 listp_1 (actual rows=0.00 loops=1)
Filter: (b = ANY (ARRAY[$1, $2]))
(4 rows)
explain (analyze, costs off, summary off, timing off, buffers off) execute q1 (2,2);
- QUERY PLAN
--------------------------------------------------------------
- Append (actual rows=0 loops=1)
+ QUERY PLAN
+----------------------------------------------------------------
+ Append (actual rows=0.00 loops=1)
Subplans Removed: 1
- -> Seq Scan on listp_2_1 listp_1 (actual rows=0 loops=1)
+ -> Seq Scan on listp_2_1 listp_1 (actual rows=0.00 loops=1)
Filter: (b = ANY (ARRAY[$1, $2]))
(4 rows)
-- Try with no matching partitions.
explain (analyze, costs off, summary off, timing off, buffers off) execute q1 (0,0);
- QUERY PLAN
---------------------------------
- Append (actual rows=0 loops=1)
+ QUERY PLAN
+-----------------------------------
+ Append (actual rows=0.00 loops=1)
Subplans Removed: 2
(2 rows)
explain (analyze, costs off, summary off, timing off, buffers off) execute q1 (1,2,2,0);
QUERY PLAN
-------------------------------------------------------------------------
- Append (actual rows=0 loops=1)
+ Append (actual rows=0.00 loops=1)
Subplans Removed: 1
- -> Seq Scan on listp_1_1 listp_1 (actual rows=0 loops=1)
+ -> Seq Scan on listp_1_1 listp_1 (actual rows=0.00 loops=1)
Filter: ((b = ANY (ARRAY[$1, $2])) AND ($3 <> b) AND ($4 <> b))
(4 rows)
-- Both partitions allowed by IN clause, then both excluded again by <> clauses.
explain (analyze, costs off, summary off, timing off, buffers off) execute q1 (1,2,2,1);
- QUERY PLAN
---------------------------------
- Append (actual rows=0 loops=1)
+ QUERY PLAN
+-----------------------------------
+ Append (actual rows=0.00 loops=1)
Subplans Removed: 2
(2 rows)
select * from listp where a = (select null::int);
QUERY PLAN
------------------------------------------------------
- Append (actual rows=0 loops=1)
+ Append (actual rows=0.00 loops=1)
InitPlan 1
- -> Result (actual rows=1 loops=1)
+ -> Result (actual rows=1.00 loops=1)
-> Seq Scan on listp_1_1 listp_1 (never executed)
Filter: (a = (InitPlan 1).col1)
-> Seq Scan on listp_2_1 listp_2 (never executed)
-- comparison against a stable value requires run-time pruning
explain (analyze, costs off, summary off, timing off, buffers off)
select * from stable_qual_pruning where a < localtimestamp;
- QUERY PLAN
---------------------------------------------------------------------------------------
- Append (actual rows=0 loops=1)
+ QUERY PLAN
+-----------------------------------------------------------------------------------------
+ Append (actual rows=0.00 loops=1)
Subplans Removed: 1
- -> Seq Scan on stable_qual_pruning1 stable_qual_pruning_1 (actual rows=0 loops=1)
+ -> Seq Scan on stable_qual_pruning1 stable_qual_pruning_1 (actual rows=0.00 loops=1)
Filter: (a < LOCALTIMESTAMP)
- -> Seq Scan on stable_qual_pruning2 stable_qual_pruning_2 (actual rows=0 loops=1)
+ -> Seq Scan on stable_qual_pruning2 stable_qual_pruning_2 (actual rows=0.00 loops=1)
Filter: (a < LOCALTIMESTAMP)
(6 rows)
-- timestamp < timestamptz comparison is only stable, not immutable
explain (analyze, costs off, summary off, timing off, buffers off)
select * from stable_qual_pruning where a < '2000-02-01'::timestamptz;
- QUERY PLAN
---------------------------------------------------------------------------------------
- Append (actual rows=0 loops=1)
+ QUERY PLAN
+-----------------------------------------------------------------------------------------
+ Append (actual rows=0.00 loops=1)
Subplans Removed: 2
- -> Seq Scan on stable_qual_pruning1 stable_qual_pruning_1 (actual rows=0 loops=1)
+ -> Seq Scan on stable_qual_pruning1 stable_qual_pruning_1 (actual rows=0.00 loops=1)
Filter: (a < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)
(4 rows)
explain (analyze, costs off, summary off, timing off, buffers off)
select * from stable_qual_pruning
where a = any(array['2010-02-01', '2020-01-01']::timestamp[]);
- QUERY PLAN
---------------------------------
- Result (actual rows=0 loops=1)
+ QUERY PLAN
+-----------------------------------
+ Result (actual rows=0.00 loops=1)
One-Time Filter: false
(2 rows)
where a = any(array['2000-02-01', '2010-01-01']::timestamp[]);
QUERY PLAN
----------------------------------------------------------------------------------------------------------------
- Seq Scan on stable_qual_pruning2 stable_qual_pruning (actual rows=0 loops=1)
+ Seq Scan on stable_qual_pruning2 stable_qual_pruning (actual rows=0.00 loops=1)
Filter: (a = ANY ('{"Tue Feb 01 00:00:00 2000","Fri Jan 01 00:00:00 2010"}'::timestamp without time zone[]))
(2 rows)
where a = any(array['2000-02-01', localtimestamp]::timestamp[]);
QUERY PLAN
------------------------------------------------------------------------------------------------------------
- Append (actual rows=0 loops=1)
+ Append (actual rows=0.00 loops=1)
Subplans Removed: 2
- -> Seq Scan on stable_qual_pruning2 stable_qual_pruning_1 (actual rows=0 loops=1)
+ -> Seq Scan on stable_qual_pruning2 stable_qual_pruning_1 (actual rows=0.00 loops=1)
Filter: (a = ANY (ARRAY['Tue Feb 01 00:00:00 2000'::timestamp without time zone, LOCALTIMESTAMP]))
(4 rows)
explain (analyze, costs off, summary off, timing off, buffers off)
select * from stable_qual_pruning
where a = any(array['2010-02-01', '2020-01-01']::timestamptz[]);
- QUERY PLAN
---------------------------------
- Append (actual rows=0 loops=1)
+ QUERY PLAN
+-----------------------------------
+ Append (actual rows=0.00 loops=1)
Subplans Removed: 3
(2 rows)
where a = any(array['2000-02-01', '2010-01-01']::timestamptz[]);
QUERY PLAN
---------------------------------------------------------------------------------------------------------------------------
- Append (actual rows=0 loops=1)
+ Append (actual rows=0.00 loops=1)
Subplans Removed: 2
- -> Seq Scan on stable_qual_pruning2 stable_qual_pruning_1 (actual rows=0 loops=1)
+ -> Seq Scan on stable_qual_pruning2 stable_qual_pruning_1 (actual rows=0.00 loops=1)
Filter: (a = ANY ('{"Tue Feb 01 00:00:00 2000 PST","Fri Jan 01 00:00:00 2010 PST"}'::timestamp with time zone[]))
(4 rows)
explain (analyze, costs off, summary off, timing off, buffers off)
select * from stable_qual_pruning
where a = any(null::timestamptz[]);
- QUERY PLAN
---------------------------------------------------------------------------------------
- Append (actual rows=0 loops=1)
- -> Seq Scan on stable_qual_pruning1 stable_qual_pruning_1 (actual rows=0 loops=1)
+ QUERY PLAN
+-----------------------------------------------------------------------------------------
+ Append (actual rows=0.00 loops=1)
+ -> Seq Scan on stable_qual_pruning1 stable_qual_pruning_1 (actual rows=0.00 loops=1)
Filter: (a = ANY (NULL::timestamp with time zone[]))
- -> Seq Scan on stable_qual_pruning2 stable_qual_pruning_2 (actual rows=0 loops=1)
+ -> Seq Scan on stable_qual_pruning2 stable_qual_pruning_2 (actual rows=0.00 loops=1)
Filter: (a = ANY (NULL::timestamp with time zone[]))
- -> Seq Scan on stable_qual_pruning3 stable_qual_pruning_3 (actual rows=0 loops=1)
+ -> Seq Scan on stable_qual_pruning3 stable_qual_pruning_3 (actual rows=0.00 loops=1)
Filter: (a = ANY (NULL::timestamp with time zone[]))
(7 rows)
insert into mc3p values (0, 1, 1), (1, 1, 1), (2, 1, 1);
explain (analyze, costs off, summary off, timing off, buffers off)
select * from mc3p where a < 3 and abs(b) = 1;
- QUERY PLAN
---------------------------------------------------------
- Append (actual rows=3 loops=1)
- -> Seq Scan on mc3p0 mc3p_1 (actual rows=1 loops=1)
+ QUERY PLAN
+-----------------------------------------------------------
+ Append (actual rows=3.00 loops=1)
+ -> Seq Scan on mc3p0 mc3p_1 (actual rows=1.00 loops=1)
Filter: ((a < 3) AND (abs(b) = 1))
- -> Seq Scan on mc3p1 mc3p_2 (actual rows=1 loops=1)
+ -> Seq Scan on mc3p1 mc3p_2 (actual rows=1.00 loops=1)
Filter: ((a < 3) AND (abs(b) = 1))
- -> Seq Scan on mc3p2 mc3p_3 (actual rows=1 loops=1)
+ -> Seq Scan on mc3p2 mc3p_3 (actual rows=1.00 loops=1)
Filter: ((a < 3) AND (abs(b) = 1))
(7 rows)
execute ps1(1);
QUERY PLAN
-------------------------------------------------------------
- Append (actual rows=1 loops=1)
+ Append (actual rows=1.00 loops=1)
Subplans Removed: 2
InitPlan 1
- -> Result (actual rows=1 loops=1)
- -> Seq Scan on mc3p1 mc3p_1 (actual rows=1 loops=1)
+ -> Result (actual rows=1.00 loops=1)
+ -> Seq Scan on mc3p1 mc3p_1 (actual rows=1.00 loops=1)
Filter: ((a = $1) AND (abs(b) < (InitPlan 1).col1))
(6 rows)
execute ps2(1);
QUERY PLAN
--------------------------------------------------------------
- Append (actual rows=2 loops=1)
+ Append (actual rows=2.00 loops=1)
Subplans Removed: 1
InitPlan 1
- -> Result (actual rows=1 loops=1)
- -> Seq Scan on mc3p0 mc3p_1 (actual rows=1 loops=1)
+ -> Result (actual rows=1.00 loops=1)
+ -> Seq Scan on mc3p0 mc3p_1 (actual rows=1.00 loops=1)
Filter: ((a <= $1) AND (abs(b) < (InitPlan 1).col1))
- -> Seq Scan on mc3p1 mc3p_2 (actual rows=1 loops=1)
+ -> Seq Scan on mc3p1 mc3p_2 (actual rows=1.00 loops=1)
Filter: ((a <= $1) AND (abs(b) < (InitPlan 1).col1))
(8 rows)
create table boolp_f partition of boolp for values in('f');
explain (analyze, costs off, summary off, timing off, buffers off)
select * from boolp where a = (select value from boolvalues where value);
- QUERY PLAN
------------------------------------------------------------
- Append (actual rows=0 loops=1)
+ QUERY PLAN
+--------------------------------------------------------------
+ Append (actual rows=0.00 loops=1)
InitPlan 1
- -> Seq Scan on boolvalues (actual rows=1 loops=1)
+ -> Seq Scan on boolvalues (actual rows=1.00 loops=1)
Filter: value
Rows Removed by Filter: 1
-> Seq Scan on boolp_f boolp_1 (never executed)
Filter: (a = (InitPlan 1).col1)
- -> Seq Scan on boolp_t boolp_2 (actual rows=0 loops=1)
+ -> Seq Scan on boolp_t boolp_2 (actual rows=0.00 loops=1)
Filter: (a = (InitPlan 1).col1)
(9 rows)
explain (analyze, costs off, summary off, timing off, buffers off)
select * from boolp where a = (select value from boolvalues where not value);
- QUERY PLAN
------------------------------------------------------------
- Append (actual rows=0 loops=1)
+ QUERY PLAN
+--------------------------------------------------------------
+ Append (actual rows=0.00 loops=1)
InitPlan 1
- -> Seq Scan on boolvalues (actual rows=1 loops=1)
+ -> Seq Scan on boolvalues (actual rows=1.00 loops=1)
Filter: (NOT value)
Rows Removed by Filter: 1
- -> Seq Scan on boolp_f boolp_1 (actual rows=0 loops=1)
+ -> Seq Scan on boolp_f boolp_1 (actual rows=0.00 loops=1)
Filter: (a = (InitPlan 1).col1)
-> Seq Scan on boolp_t boolp_2 (never executed)
Filter: (a = (InitPlan 1).col1)
analyze ma_test;
prepare mt_q1 (int) as select a from ma_test where a >= $1 and a % 10 = 5 order by b;
explain (analyze, costs off, summary off, timing off, buffers off) execute mt_q1(15);
- QUERY PLAN
------------------------------------------------------------------------------------------
- Merge Append (actual rows=2 loops=1)
+ QUERY PLAN
+--------------------------------------------------------------------------------------------
+ Merge Append (actual rows=2.00 loops=1)
Sort Key: ma_test.b
Subplans Removed: 1
- -> Index Scan using ma_test_p2_b_idx on ma_test_p2 ma_test_1 (actual rows=1 loops=1)
+ -> Index Scan using ma_test_p2_b_idx on ma_test_p2 ma_test_1 (actual rows=1.00 loops=1)
Filter: ((a >= $1) AND ((a % 10) = 5))
Rows Removed by Filter: 9
- -> Index Scan using ma_test_p3_b_idx on ma_test_p3 ma_test_2 (actual rows=1 loops=1)
+ -> Index Scan using ma_test_p3_b_idx on ma_test_p3 ma_test_2 (actual rows=1.00 loops=1)
Filter: ((a >= $1) AND ((a % 10) = 5))
Rows Removed by Filter: 9
(9 rows)
(2 rows)
explain (analyze, costs off, summary off, timing off, buffers off) execute mt_q1(25);
- QUERY PLAN
------------------------------------------------------------------------------------------
- Merge Append (actual rows=1 loops=1)
+ QUERY PLAN
+--------------------------------------------------------------------------------------------
+ Merge Append (actual rows=1.00 loops=1)
Sort Key: ma_test.b
Subplans Removed: 2
- -> Index Scan using ma_test_p3_b_idx on ma_test_p3 ma_test_1 (actual rows=1 loops=1)
+ -> Index Scan using ma_test_p3_b_idx on ma_test_p3 ma_test_1 (actual rows=1.00 loops=1)
Filter: ((a >= $1) AND ((a % 10) = 5))
Rows Removed by Filter: 9
(6 rows)
-- Ensure MergeAppend behaves correctly when no subplans match
explain (analyze, costs off, summary off, timing off, buffers off) execute mt_q1(35);
- QUERY PLAN
---------------------------------------
- Merge Append (actual rows=0 loops=1)
+ QUERY PLAN
+-----------------------------------------
+ Merge Append (actual rows=0.00 loops=1)
Sort Key: ma_test.b
Subplans Removed: 3
(3 rows)
prepare mt_q2 (int) as select * from ma_test where a >= $1 order by b limit 1;
-- Ensure output list looks sane when the MergeAppend has no subplans.
explain (analyze, verbose, costs off, summary off, timing off, buffers off) execute mt_q2 (35);
- QUERY PLAN
---------------------------------------------
- Limit (actual rows=0 loops=1)
+ QUERY PLAN
+-----------------------------------------------
+ Limit (actual rows=0.00 loops=1)
Output: ma_test.a, ma_test.b
- -> Merge Append (actual rows=0 loops=1)
+ -> Merge Append (actual rows=0.00 loops=1)
Sort Key: ma_test.b
Subplans Removed: 3
(5 rows)
deallocate mt_q2;
-- ensure initplan params properly prune partitions
explain (analyze, costs off, summary off, timing off, buffers off) select * from ma_test where a >= (select min(b) from ma_test_p2) order by b;
- QUERY PLAN
------------------------------------------------------------------------------------------------
- Merge Append (actual rows=20 loops=1)
+ QUERY PLAN
+--------------------------------------------------------------------------------------------------
+ Merge Append (actual rows=20.00 loops=1)
Sort Key: ma_test.b
InitPlan 2
- -> Result (actual rows=1 loops=1)
+ -> Result (actual rows=1.00 loops=1)
InitPlan 1
- -> Limit (actual rows=1 loops=1)
- -> Index Scan using ma_test_p2_b_idx on ma_test_p2 (actual rows=1 loops=1)
+ -> Limit (actual rows=1.00 loops=1)
+ -> Index Scan using ma_test_p2_b_idx on ma_test_p2 (actual rows=1.00 loops=1)
Index Cond: (b IS NOT NULL)
-> Index Scan using ma_test_p1_b_idx on ma_test_p1 ma_test_1 (never executed)
Filter: (a >= (InitPlan 2).col1)
- -> Index Scan using ma_test_p2_b_idx on ma_test_p2 ma_test_2 (actual rows=10 loops=1)
+ -> Index Scan using ma_test_p2_b_idx on ma_test_p2 ma_test_2 (actual rows=10.00 loops=1)
Filter: (a >= (InitPlan 2).col1)
- -> Index Scan using ma_test_p3_b_idx on ma_test_p3 ma_test_3 (actual rows=10 loops=1)
+ -> Index Scan using ma_test_p3_b_idx on ma_test_p3 ma_test_3 (actual rows=10.00 loops=1)
Filter: (a >= (InitPlan 2).col1)
(14 rows)
create table listp2_10 partition of listp2 for values in (10);
explain (analyze, costs off, summary off, timing off, buffers off)
select * from listp where a = (select 2) and b <> 10;
- QUERY PLAN
----------------------------------------------------
- Seq Scan on listp1 listp (actual rows=0 loops=1)
+ QUERY PLAN
+-----------------------------------------------------
+ Seq Scan on listp1 listp (actual rows=0.00 loops=1)
Filter: ((b <> 10) AND (a = (InitPlan 1).col1))
InitPlan 1
-> Result (never executed)
-- Ensure run-time pruning works on the nested Merge Append
explain (analyze on, costs off, timing off, summary off, buffers off)
select * from rangep where b IN((select 1),(select 2)) order by a;
- QUERY PLAN
-------------------------------------------------------------------------------------------------------------
- Append (actual rows=0 loops=1)
+ QUERY PLAN
+---------------------------------------------------------------------------------------------------------------
+ Append (actual rows=0.00 loops=1)
InitPlan 1
- -> Result (actual rows=1 loops=1)
+ -> Result (actual rows=1.00 loops=1)
InitPlan 2
- -> Result (actual rows=1 loops=1)
- -> Merge Append (actual rows=0 loops=1)
+ -> Result (actual rows=1.00 loops=1)
+ -> Merge Append (actual rows=0.00 loops=1)
Sort Key: rangep_2.a
- -> Index Scan using rangep_0_to_100_1_a_idx on rangep_0_to_100_1 rangep_2 (actual rows=0 loops=1)
+ -> Index Scan using rangep_0_to_100_1_a_idx on rangep_0_to_100_1 rangep_2 (actual rows=0.00 loops=1)
Filter: (b = ANY (ARRAY[(InitPlan 1).col1, (InitPlan 2).col1]))
- -> Index Scan using rangep_0_to_100_2_a_idx on rangep_0_to_100_2 rangep_3 (actual rows=0 loops=1)
+ -> Index Scan using rangep_0_to_100_2_a_idx on rangep_0_to_100_2 rangep_3 (actual rows=0.00 loops=1)
Filter: (b = ANY (ARRAY[(InitPlan 1).col1, (InitPlan 2).col1]))
-> Index Scan using rangep_0_to_100_3_a_idx on rangep_0_to_100_3 rangep_4 (never executed)
Filter: (b = ANY (ARRAY[(InitPlan 1).col1, (InitPlan 2).col1]))
- -> Index Scan using rangep_100_to_200_a_idx on rangep_100_to_200 rangep_5 (actual rows=0 loops=1)
+ -> Index Scan using rangep_100_to_200_a_idx on rangep_100_to_200 rangep_5 (actual rows=0.00 loops=1)
Filter: (b = ANY (ARRAY[(InitPlan 1).col1, (InitPlan 2).col1]))
(15 rows)
-- actually run the query with an analyze to use the partial index
explain (costs off, analyze on, timing off, summary off, buffers off)
select * from onek2 where unique2 = 11 and stringu1 = 'ATAAAA';
- QUERY PLAN
------------------------------------------------------------------
- Index Scan using onek2_u2_prtl on onek2 (actual rows=1 loops=1)
+ QUERY PLAN
+--------------------------------------------------------------------
+ Index Scan using onek2_u2_prtl on onek2 (actual rows=1.00 loops=1)
Index Cond: (unique2 = 11)
Filter: (stringu1 = 'ATAAAA'::name)
(3 rows)
EXPLAIN (ANALYZE, COSTS OFF, SUMMARY OFF, TIMING OFF, BUFFERS OFF)
CREATE TABLE selinto_schema.tbl_withdata2 (a) AS
SELECT generate_series(1,3) WITH DATA;
- QUERY PLAN
---------------------------------------
- ProjectSet (actual rows=3 loops=1)
- -> Result (actual rows=1 loops=1)
+ QUERY PLAN
+-----------------------------------------
+ ProjectSet (actual rows=3.00 loops=1)
+ -> Result (actual rows=1.00 loops=1)
(2 rows)
-- WITH NO DATA, passes.
EXPLAIN (ANALYZE, COSTS OFF, SUMMARY OFF, TIMING OFF, BUFFERS OFF)
CREATE TABLE selinto_schema.tbl_withdata4 (a) AS
EXECUTE data_sel WITH DATA;
- QUERY PLAN
---------------------------------------
- ProjectSet (actual rows=3 loops=1)
- -> Result (actual rows=1 loops=1)
+ QUERY PLAN
+-----------------------------------------
+ ProjectSet (actual rows=3.00 loops=1)
+ -> Result (actual rows=1.00 loops=1)
(2 rows)
-- EXECUTE and WITH NO DATA, passes.
and tenk2.thousand=0;
QUERY PLAN
-----------------------------------------------------------------------------
- Aggregate (actual rows=1 loops=1)
- -> Nested Loop (actual rows=98000 loops=1)
- -> Seq Scan on tenk2 (actual rows=10 loops=1)
+ Aggregate (actual rows=1.00 loops=1)
+ -> Nested Loop (actual rows=98000.00 loops=1)
+ -> Seq Scan on tenk2 (actual rows=10.00 loops=1)
Filter: (thousand = 0)
Rows Removed by Filter: 9990
-> Gather (actual rows=9800.00 loops=10)
select * from explain_parallel_sort_stats();
explain_parallel_sort_stats
-----------------------------------------------------------------------------
- Nested Loop Left Join (actual rows=30000 loops=1)
- -> Values Scan on "*VALUES*" (actual rows=3 loops=1)
+ Nested Loop Left Join (actual rows=30000.00 loops=1)
+ -> Values Scan on "*VALUES*" (actual rows=3.00 loops=1)
-> Gather Merge (actual rows=10000.00 loops=3)
Workers Planned: 4
Workers Launched: 4
EXPLAIN (analyze, timing off, summary off, costs off, buffers off) SELECT * FROM tenk1;
QUERY PLAN
----------------------------------------------------------------
- Gather (actual rows=10000 loops=1)
+ Gather (actual rows=10000.00 loops=1)
Workers Planned: 4
Workers Launched: 4
-> Parallel Seq Scan on tenk1 (actual rows=2000.00 loops=5)
end;
$$;
select * from explain_sq_limit();
- explain_sq_limit
-----------------------------------------------------------------
- Limit (actual rows=3 loops=1)
- -> Subquery Scan on x (actual rows=3 loops=1)
- -> Sort (actual rows=3 loops=1)
+ explain_sq_limit
+-------------------------------------------------------------------
+ Limit (actual rows=3.00 loops=1)
+ -> Subquery Scan on x (actual rows=3.00 loops=1)
+ -> Sort (actual rows=3.00 loops=1)
Sort Key: sq_limit.c1, sq_limit.pk
Sort Method: top-N heapsort Memory: xxx
- -> Seq Scan on sq_limit (actual rows=8 loops=1)
+ -> Seq Scan on sq_limit (actual rows=8.00 loops=1)
(6 rows)
select * from (select pk,c2 from sq_limit order by c1,pk) as x limit 3;
-- perform update
EXPLAIN (ANALYZE, COSTS OFF, SUMMARY OFF, TIMING OFF, BUFFERS OFF)
UPDATE tidscan SET id = -id WHERE CURRENT OF c RETURNING *;
- QUERY PLAN
----------------------------------------------------
- Update on tidscan (actual rows=1 loops=1)
- -> Tid Scan on tidscan (actual rows=1 loops=1)
+ QUERY PLAN
+------------------------------------------------------
+ Update on tidscan (actual rows=1.00 loops=1)
+ -> Tid Scan on tidscan (actual rows=1.00 loops=1)
TID Cond: CURRENT OF c
(3 rows)
-- perform update
EXPLAIN (ANALYZE, COSTS OFF, SUMMARY OFF, TIMING OFF, BUFFERS OFF)
UPDATE tidscan SET id = -id WHERE CURRENT OF c RETURNING *;
- QUERY PLAN
----------------------------------------------------
- Update on tidscan (actual rows=1 loops=1)
- -> Tid Scan on tidscan (actual rows=1 loops=1)
+ QUERY PLAN
+------------------------------------------------------
+ Update on tidscan (actual rows=1.00 loops=1)
+ -> Tid Scan on tidscan (actual rows=1.00 loops=1)
TID Cond: CURRENT OF c
(3 rows)
-- Also remove its sort-type fields, as those aren't 100% stable
#- '{0,Plan,Plans,0,Sort Method}'
#- '{0,Plan,Plans,0,Sort Space Type}'
- -- Actual Rows can be 0 or 0.0 depending on whether loops>1
- #- '{0,Plan,Plans,0,Actual Rows}'
- #- '{0,Plan,Plans,0,Plans,0,Actual Rows}'
);
rollback;
projects / postgresql.git / commitdiff