From b04ca32d79ca18a7b68e04c12e2ae053351a2bbb Mon Sep 17 00:00:00 2001 From: David Fetter Date: Tue, 14 May 2019 22:54:15 -0700 Subject: [PATCH v4 6/8] Mechanical changes to regression tests and their output To: hackers MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="------------2.21.0" This is a multi-part message in MIME format. --------------2.21.0 Content-Type: text/plain; charset=UTF-8; format=fixed Content-Transfer-Encoding: 8bit diff --git a/src/test/regress/expected/aggregates.out b/src/test/regress/expected/aggregates.out index 129c1e5075..4c06b8b507 100644 --- a/src/test/regress/expected/aggregates.out +++ b/src/test/regress/expected/aggregates.out @@ -795,7 +795,8 @@ explain (costs off) -> Limit -> Index Only Scan Backward using tenk1_unique1 on tenk1 Index Cond: ((unique1 IS NOT NULL) AND (unique1 > 42000)) -(5 rows) + Settings: max_parallel_workers_per_gather = '0' +(6 rows) select max(unique1) from tenk1 where unique1 > 42000; max @@ -2179,14 +2180,15 @@ ALTER TABLE tenk1 set (parallel_workers = 4); SET LOCAL parallel_setup_cost=0; SET LOCAL max_parallel_workers_per_gather=4; EXPLAIN (COSTS OFF) SELECT balk(hundred) FROM tenk1; - QUERY PLAN -------------------------------------------------------------------------- + QUERY PLAN +---------------------------------------------------------------------------- Finalize Aggregate -> Gather Workers Planned: 4 -> Partial Aggregate -> Parallel Index Only Scan using tenk1_hundred on tenk1 -(5 rows) + Settings: max_parallel_workers_per_gather = '4', parallel_setup_cost = '0' +(6 rows) SELECT balk(hundred) FROM tenk1; balk @@ -2206,14 +2208,15 @@ SET enable_indexonlyscan = off; -- sum(int8) covers int8_avg_combine EXPLAIN (COSTS OFF) SELECT variance(unique1::int4), sum(unique1::int8) FROM tenk1; - QUERY PLAN ----------------------------------------------- + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Finalize Aggregate -> Gather Workers Planned: 4 -> Partial Aggregate -> Parallel Seq Scan on tenk1 -(5 rows) + Settings: enable_indexonlyscan = 'off', max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(6 rows) SELECT variance(unique1::int4), sum(unique1::int8) FROM tenk1; variance | sum diff --git a/src/test/regress/expected/box.out b/src/test/regress/expected/box.out index 998b52223c..b3ee86063f 100644 --- a/src/test/regress/expected/box.out +++ b/src/test/regress/expected/box.out @@ -270,7 +270,8 @@ EXPLAIN (COSTS OFF) SELECT * FROM box_temp WHERE f1 << '(10,20),(30,40)'; ---------------------------------------------- Index Only Scan using box_spgist on box_temp Index Cond: (f1 << '(30,40),(10,20)'::box) -(2 rows) + Settings: enable_seqscan = 'off' +(3 rows) SELECT * FROM box_temp WHERE f1 &< '(10,4.333334),(5,100)'; f1 @@ -290,7 +291,8 @@ EXPLAIN (COSTS OFF) SELECT * FROM box_temp WHERE f1 &< '(10,4.333334),(5,100)'; ---------------------------------------------------- Index Only Scan using box_spgist on box_temp Index Cond: (f1 &< '(10,100),(5,4.333334)'::box) -(2 rows) + Settings: enable_seqscan = 'off' +(3 rows) SELECT * FROM box_temp WHERE f1 && '(15,20),(25,30)'; f1 @@ -319,7 +321,8 @@ EXPLAIN (COSTS OFF) SELECT * FROM box_temp WHERE f1 && '(15,20),(25,30)'; ---------------------------------------------- Index Only Scan using box_spgist on box_temp Index Cond: (f1 && '(25,30),(15,20)'::box) -(2 rows) + Settings: enable_seqscan = 'off' +(3 rows) SELECT * FROM box_temp WHERE f1 &> '(40,30),(45,50)'; f1 @@ -342,7 +345,8 @@ EXPLAIN (COSTS OFF) SELECT * FROM box_temp WHERE f1 &> '(40,30),(45,50)'; ---------------------------------------------- Index Only Scan using box_spgist on box_temp Index Cond: (f1 &> '(45,50),(40,30)'::box) -(2 rows) + Settings: enable_seqscan = 'off' +(3 rows) SELECT * FROM box_temp WHERE f1 >> '(30,40),(40,30)'; f1 @@ -364,7 +368,8 @@ EXPLAIN (COSTS OFF) SELECT * FROM box_temp WHERE f1 >> '(30,40),(40,30)'; ---------------------------------------------- Index Only Scan using box_spgist on box_temp Index Cond: (f1 >> '(40,40),(30,30)'::box) -(2 rows) + Settings: enable_seqscan = 'off' +(3 rows) SELECT * FROM box_temp WHERE f1 <<| '(10,4.33334),(5,100)'; f1 @@ -379,7 +384,8 @@ EXPLAIN (COSTS OFF) SELECT * FROM box_temp WHERE f1 <<| '(10,4.33334),(5,100)'; ---------------------------------------------------- Index Only Scan using box_spgist on box_temp Index Cond: (f1 <<| '(10,100),(5,4.33334)'::box) -(2 rows) + Settings: enable_seqscan = 'off' +(3 rows) SELECT * FROM box_temp WHERE f1 &<| '(10,4.3333334),(5,1)'; f1 @@ -394,7 +400,8 @@ EXPLAIN (COSTS OFF) SELECT * FROM box_temp WHERE f1 &<| '(10,4.3333334),(5,1)'; ---------------------------------------------------- Index Only Scan using box_spgist on box_temp Index Cond: (f1 &<| '(10,4.3333334),(5,1)'::box) -(2 rows) + Settings: enable_seqscan = 'off' +(3 rows) SELECT * FROM box_temp WHERE f1 |&> '(49.99,49.99),(49.99,49.99)'; f1 @@ -408,7 +415,8 @@ EXPLAIN (COSTS OFF) SELECT * FROM box_temp WHERE f1 |&> '(49.99,49.99),(49.99,49 ----------------------------------------------------------- Index Only Scan using box_spgist on box_temp Index Cond: (f1 |&> '(49.99,49.99),(49.99,49.99)'::box) -(2 rows) + Settings: enable_seqscan = 'off' +(3 rows) SELECT * FROM box_temp WHERE f1 |>> '(37,38),(39,40)'; f1 @@ -431,7 +439,8 @@ EXPLAIN (COSTS OFF) SELECT * FROM box_temp WHERE f1 |>> '(37,38),(39,40)'; ----------------------------------------------- Index Only Scan using box_spgist on box_temp Index Cond: (f1 |>> '(39,40),(37,38)'::box) -(2 rows) + Settings: enable_seqscan = 'off' +(3 rows) SELECT * FROM box_temp WHERE f1 @> '(10,11),(15,16)'; f1 @@ -447,7 +456,8 @@ EXPLAIN (COSTS OFF) SELECT * FROM box_temp WHERE f1 @> '(10,11),(15,15)'; ---------------------------------------------- Index Only Scan using box_spgist on box_temp Index Cond: (f1 @> '(15,15),(10,11)'::box) -(2 rows) + Settings: enable_seqscan = 'off' +(3 rows) SELECT * FROM box_temp WHERE f1 <@ '(10,15),(30,35)'; f1 @@ -460,7 +470,8 @@ EXPLAIN (COSTS OFF) SELECT * FROM box_temp WHERE f1 <@ '(10,15),(30,35)'; ---------------------------------------------- Index Only Scan using box_spgist on box_temp Index Cond: (f1 <@ '(30,35),(10,15)'::box) -(2 rows) + Settings: enable_seqscan = 'off' +(3 rows) SELECT * FROM box_temp WHERE f1 ~= '(20,20),(40,40)'; f1 @@ -473,7 +484,8 @@ EXPLAIN (COSTS OFF) SELECT * FROM box_temp WHERE f1 ~= '(20,20),(40,40)'; ---------------------------------------------- Index Only Scan using box_spgist on box_temp Index Cond: (f1 ~= '(40,40),(20,20)'::box) -(2 rows) + Settings: enable_seqscan = 'off' +(3 rows) RESET enable_seqscan; DROP INDEX box_spgist; diff --git a/src/test/regress/expected/btree_index.out b/src/test/regress/expected/btree_index.out index acab8e0b11..e7121823a2 100644 --- a/src/test/regress/expected/btree_index.out +++ b/src/test/regress/expected/btree_index.out @@ -112,7 +112,8 @@ select proname from pg_proc where proname like E'RI\\_FKey%del' order by 1; Index Only Scan using pg_proc_proname_args_nsp_index on pg_proc Index Cond: ((proname >= 'RI_FKey'::text) AND (proname < 'RI_FKez'::text)) Filter: (proname ~~ 'RI\_FKey%del'::text) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) select proname from pg_proc where proname like E'RI\\_FKey%del' order by 1; proname @@ -131,7 +132,8 @@ select proname from pg_proc where proname ilike '00%foo' order by 1; Index Only Scan using pg_proc_proname_args_nsp_index on pg_proc Index Cond: ((proname >= '00'::text) AND (proname < '01'::text)) Filter: (proname ~~* '00%foo'::text) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) select proname from pg_proc where proname ilike '00%foo' order by 1; proname @@ -144,7 +146,8 @@ select proname from pg_proc where proname ilike 'ri%foo' order by 1; ----------------------------------------------------------------- Index Only Scan using pg_proc_proname_args_nsp_index on pg_proc Filter: (proname ~~* 'ri%foo'::text) -(2 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(3 rows) set enable_indexscan to false; set enable_bitmapscan to true; @@ -158,7 +161,8 @@ select proname from pg_proc where proname like E'RI\\_FKey%del' order by 1; Filter: (proname ~~ 'RI\_FKey%del'::text) -> Bitmap Index Scan on pg_proc_proname_args_nsp_index Index Cond: ((proname >= 'RI_FKey'::text) AND (proname < 'RI_FKez'::text)) -(6 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(7 rows) select proname from pg_proc where proname like E'RI\\_FKey%del' order by 1; proname @@ -180,7 +184,8 @@ select proname from pg_proc where proname ilike '00%foo' order by 1; Filter: (proname ~~* '00%foo'::text) -> Bitmap Index Scan on pg_proc_proname_args_nsp_index Index Cond: ((proname >= '00'::text) AND (proname < '01'::text)) -(6 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(7 rows) select proname from pg_proc where proname ilike '00%foo' order by 1; proname @@ -193,7 +198,8 @@ select proname from pg_proc where proname ilike 'ri%foo' order by 1; ----------------------------------------------------------------- Index Only Scan using pg_proc_proname_args_nsp_index on pg_proc Filter: (proname ~~* 'ri%foo'::text) -(2 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(3 rows) reset enable_seqscan; reset enable_indexscan; diff --git a/src/test/regress/expected/collate.out b/src/test/regress/expected/collate.out index 0dee7d783a..c3a390850b 100644 --- a/src/test/regress/expected/collate.out +++ b/src/test/regress/expected/collate.out @@ -626,7 +626,8 @@ EXPLAIN (COSTS OFF) Sort Sort Key: x COLLATE "C", y COLLATE "POSIX" -> Seq Scan on collate_test10 -(3 rows) + Settings: search_path = 'collate_tests' +(4 rows) EXPLAIN (COSTS OFF) SELECT * FROM collate_test10 ORDER BY x DESC, y COLLATE "C" ASC NULLS FIRST; @@ -635,7 +636,8 @@ EXPLAIN (COSTS OFF) Sort Sort Key: x COLLATE "C" DESC, y COLLATE "C" NULLS FIRST -> Seq Scan on collate_test10 -(3 rows) + Settings: search_path = 'collate_tests' +(4 rows) -- CREATE/DROP COLLATION CREATE COLLATION mycoll1 FROM "C"; diff --git a/src/test/regress/expected/create_am.out b/src/test/regress/expected/create_am.out index 352959b751..763ab8b2b6 100644 --- a/src/test/regress/expected/create_am.out +++ b/src/test/regress/expected/create_am.out @@ -54,7 +54,8 @@ SELECT * FROM fast_emp4000 Sort Key: ((home_base[0])[0]) -> Index Only Scan using grect2ind2 on fast_emp4000 Index Cond: (home_base @ '(2000,1000),(200,200)'::box) -(4 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(5 rows) SELECT * FROM fast_emp4000 WHERE home_base @ '(200,200),(2000,1000)'::box @@ -72,7 +73,8 @@ SELECT count(*) FROM fast_emp4000 WHERE home_base && '(1000,1000,0,0)'::box; Aggregate -> Index Only Scan using grect2ind2 on fast_emp4000 Index Cond: (home_base && '(1000,1000),(0,0)'::box) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM fast_emp4000 WHERE home_base && '(1000,1000,0,0)'::box; count @@ -82,12 +84,13 @@ SELECT count(*) FROM fast_emp4000 WHERE home_base && '(1000,1000,0,0)'::box; EXPLAIN (COSTS OFF) SELECT count(*) FROM fast_emp4000 WHERE home_base IS NULL; - QUERY PLAN --------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Aggregate -> Index Only Scan using grect2ind2 on fast_emp4000 Index Cond: (home_base IS NULL) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM fast_emp4000 WHERE home_base IS NULL; count diff --git a/src/test/regress/expected/create_function_3.out b/src/test/regress/expected/create_function_3.out index ba260df996..55832d399c 100644 --- a/src/test/regress/expected/create_function_3.out +++ b/src/test/regress/expected/create_function_3.out @@ -303,11 +303,12 @@ SELECT voidtest2(11,22); -- currently, we can inline voidtest2 but not voidtest1 EXPLAIN (verbose, costs off) SELECT voidtest2(11,22); - QUERY PLAN -------------------------- + QUERY PLAN +-------------------------------------------------- Result Output: voidtest1(33) -(2 rows) + Settings: search_path = 'temp_func_test, public' +(3 rows) CREATE TEMP TABLE sometable(f1 int); CREATE FUNCTION voidtest3(a int) RETURNS VOID LANGUAGE SQL AS diff --git a/src/test/regress/expected/create_index.out b/src/test/regress/expected/create_index.out index c8bc6be061..e853c4ff82 100644 --- a/src/test/regress/expected/create_index.out +++ b/src/test/regress/expected/create_index.out @@ -267,7 +267,8 @@ SELECT * FROM fast_emp4000 Sort Key: ((home_base[0])[0]) -> Index Only Scan using grect2ind on fast_emp4000 Index Cond: (home_base @ '(2000,1000),(200,200)'::box) -(4 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(5 rows) SELECT * FROM fast_emp4000 WHERE home_base @ '(200,200),(2000,1000)'::box @@ -285,7 +286,8 @@ SELECT count(*) FROM fast_emp4000 WHERE home_base && '(1000,1000,0,0)'::box; Aggregate -> Index Only Scan using grect2ind on fast_emp4000 Index Cond: (home_base && '(1000,1000),(0,0)'::box) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM fast_emp4000 WHERE home_base && '(1000,1000,0,0)'::box; count @@ -295,12 +297,13 @@ SELECT count(*) FROM fast_emp4000 WHERE home_base && '(1000,1000,0,0)'::box; EXPLAIN (COSTS OFF) SELECT count(*) FROM fast_emp4000 WHERE home_base IS NULL; - QUERY PLAN -------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Aggregate -> Index Only Scan using grect2ind on fast_emp4000 Index Cond: (home_base IS NULL) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM fast_emp4000 WHERE home_base IS NULL; count @@ -311,13 +314,14 @@ SELECT count(*) FROM fast_emp4000 WHERE home_base IS NULL; EXPLAIN (COSTS OFF) SELECT * FROM polygon_tbl WHERE f1 ~ '((1,1),(2,2),(2,1))'::polygon ORDER BY (poly_center(f1))[0]; - QUERY PLAN ------------------------------------------------------------ + QUERY PLAN +------------------------------------------------------------- Sort Sort Key: ((poly_center(f1))[0]) -> Index Scan using gpolygonind on polygon_tbl Index Cond: (f1 ~ '((1,1),(2,2),(2,1))'::polygon) -(4 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(5 rows) SELECT * FROM polygon_tbl WHERE f1 ~ '((1,1),(2,2),(2,1))'::polygon ORDER BY (poly_center(f1))[0]; @@ -329,13 +333,14 @@ SELECT * FROM polygon_tbl WHERE f1 ~ '((1,1),(2,2),(2,1))'::polygon EXPLAIN (COSTS OFF) SELECT * FROM circle_tbl WHERE f1 && circle(point(1,-2), 1) ORDER BY area(f1); - QUERY PLAN --------------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Sort Sort Key: (area(f1)) -> Index Scan using gcircleind on circle_tbl Index Cond: (f1 && '<(1,-2),1>'::circle) -(4 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(5 rows) SELECT * FROM circle_tbl WHERE f1 && circle(point(1,-2), 1) ORDER BY area(f1); @@ -349,12 +354,13 @@ SELECT * FROM circle_tbl WHERE f1 && circle(point(1,-2), 1) EXPLAIN (COSTS OFF) SELECT count(*) FROM gpolygon_tbl WHERE f1 && '(1000,1000,0,0)'::polygon; - QUERY PLAN ------------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Aggregate -> Index Scan using ggpolygonind on gpolygon_tbl Index Cond: (f1 && '((1000,1000),(0,0))'::polygon) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM gpolygon_tbl WHERE f1 && '(1000,1000,0,0)'::polygon; count @@ -364,12 +370,13 @@ SELECT count(*) FROM gpolygon_tbl WHERE f1 && '(1000,1000,0,0)'::polygon; EXPLAIN (COSTS OFF) SELECT count(*) FROM gcircle_tbl WHERE f1 && '<(500,500),500>'::circle; - QUERY PLAN -------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Aggregate -> Index Scan using ggcircleind on gcircle_tbl Index Cond: (f1 && '<(500,500),500>'::circle) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM gcircle_tbl WHERE f1 && '<(500,500),500>'::circle; count @@ -379,12 +386,13 @@ SELECT count(*) FROM gcircle_tbl WHERE f1 && '<(500,500),500>'::circle; EXPLAIN (COSTS OFF) SELECT count(*) FROM point_tbl WHERE f1 <@ box '(0,0,100,100)'; - QUERY PLAN ----------------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Aggregate -> Index Only Scan using gpointind on point_tbl Index Cond: (f1 <@ '(100,100),(0,0)'::box) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM point_tbl WHERE f1 <@ box '(0,0,100,100)'; count @@ -394,12 +402,13 @@ SELECT count(*) FROM point_tbl WHERE f1 <@ box '(0,0,100,100)'; EXPLAIN (COSTS OFF) SELECT count(*) FROM point_tbl WHERE box '(0,0,100,100)' @> f1; - QUERY PLAN ----------------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Aggregate -> Index Only Scan using gpointind on point_tbl Index Cond: (f1 <@ '(100,100),(0,0)'::box) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM point_tbl WHERE box '(0,0,100,100)' @> f1; count @@ -414,7 +423,8 @@ SELECT count(*) FROM point_tbl WHERE f1 <@ polygon '(0,0),(0,100),(100,100),(50, Aggregate -> Index Only Scan using gpointind on point_tbl Index Cond: (f1 <@ '((0,0),(0,100),(100,100),(50,50),(100,0),(0,0))'::polygon) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM point_tbl WHERE f1 <@ polygon '(0,0),(0,100),(100,100),(50,50),(100,0),(0,0)'; count @@ -424,12 +434,13 @@ SELECT count(*) FROM point_tbl WHERE f1 <@ polygon '(0,0),(0,100),(100,100),(50, EXPLAIN (COSTS OFF) SELECT count(*) FROM point_tbl WHERE f1 <@ circle '<(50,50),50>'; - QUERY PLAN ----------------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Aggregate -> Index Only Scan using gpointind on point_tbl Index Cond: (f1 <@ '<(50,50),50>'::circle) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM point_tbl WHERE f1 <@ circle '<(50,50),50>'; count @@ -439,12 +450,13 @@ SELECT count(*) FROM point_tbl WHERE f1 <@ circle '<(50,50),50>'; EXPLAIN (COSTS OFF) SELECT count(*) FROM point_tbl p WHERE p.f1 << '(0.0, 0.0)'; - QUERY PLAN ------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Aggregate -> Index Only Scan using gpointind on point_tbl p Index Cond: (f1 << '(0,0)'::point) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM point_tbl p WHERE p.f1 << '(0.0, 0.0)'; count @@ -454,12 +466,13 @@ SELECT count(*) FROM point_tbl p WHERE p.f1 << '(0.0, 0.0)'; EXPLAIN (COSTS OFF) SELECT count(*) FROM point_tbl p WHERE p.f1 >> '(0.0, 0.0)'; - QUERY PLAN ------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Aggregate -> Index Only Scan using gpointind on point_tbl p Index Cond: (f1 >> '(0,0)'::point) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM point_tbl p WHERE p.f1 >> '(0.0, 0.0)'; count @@ -469,12 +482,13 @@ SELECT count(*) FROM point_tbl p WHERE p.f1 >> '(0.0, 0.0)'; EXPLAIN (COSTS OFF) SELECT count(*) FROM point_tbl p WHERE p.f1 <^ '(0.0, 0.0)'; - QUERY PLAN ------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Aggregate -> Index Only Scan using gpointind on point_tbl p Index Cond: (f1 <^ '(0,0)'::point) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM point_tbl p WHERE p.f1 <^ '(0.0, 0.0)'; count @@ -484,12 +498,13 @@ SELECT count(*) FROM point_tbl p WHERE p.f1 <^ '(0.0, 0.0)'; EXPLAIN (COSTS OFF) SELECT count(*) FROM point_tbl p WHERE p.f1 >^ '(0.0, 0.0)'; - QUERY PLAN ------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Aggregate -> Index Only Scan using gpointind on point_tbl p Index Cond: (f1 >^ '(0,0)'::point) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM point_tbl p WHERE p.f1 >^ '(0.0, 0.0)'; count @@ -499,12 +514,13 @@ SELECT count(*) FROM point_tbl p WHERE p.f1 >^ '(0.0, 0.0)'; EXPLAIN (COSTS OFF) SELECT count(*) FROM point_tbl p WHERE p.f1 ~= '(-5, -12)'; - QUERY PLAN ------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Aggregate -> Index Only Scan using gpointind on point_tbl p Index Cond: (f1 ~= '(-5,-12)'::point) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM point_tbl p WHERE p.f1 ~= '(-5, -12)'; count @@ -514,11 +530,12 @@ SELECT count(*) FROM point_tbl p WHERE p.f1 ~= '(-5, -12)'; EXPLAIN (COSTS OFF) SELECT * FROM point_tbl ORDER BY f1 <-> '0,1'; - QUERY PLAN ----------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Index Only Scan using gpointind on point_tbl Order By: (f1 <-> '(0,1)'::point) -(2 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(3 rows) SELECT * FROM point_tbl ORDER BY f1 <-> '0,1'; f1 @@ -537,11 +554,12 @@ SELECT * FROM point_tbl ORDER BY f1 <-> '0,1'; EXPLAIN (COSTS OFF) SELECT * FROM point_tbl WHERE f1 IS NULL; - QUERY PLAN ----------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Index Only Scan using gpointind on point_tbl Index Cond: (f1 IS NULL) -(2 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(3 rows) SELECT * FROM point_tbl WHERE f1 IS NULL; f1 @@ -551,12 +569,13 @@ SELECT * FROM point_tbl WHERE f1 IS NULL; EXPLAIN (COSTS OFF) SELECT * FROM point_tbl WHERE f1 IS NOT NULL ORDER BY f1 <-> '0,1'; - QUERY PLAN ----------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Index Only Scan using gpointind on point_tbl Index Cond: (f1 IS NOT NULL) Order By: (f1 <-> '(0,1)'::point) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT * FROM point_tbl WHERE f1 IS NOT NULL ORDER BY f1 <-> '0,1'; f1 @@ -574,12 +593,13 @@ SELECT * FROM point_tbl WHERE f1 IS NOT NULL ORDER BY f1 <-> '0,1'; EXPLAIN (COSTS OFF) SELECT * FROM point_tbl WHERE f1 <@ '(-10,-10),(10,10)':: box ORDER BY f1 <-> '0,1'; - QUERY PLAN ------------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Index Only Scan using gpointind on point_tbl Index Cond: (f1 <@ '(10,10),(-10,-10)'::box) Order By: (f1 <-> '(0,1)'::point) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT * FROM point_tbl WHERE f1 <@ '(-10,-10),(10,10)':: box ORDER BY f1 <-> '0,1'; f1 @@ -593,12 +613,13 @@ SELECT * FROM point_tbl WHERE f1 <@ '(-10,-10),(10,10)':: box ORDER BY f1 <-> '0 EXPLAIN (COSTS OFF) SELECT * FROM gpolygon_tbl ORDER BY f1 <-> '(0,0)'::point LIMIT 10; - QUERY PLAN ------------------------------------------------------ + QUERY PLAN +------------------------------------------------------------- Limit -> Index Scan using ggpolygonind on gpolygon_tbl Order By: (f1 <-> '(0,0)'::point) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT * FROM gpolygon_tbl ORDER BY f1 <-> '(0,0)'::point LIMIT 10; f1 @@ -617,12 +638,13 @@ SELECT * FROM gpolygon_tbl ORDER BY f1 <-> '(0,0)'::point LIMIT 10; EXPLAIN (COSTS OFF) SELECT circle_center(f1), round(radius(f1)) as radius FROM gcircle_tbl ORDER BY f1 <-> '(200,300)'::point LIMIT 10; - QUERY PLAN ---------------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Limit -> Index Scan using ggcircleind on gcircle_tbl Order By: (f1 <-> '(200,300)'::point) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT circle_center(f1), round(radius(f1)) as radius FROM gcircle_tbl ORDER BY f1 <-> '(200,300)'::point LIMIT 10; circle_center | radius @@ -653,7 +675,8 @@ SELECT * FROM point_tbl WHERE f1 <@ '(-10,-10),(10,10)':: box ORDER BY f1 <-> '0 Recheck Cond: (f1 <@ '(10,10),(-10,-10)'::box) -> Bitmap Index Scan on gpointind Index Cond: (f1 <@ '(10,10),(-10,-10)'::box) -(6 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(7 rows) SELECT * FROM point_tbl WHERE f1 <@ '(-10,-10),(10,10)':: box ORDER BY f1 <-> '0,1'; f1 @@ -679,15 +702,16 @@ SET enable_bitmapscan = ON; CREATE INDEX intarrayidx ON array_index_op_test USING gin (i); explain (costs off) SELECT * FROM array_index_op_test WHERE i @> '{32}' ORDER BY seqno; - QUERY PLAN ----------------------------------------------------- + QUERY PLAN +------------------------------------------------------------ Sort Sort Key: seqno -> Bitmap Heap Scan on array_index_op_test Recheck Cond: (i @> '{32}'::integer[]) -> Bitmap Index Scan on intarrayidx Index Cond: (i @> '{32}'::integer[]) -(6 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(7 rows) SELECT * FROM array_index_op_test WHERE i @> '{32}' ORDER BY seqno; seqno | i | t @@ -933,7 +957,8 @@ SELECT * FROM array_index_op_test WHERE t @> '{AAAAAAAA72908}' ORDER BY seqno; Recheck Cond: (t @> '{AAAAAAAA72908}'::text[]) -> Bitmap Index Scan on textarrayidx Index Cond: (t @> '{AAAAAAAA72908}'::text[]) -(6 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(7 rows) SELECT * FROM array_index_op_test WHERE t @> '{AAAAAAAA72908}' ORDER BY seqno; seqno | i | t @@ -1849,7 +1874,8 @@ ORDER BY thousand; Sort Key: thousand -> Index Scan using tenk1_thous_tenthous on tenk1 Index Cond: ((thousand < 2) AND (tenthous = ANY ('{1001,3000}'::integer[]))) -(4 rows) + Settings: enable_indexonlyscan = 'off' +(5 rows) SELECT thousand, tenthous FROM tenk1 WHERE thousand < 2 AND tenthous IN (1001,3000) diff --git a/src/test/regress/expected/create_index_spgist.out b/src/test/regress/expected/create_index_spgist.out index 81b4a67c39..21246bcc42 100644 --- a/src/test/regress/expected/create_index_spgist.out +++ b/src/test/regress/expected/create_index_spgist.out @@ -179,12 +179,13 @@ SET enable_indexscan = ON; SET enable_bitmapscan = OFF; EXPLAIN (COSTS OFF) SELECT count(*) FROM quad_point_tbl WHERE p IS NULL; - QUERY PLAN ------------------------------------------------------------ + QUERY PLAN +------------------------------------------------------------- Aggregate -> Index Only Scan using sp_quad_ind on quad_point_tbl Index Cond: (p IS NULL) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM quad_point_tbl WHERE p IS NULL; count @@ -194,12 +195,13 @@ SELECT count(*) FROM quad_point_tbl WHERE p IS NULL; EXPLAIN (COSTS OFF) SELECT count(*) FROM quad_point_tbl WHERE p IS NOT NULL; - QUERY PLAN ------------------------------------------------------------ + QUERY PLAN +------------------------------------------------------------- Aggregate -> Index Only Scan using sp_quad_ind on quad_point_tbl Index Cond: (p IS NOT NULL) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM quad_point_tbl WHERE p IS NOT NULL; count @@ -209,11 +211,12 @@ SELECT count(*) FROM quad_point_tbl WHERE p IS NOT NULL; EXPLAIN (COSTS OFF) SELECT count(*) FROM quad_point_tbl; - QUERY PLAN ------------------------------------------------------------ + QUERY PLAN +------------------------------------------------------------- Aggregate -> Index Only Scan using sp_quad_ind on quad_point_tbl -(2 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(3 rows) SELECT count(*) FROM quad_point_tbl; count @@ -223,12 +226,13 @@ SELECT count(*) FROM quad_point_tbl; EXPLAIN (COSTS OFF) SELECT count(*) FROM quad_point_tbl WHERE p <@ box '(200,200,1000,1000)'; - QUERY PLAN ------------------------------------------------------------ + QUERY PLAN +------------------------------------------------------------- Aggregate -> Index Only Scan using sp_quad_ind on quad_point_tbl Index Cond: (p <@ '(1000,1000),(200,200)'::box) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM quad_point_tbl WHERE p <@ box '(200,200,1000,1000)'; count @@ -238,12 +242,13 @@ SELECT count(*) FROM quad_point_tbl WHERE p <@ box '(200,200,1000,1000)'; EXPLAIN (COSTS OFF) SELECT count(*) FROM quad_point_tbl WHERE box '(200,200,1000,1000)' @> p; - QUERY PLAN ------------------------------------------------------------ + QUERY PLAN +------------------------------------------------------------- Aggregate -> Index Only Scan using sp_quad_ind on quad_point_tbl Index Cond: (p <@ '(1000,1000),(200,200)'::box) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM quad_point_tbl WHERE box '(200,200,1000,1000)' @> p; count @@ -253,12 +258,13 @@ SELECT count(*) FROM quad_point_tbl WHERE box '(200,200,1000,1000)' @> p; EXPLAIN (COSTS OFF) SELECT count(*) FROM quad_point_tbl WHERE p << '(5000, 4000)'; - QUERY PLAN ------------------------------------------------------------ + QUERY PLAN +------------------------------------------------------------- Aggregate -> Index Only Scan using sp_quad_ind on quad_point_tbl Index Cond: (p << '(5000,4000)'::point) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM quad_point_tbl WHERE p << '(5000, 4000)'; count @@ -268,12 +274,13 @@ SELECT count(*) FROM quad_point_tbl WHERE p << '(5000, 4000)'; EXPLAIN (COSTS OFF) SELECT count(*) FROM quad_point_tbl WHERE p >> '(5000, 4000)'; - QUERY PLAN ------------------------------------------------------------ + QUERY PLAN +------------------------------------------------------------- Aggregate -> Index Only Scan using sp_quad_ind on quad_point_tbl Index Cond: (p >> '(5000,4000)'::point) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM quad_point_tbl WHERE p >> '(5000, 4000)'; count @@ -283,12 +290,13 @@ SELECT count(*) FROM quad_point_tbl WHERE p >> '(5000, 4000)'; EXPLAIN (COSTS OFF) SELECT count(*) FROM quad_point_tbl WHERE p <^ '(5000, 4000)'; - QUERY PLAN ------------------------------------------------------------ + QUERY PLAN +------------------------------------------------------------- Aggregate -> Index Only Scan using sp_quad_ind on quad_point_tbl Index Cond: (p <^ '(5000,4000)'::point) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM quad_point_tbl WHERE p <^ '(5000, 4000)'; count @@ -298,12 +306,13 @@ SELECT count(*) FROM quad_point_tbl WHERE p <^ '(5000, 4000)'; EXPLAIN (COSTS OFF) SELECT count(*) FROM quad_point_tbl WHERE p >^ '(5000, 4000)'; - QUERY PLAN ------------------------------------------------------------ + QUERY PLAN +------------------------------------------------------------- Aggregate -> Index Only Scan using sp_quad_ind on quad_point_tbl Index Cond: (p >^ '(5000,4000)'::point) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM quad_point_tbl WHERE p >^ '(5000, 4000)'; count @@ -313,12 +322,13 @@ SELECT count(*) FROM quad_point_tbl WHERE p >^ '(5000, 4000)'; EXPLAIN (COSTS OFF) SELECT count(*) FROM quad_point_tbl WHERE p ~= '(4585, 365)'; - QUERY PLAN ------------------------------------------------------------ + QUERY PLAN +------------------------------------------------------------- Aggregate -> Index Only Scan using sp_quad_ind on quad_point_tbl Index Cond: (p ~= '(4585,365)'::point) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM quad_point_tbl WHERE p ~= '(4585, 365)'; count @@ -329,12 +339,13 @@ SELECT count(*) FROM quad_point_tbl WHERE p ~= '(4585, 365)'; EXPLAIN (COSTS OFF) SELECT row_number() OVER (ORDER BY p <-> '0,0') n, p <-> '0,0' dist, p FROM quad_point_tbl; - QUERY PLAN ------------------------------------------------------------ + QUERY PLAN +------------------------------------------------------------- WindowAgg -> Index Only Scan using sp_quad_ind on quad_point_tbl Order By: (p <-> '(0,0)'::point) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) CREATE TEMP TABLE quad_point_tbl_ord_idx1 AS SELECT row_number() OVER (ORDER BY p <-> '0,0') n, p <-> '0,0' dist, p @@ -349,13 +360,14 @@ WHERE seq.dist IS DISTINCT FROM idx.dist; EXPLAIN (COSTS OFF) SELECT row_number() OVER (ORDER BY p <-> '0,0') n, p <-> '0,0' dist, p FROM quad_point_tbl WHERE p <@ box '(200,200,1000,1000)'; - QUERY PLAN ------------------------------------------------------------ + QUERY PLAN +------------------------------------------------------------- WindowAgg -> Index Only Scan using sp_quad_ind on quad_point_tbl Index Cond: (p <@ '(1000,1000),(200,200)'::box) Order By: (p <-> '(0,0)'::point) -(4 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(5 rows) CREATE TEMP TABLE quad_point_tbl_ord_idx2 AS SELECT row_number() OVER (ORDER BY p <-> '0,0') n, p <-> '0,0' dist, p @@ -370,13 +382,14 @@ WHERE seq.dist IS DISTINCT FROM idx.dist; EXPLAIN (COSTS OFF) SELECT row_number() OVER (ORDER BY p <-> '333,400') n, p <-> '333,400' dist, p FROM quad_point_tbl WHERE p IS NOT NULL; - QUERY PLAN ------------------------------------------------------------ + QUERY PLAN +------------------------------------------------------------- WindowAgg -> Index Only Scan using sp_quad_ind on quad_point_tbl Index Cond: (p IS NOT NULL) Order By: (p <-> '(333,400)'::point) -(4 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(5 rows) CREATE TEMP TABLE quad_point_tbl_ord_idx3 AS SELECT row_number() OVER (ORDER BY p <-> '333,400') n, p <-> '333,400' dist, p @@ -390,12 +403,13 @@ WHERE seq.dist IS DISTINCT FROM idx.dist; EXPLAIN (COSTS OFF) SELECT count(*) FROM kd_point_tbl WHERE p <@ box '(200,200,1000,1000)'; - QUERY PLAN ---------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Aggregate -> Index Only Scan using sp_kd_ind on kd_point_tbl Index Cond: (p <@ '(1000,1000),(200,200)'::box) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM kd_point_tbl WHERE p <@ box '(200,200,1000,1000)'; count @@ -405,12 +419,13 @@ SELECT count(*) FROM kd_point_tbl WHERE p <@ box '(200,200,1000,1000)'; EXPLAIN (COSTS OFF) SELECT count(*) FROM kd_point_tbl WHERE box '(200,200,1000,1000)' @> p; - QUERY PLAN ---------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Aggregate -> Index Only Scan using sp_kd_ind on kd_point_tbl Index Cond: (p <@ '(1000,1000),(200,200)'::box) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM kd_point_tbl WHERE box '(200,200,1000,1000)' @> p; count @@ -420,12 +435,13 @@ SELECT count(*) FROM kd_point_tbl WHERE box '(200,200,1000,1000)' @> p; EXPLAIN (COSTS OFF) SELECT count(*) FROM kd_point_tbl WHERE p << '(5000, 4000)'; - QUERY PLAN -------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Aggregate -> Index Only Scan using sp_kd_ind on kd_point_tbl Index Cond: (p << '(5000,4000)'::point) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM kd_point_tbl WHERE p << '(5000, 4000)'; count @@ -435,12 +451,13 @@ SELECT count(*) FROM kd_point_tbl WHERE p << '(5000, 4000)'; EXPLAIN (COSTS OFF) SELECT count(*) FROM kd_point_tbl WHERE p >> '(5000, 4000)'; - QUERY PLAN -------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Aggregate -> Index Only Scan using sp_kd_ind on kd_point_tbl Index Cond: (p >> '(5000,4000)'::point) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM kd_point_tbl WHERE p >> '(5000, 4000)'; count @@ -450,12 +467,13 @@ SELECT count(*) FROM kd_point_tbl WHERE p >> '(5000, 4000)'; EXPLAIN (COSTS OFF) SELECT count(*) FROM kd_point_tbl WHERE p <^ '(5000, 4000)'; - QUERY PLAN -------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Aggregate -> Index Only Scan using sp_kd_ind on kd_point_tbl Index Cond: (p <^ '(5000,4000)'::point) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM kd_point_tbl WHERE p <^ '(5000, 4000)'; count @@ -465,12 +483,13 @@ SELECT count(*) FROM kd_point_tbl WHERE p <^ '(5000, 4000)'; EXPLAIN (COSTS OFF) SELECT count(*) FROM kd_point_tbl WHERE p >^ '(5000, 4000)'; - QUERY PLAN -------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Aggregate -> Index Only Scan using sp_kd_ind on kd_point_tbl Index Cond: (p >^ '(5000,4000)'::point) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM kd_point_tbl WHERE p >^ '(5000, 4000)'; count @@ -480,12 +499,13 @@ SELECT count(*) FROM kd_point_tbl WHERE p >^ '(5000, 4000)'; EXPLAIN (COSTS OFF) SELECT count(*) FROM kd_point_tbl WHERE p ~= '(4585, 365)'; - QUERY PLAN -------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Aggregate -> Index Only Scan using sp_kd_ind on kd_point_tbl Index Cond: (p ~= '(4585,365)'::point) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM kd_point_tbl WHERE p ~= '(4585, 365)'; count @@ -496,12 +516,13 @@ SELECT count(*) FROM kd_point_tbl WHERE p ~= '(4585, 365)'; EXPLAIN (COSTS OFF) SELECT row_number() OVER (ORDER BY p <-> '0,0') n, p <-> '0,0' dist, p FROM kd_point_tbl; - QUERY PLAN -------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------- WindowAgg -> Index Only Scan using sp_kd_ind on kd_point_tbl Order By: (p <-> '(0,0)'::point) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) CREATE TEMP TABLE kd_point_tbl_ord_idx1 AS SELECT row_number() OVER (ORDER BY p <-> '0,0') n, p <-> '0,0' dist, p @@ -516,13 +537,14 @@ WHERE seq.dist IS DISTINCT FROM idx.dist; EXPLAIN (COSTS OFF) SELECT row_number() OVER (ORDER BY p <-> '0,0') n, p <-> '0,0' dist, p FROM kd_point_tbl WHERE p <@ box '(200,200,1000,1000)'; - QUERY PLAN ---------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------- WindowAgg -> Index Only Scan using sp_kd_ind on kd_point_tbl Index Cond: (p <@ '(1000,1000),(200,200)'::box) Order By: (p <-> '(0,0)'::point) -(4 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(5 rows) CREATE TEMP TABLE kd_point_tbl_ord_idx2 AS SELECT row_number() OVER (ORDER BY p <-> '0,0') n, p <-> '0,0' dist, p @@ -537,13 +559,14 @@ WHERE seq.dist IS DISTINCT FROM idx.dist; EXPLAIN (COSTS OFF) SELECT row_number() OVER (ORDER BY p <-> '333,400') n, p <-> '333,400' dist, p FROM kd_point_tbl WHERE p IS NOT NULL; - QUERY PLAN -------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------- WindowAgg -> Index Only Scan using sp_kd_ind on kd_point_tbl Index Cond: (p IS NOT NULL) Order By: (p <-> '(333,400)'::point) -(4 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(5 rows) CREATE TEMP TABLE kd_point_tbl_ord_idx3 AS SELECT row_number() OVER (ORDER BY p <-> '333,400') n, p <-> '333,400' dist, p @@ -557,12 +580,13 @@ WHERE seq.dist IS DISTINCT FROM idx.dist; EXPLAIN (COSTS OFF) SELECT count(*) FROM radix_text_tbl WHERE t = 'P0123456789abcdef'; - QUERY PLAN ------------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Aggregate -> Index Only Scan using sp_radix_ind on radix_text_tbl Index Cond: (t = 'P0123456789abcdef'::text) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM radix_text_tbl WHERE t = 'P0123456789abcdef'; count @@ -572,12 +596,13 @@ SELECT count(*) FROM radix_text_tbl WHERE t = 'P0123456789abcdef'; EXPLAIN (COSTS OFF) SELECT count(*) FROM radix_text_tbl WHERE t = 'P0123456789abcde'; - QUERY PLAN ------------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Aggregate -> Index Only Scan using sp_radix_ind on radix_text_tbl Index Cond: (t = 'P0123456789abcde'::text) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM radix_text_tbl WHERE t = 'P0123456789abcde'; count @@ -587,12 +612,13 @@ SELECT count(*) FROM radix_text_tbl WHERE t = 'P0123456789abcde'; EXPLAIN (COSTS OFF) SELECT count(*) FROM radix_text_tbl WHERE t = 'P0123456789abcdefF'; - QUERY PLAN ------------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Aggregate -> Index Only Scan using sp_radix_ind on radix_text_tbl Index Cond: (t = 'P0123456789abcdefF'::text) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM radix_text_tbl WHERE t = 'P0123456789abcdefF'; count @@ -607,7 +633,8 @@ SELECT count(*) FROM radix_text_tbl WHERE t < 'Aztec Aggregate -> Index Only Scan using sp_radix_ind on radix_text_tbl Index Cond: (t < 'Aztec Ct '::text) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM radix_text_tbl WHERE t < 'Aztec Ct '; count @@ -622,7 +649,8 @@ SELECT count(*) FROM radix_text_tbl WHERE t ~<~ 'Aztec Aggregate -> Index Only Scan using sp_radix_ind on radix_text_tbl Index Cond: (t ~<~ 'Aztec Ct '::text) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM radix_text_tbl WHERE t ~<~ 'Aztec Ct '; count @@ -637,7 +665,8 @@ SELECT count(*) FROM radix_text_tbl WHERE t <= 'Aztec Aggregate -> Index Only Scan using sp_radix_ind on radix_text_tbl Index Cond: (t <= 'Aztec Ct '::text) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM radix_text_tbl WHERE t <= 'Aztec Ct '; count @@ -652,7 +681,8 @@ SELECT count(*) FROM radix_text_tbl WHERE t ~<=~ 'Aztec Aggregate -> Index Only Scan using sp_radix_ind on radix_text_tbl Index Cond: (t ~<=~ 'Aztec Ct '::text) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM radix_text_tbl WHERE t ~<=~ 'Aztec Ct '; count @@ -667,7 +697,8 @@ SELECT count(*) FROM radix_text_tbl WHERE t = 'Aztec Aggregate -> Index Only Scan using sp_radix_ind on radix_text_tbl Index Cond: (t = 'Aztec Ct '::text) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM radix_text_tbl WHERE t = 'Aztec Ct '; count @@ -682,7 +713,8 @@ SELECT count(*) FROM radix_text_tbl WHERE t = 'Worth Aggregate -> Index Only Scan using sp_radix_ind on radix_text_tbl Index Cond: (t = 'Worth St '::text) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM radix_text_tbl WHERE t = 'Worth St '; count @@ -697,7 +729,8 @@ SELECT count(*) FROM radix_text_tbl WHERE t >= 'Worth Aggregate -> Index Only Scan using sp_radix_ind on radix_text_tbl Index Cond: (t >= 'Worth St '::text) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM radix_text_tbl WHERE t >= 'Worth St '; count @@ -712,7 +745,8 @@ SELECT count(*) FROM radix_text_tbl WHERE t ~>=~ 'Worth Aggregate -> Index Only Scan using sp_radix_ind on radix_text_tbl Index Cond: (t ~>=~ 'Worth St '::text) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM radix_text_tbl WHERE t ~>=~ 'Worth St '; count @@ -727,7 +761,8 @@ SELECT count(*) FROM radix_text_tbl WHERE t > 'Worth Aggregate -> Index Only Scan using sp_radix_ind on radix_text_tbl Index Cond: (t > 'Worth St '::text) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM radix_text_tbl WHERE t > 'Worth St '; count @@ -742,7 +777,8 @@ SELECT count(*) FROM radix_text_tbl WHERE t ~>~ 'Worth Aggregate -> Index Only Scan using sp_radix_ind on radix_text_tbl Index Cond: (t ~>~ 'Worth St '::text) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM radix_text_tbl WHERE t ~>~ 'Worth St '; count @@ -752,12 +788,13 @@ SELECT count(*) FROM radix_text_tbl WHERE t ~>~ 'Worth EXPLAIN (COSTS OFF) SELECT count(*) FROM radix_text_tbl WHERE t ^@ 'Worth'; - QUERY PLAN ------------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Aggregate -> Index Only Scan using sp_radix_ind on radix_text_tbl Index Cond: (t ^@ 'Worth'::text) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM radix_text_tbl WHERE t ^@ 'Worth'; count @@ -771,14 +808,15 @@ SET enable_indexscan = OFF; SET enable_bitmapscan = ON; EXPLAIN (COSTS OFF) SELECT count(*) FROM quad_point_tbl WHERE p IS NULL; - QUERY PLAN ----------------------------------------------- + QUERY PLAN +------------------------------------------------------------ Aggregate -> Bitmap Heap Scan on quad_point_tbl Recheck Cond: (p IS NULL) -> Bitmap Index Scan on sp_quad_ind Index Cond: (p IS NULL) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM quad_point_tbl WHERE p IS NULL; count @@ -788,14 +826,15 @@ SELECT count(*) FROM quad_point_tbl WHERE p IS NULL; EXPLAIN (COSTS OFF) SELECT count(*) FROM quad_point_tbl WHERE p IS NOT NULL; - QUERY PLAN ----------------------------------------------- + QUERY PLAN +------------------------------------------------------------ Aggregate -> Bitmap Heap Scan on quad_point_tbl Recheck Cond: (p IS NOT NULL) -> Bitmap Index Scan on sp_quad_ind Index Cond: (p IS NOT NULL) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM quad_point_tbl WHERE p IS NOT NULL; count @@ -805,12 +844,13 @@ SELECT count(*) FROM quad_point_tbl WHERE p IS NOT NULL; EXPLAIN (COSTS OFF) SELECT count(*) FROM quad_point_tbl; - QUERY PLAN ----------------------------------------------- + QUERY PLAN +------------------------------------------------------------ Aggregate -> Bitmap Heap Scan on quad_point_tbl -> Bitmap Index Scan on sp_quad_ind -(3 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM quad_point_tbl; count @@ -827,7 +867,8 @@ SELECT count(*) FROM quad_point_tbl WHERE p <@ box '(200,200,1000,1000)'; Recheck Cond: (p <@ '(1000,1000),(200,200)'::box) -> Bitmap Index Scan on sp_quad_ind Index Cond: (p <@ '(1000,1000),(200,200)'::box) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM quad_point_tbl WHERE p <@ box '(200,200,1000,1000)'; count @@ -844,7 +885,8 @@ SELECT count(*) FROM quad_point_tbl WHERE box '(200,200,1000,1000)' @> p; Recheck Cond: ('(1000,1000),(200,200)'::box @> p) -> Bitmap Index Scan on sp_quad_ind Index Cond: (p <@ '(1000,1000),(200,200)'::box) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM quad_point_tbl WHERE box '(200,200,1000,1000)' @> p; count @@ -854,14 +896,15 @@ SELECT count(*) FROM quad_point_tbl WHERE box '(200,200,1000,1000)' @> p; EXPLAIN (COSTS OFF) SELECT count(*) FROM quad_point_tbl WHERE p << '(5000, 4000)'; - QUERY PLAN -------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------ Aggregate -> Bitmap Heap Scan on quad_point_tbl Recheck Cond: (p << '(5000,4000)'::point) -> Bitmap Index Scan on sp_quad_ind Index Cond: (p << '(5000,4000)'::point) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM quad_point_tbl WHERE p << '(5000, 4000)'; count @@ -871,14 +914,15 @@ SELECT count(*) FROM quad_point_tbl WHERE p << '(5000, 4000)'; EXPLAIN (COSTS OFF) SELECT count(*) FROM quad_point_tbl WHERE p >> '(5000, 4000)'; - QUERY PLAN -------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------ Aggregate -> Bitmap Heap Scan on quad_point_tbl Recheck Cond: (p >> '(5000,4000)'::point) -> Bitmap Index Scan on sp_quad_ind Index Cond: (p >> '(5000,4000)'::point) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM quad_point_tbl WHERE p >> '(5000, 4000)'; count @@ -888,14 +932,15 @@ SELECT count(*) FROM quad_point_tbl WHERE p >> '(5000, 4000)'; EXPLAIN (COSTS OFF) SELECT count(*) FROM quad_point_tbl WHERE p <^ '(5000, 4000)'; - QUERY PLAN -------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------ Aggregate -> Bitmap Heap Scan on quad_point_tbl Recheck Cond: (p <^ '(5000,4000)'::point) -> Bitmap Index Scan on sp_quad_ind Index Cond: (p <^ '(5000,4000)'::point) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM quad_point_tbl WHERE p <^ '(5000, 4000)'; count @@ -905,14 +950,15 @@ SELECT count(*) FROM quad_point_tbl WHERE p <^ '(5000, 4000)'; EXPLAIN (COSTS OFF) SELECT count(*) FROM quad_point_tbl WHERE p >^ '(5000, 4000)'; - QUERY PLAN -------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------ Aggregate -> Bitmap Heap Scan on quad_point_tbl Recheck Cond: (p >^ '(5000,4000)'::point) -> Bitmap Index Scan on sp_quad_ind Index Cond: (p >^ '(5000,4000)'::point) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM quad_point_tbl WHERE p >^ '(5000, 4000)'; count @@ -922,14 +968,15 @@ SELECT count(*) FROM quad_point_tbl WHERE p >^ '(5000, 4000)'; EXPLAIN (COSTS OFF) SELECT count(*) FROM quad_point_tbl WHERE p ~= '(4585, 365)'; - QUERY PLAN ------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------ Aggregate -> Bitmap Heap Scan on quad_point_tbl Recheck Cond: (p ~= '(4585,365)'::point) -> Bitmap Index Scan on sp_quad_ind Index Cond: (p ~= '(4585,365)'::point) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM quad_point_tbl WHERE p ~= '(4585, 365)'; count @@ -946,7 +993,8 @@ SELECT count(*) FROM kd_point_tbl WHERE p <@ box '(200,200,1000,1000)'; Recheck Cond: (p <@ '(1000,1000),(200,200)'::box) -> Bitmap Index Scan on sp_kd_ind Index Cond: (p <@ '(1000,1000),(200,200)'::box) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM kd_point_tbl WHERE p <@ box '(200,200,1000,1000)'; count @@ -963,7 +1011,8 @@ SELECT count(*) FROM kd_point_tbl WHERE box '(200,200,1000,1000)' @> p; Recheck Cond: ('(1000,1000),(200,200)'::box @> p) -> Bitmap Index Scan on sp_kd_ind Index Cond: (p <@ '(1000,1000),(200,200)'::box) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM kd_point_tbl WHERE box '(200,200,1000,1000)' @> p; count @@ -973,14 +1022,15 @@ SELECT count(*) FROM kd_point_tbl WHERE box '(200,200,1000,1000)' @> p; EXPLAIN (COSTS OFF) SELECT count(*) FROM kd_point_tbl WHERE p << '(5000, 4000)'; - QUERY PLAN -------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------ Aggregate -> Bitmap Heap Scan on kd_point_tbl Recheck Cond: (p << '(5000,4000)'::point) -> Bitmap Index Scan on sp_kd_ind Index Cond: (p << '(5000,4000)'::point) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM kd_point_tbl WHERE p << '(5000, 4000)'; count @@ -990,14 +1040,15 @@ SELECT count(*) FROM kd_point_tbl WHERE p << '(5000, 4000)'; EXPLAIN (COSTS OFF) SELECT count(*) FROM kd_point_tbl WHERE p >> '(5000, 4000)'; - QUERY PLAN -------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------ Aggregate -> Bitmap Heap Scan on kd_point_tbl Recheck Cond: (p >> '(5000,4000)'::point) -> Bitmap Index Scan on sp_kd_ind Index Cond: (p >> '(5000,4000)'::point) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM kd_point_tbl WHERE p >> '(5000, 4000)'; count @@ -1007,14 +1058,15 @@ SELECT count(*) FROM kd_point_tbl WHERE p >> '(5000, 4000)'; EXPLAIN (COSTS OFF) SELECT count(*) FROM kd_point_tbl WHERE p <^ '(5000, 4000)'; - QUERY PLAN -------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------ Aggregate -> Bitmap Heap Scan on kd_point_tbl Recheck Cond: (p <^ '(5000,4000)'::point) -> Bitmap Index Scan on sp_kd_ind Index Cond: (p <^ '(5000,4000)'::point) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM kd_point_tbl WHERE p <^ '(5000, 4000)'; count @@ -1024,14 +1076,15 @@ SELECT count(*) FROM kd_point_tbl WHERE p <^ '(5000, 4000)'; EXPLAIN (COSTS OFF) SELECT count(*) FROM kd_point_tbl WHERE p >^ '(5000, 4000)'; - QUERY PLAN -------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------ Aggregate -> Bitmap Heap Scan on kd_point_tbl Recheck Cond: (p >^ '(5000,4000)'::point) -> Bitmap Index Scan on sp_kd_ind Index Cond: (p >^ '(5000,4000)'::point) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM kd_point_tbl WHERE p >^ '(5000, 4000)'; count @@ -1041,14 +1094,15 @@ SELECT count(*) FROM kd_point_tbl WHERE p >^ '(5000, 4000)'; EXPLAIN (COSTS OFF) SELECT count(*) FROM kd_point_tbl WHERE p ~= '(4585, 365)'; - QUERY PLAN ------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------ Aggregate -> Bitmap Heap Scan on kd_point_tbl Recheck Cond: (p ~= '(4585,365)'::point) -> Bitmap Index Scan on sp_kd_ind Index Cond: (p ~= '(4585,365)'::point) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM kd_point_tbl WHERE p ~= '(4585, 365)'; count @@ -1058,14 +1112,15 @@ SELECT count(*) FROM kd_point_tbl WHERE p ~= '(4585, 365)'; EXPLAIN (COSTS OFF) SELECT count(*) FROM radix_text_tbl WHERE t = 'P0123456789abcdef'; - QUERY PLAN ------------------------------------------------------------ + QUERY PLAN +------------------------------------------------------------ Aggregate -> Bitmap Heap Scan on radix_text_tbl Recheck Cond: (t = 'P0123456789abcdef'::text) -> Bitmap Index Scan on sp_radix_ind Index Cond: (t = 'P0123456789abcdef'::text) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM radix_text_tbl WHERE t = 'P0123456789abcdef'; count @@ -1075,14 +1130,15 @@ SELECT count(*) FROM radix_text_tbl WHERE t = 'P0123456789abcdef'; EXPLAIN (COSTS OFF) SELECT count(*) FROM radix_text_tbl WHERE t = 'P0123456789abcde'; - QUERY PLAN ----------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------ Aggregate -> Bitmap Heap Scan on radix_text_tbl Recheck Cond: (t = 'P0123456789abcde'::text) -> Bitmap Index Scan on sp_radix_ind Index Cond: (t = 'P0123456789abcde'::text) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM radix_text_tbl WHERE t = 'P0123456789abcde'; count @@ -1099,7 +1155,8 @@ SELECT count(*) FROM radix_text_tbl WHERE t = 'P0123456789abcdefF'; Recheck Cond: (t = 'P0123456789abcdefF'::text) -> Bitmap Index Scan on sp_radix_ind Index Cond: (t = 'P0123456789abcdefF'::text) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM radix_text_tbl WHERE t = 'P0123456789abcdefF'; count @@ -1116,7 +1173,8 @@ SELECT count(*) FROM radix_text_tbl WHERE t < 'Aztec Recheck Cond: (t < 'Aztec Ct '::text) -> Bitmap Index Scan on sp_radix_ind Index Cond: (t < 'Aztec Ct '::text) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM radix_text_tbl WHERE t < 'Aztec Ct '; count @@ -1133,7 +1191,8 @@ SELECT count(*) FROM radix_text_tbl WHERE t ~<~ 'Aztec Recheck Cond: (t ~<~ 'Aztec Ct '::text) -> Bitmap Index Scan on sp_radix_ind Index Cond: (t ~<~ 'Aztec Ct '::text) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM radix_text_tbl WHERE t ~<~ 'Aztec Ct '; count @@ -1150,7 +1209,8 @@ SELECT count(*) FROM radix_text_tbl WHERE t <= 'Aztec Recheck Cond: (t <= 'Aztec Ct '::text) -> Bitmap Index Scan on sp_radix_ind Index Cond: (t <= 'Aztec Ct '::text) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM radix_text_tbl WHERE t <= 'Aztec Ct '; count @@ -1167,7 +1227,8 @@ SELECT count(*) FROM radix_text_tbl WHERE t ~<=~ 'Aztec Recheck Cond: (t ~<=~ 'Aztec Ct '::text) -> Bitmap Index Scan on sp_radix_ind Index Cond: (t ~<=~ 'Aztec Ct '::text) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM radix_text_tbl WHERE t ~<=~ 'Aztec Ct '; count @@ -1184,7 +1245,8 @@ SELECT count(*) FROM radix_text_tbl WHERE t = 'Aztec Recheck Cond: (t = 'Aztec Ct '::text) -> Bitmap Index Scan on sp_radix_ind Index Cond: (t = 'Aztec Ct '::text) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM radix_text_tbl WHERE t = 'Aztec Ct '; count @@ -1201,7 +1263,8 @@ SELECT count(*) FROM radix_text_tbl WHERE t = 'Worth Recheck Cond: (t = 'Worth St '::text) -> Bitmap Index Scan on sp_radix_ind Index Cond: (t = 'Worth St '::text) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM radix_text_tbl WHERE t = 'Worth St '; count @@ -1218,7 +1281,8 @@ SELECT count(*) FROM radix_text_tbl WHERE t >= 'Worth Recheck Cond: (t >= 'Worth St '::text) -> Bitmap Index Scan on sp_radix_ind Index Cond: (t >= 'Worth St '::text) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM radix_text_tbl WHERE t >= 'Worth St '; count @@ -1235,7 +1299,8 @@ SELECT count(*) FROM radix_text_tbl WHERE t ~>=~ 'Worth Recheck Cond: (t ~>=~ 'Worth St '::text) -> Bitmap Index Scan on sp_radix_ind Index Cond: (t ~>=~ 'Worth St '::text) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM radix_text_tbl WHERE t ~>=~ 'Worth St '; count @@ -1252,7 +1317,8 @@ SELECT count(*) FROM radix_text_tbl WHERE t > 'Worth Recheck Cond: (t > 'Worth St '::text) -> Bitmap Index Scan on sp_radix_ind Index Cond: (t > 'Worth St '::text) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM radix_text_tbl WHERE t > 'Worth St '; count @@ -1269,7 +1335,8 @@ SELECT count(*) FROM radix_text_tbl WHERE t ~>~ 'Worth Recheck Cond: (t ~>~ 'Worth St '::text) -> Bitmap Index Scan on sp_radix_ind Index Cond: (t ~>~ 'Worth St '::text) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM radix_text_tbl WHERE t ~>~ 'Worth St '; count @@ -1279,14 +1346,15 @@ SELECT count(*) FROM radix_text_tbl WHERE t ~>~ 'Worth EXPLAIN (COSTS OFF) SELECT count(*) FROM radix_text_tbl WHERE t ^@ 'Worth'; - QUERY PLAN ------------------------------------------------- + QUERY PLAN +------------------------------------------------------------ Aggregate -> Bitmap Heap Scan on radix_text_tbl Recheck Cond: (t ^@ 'Worth'::text) -> Bitmap Index Scan on sp_radix_ind Index Cond: (t ^@ 'Worth'::text) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM radix_text_tbl WHERE t ^@ 'Worth'; count diff --git a/src/test/regress/expected/create_view.out b/src/test/regress/expected/create_view.out index e367ea2571..1ac8427c04 100644 --- a/src/test/regress/expected/create_view.out +++ b/src/test/regress/expected/create_view.out @@ -1602,7 +1602,8 @@ explain (costs off) select * from tt18v; Append -> Seq Scan on int8_tbl xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx -> Seq Scan on int8_tbl xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx_1 -(3 rows) + Settings: search_path = 'testviewschm2, public' +(4 rows) -- check display of ScalarArrayOp with a sub-select select 'foo'::text = any(array['abc','def','foo']::text[]); diff --git a/src/test/regress/expected/equivclass.out b/src/test/regress/expected/equivclass.out index c448d85dec..e15374d72b 100644 --- a/src/test/regress/expected/equivclass.out +++ b/src/test/regress/expected/equivclass.out @@ -104,38 +104,42 @@ set enable_mergejoin = off; -- explain (costs off) select * from ec0 where ff = f1 and f1 = '42'::int8; - QUERY PLAN ------------------------------------ + QUERY PLAN +------------------------------------------------------------- Index Scan using ec0_pkey on ec0 Index Cond: (ff = '42'::bigint) Filter: (f1 = '42'::bigint) -(3 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off' +(4 rows) explain (costs off) select * from ec0 where ff = f1 and f1 = '42'::int8alias1; - QUERY PLAN ---------------------------------------- + QUERY PLAN +------------------------------------------------------------- Index Scan using ec0_pkey on ec0 Index Cond: (ff = '42'::int8alias1) Filter: (f1 = '42'::int8alias1) -(3 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off' +(4 rows) explain (costs off) select * from ec1 where ff = f1 and f1 = '42'::int8alias1; - QUERY PLAN ---------------------------------------- + QUERY PLAN +------------------------------------------------------------- Index Scan using ec1_pkey on ec1 Index Cond: (ff = '42'::int8alias1) Filter: (f1 = '42'::int8alias1) -(3 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off' +(4 rows) explain (costs off) select * from ec1 where ff = f1 and f1 = '42'::int8alias2; - QUERY PLAN ---------------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Seq Scan on ec1 Filter: ((ff = f1) AND (f1 = '42'::int8alias2)) -(2 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off' +(3 rows) explain (costs off) select * from ec1, ec2 where ff = x1 and ff = '42'::int8; @@ -146,52 +150,57 @@ explain (costs off) -> Index Scan using ec1_pkey on ec1 Index Cond: ((ff = '42'::bigint) AND (ff = '42'::bigint)) -> Seq Scan on ec2 -(5 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off' +(6 rows) explain (costs off) select * from ec1, ec2 where ff = x1 and ff = '42'::int8alias1; - QUERY PLAN ---------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Nested Loop -> Index Scan using ec1_pkey on ec1 Index Cond: (ff = '42'::int8alias1) -> Seq Scan on ec2 Filter: (x1 = '42'::int8alias1) -(5 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off' +(6 rows) explain (costs off) select * from ec1, ec2 where ff = x1 and '42'::int8 = x1; - QUERY PLAN ------------------------------------------ + QUERY PLAN +------------------------------------------------------------- Nested Loop Join Filter: (ec1.ff = ec2.x1) -> Index Scan using ec1_pkey on ec1 Index Cond: (ff = '42'::bigint) -> Seq Scan on ec2 Filter: ('42'::bigint = x1) -(6 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off' +(7 rows) explain (costs off) select * from ec1, ec2 where ff = x1 and x1 = '42'::int8alias1; - QUERY PLAN ---------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Nested Loop -> Index Scan using ec1_pkey on ec1 Index Cond: (ff = '42'::int8alias1) -> Seq Scan on ec2 Filter: (x1 = '42'::int8alias1) -(5 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off' +(6 rows) explain (costs off) select * from ec1, ec2 where ff = x1 and x1 = '42'::int8alias2; - QUERY PLAN ------------------------------------------ + QUERY PLAN +------------------------------------------------------------- Nested Loop -> Seq Scan on ec2 Filter: (x1 = '42'::int8alias2) -> Index Scan using ec1_pkey on ec1 Index Cond: (ff = ec2.x1) -(5 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off' +(6 rows) create unique index ec1_expr1 on ec1((ff + 1)); create unique index ec1_expr2 on ec1((ff + 2 + 1)); @@ -206,8 +215,8 @@ explain (costs off) union all select ff + 4 as x from ec1) as ss1 where ss1.x = ec1.f1 and ec1.ff = 42::int8; - QUERY PLAN ------------------------------------------------------ + QUERY PLAN +------------------------------------------------------------- Nested Loop -> Index Scan using ec1_pkey on ec1 Index Cond: (ff = '42'::bigint) @@ -218,7 +227,8 @@ explain (costs off) Index Cond: (((ff + 3) + 1) = ec1.f1) -> Index Scan using ec1_expr4 on ec1 ec1_3 Index Cond: ((ff + 4) = ec1.f1) -(10 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off' +(11 rows) explain (costs off) select * from ec1, @@ -243,7 +253,8 @@ explain (costs off) Index Cond: (((ff + 3) + 1) = '42'::bigint) -> Index Scan using ec1_expr4 on ec1 ec1_3 Index Cond: ((ff + 4) = '42'::bigint) -(12 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off' +(13 rows) explain (costs off) select * from ec1, @@ -280,7 +291,8 @@ explain (costs off) Index Cond: (((ff + 3) + 1) = (((ec1_1.ff + 2) + 1))) -> Index Scan using ec1_expr4 on ec1 ec1_6 Index Cond: ((ff + 4) = (((ec1_1.ff + 2) + 1))) -(18 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off' +(19 rows) -- let's try that as a mergejoin set enable_mergejoin = on; @@ -321,7 +333,8 @@ explain (costs off) Sort Key: ec1.f1 USING < -> Index Scan using ec1_pkey on ec1 Index Cond: (ff = '42'::bigint) -(19 rows) + Settings: enable_hashjoin = 'off', enable_nestloop = 'off' +(20 rows) -- check partially indexed scan set enable_nestloop = on; @@ -336,8 +349,8 @@ explain (costs off) union all select ff + 4 as x from ec1) as ss1 where ss1.x = ec1.f1 and ec1.ff = 42::int8; - QUERY PLAN ------------------------------------------------------ + QUERY PLAN +------------------------------------------------------------- Nested Loop -> Index Scan using ec1_pkey on ec1 Index Cond: (ff = '42'::bigint) @@ -348,7 +361,8 @@ explain (costs off) Filter: (((ff + 3) + 1) = ec1.f1) -> Index Scan using ec1_expr4 on ec1 ec1_3 Index Cond: ((ff + 4) = ec1.f1) -(10 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off' +(11 rows) -- let's try that as a mergejoin set enable_mergejoin = on; @@ -362,8 +376,8 @@ explain (costs off) union all select ff + 4 as x from ec1) as ss1 where ss1.x = ec1.f1 and ec1.ff = 42::int8; - QUERY PLAN ------------------------------------------------------ + QUERY PLAN +------------------------------------------------------------ Merge Join Merge Cond: ((((ec1_1.ff + 2) + 1)) = ec1.f1) -> Merge Append @@ -377,7 +391,8 @@ explain (costs off) Sort Key: ec1.f1 USING < -> Index Scan using ec1_pkey on ec1 Index Cond: (ff = '42'::bigint) -(13 rows) + Settings: enable_hashjoin = 'off', enable_nestloop = 'off' +(14 rows) -- check effects of row-level security set enable_nestloop = on; @@ -391,14 +406,15 @@ grant select on ec1 to regress_user_ectest; explain (costs off) select * from ec0 a, ec1 b where a.ff = b.ff and a.ff = 43::bigint::int8alias1; - QUERY PLAN ---------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Nested Loop -> Index Scan using ec0_pkey on ec0 a Index Cond: (ff = '43'::int8alias1) -> Index Scan using ec1_pkey on ec1 b Index Cond: (ff = '43'::int8alias1) -(5 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off' +(6 rows) set session authorization regress_user_ectest; -- with RLS active, the non-leakproof a.ff = 43 clause is not treated @@ -407,15 +423,16 @@ set session authorization regress_user_ectest; explain (costs off) select * from ec0 a, ec1 b where a.ff = b.ff and a.ff = 43::bigint::int8alias1; - QUERY PLAN ---------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Nested Loop -> Index Scan using ec0_pkey on ec0 a Index Cond: (ff = '43'::int8alias1) -> Index Scan using ec1_pkey on ec1 b Index Cond: (ff = a.ff) Filter: (f1 < '5'::int8alias1) -(6 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off' +(7 rows) reset session authorization; revoke select on ec0 from regress_user_ectest; @@ -428,14 +445,16 @@ explain (costs off) ------------------------------------------------------------- Seq Scan on tenk1 Filter: ((unique1 IS NOT NULL) AND (unique2 IS NOT NULL)) -(2 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off' +(3 rows) -- this could be converted, but isn't at present explain (costs off) select * from tenk1 where unique1 = unique1 or unique2 = unique2; - QUERY PLAN --------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Seq Scan on tenk1 Filter: ((unique1 = unique1) OR (unique2 = unique2)) -(2 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off' +(3 rows) diff --git a/src/test/regress/expected/fast_default.out b/src/test/regress/expected/fast_default.out index 10bc5ff757..261bd47805 100644 --- a/src/test/regress/expected/fast_default.out +++ b/src/test/regress/expected/fast_default.out @@ -302,7 +302,8 @@ SELECT c_bigint, c_text FROM T WHERE c_bigint = -1 LIMIT 1; -> Seq Scan on fast_default.t Output: c_bigint, c_text Filter: (t.c_bigint = '-1'::integer) -(5 rows) + Settings: search_path = 'fast_default' +(6 rows) SELECT c_bigint, c_text FROM T WHERE c_text = 'hello' LIMIT 1; c_bigint | c_text @@ -318,7 +319,8 @@ EXPLAIN (VERBOSE TRUE, COSTS FALSE) SELECT c_bigint, c_text FROM T WHERE c_text -> Seq Scan on fast_default.t Output: c_bigint, c_text Filter: (t.c_text = 'hello'::text) -(5 rows) + Settings: search_path = 'fast_default' +(6 rows) -- COALESCE SELECT COALESCE(c_bigint, pk), COALESCE(c_text, pk::text) @@ -372,7 +374,8 @@ SELECT * FROM T ORDER BY c_bigint, c_text, pk LIMIT 10; Sort Key: t.c_bigint, t.c_text, t.pk -> Seq Scan on fast_default.t Output: pk, c_bigint, c_text -(7 rows) + Settings: search_path = 'fast_default' +(8 rows) -- LIMIT SELECT * FROM T WHERE c_bigint > -1 ORDER BY c_bigint, c_text, pk LIMIT 10; @@ -402,7 +405,8 @@ SELECT * FROM T WHERE c_bigint > -1 ORDER BY c_bigint, c_text, pk LIMIT 10; -> Seq Scan on fast_default.t Output: pk, c_bigint, c_text Filter: (t.c_bigint > '-1'::integer) -(8 rows) + Settings: search_path = 'fast_default' +(9 rows) -- DELETE with RETURNING DELETE FROM T WHERE pk BETWEEN 10 AND 20 RETURNING *; @@ -432,7 +436,8 @@ DELETE FROM T WHERE pk BETWEEN 10 AND 20 RETURNING *; Recheck Cond: ((t.pk >= 10) AND (t.pk <= 20)) -> Bitmap Index Scan on t_pkey Index Cond: ((t.pk >= 10) AND (t.pk <= 20)) -(7 rows) + Settings: search_path = 'fast_default' +(8 rows) -- UPDATE UPDATE T SET c_text = '"' || c_text || '"' WHERE pk < 10; diff --git a/src/test/regress/expected/generated.out b/src/test/regress/expected/generated.out index d4ed3f7ae1..bb14be3b14 100644 --- a/src/test/regress/expected/generated.out +++ b/src/test/regress/expected/generated.out @@ -436,11 +436,12 @@ INSERT INTO gtest22c VALUES (1), (2), (3); SET enable_seqscan TO off; SET enable_bitmapscan TO off; EXPLAIN (COSTS OFF) SELECT * FROM gtest22c WHERE b = 4; - QUERY PLAN ---------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Index Scan using gtest22c_b_idx on gtest22c Index Cond: (b = 4) -(2 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(3 rows) SELECT * FROM gtest22c WHERE b = 4; a | b @@ -449,11 +450,12 @@ SELECT * FROM gtest22c WHERE b = 4; (1 row) EXPLAIN (COSTS OFF) SELECT * FROM gtest22c WHERE b * 3 = 6; - QUERY PLAN ------------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Index Scan using gtest22c_expr_idx on gtest22c Index Cond: ((b * 3) = 6) -(2 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(3 rows) SELECT * FROM gtest22c WHERE b * 3 = 6; a | b @@ -462,11 +464,12 @@ SELECT * FROM gtest22c WHERE b * 3 = 6; (1 row) EXPLAIN (COSTS OFF) SELECT * FROM gtest22c WHERE a = 1 AND b > 0; - QUERY PLAN ------------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Index Scan using gtest22c_pred_idx on gtest22c Index Cond: (a = 1) -(2 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(3 rows) SELECT * FROM gtest22c WHERE a = 1 AND b > 0; a | b diff --git a/src/test/regress/expected/gist.out b/src/test/regress/expected/gist.out index 0a43449f00..f716b4825e 100644 --- a/src/test/regress/expected/gist.out +++ b/src/test/regress/expected/gist.out @@ -51,11 +51,12 @@ create index gist_tbl_point_index on gist_tbl using gist (p); -- check that the planner chooses an index-only scan explain (costs off) select p from gist_tbl where p <@ box(point(0,0), point(0.5, 0.5)); - QUERY PLAN --------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Index Only Scan using gist_tbl_point_index on gist_tbl Index Cond: (p <@ '(0.5,0.5),(0,0)'::box) -(2 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(3 rows) -- execute the same select p from gist_tbl where p <@ box(point(0,0), point(0.5, 0.5)); @@ -78,12 +79,13 @@ select p from gist_tbl where p <@ box(point(0,0), point(0.5, 0.5)); explain (costs off) select p from gist_tbl where p <@ box(point(0,0), point(0.5, 0.5)) order by p <-> point(0.201, 0.201); - QUERY PLAN --------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Index Only Scan using gist_tbl_point_index on gist_tbl Index Cond: (p <@ '(0.5,0.5),(0,0)'::box) Order By: (p <-> '(0.201,0.201)'::point) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) select p from gist_tbl where p <@ box(point(0,0), point(0.5, 0.5)) order by p <-> point(0.201, 0.201); @@ -106,12 +108,13 @@ order by p <-> point(0.201, 0.201); explain (costs off) select p from gist_tbl where p <@ box(point(0,0), point(0.5, 0.5)) order by point(0.101, 0.101) <-> p; - QUERY PLAN --------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Index Only Scan using gist_tbl_point_index on gist_tbl Index Cond: (p <@ '(0.5,0.5),(0,0)'::box) Order By: (p <-> '(0.101,0.101)'::point) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) select p from gist_tbl where p <@ box(point(0,0), point(0.5, 0.5)) order by point(0.101, 0.101) <-> p; @@ -146,7 +149,8 @@ cross join lateral -> Index Only Scan using gist_tbl_point_index on gist_tbl Index Cond: (p <@ "*VALUES*".column1) Order By: (p <-> ("*VALUES*".column1)[0]) -(6 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(7 rows) select p from (values (box(point(0,0), point(0.5,0.5))), @@ -170,11 +174,12 @@ create index gist_tbl_box_index on gist_tbl using gist (b); -- check that the planner chooses an index-only scan explain (costs off) select b from gist_tbl where b <@ box(point(5,5), point(6,6)); - QUERY PLAN ------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Index Only Scan using gist_tbl_box_index on gist_tbl Index Cond: (b <@ '(6,6),(5,5)'::box) -(2 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(3 rows) -- execute the same select b from gist_tbl where b <@ box(point(5,5), point(6,6)); @@ -210,11 +215,12 @@ create index gist_tbl_multi_index on gist_tbl using gist (p, c); explain (costs off) select p, c from gist_tbl where p <@ box(point(5,5), point(6, 6)); - QUERY PLAN ---------------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Index Scan using gist_tbl_multi_index on gist_tbl Index Cond: (p <@ '(6,6),(5,5)'::box) -(2 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(3 rows) -- execute the same select b, p from gist_tbl diff --git a/src/test/regress/expected/groupingsets.out b/src/test/regress/expected/groupingsets.out index 381ebce8a1..792ca82443 100644 --- a/src/test/regress/expected/groupingsets.out +++ b/src/test/regress/expected/groupingsets.out @@ -374,7 +374,8 @@ select g as alias1, g as alias2 -> Sort Sort Key: g -> Function Scan on generate_series g -(6 rows) + Settings: enable_hashagg = 'off' +(7 rows) select g as alias1, g as alias2 from generate_series(1,3) g @@ -467,7 +468,8 @@ explain (costs off) -> Limit -> Index Only Scan using tenk1_unique1 on tenk1 Index Cond: (unique1 IS NOT NULL) -(5 rows) + Settings: enable_hashagg = 'off' +(6 rows) -- Views with GROUPING SET queries CREATE VIEW gstest_view AS select a, b, grouping(a,b), sum(c), count(*), max(c) @@ -716,7 +718,8 @@ explain (costs off) -> Sort Sort Key: a -> Seq Scan on gstest2 -(7 rows) + Settings: enable_hashagg = 'off' +(8 rows) select v.c, (select count(*) from gstest2 group by () having v.c) from (values (false),(true)) v(c) order by v.c; @@ -741,7 +744,8 @@ explain (costs off) -> Result One-Time Filter: "*VALUES*".column1 -> Seq Scan on gstest2 -(10 rows) + Settings: enable_hashagg = 'off' +(11 rows) -- HAVING with GROUPING queries select ten, grouping(ten) from onek @@ -1481,8 +1485,8 @@ explain (costs off) count(hundred), count(thousand), count(twothousand), count(*) from tenk1 group by grouping sets (unique1,twothousand,thousand,hundred,ten,four,two); - QUERY PLAN -------------------------------- + QUERY PLAN +------------------------------------------------------- MixedAggregate Hash Key: two Hash Key: four @@ -1496,7 +1500,8 @@ explain (costs off) -> Sort Sort Key: unique1 -> Seq Scan on tenk1 -(13 rows) + Settings: enable_indexscan = 'off', work_mem = '64kB' +(14 rows) explain (costs off) select unique1, @@ -1504,8 +1509,8 @@ explain (costs off) count(hundred), count(thousand), count(twothousand), count(*) from tenk1 group by grouping sets (unique1,hundred,ten,four,two); - QUERY PLAN -------------------------------- + QUERY PLAN +------------------------------------------------------- MixedAggregate Hash Key: two Hash Key: four @@ -1515,7 +1520,8 @@ explain (costs off) -> Sort Sort Key: unique1 -> Seq Scan on tenk1 -(9 rows) + Settings: enable_indexscan = 'off', work_mem = '64kB' +(10 rows) set work_mem = '384kB'; explain (costs off) @@ -1524,8 +1530,8 @@ explain (costs off) count(hundred), count(thousand), count(twothousand), count(*) from tenk1 group by grouping sets (unique1,twothousand,thousand,hundred,ten,four,two); - QUERY PLAN -------------------------------- + QUERY PLAN +-------------------------------------------------------- MixedAggregate Hash Key: two Hash Key: four @@ -1538,7 +1544,8 @@ explain (costs off) -> Sort Sort Key: unique1 -> Seq Scan on tenk1 -(12 rows) + Settings: enable_indexscan = 'off', work_mem = '384kB' +(13 rows) -- check collation-sensitive matching between grouping expressions -- (similar to a check for aggregates, but there are additional code diff --git a/src/test/regress/expected/index_including.out b/src/test/regress/expected/index_including.out index 2405709f40..0b712c289c 100644 --- a/src/test/regress/expected/index_including.out +++ b/src/test/regress/expected/index_including.out @@ -154,7 +154,8 @@ select * from tbl where (c1,c2,c3) < (262,1,1) limit 1; -> Index Only Scan using covering on tbl Index Cond: (ROW(c1, c2) <= ROW(262, 1)) Filter: (ROW(c1, c2, c3) < ROW(262, 1, 1)) -(4 rows) + Settings: enable_seqscan = 'off' +(5 rows) select * from tbl where (c1,c2,c3) < (262,1,1) limit 1; c1 | c2 | c3 | c4 diff --git a/src/test/regress/expected/index_including_gist.out b/src/test/regress/expected/index_including_gist.out index ed9906da66..f013380ce9 100644 --- a/src/test/regress/expected/index_including_gist.out +++ b/src/test/regress/expected/index_including_gist.out @@ -29,7 +29,8 @@ EXPLAIN (costs off) SELECT * FROM tbl_gist where c4 <@ box(point(1,1),point(10, ------------------------------------------------ Index Only Scan using tbl_gist_idx on tbl_gist Index Cond: (c4 <@ '(10,10),(1,1)'::box) -(2 rows) + Settings: enable_bitmapscan = 'off' +(3 rows) SET enable_bitmapscan TO default; DROP TABLE tbl_gist; @@ -64,7 +65,8 @@ EXPLAIN (costs off) SELECT * FROM tbl_gist where c4 <@ box(point(1,1),point(10, ------------------------------------------------ Index Only Scan using tbl_gist_idx on tbl_gist Index Cond: (c4 <@ '(10,10),(1,1)'::box) -(2 rows) + Settings: enable_bitmapscan = 'off' +(3 rows) SET enable_bitmapscan TO default; DROP TABLE tbl_gist; diff --git a/src/test/regress/expected/inet.out b/src/test/regress/expected/inet.out index 24202376f1..58af8d5564 100644 --- a/src/test/regress/expected/inet.out +++ b/src/test/regress/expected/inet.out @@ -249,7 +249,8 @@ SELECT * FROM inet_tbl WHERE i<<'192.168.1.0/24'::cidr; Index Scan using inet_idx1 on inet_tbl Index Cond: ((i > '192.168.1.0/24'::inet) AND (i <= '192.168.1.255'::inet)) Filter: (i << '192.168.1.0/24'::inet) -(3 rows) + Settings: enable_seqscan = 'off' +(4 rows) SELECT * FROM inet_tbl WHERE i<<'192.168.1.0/24'::cidr; c | i @@ -266,7 +267,8 @@ SELECT * FROM inet_tbl WHERE i<<='192.168.1.0/24'::cidr; Index Scan using inet_idx1 on inet_tbl Index Cond: ((i >= '192.168.1.0/24'::inet) AND (i <= '192.168.1.255'::inet)) Filter: (i <<= '192.168.1.0/24'::inet) -(3 rows) + Settings: enable_seqscan = 'off' +(4 rows) SELECT * FROM inet_tbl WHERE i<<='192.168.1.0/24'::cidr; c | i @@ -286,7 +288,8 @@ SELECT * FROM inet_tbl WHERE '192.168.1.0/24'::cidr >>= i; Index Scan using inet_idx1 on inet_tbl Index Cond: ((i >= '192.168.1.0/24'::inet) AND (i <= '192.168.1.255'::inet)) Filter: ('192.168.1.0/24'::inet >>= i) -(3 rows) + Settings: enable_seqscan = 'off' +(4 rows) SELECT * FROM inet_tbl WHERE '192.168.1.0/24'::cidr >>= i; c | i @@ -306,7 +309,8 @@ SELECT * FROM inet_tbl WHERE '192.168.1.0/24'::cidr >> i; Index Scan using inet_idx1 on inet_tbl Index Cond: ((i > '192.168.1.0/24'::inet) AND (i <= '192.168.1.255'::inet)) Filter: ('192.168.1.0/24'::inet >> i) -(3 rows) + Settings: enable_seqscan = 'off' +(4 rows) SELECT * FROM inet_tbl WHERE '192.168.1.0/24'::cidr >> i; c | i @@ -454,7 +458,8 @@ SELECT i FROM inet_tbl WHERE i << '192.168.1.0/24'::cidr ORDER BY i; Sort Key: i -> Index Only Scan using inet_idx2 on inet_tbl Index Cond: (i << '192.168.1.0/24'::inet) -(4 rows) + Settings: enable_seqscan = 'off' +(5 rows) SELECT i FROM inet_tbl WHERE i << '192.168.1.0/24'::cidr ORDER BY i; i @@ -602,7 +607,8 @@ SELECT i FROM inet_tbl WHERE i << '192.168.1.0/24'::cidr ORDER BY i; Sort Key: i -> Index Only Scan using inet_idx3 on inet_tbl Index Cond: (i << '192.168.1.0/24'::inet) -(4 rows) + Settings: enable_seqscan = 'off' +(5 rows) SELECT i FROM inet_tbl WHERE i << '192.168.1.0/24'::cidr ORDER BY i; i diff --git a/src/test/regress/expected/inherit.out b/src/test/regress/expected/inherit.out index c6abcfc3cb..a30ff26734 100644 --- a/src/test/regress/expected/inherit.out +++ b/src/test/regress/expected/inherit.out @@ -1411,7 +1411,8 @@ explain (verbose, costs off) select * from matest0 order by 1-id; Output: matest2.id, matest2.name -> Seq Scan on public.matest3 Output: matest3.id, matest3.name -(14 rows) + Settings: enable_indexscan = 'off' +(15 rows) select * from matest0 order by 1-id; id | name @@ -1438,7 +1439,8 @@ explain (verbose, costs off) select min(1-id) from matest0; Output: matest2.id -> Seq Scan on public.matest3 Output: matest3.id -(11 rows) + Settings: enable_indexscan = 'off' +(12 rows) select min(1-id) from matest0; min @@ -1465,7 +1467,8 @@ explain (verbose, costs off) select * from matest0 order by 1-id; Output: matest2.id, matest2.name, (1 - matest2.id) -> Index Scan using matest3i on public.matest3 Output: matest3.id, matest3.name, (1 - matest3.id) -(13 rows) + Settings: enable_parallel_append = 'off', enable_seqscan = 'off' +(14 rows) select * from matest0 order by 1-id; id | name @@ -1506,7 +1509,8 @@ explain (verbose, costs off) select min(1-id) from matest0; -> Index Scan using matest3i on public.matest3 Output: matest3.id, (1 - matest3.id) Index Cond: ((1 - matest3.id) IS NOT NULL) -(25 rows) + Settings: enable_parallel_append = 'off', enable_seqscan = 'off' +(26 rows) select min(1-id) from matest0; min @@ -1550,7 +1554,8 @@ order by t1.b limit 10; Filter: (c = d) -> Index Scan using matest1i on matest1 t2_1 Filter: (c = d) -(14 rows) + Settings: enable_nestloop = 'off' +(15 rows) reset enable_nestloop; drop table matest0 cascade; @@ -1575,7 +1580,8 @@ ORDER BY thousand, tenthous; -> Sort Sort Key: tenk1_1.thousand, tenk1_1.thousand -> Index Only Scan using tenk1_thous_tenthous on tenk1 tenk1_1 -(6 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(7 rows) explain (costs off) SELECT thousand, tenthous, thousand+tenthous AS x FROM tenk1 @@ -1590,7 +1596,8 @@ ORDER BY thousand, tenthous; -> Sort Sort Key: 42, 42 -> Index Only Scan using tenk1_hundred on tenk1 tenk1_1 -(6 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(7 rows) explain (costs off) SELECT thousand, tenthous FROM tenk1 @@ -1605,7 +1612,8 @@ ORDER BY thousand, tenthous; -> Sort Sort Key: tenk1_1.thousand, ((random())::integer) -> Index Only Scan using tenk1_thous_tenthous on tenk1 tenk1_1 -(6 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(7 rows) -- Check min/max aggregate optimization explain (costs off) @@ -1624,7 +1632,8 @@ SELECT min(x) FROM Index Cond: (unique1 IS NOT NULL) -> Index Only Scan using tenk1_unique2 on tenk1 b Index Cond: (unique2 IS NOT NULL) -(9 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(10 rows) explain (costs off) SELECT min(y) FROM @@ -1642,7 +1651,8 @@ SELECT min(y) FROM Index Cond: (unique1 IS NOT NULL) -> Index Only Scan using tenk1_unique2 on tenk1 b Index Cond: (unique2 IS NOT NULL) -(9 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(10 rows) -- XXX planner doesn't recognize that index on unique2 is sufficiently sorted explain (costs off) @@ -1659,7 +1669,8 @@ ORDER BY x, y; -> Sort Sort Key: b.unique2, b.unique2 -> Index Only Scan using tenk1_unique2 on tenk1 b -(6 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(7 rows) -- exercise rescan code path via a repeatedly-evaluated subquery explain (costs off) @@ -1684,7 +1695,8 @@ FROM generate_series(1, 3) g(i); -> Sort Sort Key: ((d_1.d + g.i)) -> Function Scan on generate_series d_1 -(11 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(12 rows) SELECT ARRAY(SELECT f.i FROM ( @@ -2236,7 +2248,8 @@ explain (costs off) select * from mcrparted where a = 10 order by a, abs(b), c; Index Cond: (a = 10) -> Index Scan using mcrparted2_a_abs_c_idx on mcrparted2 Index Cond: (a = 10) -(5 rows) + Settings: enable_bitmapscan = 'off' +(6 rows) reset enable_bitmapscan; drop table mcrparted; diff --git a/src/test/regress/expected/interval.out b/src/test/regress/expected/interval.out index f88f34550a..3f7b3fd441 100644 --- a/src/test/regress/expected/interval.out +++ b/src/test/regress/expected/interval.out @@ -257,7 +257,8 @@ SELECT f1 FROM INTERVAL_TBL_OF r1 ORDER BY f1; QUERY PLAN -------------------------------------------------------------------- Index Only Scan using interval_tbl_of_f1_idx on interval_tbl_of r1 -(1 row) + Settings: enable_seqscan = 'off' +(2 rows) SELECT f1 FROM INTERVAL_TBL_OF r1 ORDER BY f1; f1 diff --git a/src/test/regress/expected/join.out b/src/test/regress/expected/join.out index 07e631d45e..a0b8181889 100644 --- a/src/test/regress/expected/join.out +++ b/src/test/regress/expected/join.out @@ -2496,7 +2496,8 @@ select count(*) from tenk1 a, tenk1 b -> Hash -> Seq Scan on tenk1 b Filter: ((fivethous % 10) < 10) -(7 rows) + Settings: enable_mergejoin = 'off', work_mem = '64kB' +(8 rows) select count(*) from tenk1 a, tenk1 b where a.hundred = b.thousand and (b.fivethous % 10) < 10; @@ -2715,7 +2716,8 @@ select a.idv, b.idv from tidv a, tidv b where a.idv = b.idv; -> Seq Scan on tidv a -> Index Only Scan using tidv_idv_idx on tidv b Index Cond: (idv = a.idv) -(4 rows) + Settings: enable_mergejoin = 'off' +(5 rows) rollback; -- @@ -4119,8 +4121,8 @@ explain (verbose, costs off) select a.q2, b.q1 from int8_tbl a left join int8_tbl b on a.q2 = coalesce(b.q1, 1) where coalesce(b.q1, 1) > 0; - QUERY PLAN ---------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------ Merge Left Join Output: a.q2, b.q1 Merge Cond: (a.q2 = (COALESCE(b.q1, '1'::bigint))) @@ -4135,7 +4137,8 @@ explain (verbose, costs off) Sort Key: (COALESCE(b.q1, '1'::bigint)) -> Seq Scan on public.int8_tbl b Output: b.q1, COALESCE(b.q1, '1'::bigint) -(14 rows) + Settings: enable_hashjoin = 'off', enable_nestloop = 'off' +(15 rows) select a.q2, b.q1 from int8_tbl a left join int8_tbl b on a.q2 = coalesce(b.q1, 1) @@ -5970,14 +5973,15 @@ analyze j2; explain (costs off) select * from j1 inner join j2 on j1.id1 = j2.id1 and j1.id2 = j2.id2 where j1.id1 % 1000 = 1 and j2.id1 % 1000 = 1; - QUERY PLAN ------------------------------------------ + QUERY PLAN +--------------------------------------------------------------------------------- Merge Join Merge Cond: (j1.id1 = j2.id1) Join Filter: (j1.id2 = j2.id2) -> Index Scan using j1_id1_idx on j1 -> Index Scan using j2_id1_idx on j2 -(5 rows) + Settings: enable_hashjoin = 'off', enable_nestloop = 'off', enable_sort = 'off' +(6 rows) select * from j1 inner join j2 on j1.id1 = j2.id1 and j1.id2 = j2.id2 diff --git a/src/test/regress/expected/join_hash.out b/src/test/regress/expected/join_hash.out index 9eee39bdd3..9b1de7274f 100644 --- a/src/test/regress/expected/join_hash.out +++ b/src/test/regress/expected/join_hash.out @@ -4,7 +4,7 @@ begin; set local min_parallel_table_scan_size = 0; set local parallel_setup_cost = 0; --- Extract bucket and batch counts from an explain analyze plan. In +-- Extract bucket and batch counts from an explain exec plan. In -- general we can't make assertions about how many batches (or -- buckets) will be required because it can vary, but we can in some -- special cases and we can check for growth. @@ -39,7 +39,7 @@ declare hash_node json; begin for whole_plan in - execute 'explain (analyze, format ''json'') ' || query + execute 'explain (exec, format ''json'') ' || query loop hash_node := find_hash(json_extract_path(whole_plan, '0', 'Plan')); original := hash_node->>'Original Hash Batches'; @@ -87,15 +87,16 @@ set local max_parallel_workers_per_gather = 0; set local work_mem = '4MB'; explain (costs off) select count(*) from simple r join simple s using (id); - QUERY PLAN ----------------------------------------- + QUERY PLAN +---------------------------------------------------------------------------------------------------------------- Aggregate -> Hash Join Hash Cond: (r.id = s.id) -> Seq Scan on simple r -> Hash -> Seq Scan on simple s -(6 rows) + Settings: max_parallel_workers_per_gather = '0', min_parallel_table_scan_size = '0', parallel_setup_cost = '0' +(7 rows) select count(*) from simple r join simple s using (id); count @@ -121,8 +122,8 @@ set local work_mem = '4MB'; set local enable_parallel_hash = off; explain (costs off) select count(*) from simple r join simple s using (id); - QUERY PLAN -------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------------------------------------------------- Finalize Aggregate -> Gather Workers Planned: 2 @@ -132,7 +133,8 @@ explain (costs off) -> Parallel Seq Scan on simple r -> Hash -> Seq Scan on simple s -(9 rows) + Settings: enable_parallel_hash = 'off', min_parallel_table_scan_size = '0', parallel_setup_cost = '0' +(10 rows) select count(*) from simple r join simple s using (id); count @@ -158,8 +160,8 @@ set local work_mem = '4MB'; set local enable_parallel_hash = on; explain (costs off) select count(*) from simple r join simple s using (id); - QUERY PLAN -------------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------------------- Finalize Aggregate -> Gather Workers Planned: 2 @@ -169,7 +171,8 @@ explain (costs off) -> Parallel Seq Scan on simple r -> Parallel Hash -> Parallel Seq Scan on simple s -(9 rows) + Settings: min_parallel_table_scan_size = '0', parallel_setup_cost = '0' +(10 rows) select count(*) from simple r join simple s using (id); count @@ -197,15 +200,16 @@ set local max_parallel_workers_per_gather = 0; set local work_mem = '128kB'; explain (costs off) select count(*) from simple r join simple s using (id); - QUERY PLAN ----------------------------------------- + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------ Aggregate -> Hash Join Hash Cond: (r.id = s.id) -> Seq Scan on simple r -> Hash -> Seq Scan on simple s -(6 rows) + Settings: max_parallel_workers_per_gather = '0', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', work_mem = '128kB' +(7 rows) select count(*) from simple r join simple s using (id); count @@ -231,8 +235,8 @@ set local work_mem = '128kB'; set local enable_parallel_hash = off; explain (costs off) select count(*) from simple r join simple s using (id); - QUERY PLAN -------------------------------------------------------- + QUERY PLAN +--------------------------------------------------------------------------------------------------------------------------- Finalize Aggregate -> Gather Workers Planned: 2 @@ -242,7 +246,8 @@ explain (costs off) -> Parallel Seq Scan on simple r -> Hash -> Seq Scan on simple s -(9 rows) + Settings: enable_parallel_hash = 'off', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', work_mem = '128kB' +(10 rows) select count(*) from simple r join simple s using (id); count @@ -268,8 +273,8 @@ set local work_mem = '192kB'; set local enable_parallel_hash = on; explain (costs off) select count(*) from simple r join simple s using (id); - QUERY PLAN -------------------------------------------------------------- + QUERY PLAN +--------------------------------------------------------------------------------------------- Finalize Aggregate -> Gather Workers Planned: 2 @@ -279,7 +284,8 @@ explain (costs off) -> Parallel Seq Scan on simple r -> Parallel Hash -> Parallel Seq Scan on simple s -(9 rows) + Settings: min_parallel_table_scan_size = '0', parallel_setup_cost = '0', work_mem = '192kB' +(10 rows) select count(*) from simple r join simple s using (id); count @@ -308,15 +314,16 @@ set local max_parallel_workers_per_gather = 0; set local work_mem = '128kB'; explain (costs off) select count(*) FROM simple r JOIN bigger_than_it_looks s USING (id); - QUERY PLAN ------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------ Aggregate -> Hash Join Hash Cond: (r.id = s.id) -> Seq Scan on simple r -> Hash -> Seq Scan on bigger_than_it_looks s -(6 rows) + Settings: max_parallel_workers_per_gather = '0', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', work_mem = '128kB' +(7 rows) select count(*) FROM simple r JOIN bigger_than_it_looks s USING (id); count @@ -342,8 +349,8 @@ set local work_mem = '128kB'; set local enable_parallel_hash = off; explain (costs off) select count(*) from simple r join bigger_than_it_looks s using (id); - QUERY PLAN ------------------------------------------------------------------- + QUERY PLAN +--------------------------------------------------------------------------------------------------------------------------- Finalize Aggregate -> Gather Workers Planned: 2 @@ -353,7 +360,8 @@ explain (costs off) -> Parallel Seq Scan on simple r -> Hash -> Seq Scan on bigger_than_it_looks s -(9 rows) + Settings: enable_parallel_hash = 'off', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', work_mem = '128kB' +(10 rows) select count(*) from simple r join bigger_than_it_looks s using (id); count @@ -379,8 +387,8 @@ set local work_mem = '192kB'; set local enable_parallel_hash = on; explain (costs off) select count(*) from simple r join bigger_than_it_looks s using (id); - QUERY PLAN ---------------------------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------ Finalize Aggregate -> Gather Workers Planned: 1 @@ -390,7 +398,8 @@ explain (costs off) -> Parallel Seq Scan on simple r -> Parallel Hash -> Parallel Seq Scan on bigger_than_it_looks s -(9 rows) + Settings: max_parallel_workers_per_gather = '1', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', work_mem = '192kB' +(10 rows) select count(*) from simple r join bigger_than_it_looks s using (id); count @@ -420,15 +429,16 @@ set local max_parallel_workers_per_gather = 0; set local work_mem = '128kB'; explain (costs off) select count(*) from simple r join extremely_skewed s using (id); - QUERY PLAN --------------------------------------------------- + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------ Aggregate -> Hash Join Hash Cond: (r.id = s.id) -> Seq Scan on simple r -> Hash -> Seq Scan on extremely_skewed s -(6 rows) + Settings: max_parallel_workers_per_gather = '0', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', work_mem = '128kB' +(7 rows) select count(*) from simple r join extremely_skewed s using (id); count @@ -453,8 +463,8 @@ set local work_mem = '128kB'; set local enable_parallel_hash = off; explain (costs off) select count(*) from simple r join extremely_skewed s using (id); - QUERY PLAN --------------------------------------------------------- + QUERY PLAN +--------------------------------------------------------------------------------------------------------------------------- Aggregate -> Gather Workers Planned: 2 @@ -463,7 +473,8 @@ explain (costs off) -> Parallel Seq Scan on simple r -> Hash -> Seq Scan on extremely_skewed s -(8 rows) + Settings: enable_parallel_hash = 'off', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', work_mem = '128kB' +(9 rows) select count(*) from simple r join extremely_skewed s using (id); count @@ -488,8 +499,8 @@ set local work_mem = '128kB'; set local enable_parallel_hash = on; explain (costs off) select count(*) from simple r join extremely_skewed s using (id); - QUERY PLAN ------------------------------------------------------------------------ + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------ Finalize Aggregate -> Gather Workers Planned: 1 @@ -499,7 +510,8 @@ explain (costs off) -> Parallel Seq Scan on simple r -> Parallel Hash -> Parallel Seq Scan on extremely_skewed s -(9 rows) + Settings: max_parallel_workers_per_gather = '1', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', work_mem = '128kB' +(10 rows) select count(*) from simple r join extremely_skewed s using (id); count @@ -518,7 +530,7 @@ $$); rollback to settings; -- A couple of other hash join tests unrelated to work_mem management. --- Check that EXPLAIN ANALYZE has data even if the leader doesn't participate +-- Check that EXPLAIN EXEC has data even if the leader doesn't participate savepoint settings; set local max_parallel_workers_per_gather = 2; set local work_mem = '4MB'; @@ -554,8 +566,8 @@ explain (costs off) select count(*) from join_foo left join (select b1.id, b1.t from join_bar b1 join join_bar b2 using (id)) ss on join_foo.id < ss.id + 1 and join_foo.id > ss.id - 1; - QUERY PLAN ------------------------------------------------------------------------------------- + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Aggregate -> Nested Loop Left Join Join Filter: ((join_foo.id < (b1.id + 1)) AND (join_foo.id > (b1.id - 1))) @@ -567,7 +579,8 @@ explain (costs off) -> Parallel Seq Scan on join_bar b1 -> Hash -> Seq Scan on join_bar b2 -(11 rows) + Settings: enable_material = 'off', enable_mergejoin = 'off', enable_parallel_hash = 'off', min_parallel_table_scan_size = '0', parallel_leader_participation = 'off', parallel_setup_cost = '0', parallel_tuple_cost = '0', work_mem = '64kB' +(12 rows) select count(*) from join_foo left join (select b1.id, b1.t from join_bar b1 join join_bar b2 using (id)) ss @@ -605,8 +618,8 @@ explain (costs off) select count(*) from join_foo left join (select b1.id, b1.t from join_bar b1 join join_bar b2 using (id)) ss on join_foo.id < ss.id + 1 and join_foo.id > ss.id - 1; - QUERY PLAN ------------------------------------------------------------------------------------- + QUERY PLAN +---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Aggregate -> Nested Loop Left Join Join Filter: ((join_foo.id < (b1.id + 1)) AND (join_foo.id > (b1.id - 1))) @@ -618,7 +631,8 @@ explain (costs off) -> Parallel Seq Scan on join_bar b1 -> Hash -> Seq Scan on join_bar b2 -(11 rows) + Settings: enable_material = 'off', enable_mergejoin = 'off', enable_parallel_hash = 'off', min_parallel_table_scan_size = '0', parallel_leader_participation = 'off', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(12 rows) select count(*) from join_foo left join (select b1.id, b1.t from join_bar b1 join join_bar b2 using (id)) ss @@ -656,8 +670,8 @@ explain (costs off) select count(*) from join_foo left join (select b1.id, b1.t from join_bar b1 join join_bar b2 using (id)) ss on join_foo.id < ss.id + 1 and join_foo.id > ss.id - 1; - QUERY PLAN ------------------------------------------------------------------------------------- + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Aggregate -> Nested Loop Left Join Join Filter: ((join_foo.id < (b1.id + 1)) AND (join_foo.id > (b1.id - 1))) @@ -669,7 +683,8 @@ explain (costs off) -> Parallel Seq Scan on join_bar b1 -> Parallel Hash -> Parallel Seq Scan on join_bar b2 -(11 rows) + Settings: enable_material = 'off', enable_mergejoin = 'off', min_parallel_table_scan_size = '0', parallel_leader_participation = 'off', parallel_setup_cost = '0', parallel_tuple_cost = '0', work_mem = '64kB' +(12 rows) select count(*) from join_foo left join (select b1.id, b1.t from join_bar b1 join join_bar b2 using (id)) ss @@ -707,8 +722,8 @@ explain (costs off) select count(*) from join_foo left join (select b1.id, b1.t from join_bar b1 join join_bar b2 using (id)) ss on join_foo.id < ss.id + 1 and join_foo.id > ss.id - 1; - QUERY PLAN ------------------------------------------------------------------------------------- + QUERY PLAN +---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Aggregate -> Nested Loop Left Join Join Filter: ((join_foo.id < (b1.id + 1)) AND (join_foo.id > (b1.id - 1))) @@ -720,7 +735,8 @@ explain (costs off) -> Parallel Seq Scan on join_bar b1 -> Parallel Hash -> Parallel Seq Scan on join_bar b2 -(11 rows) + Settings: enable_material = 'off', enable_mergejoin = 'off', min_parallel_table_scan_size = '0', parallel_leader_participation = 'off', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(12 rows) select count(*) from join_foo left join (select b1.id, b1.t from join_bar b1 join join_bar b2 using (id)) ss @@ -749,15 +765,16 @@ savepoint settings; set local max_parallel_workers_per_gather = 0; explain (costs off) select count(*) from simple r full outer join simple s using (id); - QUERY PLAN ----------------------------------------- + QUERY PLAN +---------------------------------------------------------------------------------------------------------------- Aggregate -> Hash Full Join Hash Cond: (r.id = s.id) -> Seq Scan on simple r -> Hash -> Seq Scan on simple s -(6 rows) + Settings: max_parallel_workers_per_gather = '0', min_parallel_table_scan_size = '0', parallel_setup_cost = '0' +(7 rows) select count(*) from simple r full outer join simple s using (id); count @@ -771,15 +788,16 @@ savepoint settings; set local max_parallel_workers_per_gather = 2; explain (costs off) select count(*) from simple r full outer join simple s using (id); - QUERY PLAN ----------------------------------------- + QUERY PLAN +------------------------------------------------------------------------- Aggregate -> Hash Full Join Hash Cond: (r.id = s.id) -> Seq Scan on simple r -> Hash -> Seq Scan on simple s -(6 rows) + Settings: min_parallel_table_scan_size = '0', parallel_setup_cost = '0' +(7 rows) select count(*) from simple r full outer join simple s using (id); count @@ -794,15 +812,16 @@ savepoint settings; set local max_parallel_workers_per_gather = 0; explain (costs off) select count(*) from simple r full outer join simple s on (r.id = 0 - s.id); - QUERY PLAN ----------------------------------------- + QUERY PLAN +---------------------------------------------------------------------------------------------------------------- Aggregate -> Hash Full Join Hash Cond: ((0 - s.id) = r.id) -> Seq Scan on simple s -> Hash -> Seq Scan on simple r -(6 rows) + Settings: max_parallel_workers_per_gather = '0', min_parallel_table_scan_size = '0', parallel_setup_cost = '0' +(7 rows) select count(*) from simple r full outer join simple s on (r.id = 0 - s.id); count @@ -816,15 +835,16 @@ savepoint settings; set local max_parallel_workers_per_gather = 2; explain (costs off) select count(*) from simple r full outer join simple s on (r.id = 0 - s.id); - QUERY PLAN ----------------------------------------- + QUERY PLAN +------------------------------------------------------------------------- Aggregate -> Hash Full Join Hash Cond: ((0 - s.id) = r.id) -> Seq Scan on simple s -> Hash -> Seq Scan on simple r -(6 rows) + Settings: min_parallel_table_scan_size = '0', parallel_setup_cost = '0' +(7 rows) select count(*) from simple r full outer join simple s on (r.id = 0 - s.id); count @@ -845,8 +865,8 @@ set work_mem = '128kB'; explain (costs off) select length(max(s.t)) from wide left join (select id, coalesce(t, '') || '' as t from wide) s using (id); - QUERY PLAN ----------------------------------------------------------------- + QUERY PLAN +--------------------------------------------------------------------------------------------- Finalize Aggregate -> Gather Workers Planned: 2 @@ -856,7 +876,8 @@ explain (costs off) -> Parallel Seq Scan on wide -> Parallel Hash -> Parallel Seq Scan on wide wide_1 -(9 rows) + Settings: min_parallel_table_scan_size = '0', parallel_setup_cost = '0', work_mem = '128kB' +(10 rows) select length(max(s.t)) from wide left join (select id, coalesce(t, '') || '' as t from wide) s using (id); diff --git a/src/test/regress/expected/jsonb.out b/src/test/regress/expected/jsonb.out index 1018303006..da4bfd2bdc 100644 --- a/src/test/regress/expected/jsonb.out +++ b/src/test/regress/expected/jsonb.out @@ -2923,7 +2923,8 @@ SELECT count(*) FROM testjsonb WHERE j @@ '$.wait == null'; Recheck Cond: (j @@ '($."wait" == null)'::jsonpath) -> Bitmap Index Scan on jidx Index Cond: (j @@ '($."wait" == null)'::jsonpath) -(5 rows) + Settings: enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM testjsonb WHERE j @@ '$.wait == null'; count @@ -3036,7 +3037,8 @@ SELECT count(*) FROM testjsonb WHERE j @? '$.wait ? (@ == null)'; Recheck Cond: (j @? '$."wait"?(@ == null)'::jsonpath) -> Bitmap Index Scan on jidx Index Cond: (j @? '$."wait"?(@ == null)'::jsonpath) -(5 rows) + Settings: enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM testjsonb WHERE j @? '$.wait ? (@ == null)'; count @@ -3341,7 +3343,8 @@ SELECT count(*) FROM testjsonb WHERE j @? '$.wait ? (@ == null)'; Recheck Cond: (j @? '$."wait"?(@ == null)'::jsonpath) -> Bitmap Index Scan on jidx Index Cond: (j @? '$."wait"?(@ == null)'::jsonpath) -(5 rows) + Settings: enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM testjsonb WHERE j @? '$.wait ? (@ == null)'; count diff --git a/src/test/regress/expected/partition_aggregate.out b/src/test/regress/expected/partition_aggregate.out index 10349ec29c..95ac71d77d 100644 --- a/src/test/regress/expected/partition_aggregate.out +++ b/src/test/regress/expected/partition_aggregate.out @@ -20,8 +20,8 @@ ANALYZE pagg_tab; -- When GROUP BY clause matches; full aggregation is performed for each partition. EXPLAIN (COSTS OFF) SELECT c, sum(a), avg(b), count(*), min(a), max(b) FROM pagg_tab GROUP BY c HAVING avg(d) < 15 ORDER BY 1, 2, 3; - QUERY PLAN ------------------------------------------------------------------------ + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------- Sort Sort Key: pagg_tab_p1.c, (sum(pagg_tab_p1.a)), (avg(pagg_tab_p1.b)) -> Append @@ -37,7 +37,8 @@ SELECT c, sum(a), avg(b), count(*), min(a), max(b) FROM pagg_tab GROUP BY c HAVI Group Key: pagg_tab_p3.c Filter: (avg(pagg_tab_p3.d) < '15'::numeric) -> Seq Scan on pagg_tab_p3 -(15 rows) + Settings: enable_partitionwise_aggregate = 'on', enable_partitionwise_join = 'on', max_parallel_workers_per_gather = '0' +(16 rows) SELECT c, sum(a), avg(b), count(*), min(a), max(b) FROM pagg_tab GROUP BY c HAVING avg(d) < 15 ORDER BY 1, 2, 3; c | sum | avg | count | min | max @@ -53,8 +54,8 @@ SELECT c, sum(a), avg(b), count(*), min(a), max(b) FROM pagg_tab GROUP BY c HAVI -- When GROUP BY clause does not match; partial aggregation is performed for each partition. EXPLAIN (COSTS OFF) SELECT a, sum(b), avg(b), count(*), min(a), max(b) FROM pagg_tab GROUP BY a HAVING avg(d) < 15 ORDER BY 1, 2, 3; - QUERY PLAN ------------------------------------------------------------------------ + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------- Sort Sort Key: pagg_tab_p1.a, (sum(pagg_tab_p1.b)), (avg(pagg_tab_p1.b)) -> Finalize HashAggregate @@ -70,7 +71,8 @@ SELECT a, sum(b), avg(b), count(*), min(a), max(b) FROM pagg_tab GROUP BY a HAVI -> Partial HashAggregate Group Key: pagg_tab_p3.a -> Seq Scan on pagg_tab_p3 -(15 rows) + Settings: enable_partitionwise_aggregate = 'on', enable_partitionwise_join = 'on', max_parallel_workers_per_gather = '0' +(16 rows) SELECT a, sum(b), avg(b), count(*), min(a), max(b) FROM pagg_tab GROUP BY a HAVING avg(d) < 15 ORDER BY 1, 2, 3; a | sum | avg | count | min | max @@ -90,8 +92,8 @@ SELECT a, sum(b), avg(b), count(*), min(a), max(b) FROM pagg_tab GROUP BY a HAVI -- Check with multiple columns in GROUP BY EXPLAIN (COSTS OFF) SELECT a, c, count(*) FROM pagg_tab GROUP BY a, c; - QUERY PLAN -------------------------------------------------- + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------- Append -> HashAggregate Group Key: pagg_tab_p1.a, pagg_tab_p1.c @@ -102,13 +104,14 @@ SELECT a, c, count(*) FROM pagg_tab GROUP BY a, c; -> HashAggregate Group Key: pagg_tab_p3.a, pagg_tab_p3.c -> Seq Scan on pagg_tab_p3 -(10 rows) + Settings: enable_partitionwise_aggregate = 'on', enable_partitionwise_join = 'on', max_parallel_workers_per_gather = '0' +(11 rows) -- Check with multiple columns in GROUP BY, order in GROUP BY is reversed EXPLAIN (COSTS OFF) SELECT a, c, count(*) FROM pagg_tab GROUP BY c, a; - QUERY PLAN -------------------------------------------------- + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------- Append -> HashAggregate Group Key: pagg_tab_p1.c, pagg_tab_p1.a @@ -119,13 +122,14 @@ SELECT a, c, count(*) FROM pagg_tab GROUP BY c, a; -> HashAggregate Group Key: pagg_tab_p3.c, pagg_tab_p3.a -> Seq Scan on pagg_tab_p3 -(10 rows) + Settings: enable_partitionwise_aggregate = 'on', enable_partitionwise_join = 'on', max_parallel_workers_per_gather = '0' +(11 rows) -- Check with multiple columns in GROUP BY, order in target-list is reversed EXPLAIN (COSTS OFF) SELECT c, a, count(*) FROM pagg_tab GROUP BY a, c; - QUERY PLAN -------------------------------------------------- + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------- Append -> HashAggregate Group Key: pagg_tab_p1.a, pagg_tab_p1.c @@ -136,18 +140,20 @@ SELECT c, a, count(*) FROM pagg_tab GROUP BY a, c; -> HashAggregate Group Key: pagg_tab_p3.a, pagg_tab_p3.c -> Seq Scan on pagg_tab_p3 -(10 rows) + Settings: enable_partitionwise_aggregate = 'on', enable_partitionwise_join = 'on', max_parallel_workers_per_gather = '0' +(11 rows) -- Test when input relation for grouping is dummy EXPLAIN (COSTS OFF) SELECT c, sum(a) FROM pagg_tab WHERE 1 = 2 GROUP BY c; - QUERY PLAN --------------------------------- + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------- HashAggregate Group Key: c -> Result One-Time Filter: false -(4 rows) + Settings: enable_partitionwise_aggregate = 'on', enable_partitionwise_join = 'on', max_parallel_workers_per_gather = '0' +(5 rows) SELECT c, sum(a) FROM pagg_tab WHERE 1 = 2 GROUP BY c; c | sum @@ -156,13 +162,14 @@ SELECT c, sum(a) FROM pagg_tab WHERE 1 = 2 GROUP BY c; EXPLAIN (COSTS OFF) SELECT c, sum(a) FROM pagg_tab WHERE c = 'x' GROUP BY c; - QUERY PLAN --------------------------------- + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------- GroupAggregate Group Key: c -> Result One-Time Filter: false -(4 rows) + Settings: enable_partitionwise_aggregate = 'on', enable_partitionwise_join = 'on', max_parallel_workers_per_gather = '0' +(5 rows) SELECT c, sum(a) FROM pagg_tab WHERE c = 'x' GROUP BY c; c | sum @@ -174,8 +181,8 @@ SET enable_hashagg TO false; -- When GROUP BY clause matches full aggregation is performed for each partition. EXPLAIN (COSTS OFF) SELECT c, sum(a), avg(b), count(*) FROM pagg_tab GROUP BY 1 HAVING avg(d) < 15 ORDER BY 1, 2, 3; - QUERY PLAN ------------------------------------------------------------------------ + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------------------------------- Sort Sort Key: pagg_tab_p1.c, (sum(pagg_tab_p1.a)), (avg(pagg_tab_p1.b)) -> Append @@ -197,7 +204,8 @@ SELECT c, sum(a), avg(b), count(*) FROM pagg_tab GROUP BY 1 HAVING avg(d) < 15 O -> Sort Sort Key: pagg_tab_p3.c -> Seq Scan on pagg_tab_p3 -(21 rows) + Settings: enable_hashagg = 'off', enable_partitionwise_aggregate = 'on', enable_partitionwise_join = 'on', max_parallel_workers_per_gather = '0' +(22 rows) SELECT c, sum(a), avg(b), count(*) FROM pagg_tab GROUP BY 1 HAVING avg(d) < 15 ORDER BY 1, 2, 3; c | sum | avg | count @@ -213,8 +221,8 @@ SELECT c, sum(a), avg(b), count(*) FROM pagg_tab GROUP BY 1 HAVING avg(d) < 15 O -- When GROUP BY clause does not match; partial aggregation is performed for each partition. EXPLAIN (COSTS OFF) SELECT a, sum(b), avg(b), count(*) FROM pagg_tab GROUP BY 1 HAVING avg(d) < 15 ORDER BY 1, 2, 3; - QUERY PLAN ------------------------------------------------------------------------ + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------------------------------- Sort Sort Key: pagg_tab_p1.a, (sum(pagg_tab_p1.b)), (avg(pagg_tab_p1.b)) -> Finalize GroupAggregate @@ -237,7 +245,8 @@ SELECT a, sum(b), avg(b), count(*) FROM pagg_tab GROUP BY 1 HAVING avg(d) < 15 O -> Sort Sort Key: pagg_tab_p3.a -> Seq Scan on pagg_tab_p3 -(22 rows) + Settings: enable_hashagg = 'off', enable_partitionwise_aggregate = 'on', enable_partitionwise_join = 'on', max_parallel_workers_per_gather = '0' +(23 rows) SELECT a, sum(b), avg(b), count(*) FROM pagg_tab GROUP BY 1 HAVING avg(d) < 15 ORDER BY 1, 2, 3; a | sum | avg | count @@ -257,8 +266,8 @@ SELECT a, sum(b), avg(b), count(*) FROM pagg_tab GROUP BY 1 HAVING avg(d) < 15 O -- Test partitionwise grouping without any aggregates EXPLAIN (COSTS OFF) SELECT c FROM pagg_tab GROUP BY c ORDER BY 1; - QUERY PLAN -------------------------------------------- + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------------------------------- Merge Append Sort Key: pagg_tab_p1.c -> Group @@ -276,7 +285,8 @@ SELECT c FROM pagg_tab GROUP BY c ORDER BY 1; -> Sort Sort Key: pagg_tab_p3.c -> Seq Scan on pagg_tab_p3 -(17 rows) + Settings: enable_hashagg = 'off', enable_partitionwise_aggregate = 'on', enable_partitionwise_join = 'on', max_parallel_workers_per_gather = '0' +(18 rows) SELECT c FROM pagg_tab GROUP BY c ORDER BY 1; c @@ -297,8 +307,8 @@ SELECT c FROM pagg_tab GROUP BY c ORDER BY 1; EXPLAIN (COSTS OFF) SELECT a FROM pagg_tab WHERE a < 3 GROUP BY a ORDER BY 1; - QUERY PLAN -------------------------------------------------- + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------------------------------- Group Group Key: pagg_tab_p1.a -> Merge Append @@ -321,7 +331,8 @@ SELECT a FROM pagg_tab WHERE a < 3 GROUP BY a ORDER BY 1; Sort Key: pagg_tab_p3.a -> Seq Scan on pagg_tab_p3 Filter: (a < 3) -(22 rows) + Settings: enable_hashagg = 'off', enable_partitionwise_aggregate = 'on', enable_partitionwise_join = 'on', max_parallel_workers_per_gather = '0' +(23 rows) SELECT a FROM pagg_tab WHERE a < 3 GROUP BY a ORDER BY 1; a @@ -335,8 +346,8 @@ RESET enable_hashagg; -- ROLLUP, partitionwise aggregation does not apply EXPLAIN (COSTS OFF) SELECT c, sum(a) FROM pagg_tab GROUP BY rollup(c) ORDER BY 1, 2; - QUERY PLAN -------------------------------------------------- + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------- Sort Sort Key: pagg_tab_p1.c, (sum(pagg_tab_p1.a)) -> MixedAggregate @@ -346,7 +357,8 @@ SELECT c, sum(a) FROM pagg_tab GROUP BY rollup(c) ORDER BY 1, 2; -> Seq Scan on pagg_tab_p1 -> Seq Scan on pagg_tab_p2 -> Seq Scan on pagg_tab_p3 -(9 rows) + Settings: enable_partitionwise_aggregate = 'on', enable_partitionwise_join = 'on', max_parallel_workers_per_gather = '0' +(10 rows) -- ORDERED SET within the aggregate. -- Full aggregation; since all the rows that belong to the same group come @@ -354,8 +366,8 @@ SELECT c, sum(a) FROM pagg_tab GROUP BY rollup(c) ORDER BY 1, 2; -- make any difference. EXPLAIN (COSTS OFF) SELECT c, sum(b order by a) FROM pagg_tab GROUP BY c ORDER BY 1, 2; - QUERY PLAN ------------------------------------------------------------------------- + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------- Sort Sort Key: pagg_tab_p1.c, (sum(pagg_tab_p1.b ORDER BY pagg_tab_p1.a)) -> Append @@ -374,15 +386,16 @@ SELECT c, sum(b order by a) FROM pagg_tab GROUP BY c ORDER BY 1, 2; -> Sort Sort Key: pagg_tab_p3.c -> Seq Scan on pagg_tab_p3 -(18 rows) + Settings: enable_partitionwise_aggregate = 'on', enable_partitionwise_join = 'on', max_parallel_workers_per_gather = '0' +(19 rows) -- Since GROUP BY clause does not match with PARTITION KEY; we need to do -- partial aggregation. However, ORDERED SET are not partial safe and thus -- partitionwise aggregation plan is not generated. EXPLAIN (COSTS OFF) SELECT a, sum(b order by a) FROM pagg_tab GROUP BY a ORDER BY 1, 2; - QUERY PLAN ------------------------------------------------------------------------- + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------- Sort Sort Key: pagg_tab_p1.a, (sum(pagg_tab_p1.b ORDER BY pagg_tab_p1.a)) -> GroupAggregate @@ -393,7 +406,8 @@ SELECT a, sum(b order by a) FROM pagg_tab GROUP BY a ORDER BY 1, 2; -> Seq Scan on pagg_tab_p1 -> Seq Scan on pagg_tab_p2 -> Seq Scan on pagg_tab_p3 -(10 rows) + Settings: enable_partitionwise_aggregate = 'on', enable_partitionwise_join = 'on', max_parallel_workers_per_gather = '0' +(11 rows) -- JOIN query CREATE TABLE pagg_tab1(x int, y int) PARTITION BY RANGE(x); @@ -411,8 +425,8 @@ ANALYZE pagg_tab2; -- When GROUP BY clause matches; full aggregation is performed for each partition. EXPLAIN (COSTS OFF) SELECT t1.x, sum(t1.y), count(*) FROM pagg_tab1 t1, pagg_tab2 t2 WHERE t1.x = t2.y GROUP BY t1.x ORDER BY 1, 2, 3; - QUERY PLAN -------------------------------------------------------------- + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------- Sort Sort Key: t1.x, (sum(t1.y)), (count(*)) -> Append @@ -437,7 +451,8 @@ SELECT t1.x, sum(t1.y), count(*) FROM pagg_tab1 t1, pagg_tab2 t2 WHERE t1.x = t2 -> Seq Scan on pagg_tab2_p3 t2_2 -> Hash -> Seq Scan on pagg_tab1_p3 t1_2 -(24 rows) + Settings: enable_partitionwise_aggregate = 'on', enable_partitionwise_join = 'on', max_parallel_workers_per_gather = '0' +(25 rows) SELECT t1.x, sum(t1.y), count(*) FROM pagg_tab1 t1, pagg_tab2 t2 WHERE t1.x = t2.y GROUP BY t1.x ORDER BY 1, 2, 3; x | sum | count @@ -452,8 +467,8 @@ SELECT t1.x, sum(t1.y), count(*) FROM pagg_tab1 t1, pagg_tab2 t2 WHERE t1.x = t2 -- Check with whole-row reference; partitionwise aggregation does not apply EXPLAIN (COSTS OFF) SELECT t1.x, sum(t1.y), count(t1) FROM pagg_tab1 t1, pagg_tab2 t2 WHERE t1.x = t2.y GROUP BY t1.x ORDER BY 1, 2, 3; - QUERY PLAN -------------------------------------------------------------- + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------- Sort Sort Key: t1.x, (sum(t1.y)), (count(((t1.*)::pagg_tab1))) -> HashAggregate @@ -469,7 +484,8 @@ SELECT t1.x, sum(t1.y), count(t1) FROM pagg_tab1 t1, pagg_tab2 t2 WHERE t1.x = t -> Seq Scan on pagg_tab2_p1 t2 -> Seq Scan on pagg_tab2_p2 t2_1 -> Seq Scan on pagg_tab2_p3 t2_2 -(15 rows) + Settings: enable_partitionwise_aggregate = 'on', enable_partitionwise_join = 'on', max_parallel_workers_per_gather = '0' +(16 rows) SELECT t1.x, sum(t1.y), count(t1) FROM pagg_tab1 t1, pagg_tab2 t2 WHERE t1.x = t2.y GROUP BY t1.x ORDER BY 1, 2, 3; x | sum | count @@ -484,8 +500,8 @@ SELECT t1.x, sum(t1.y), count(t1) FROM pagg_tab1 t1, pagg_tab2 t2 WHERE t1.x = t -- GROUP BY having other matching key EXPLAIN (COSTS OFF) SELECT t2.y, sum(t1.y), count(*) FROM pagg_tab1 t1, pagg_tab2 t2 WHERE t1.x = t2.y GROUP BY t2.y ORDER BY 1, 2, 3; - QUERY PLAN -------------------------------------------------------------- + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------- Sort Sort Key: t2.y, (sum(t1.y)), (count(*)) -> Append @@ -510,15 +526,16 @@ SELECT t2.y, sum(t1.y), count(*) FROM pagg_tab1 t1, pagg_tab2 t2 WHERE t1.x = t2 -> Seq Scan on pagg_tab2_p3 t2_2 -> Hash -> Seq Scan on pagg_tab1_p3 t1_2 -(24 rows) + Settings: enable_partitionwise_aggregate = 'on', enable_partitionwise_join = 'on', max_parallel_workers_per_gather = '0' +(25 rows) -- When GROUP BY clause does not match; partial aggregation is performed for each partition. -- Also test GroupAggregate paths by disabling hash aggregates. SET enable_hashagg TO false; EXPLAIN (COSTS OFF) SELECT t1.y, sum(t1.x), count(*) FROM pagg_tab1 t1, pagg_tab2 t2 WHERE t1.x = t2.y GROUP BY t1.y HAVING avg(t1.x) > 10 ORDER BY 1, 2, 3; - QUERY PLAN -------------------------------------------------------------------------- + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------------------------------- Sort Sort Key: t1.y, (sum(t1.x)), (count(*)) -> Finalize GroupAggregate @@ -553,7 +570,8 @@ SELECT t1.y, sum(t1.x), count(*) FROM pagg_tab1 t1, pagg_tab2 t2 WHERE t1.x = t2 -> Seq Scan on pagg_tab2_p3 t2_2 -> Hash -> Seq Scan on pagg_tab1_p3 t1_2 -(34 rows) + Settings: enable_hashagg = 'off', enable_partitionwise_aggregate = 'on', enable_partitionwise_join = 'on', max_parallel_workers_per_gather = '0' +(35 rows) SELECT t1.y, sum(t1.x), count(*) FROM pagg_tab1 t1, pagg_tab2 t2 WHERE t1.x = t2.y GROUP BY t1.y HAVING avg(t1.x) > 10 ORDER BY 1, 2, 3; y | sum | count @@ -573,8 +591,8 @@ RESET enable_hashagg; -- GROUP BY is on nullable column EXPLAIN (COSTS OFF) SELECT b.y, sum(a.y) FROM pagg_tab1 a LEFT JOIN pagg_tab2 b ON a.x = b.y GROUP BY b.y ORDER BY 1 NULLS LAST; - QUERY PLAN ------------------------------------------------------------------- + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------- Finalize GroupAggregate Group Key: b.y -> Sort @@ -601,7 +619,8 @@ SELECT b.y, sum(a.y) FROM pagg_tab1 a LEFT JOIN pagg_tab2 b ON a.x = b.y GROUP B -> Seq Scan on pagg_tab2_p3 b_2 -> Hash -> Seq Scan on pagg_tab1_p3 a_2 -(26 rows) + Settings: enable_partitionwise_aggregate = 'on', enable_partitionwise_join = 'on', max_parallel_workers_per_gather = '0' +(27 rows) SELECT b.y, sum(a.y) FROM pagg_tab1 a LEFT JOIN pagg_tab2 b ON a.x = b.y GROUP BY b.y ORDER BY 1 NULLS LAST; y | sum @@ -618,8 +637,8 @@ SELECT b.y, sum(a.y) FROM pagg_tab1 a LEFT JOIN pagg_tab2 b ON a.x = b.y GROUP B -- GROUP BY is on non-nullable column EXPLAIN (COSTS OFF) SELECT b.y, sum(a.y) FROM pagg_tab1 a RIGHT JOIN pagg_tab2 b ON a.x = b.y GROUP BY b.y ORDER BY 1 NULLS LAST; - QUERY PLAN ------------------------------------------------------------- + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------- Sort Sort Key: b.y -> Append @@ -644,7 +663,8 @@ SELECT b.y, sum(a.y) FROM pagg_tab1 a RIGHT JOIN pagg_tab2 b ON a.x = b.y GROUP -> Seq Scan on pagg_tab2_p3 b_2 -> Hash -> Seq Scan on pagg_tab1_p3 a_2 -(24 rows) + Settings: enable_partitionwise_aggregate = 'on', enable_partitionwise_join = 'on', max_parallel_workers_per_gather = '0' +(25 rows) SELECT b.y, sum(a.y) FROM pagg_tab1 a RIGHT JOIN pagg_tab2 b ON a.x = b.y GROUP BY b.y ORDER BY 1 NULLS LAST; y | sum @@ -665,8 +685,8 @@ SELECT b.y, sum(a.y) FROM pagg_tab1 a RIGHT JOIN pagg_tab2 b ON a.x = b.y GROUP -- GROUP BY is on nullable column EXPLAIN (COSTS OFF) SELECT a.x, sum(b.x) FROM pagg_tab1 a FULL OUTER JOIN pagg_tab2 b ON a.x = b.y GROUP BY a.x ORDER BY 1 NULLS LAST; - QUERY PLAN ------------------------------------------------------------------- + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------- Finalize GroupAggregate Group Key: a.x -> Sort @@ -693,7 +713,8 @@ SELECT a.x, sum(b.x) FROM pagg_tab1 a FULL OUTER JOIN pagg_tab2 b ON a.x = b.y G -> Seq Scan on pagg_tab2_p3 b_2 -> Hash -> Seq Scan on pagg_tab1_p3 a_2 -(26 rows) + Settings: enable_partitionwise_aggregate = 'on', enable_partitionwise_join = 'on', max_parallel_workers_per_gather = '0' +(27 rows) SELECT a.x, sum(b.x) FROM pagg_tab1 a FULL OUTER JOIN pagg_tab2 b ON a.x = b.y GROUP BY a.x ORDER BY 1 NULLS LAST; x | sum @@ -722,8 +743,8 @@ SELECT a.x, sum(b.x) FROM pagg_tab1 a FULL OUTER JOIN pagg_tab2 b ON a.x = b.y G -- But right now we are unable to do partitionwise join in this case. EXPLAIN (COSTS OFF) SELECT a.x, b.y, count(*) FROM (SELECT * FROM pagg_tab1 WHERE x < 20) a LEFT JOIN (SELECT * FROM pagg_tab2 WHERE y > 10) b ON a.x = b.y WHERE a.x > 5 or b.y < 20 GROUP BY a.x, b.y ORDER BY 1, 2; - QUERY PLAN ------------------------------------------------------------------------ + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------- Sort Sort Key: pagg_tab1_p1.x, pagg_tab2_p2.y -> HashAggregate @@ -742,7 +763,8 @@ SELECT a.x, b.y, count(*) FROM (SELECT * FROM pagg_tab1 WHERE x < 20) a LEFT JOI Filter: (y > 10) -> Seq Scan on pagg_tab2_p3 Filter: (y > 10) -(18 rows) + Settings: enable_partitionwise_aggregate = 'on', enable_partitionwise_join = 'on', max_parallel_workers_per_gather = '0' +(19 rows) SELECT a.x, b.y, count(*) FROM (SELECT * FROM pagg_tab1 WHERE x < 20) a LEFT JOIN (SELECT * FROM pagg_tab2 WHERE y > 10) b ON a.x = b.y WHERE a.x > 5 or b.y < 20 GROUP BY a.x, b.y ORDER BY 1, 2; x | y | count @@ -762,8 +784,8 @@ SELECT a.x, b.y, count(*) FROM (SELECT * FROM pagg_tab1 WHERE x < 20) a LEFT JOI -- But right now we are unable to do partitionwise join in this case. EXPLAIN (COSTS OFF) SELECT a.x, b.y, count(*) FROM (SELECT * FROM pagg_tab1 WHERE x < 20) a FULL JOIN (SELECT * FROM pagg_tab2 WHERE y > 10) b ON a.x = b.y WHERE a.x > 5 or b.y < 20 GROUP BY a.x, b.y ORDER BY 1, 2; - QUERY PLAN ------------------------------------------------------------------------ + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------- Sort Sort Key: pagg_tab1_p1.x, pagg_tab2_p2.y -> HashAggregate @@ -782,7 +804,8 @@ SELECT a.x, b.y, count(*) FROM (SELECT * FROM pagg_tab1 WHERE x < 20) a FULL JOI Filter: (y > 10) -> Seq Scan on pagg_tab2_p3 Filter: (y > 10) -(18 rows) + Settings: enable_partitionwise_aggregate = 'on', enable_partitionwise_join = 'on', max_parallel_workers_per_gather = '0' +(19 rows) SELECT a.x, b.y, count(*) FROM (SELECT * FROM pagg_tab1 WHERE x < 20) a FULL JOIN (SELECT * FROM pagg_tab2 WHERE y > 10) b ON a.x = b.y WHERE a.x > 5 or b.y < 20 GROUP BY a.x, b.y ORDER BY 1, 2; x | y | count @@ -800,15 +823,16 @@ SELECT a.x, b.y, count(*) FROM (SELECT * FROM pagg_tab1 WHERE x < 20) a FULL JOI -- Empty join relation because of empty outer side, no partitionwise agg plan EXPLAIN (COSTS OFF) SELECT a.x, a.y, count(*) FROM (SELECT * FROM pagg_tab1 WHERE x = 1 AND x = 2) a LEFT JOIN pagg_tab2 b ON a.x = b.y GROUP BY a.x, a.y ORDER BY 1, 2; - QUERY PLAN ---------------------------------------- + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------- GroupAggregate Group Key: pagg_tab1.x, pagg_tab1.y -> Sort Sort Key: pagg_tab1.y -> Result One-Time Filter: false -(6 rows) + Settings: enable_partitionwise_aggregate = 'on', enable_partitionwise_join = 'on', max_parallel_workers_per_gather = '0' +(7 rows) SELECT a.x, a.y, count(*) FROM (SELECT * FROM pagg_tab1 WHERE x = 1 AND x = 2) a LEFT JOIN pagg_tab2 b ON a.x = b.y GROUP BY a.x, a.y ORDER BY 1, 2; x | y | count @@ -825,8 +849,8 @@ ANALYZE pagg_tab_m; -- Partial aggregation as GROUP BY clause does not match with PARTITION KEY EXPLAIN (COSTS OFF) SELECT a, sum(b), avg(c), count(*) FROM pagg_tab_m GROUP BY a HAVING avg(c) < 22 ORDER BY 1, 2, 3; - QUERY PLAN ------------------------------------------------------------------------------ + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------- Sort Sort Key: pagg_tab_m_p1.a, (sum(pagg_tab_m_p1.b)), (avg(pagg_tab_m_p1.c)) -> Finalize HashAggregate @@ -842,7 +866,8 @@ SELECT a, sum(b), avg(c), count(*) FROM pagg_tab_m GROUP BY a HAVING avg(c) < 22 -> Partial HashAggregate Group Key: pagg_tab_m_p3.a -> Seq Scan on pagg_tab_m_p3 -(15 rows) + Settings: enable_partitionwise_aggregate = 'on', enable_partitionwise_join = 'on', max_parallel_workers_per_gather = '0' +(16 rows) SELECT a, sum(b), avg(c), count(*) FROM pagg_tab_m GROUP BY a HAVING avg(c) < 22 ORDER BY 1, 2, 3; a | sum | avg | count @@ -858,8 +883,8 @@ SELECT a, sum(b), avg(c), count(*) FROM pagg_tab_m GROUP BY a HAVING avg(c) < 22 -- Full aggregation as GROUP BY clause matches with PARTITION KEY EXPLAIN (COSTS OFF) SELECT a, sum(b), avg(c), count(*) FROM pagg_tab_m GROUP BY a, (a+b)/2 HAVING sum(b) < 50 ORDER BY 1, 2, 3; - QUERY PLAN -------------------------------------------------------------------------------------- + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------- Sort Sort Key: pagg_tab_m_p1.a, (sum(pagg_tab_m_p1.b)), (avg(pagg_tab_m_p1.c)) -> Append @@ -875,7 +900,8 @@ SELECT a, sum(b), avg(c), count(*) FROM pagg_tab_m GROUP BY a, (a+b)/2 HAVING su Group Key: pagg_tab_m_p3.a, ((pagg_tab_m_p3.a + pagg_tab_m_p3.b) / 2) Filter: (sum(pagg_tab_m_p3.b) < 50) -> Seq Scan on pagg_tab_m_p3 -(15 rows) + Settings: enable_partitionwise_aggregate = 'on', enable_partitionwise_join = 'on', max_parallel_workers_per_gather = '0' +(16 rows) SELECT a, sum(b), avg(c), count(*) FROM pagg_tab_m GROUP BY a, (a+b)/2 HAVING sum(b) < 50 ORDER BY 1, 2, 3; a | sum | avg | count @@ -891,8 +917,8 @@ SELECT a, sum(b), avg(c), count(*) FROM pagg_tab_m GROUP BY a, (a+b)/2 HAVING su -- Full aggregation as PARTITION KEY is part of GROUP BY clause EXPLAIN (COSTS OFF) SELECT a, c, sum(b), avg(c), count(*) FROM pagg_tab_m GROUP BY (a+b)/2, 2, 1 HAVING sum(b) = 50 AND avg(c) > 25 ORDER BY 1, 2, 3; - QUERY PLAN ------------------------------------------------------------------------------------------------------- + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------- Sort Sort Key: pagg_tab_m_p1.a, pagg_tab_m_p1.c, (sum(pagg_tab_m_p1.b)) -> Append @@ -908,7 +934,8 @@ SELECT a, c, sum(b), avg(c), count(*) FROM pagg_tab_m GROUP BY (a+b)/2, 2, 1 HAV Group Key: ((pagg_tab_m_p3.a + pagg_tab_m_p3.b) / 2), pagg_tab_m_p3.c, pagg_tab_m_p3.a Filter: ((sum(pagg_tab_m_p3.b) = 50) AND (avg(pagg_tab_m_p3.c) > '25'::numeric)) -> Seq Scan on pagg_tab_m_p3 -(15 rows) + Settings: enable_partitionwise_aggregate = 'on', enable_partitionwise_join = 'on', max_parallel_workers_per_gather = '0' +(16 rows) SELECT a, c, sum(b), avg(c), count(*) FROM pagg_tab_m GROUP BY (a+b)/2, 2, 1 HAVING sum(b) = 50 AND avg(c) > 25 ORDER BY 1, 2, 3; a | c | sum | avg | count @@ -972,7 +999,8 @@ SELECT a, sum(b), array_agg(distinct c), count(*) FROM pagg_tab_ml GROUP BY a HA -> Sort Sort Key: pagg_tab_ml_p1.a -> Seq Scan on pagg_tab_ml_p1 -(27 rows) + Settings: enable_partitionwise_aggregate = 'on', enable_partitionwise_join = 'on' +(28 rows) SELECT a, sum(b), array_agg(distinct c), count(*) FROM pagg_tab_ml GROUP BY a HAVING avg(b) < 3 ORDER BY 1, 2, 3; a | sum | array_agg | count @@ -991,8 +1019,8 @@ SELECT a, sum(b), array_agg(distinct c), count(*) FROM pagg_tab_ml GROUP BY a HA -- Without ORDER BY clause, to test Gather at top-most path EXPLAIN (COSTS OFF) SELECT a, sum(b), array_agg(distinct c), count(*) FROM pagg_tab_ml GROUP BY a HAVING avg(b) < 3; - QUERY PLAN ------------------------------------------------------------------ + QUERY PLAN +----------------------------------------------------------------------------------- Gather Workers Planned: 2 -> Parallel Append @@ -1018,15 +1046,16 @@ SELECT a, sum(b), array_agg(distinct c), count(*) FROM pagg_tab_ml GROUP BY a HA -> Sort Sort Key: pagg_tab_ml_p1.a -> Seq Scan on pagg_tab_ml_p1 -(25 rows) + Settings: enable_partitionwise_aggregate = 'on', enable_partitionwise_join = 'on' +(26 rows) -- Full aggregation at level 1 as GROUP BY clause matches with PARTITION KEY -- for level 1 only. For subpartitions, GROUP BY clause does not match with -- PARTITION KEY, thus we will have a partial aggregation for them. EXPLAIN (COSTS OFF) SELECT a, sum(b), count(*) FROM pagg_tab_ml GROUP BY a HAVING avg(b) < 3 ORDER BY 1, 2, 3; - QUERY PLAN -------------------------------------------------------------------- + QUERY PLAN +----------------------------------------------------------------------------------- Sort Sort Key: pagg_tab_ml_p1.a, (sum(pagg_tab_ml_p1.b)), (count(*)) -> Append @@ -1058,7 +1087,8 @@ SELECT a, sum(b), count(*) FROM pagg_tab_ml GROUP BY a HAVING avg(b) < 3 ORDER B -> Partial HashAggregate Group Key: pagg_tab_ml_p3_s2.a -> Seq Scan on pagg_tab_ml_p3_s2 -(31 rows) + Settings: enable_partitionwise_aggregate = 'on', enable_partitionwise_join = 'on' +(32 rows) SELECT a, sum(b), count(*) FROM pagg_tab_ml GROUP BY a HAVING avg(b) < 3 ORDER BY 1, 2, 3; a | sum | count @@ -1078,8 +1108,8 @@ SELECT a, sum(b), count(*) FROM pagg_tab_ml GROUP BY a HAVING avg(b) < 3 ORDER B -- PARTITION KEY EXPLAIN (COSTS OFF) SELECT b, sum(a), count(*) FROM pagg_tab_ml GROUP BY b ORDER BY 1, 2, 3; - QUERY PLAN -------------------------------------------------------------------- + QUERY PLAN +----------------------------------------------------------------------------------- Sort Sort Key: pagg_tab_ml_p1.b, (sum(pagg_tab_ml_p1.a)), (count(*)) -> Finalize GroupAggregate @@ -1102,7 +1132,8 @@ SELECT b, sum(a), count(*) FROM pagg_tab_ml GROUP BY b ORDER BY 1, 2, 3; -> Partial HashAggregate Group Key: pagg_tab_ml_p3_s2.b -> Seq Scan on pagg_tab_ml_p3_s2 -(22 rows) + Settings: enable_partitionwise_aggregate = 'on', enable_partitionwise_join = 'on' +(23 rows) SELECT b, sum(a), count(*) FROM pagg_tab_ml GROUP BY b HAVING avg(a) < 15 ORDER BY 1, 2, 3; b | sum | count @@ -1142,7 +1173,8 @@ SELECT a, sum(b), count(*) FROM pagg_tab_ml GROUP BY a, b, c HAVING avg(b) > 7 O Group Key: pagg_tab_ml_p3_s2.a, pagg_tab_ml_p3_s2.b, pagg_tab_ml_p3_s2.c Filter: (avg(pagg_tab_ml_p3_s2.b) > '7'::numeric) -> Seq Scan on pagg_tab_ml_p3_s2 -(23 rows) + Settings: enable_partitionwise_aggregate = 'on', enable_partitionwise_join = 'on' +(24 rows) SELECT a, sum(b), count(*) FROM pagg_tab_ml GROUP BY a, b, c HAVING avg(b) > 7 ORDER BY 1, 2, 3; a | sum | count @@ -1169,8 +1201,8 @@ SET parallel_setup_cost TO 0; -- PARTITION KEY, thus we will have a partial aggregation for them. EXPLAIN (COSTS OFF) SELECT a, sum(b), count(*) FROM pagg_tab_ml GROUP BY a HAVING avg(b) < 3 ORDER BY 1, 2, 3; - QUERY PLAN ----------------------------------------------------------------------------------- + QUERY PLAN +---------------------------------------------------------------------------------------------------------------------------------------------------- Sort Sort Key: pagg_tab_ml_p1.a, (sum(pagg_tab_ml_p1.b)), (count(*)) -> Append @@ -1212,7 +1244,8 @@ SELECT a, sum(b), count(*) FROM pagg_tab_ml GROUP BY a HAVING avg(b) < 3 ORDER B -> Partial HashAggregate Group Key: pagg_tab_ml_p3_s2.a -> Parallel Seq Scan on pagg_tab_ml_p3_s2 -(41 rows) + Settings: enable_partitionwise_aggregate = 'on', enable_partitionwise_join = 'on', min_parallel_table_scan_size = '8kB', parallel_setup_cost = '0' +(42 rows) SELECT a, sum(b), count(*) FROM pagg_tab_ml GROUP BY a HAVING avg(b) < 3 ORDER BY 1, 2, 3; a | sum | count @@ -1232,8 +1265,8 @@ SELECT a, sum(b), count(*) FROM pagg_tab_ml GROUP BY a HAVING avg(b) < 3 ORDER B -- PARTITION KEY EXPLAIN (COSTS OFF) SELECT b, sum(a), count(*) FROM pagg_tab_ml GROUP BY b ORDER BY 1, 2, 3; - QUERY PLAN ----------------------------------------------------------------------------- + QUERY PLAN +---------------------------------------------------------------------------------------------------------------------------------------------------- Sort Sort Key: pagg_tab_ml_p1.b, (sum(pagg_tab_ml_p1.a)), (count(*)) -> Finalize GroupAggregate @@ -1258,7 +1291,8 @@ SELECT b, sum(a), count(*) FROM pagg_tab_ml GROUP BY b ORDER BY 1, 2, 3; -> Partial HashAggregate Group Key: pagg_tab_ml_p3_s2.b -> Parallel Seq Scan on pagg_tab_ml_p3_s2 -(24 rows) + Settings: enable_partitionwise_aggregate = 'on', enable_partitionwise_join = 'on', min_parallel_table_scan_size = '8kB', parallel_setup_cost = '0' +(25 rows) SELECT b, sum(a), count(*) FROM pagg_tab_ml GROUP BY b HAVING avg(a) < 15 ORDER BY 1, 2, 3; b | sum | count @@ -1273,8 +1307,8 @@ SELECT b, sum(a), count(*) FROM pagg_tab_ml GROUP BY b HAVING avg(a) < 15 ORDER -- Full aggregation at all levels as GROUP BY clause matches with PARTITION KEY EXPLAIN (COSTS OFF) SELECT a, sum(b), count(*) FROM pagg_tab_ml GROUP BY a, b, c HAVING avg(b) > 7 ORDER BY 1, 2, 3; - QUERY PLAN ----------------------------------------------------------------------------------------------- + QUERY PLAN +---------------------------------------------------------------------------------------------------------------------------------------------------- Gather Merge Workers Planned: 2 -> Sort @@ -1300,7 +1334,8 @@ SELECT a, sum(b), count(*) FROM pagg_tab_ml GROUP BY a, b, c HAVING avg(b) > 7 O Group Key: pagg_tab_ml_p3_s2.a, pagg_tab_ml_p3_s2.b, pagg_tab_ml_p3_s2.c Filter: (avg(pagg_tab_ml_p3_s2.b) > '7'::numeric) -> Seq Scan on pagg_tab_ml_p3_s2 -(25 rows) + Settings: enable_partitionwise_aggregate = 'on', enable_partitionwise_join = 'on', min_parallel_table_scan_size = '8kB', parallel_setup_cost = '0' +(26 rows) SELECT a, sum(b), count(*) FROM pagg_tab_ml GROUP BY a, b, c HAVING avg(b) > 7 ORDER BY 1, 2, 3; a | sum | count @@ -1337,8 +1372,8 @@ ANALYZE pagg_tab_para; -- When GROUP BY clause matches; full aggregation is performed for each partition. EXPLAIN (COSTS OFF) SELECT x, sum(y), avg(y), count(*) FROM pagg_tab_para GROUP BY x HAVING avg(y) < 7 ORDER BY 1, 2, 3; - QUERY PLAN --------------------------------------------------------------------------------------- + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------------------------------- Sort Sort Key: pagg_tab_para_p1.x, (sum(pagg_tab_para_p1.y)), (avg(pagg_tab_para_p1.y)) -> Finalize GroupAggregate @@ -1358,7 +1393,8 @@ SELECT x, sum(y), avg(y), count(*) FROM pagg_tab_para GROUP BY x HAVING avg(y) < -> Partial HashAggregate Group Key: pagg_tab_para_p3.x -> Parallel Seq Scan on pagg_tab_para_p3 -(19 rows) + Settings: enable_partitionwise_aggregate = 'on', enable_partitionwise_join = 'on', min_parallel_table_scan_size = '8kB', parallel_setup_cost = '10' +(20 rows) SELECT x, sum(y), avg(y), count(*) FROM pagg_tab_para GROUP BY x HAVING avg(y) < 7 ORDER BY 1, 2, 3; x | sum | avg | count @@ -1374,8 +1410,8 @@ SELECT x, sum(y), avg(y), count(*) FROM pagg_tab_para GROUP BY x HAVING avg(y) < -- When GROUP BY clause does not match; partial aggregation is performed for each partition. EXPLAIN (COSTS OFF) SELECT y, sum(x), avg(x), count(*) FROM pagg_tab_para GROUP BY y HAVING avg(x) < 12 ORDER BY 1, 2, 3; - QUERY PLAN --------------------------------------------------------------------------------------- + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------------------------------- Sort Sort Key: pagg_tab_para_p1.y, (sum(pagg_tab_para_p1.x)), (avg(pagg_tab_para_p1.x)) -> Finalize GroupAggregate @@ -1395,7 +1431,8 @@ SELECT y, sum(x), avg(x), count(*) FROM pagg_tab_para GROUP BY y HAVING avg(x) < -> Partial HashAggregate Group Key: pagg_tab_para_p3.y -> Parallel Seq Scan on pagg_tab_para_p3 -(19 rows) + Settings: enable_partitionwise_aggregate = 'on', enable_partitionwise_join = 'on', min_parallel_table_scan_size = '8kB', parallel_setup_cost = '10' +(20 rows) SELECT y, sum(x), avg(x), count(*) FROM pagg_tab_para GROUP BY y HAVING avg(x) < 12 ORDER BY 1, 2, 3; y | sum | avg | count @@ -1412,8 +1449,8 @@ ALTER TABLE pagg_tab_para_p3 SET (parallel_workers = 0); ANALYZE pagg_tab_para; EXPLAIN (COSTS OFF) SELECT x, sum(y), avg(y), count(*) FROM pagg_tab_para GROUP BY x HAVING avg(y) < 7 ORDER BY 1, 2, 3; - QUERY PLAN --------------------------------------------------------------------------------------- + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------------------------------- Sort Sort Key: pagg_tab_para_p1.x, (sum(pagg_tab_para_p1.y)), (avg(pagg_tab_para_p1.y)) -> Finalize GroupAggregate @@ -1429,7 +1466,8 @@ SELECT x, sum(y), avg(y), count(*) FROM pagg_tab_para GROUP BY x HAVING avg(y) < -> Seq Scan on pagg_tab_para_p1 -> Seq Scan on pagg_tab_para_p3 -> Parallel Seq Scan on pagg_tab_para_p2 -(15 rows) + Settings: enable_partitionwise_aggregate = 'on', enable_partitionwise_join = 'on', min_parallel_table_scan_size = '8kB', parallel_setup_cost = '10' +(16 rows) SELECT x, sum(y), avg(y), count(*) FROM pagg_tab_para GROUP BY x HAVING avg(y) < 7 ORDER BY 1, 2, 3; x | sum | avg | count @@ -1446,8 +1484,8 @@ ALTER TABLE pagg_tab_para_p2 SET (parallel_workers = 0); ANALYZE pagg_tab_para; EXPLAIN (COSTS OFF) SELECT x, sum(y), avg(y), count(*) FROM pagg_tab_para GROUP BY x HAVING avg(y) < 7 ORDER BY 1, 2, 3; - QUERY PLAN --------------------------------------------------------------------------------------- + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------------------------------- Sort Sort Key: pagg_tab_para_p1.x, (sum(pagg_tab_para_p1.y)), (avg(pagg_tab_para_p1.y)) -> Finalize GroupAggregate @@ -1463,7 +1501,8 @@ SELECT x, sum(y), avg(y), count(*) FROM pagg_tab_para GROUP BY x HAVING avg(y) < -> Seq Scan on pagg_tab_para_p1 -> Seq Scan on pagg_tab_para_p2 -> Seq Scan on pagg_tab_para_p3 -(15 rows) + Settings: enable_partitionwise_aggregate = 'on', enable_partitionwise_join = 'on', min_parallel_table_scan_size = '8kB', parallel_setup_cost = '10' +(16 rows) SELECT x, sum(y), avg(y), count(*) FROM pagg_tab_para GROUP BY x HAVING avg(y) < 7 ORDER BY 1, 2, 3; x | sum | avg | count @@ -1498,7 +1537,8 @@ SELECT x, sum(y), avg(y), count(*) FROM pagg_tab_para GROUP BY x HAVING avg(y) < Group Key: pagg_tab_para_p3.x Filter: (avg(pagg_tab_para_p3.y) < '7'::numeric) -> Seq Scan on pagg_tab_para_p3 -(15 rows) + Settings: enable_partitionwise_aggregate = 'on', enable_partitionwise_join = 'on' +(16 rows) SELECT x, sum(y), avg(y), count(*) FROM pagg_tab_para GROUP BY x HAVING avg(y) < 7 ORDER BY 1, 2, 3; x | sum | avg | count diff --git a/src/test/regress/expected/partition_join.out b/src/test/regress/expected/partition_join.out index 1296edcdae..01a1444311 100644 --- a/src/test/regress/expected/partition_join.out +++ b/src/test/regress/expected/partition_join.out @@ -51,7 +51,8 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = -> Hash -> Seq Scan on prt1_p3 t1_2 Filter: (b = 0) -(21 rows) + Settings: enable_partitionwise_join = 'on' +(22 rows) SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b; a | c | b | c @@ -83,7 +84,8 @@ SELECT t1, t2 FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER Filter: (b = 0) -> Seq Scan on prt1_p3 t1_2 Filter: (b = 0) -(16 rows) + Settings: enable_partitionwise_join = 'on' +(17 rows) SELECT t1, t2 FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b; t1 | t2 @@ -127,7 +129,8 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHE Filter: (a = 0) -> Index Scan using iprt1_p3_a on prt1_p3 t1_2 Index Cond: (a = t2_2.b) -(20 rows) + Settings: enable_partitionwise_join = 'on' +(21 rows) SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t1.a, t2.b; a | c | b | c @@ -174,7 +177,8 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0) -> Hash -> Seq Scan on prt2_p3 Filter: (a = 0) -(27 rows) + Settings: enable_partitionwise_join = 'on' +(28 rows) SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0) t1 FULL JOIN (SELECT 75 phv, * FROM prt2 WHERE prt2.a = 0) t2 ON (t1.a = t2.b) WHERE t1.phv = t1.a OR t2.phv = t2.b ORDER BY t1.a, t2.b; a | c | b | c @@ -197,7 +201,8 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.a < -> Hash -> Seq Scan on prt1_p2 t1 Filter: ((a < 450) AND (b = 0)) -(9 rows) + Settings: enable_partitionwise_join = 'on' +(10 rows) SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.a < 450 AND t2.b > 250 AND t1.b = 0 ORDER BY t1.a, t2.b; a | c | b | c @@ -225,7 +230,8 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JO Filter: ((a < 450) AND (b = 0)) -> Seq Scan on prt1_p2 Filter: ((a < 450) AND (b = 0)) -(15 rows) + Settings: enable_partitionwise_join = 'on' +(16 rows) SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b; a | c | b | c @@ -262,7 +268,8 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JO Filter: (b > 250) -> Seq Scan on prt2_p3 Filter: (b > 250) -(16 rows) + Settings: enable_partitionwise_join = 'on' +(17 rows) SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 OR t2.a = 0 ORDER BY t1.a, t2.b; a | c | b | c @@ -310,7 +317,8 @@ SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) -> Materialize -> Seq Scan on prt2_p3 t2_2 Filter: (a = 0) -(24 rows) + Settings: enable_partitionwise_join = 'on' +(25 rows) SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a; a | b | c @@ -343,7 +351,8 @@ SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS -> Seq Scan on prt1_p3 t1_2 -> Hash -> Seq Scan on prt2_p3 t2_2 -(17 rows) + Settings: enable_partitionwise_join = 'on' +(18 rows) SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b); sum | avg | sum | avg @@ -385,7 +394,8 @@ SELECT * FROM prt1 t1 LEFT JOIN LATERAL Index Cond: (a = t1_2.a) -> Index Scan using iprt2_p3_b on prt2_p3 t3_2 Index Cond: (b = t2_2.a) -(27 rows) + Settings: enable_partitionwise_join = 'on' +(28 rows) SELECT * FROM prt1 t1 LEFT JOIN LATERAL (SELECT t2.a AS t2a, t3.a AS t3a, least(t1.a,t2.a,t3.b) FROM prt1 t2 JOIN prt2 t3 ON (t2.a = t3.b)) ss @@ -438,7 +448,8 @@ SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL -> Seq Scan on prt1_p3 t2_2 -> Hash -> Seq Scan on prt2_p3 t3_2 -(26 rows) + Settings: enable_partitionwise_join = 'on' +(27 rows) SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL (SELECT t2.a AS t2a, t3.a AS t3a, t2.b t2b, t2.c t2c, least(t1.a,t2.a,t3.a) FROM prt1 t2 JOIN prt2 t3 ON (t2.a = t3.b)) ss @@ -502,7 +513,8 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 = -> Hash -> Seq Scan on prt1_e_p3 t1_2 Filter: (c = 0) -(21 rows) + Settings: enable_partitionwise_join = 'on' +(22 rows) SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 = (t2.b + t2.a)/2 AND t1.c = 0 ORDER BY t1.a, t2.b; a | c | b | c @@ -553,7 +565,8 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM prt1 t1, prt2 t2, prt1_e t Filter: (b = 0) -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_2 Index Cond: (((a + b) / 2) = t2_2.b) -(33 rows) + Settings: enable_partitionwise_join = 'on' +(34 rows) SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM prt1 t1, prt2 t2, prt1_e t3 WHERE t1.a = t2.b AND t1.a = (t3.a + t3.b)/2 AND t1.b = 0 ORDER BY t1.a, t2.b; a | c | b | c | ?column? | c @@ -601,7 +614,8 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 -> Hash -> Seq Scan on prt1_p3 t1_2 Filter: (b = 0) -(33 rows) + Settings: enable_partitionwise_join = 'on' +(34 rows) SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) LEFT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.b = 0 ORDER BY t1.a, t2.b, t3.a + t3.b; a | c | b | c | ?column? | c @@ -654,7 +668,8 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 Filter: (c = 0) -> Index Scan using iprt2_p3_b on prt2_p3 t2_2 Index Cond: (b = t1_2.a) -(30 rows) + Settings: enable_partitionwise_join = 'on' +(31 rows) SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b; a | c | b | c | ?column? | c @@ -721,7 +736,8 @@ SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * F -> Hash -> Seq Scan on prt1_e_p3 Filter: (c = 0) -(42 rows) + Settings: enable_partitionwise_join = 'on' +(43 rows) SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0) t1 FULL JOIN (SELECT 75 phv, * FROM prt2 WHERE prt2.a = 0) t2 ON (t1.a = t2.b)) FULL JOIN (SELECT 50 phv, * FROM prt1_e WHERE prt1_e.c = 0) t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.a = t1.phv OR t2.b = t2.phv OR (t3.a + t3.b)/2 = t3.phv ORDER BY t1.a, t2.b, t3.a + t3.b; a | phv | b | phv | ?column? | phv @@ -776,7 +792,8 @@ SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1, prt1_e t2 WHER -> Index Scan using iprt1_p3_a on prt1_p3 t1_2 Index Cond: (a = ((t2_2.a + t2_2.b) / 2)) Filter: (b = 0) -(41 rows) + Settings: enable_partitionwise_join = 'on' +(42 rows) SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1, prt1_e t2 WHERE t1.a = 0 AND t1.b = (t2.a + t2.b)/2) AND t1.b = 0 ORDER BY t1.a; a | b | c @@ -830,7 +847,8 @@ SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN ( -> Index Scan using iprt1_p3_a on prt1_p3 t1_2 Index Cond: (a = t1_5.b) Filter: (b = 0) -(39 rows) + Settings: enable_partitionwise_join = 'on' +(40 rows) SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a; a | b | c @@ -846,8 +864,8 @@ SET enable_hashjoin TO off; SET enable_nestloop TO off; EXPLAIN (COSTS OFF) SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a; - QUERY PLAN ----------------------------------------------------------------- + QUERY PLAN +---------------------------------------------------------------------------------------------- Merge Append Sort Key: t1.a -> Merge Semi Join @@ -895,7 +913,8 @@ SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN ( Sort Key: (((t1_8.a + t1_8.b) / 2)) -> Seq Scan on prt1_e_p3 t1_8 Filter: (c = 0) -(47 rows) + Settings: enable_hashjoin = 'off', enable_nestloop = 'off', enable_partitionwise_join = 'on' +(48 rows) SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a; a | b | c @@ -908,8 +927,8 @@ SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN ( EXPLAIN (COSTS OFF) SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b; - QUERY PLAN ----------------------------------------------------------------------------- + QUERY PLAN +---------------------------------------------------------------------------------------------- Sort Sort Key: t1.a, t2.b, ((t3.a + t3.b)) -> Append @@ -961,7 +980,8 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 -> Sort Sort Key: t2_2.b -> Seq Scan on prt2_p3 t2_2 -(51 rows) + Settings: enable_hashjoin = 'off', enable_nestloop = 'off', enable_partitionwise_join = 'on' +(52 rows) SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b; a | c | b | c | ?column? | c @@ -984,8 +1004,8 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 -- This should generate a partitionwise join, but currently fails to EXPLAIN (COSTS OFF) SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b; - QUERY PLAN ------------------------------------------------------------ + QUERY PLAN +---------------------------------------------------------------------------------------------- Sort Sort Key: prt1_p1.a, prt2_p2.b -> Merge Left Join @@ -1004,7 +1024,8 @@ SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT * Filter: (b > 250) -> Seq Scan on prt2_p3 Filter: (b > 250) -(18 rows) + Settings: enable_hashjoin = 'off', enable_nestloop = 'off', enable_partitionwise_join = 'on' +(19 rows) SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b; a | b @@ -1024,8 +1045,8 @@ SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT * -- partitionwise join does not apply EXPLAIN (COSTS OFF) SELECT t1.a, t2.b FROM prt1 t1, prt2 t2 WHERE t1::text = t2::text AND t1.a = t2.b ORDER BY t1.a; - QUERY PLAN ------------------------------------------------------------------------------------------ + QUERY PLAN +---------------------------------------------------------------------------------------------- Merge Join Merge Cond: ((t1.a = t2.b) AND (((((t1.*)::prt1))::text) = ((((t2.*)::prt2))::text))) -> Sort @@ -1042,7 +1063,8 @@ SELECT t1.a, t2.b FROM prt1 t1, prt2 t2 WHERE t1::text = t2::text AND t1.a = t2. -> Seq Scan on prt2_p1 t2 -> Seq Scan on prt2_p2 t2_1 -> Seq Scan on prt2_p3 t2_2 -(16 rows) + Settings: enable_hashjoin = 'off', enable_nestloop = 'off', enable_partitionwise_join = 'on' +(17 rows) SELECT t1.a, t2.b FROM prt1 t1, prt2 t2 WHERE t1::text = t2::text AND t1.a = t2.b ORDER BY t1.a; a | b @@ -1099,7 +1121,8 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1 -> Hash -> Seq Scan on prt2_m_p3 Filter: (c = 0) -(24 rows) + Settings: enable_partitionwise_join = 'on' +(25 rows) SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1 FULL JOIN (SELECT * FROM prt2_m WHERE prt2_m.c = 0) t2 ON (t1.a = (t2.b + t2.a)/2 AND t2.b = (t1.a + t1.b)/2) ORDER BY t1.a, t2.b; a | c | b | c @@ -1183,7 +1206,8 @@ SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, pl -> Seq Scan on plt2_p3 t2_2 -> Hash -> Seq Scan on plt1_e_p3 t3_2 -(32 rows) + Settings: enable_partitionwise_join = 'on' +(33 rows) SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c; avg | avg | avg | c | c | c @@ -1205,19 +1229,21 @@ SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, pl -- joins where one of the relations is proven empty EXPLAIN (COSTS OFF) SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.a = 1 AND t1.a = 2; - QUERY PLAN --------------------------- + QUERY PLAN +-------------------------------------------- Result One-Time Filter: false -(2 rows) + Settings: enable_partitionwise_join = 'on' +(3 rows) EXPLAIN (COSTS OFF) SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a = 1 AND a = 2) t1 LEFT JOIN prt2 t2 ON t1.a = t2.b; - QUERY PLAN --------------------------- + QUERY PLAN +-------------------------------------------- Result One-Time Filter: false -(2 rows) + Settings: enable_partitionwise_join = 'on' +(3 rows) EXPLAIN (COSTS OFF) SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a = 1 AND a = 2) t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b, prt1 t3 WHERE t2.b = t3.a; @@ -1244,7 +1270,8 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a = 1 AND a = 2) t1 -> Hash -> Result One-Time Filter: false -(21 rows) + Settings: enable_partitionwise_join = 'on' +(22 rows) EXPLAIN (COSTS OFF) SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a = 1 AND a = 2) t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t1.a, t2.b; @@ -1264,7 +1291,8 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a = 1 AND a = 2) t1 -> Hash -> Result One-Time Filter: false -(14 rows) + Settings: enable_partitionwise_join = 'on' +(15 rows) -- -- tests for hash partitioned tables. @@ -1327,7 +1355,8 @@ SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM pht1 t1, ph -> Seq Scan on pht2_p3 t2_2 -> Hash -> Seq Scan on pht1_e_p3 t3_2 -(32 rows) + Settings: enable_partitionwise_join = 'on' +(33 rows) SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM pht1 t1, pht2 t2, pht1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c; avg | avg | avg | c | c | c @@ -1372,7 +1401,8 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = -> Hash -> Seq Scan on prt1_p3 t1_2 Filter: (b = 0) -(21 rows) + Settings: enable_partitionwise_join = 'on' +(22 rows) -- test default partition behavior for list ALTER TABLE plt1 DETACH PARTITION plt1_p3; @@ -1408,7 +1438,8 @@ SELECT avg(t1.a), avg(t2.b), t1.c, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c -> Hash -> Seq Scan on plt1_p3 t1_2 Filter: ((a % 25) = 0) -(23 rows) + Settings: enable_partitionwise_join = 'on' +(24 rows) -- -- multiple levels of partitioning @@ -1466,7 +1497,8 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_l t1, prt2_l t2 WHERE t1.a = t2.b AND t1 -> Hash -> Seq Scan on prt1_l_p3_p1 t1_3 Filter: (b = 0) -(28 rows) + Settings: enable_partitionwise_join = 'on' +(29 rows) SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_l t1, prt2_l t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b; a | c | b | c @@ -1511,7 +1543,8 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_l t1 LEFT JOIN prt2_l t2 ON t1.a = t2.b -> Hash -> Seq Scan on prt1_l_p3_p1 t1_3 Filter: (b = 0) -(29 rows) + Settings: enable_partitionwise_join = 'on' +(30 rows) SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_l t1 LEFT JOIN prt2_l t2 ON t1.a = t2.b AND t1.c = t2.c WHERE t1.b = 0 ORDER BY t1.a, t2.b; a | c | b | c @@ -1564,7 +1597,8 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_l t1 RIGHT JOIN prt2_l t2 ON t1.a = t2.b -> Hash -> Seq Scan on prt2_l_p3_p1 t2_3 Filter: (a = 0) -(29 rows) + Settings: enable_partitionwise_join = 'on' +(30 rows) SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_l t1 RIGHT JOIN prt2_l t2 ON t1.a = t2.b AND t1.c = t2.c WHERE t2.a = 0 ORDER BY t1.a, t2.b; a | c | b | c @@ -1615,7 +1649,8 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_l WHERE prt1_l.b = 0) t1 -> Hash -> Seq Scan on prt2_l_p3_p1 Filter: (a = 0) -(31 rows) + Settings: enable_partitionwise_join = 'on' +(32 rows) SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_l WHERE prt1_l.b = 0) t1 FULL JOIN (SELECT * FROM prt2_l WHERE prt2_l.a = 0) t2 ON (t1.a = t2.b AND t1.c = t2.c) ORDER BY t1.a, t2.b; a | c | b | c @@ -1689,7 +1724,8 @@ SELECT * FROM prt1_l t1 LEFT JOIN LATERAL Filter: ((t1_3.a = a) AND ((t1_3.c)::text = (c)::text)) -> Seq Scan on prt1_l_p3_p2 t2_4 Filter: ((t1_3.a = a) AND ((t1_3.c)::text = (c)::text)) -(44 rows) + Settings: enable_partitionwise_join = 'on' +(45 rows) SELECT * FROM prt1_l t1 LEFT JOIN LATERAL (SELECT t2.a AS t2a, t2.c AS t2c, t2.b AS t2b, t3.b AS t3b, least(t1.a,t2.a,t3.b) FROM prt1_l t2 JOIN prt2_l t3 ON (t2.a = t3.b AND t2.c = t3.c)) ss @@ -1726,7 +1762,8 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_l WHERE a = 1 AND a = 2) -> Hash -> Result One-Time Filter: false -(11 rows) + Settings: enable_partitionwise_join = 'on' +(12 rows) -- Test case to verify proper handling of subqueries in a partitioned delete. -- The weird-looking lateral join is just there to force creation of a @@ -1769,7 +1806,8 @@ WHERE EXISTS ( -> Subquery Scan on ss_2 -> Limit -> Seq Scan on int8_tbl int8_tbl_2 -(28 rows) + Settings: enable_partitionwise_join = 'on' +(29 rows) -- -- negative testcases @@ -1812,7 +1850,8 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt4_n t2 WHERE t1.a = t2.a; -> Seq Scan on prt4_n_p1 t2 -> Seq Scan on prt4_n_p2 t2_1 -> Seq Scan on prt4_n_p3 t2_2 -(11 rows) + Settings: enable_partitionwise_join = 'on' +(12 rows) EXPLAIN (COSTS OFF) SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt4_n t2, prt2 t3 WHERE t1.a = t2.a and t1.a = t3.b; @@ -1841,7 +1880,8 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt4_n t2, prt2 t3 WHERE t1.a = t2.a -> Seq Scan on prt1_p3 t1_2 -> Hash -> Seq Scan on prt2_p3 t3_2 -(23 rows) + Settings: enable_partitionwise_join = 'on' +(24 rows) -- partitionwise join can not be applied if there are no equi-join conditions -- between partition keys @@ -1861,7 +1901,8 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON (t1.a < t2.b); Index Cond: (b > t1.a) -> Index Scan using iprt2_p3_b on prt2_p3 t2_2 Index Cond: (b > t1.a) -(12 rows) + Settings: enable_partitionwise_join = 'on' +(13 rows) -- equi-join with join condition on partial keys does not qualify for -- partitionwise join @@ -1880,7 +1921,8 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_m t1, prt2_m t2 WHERE t1.a = (t2.b + t2. -> Seq Scan on prt1_m_p1 t1 -> Seq Scan on prt1_m_p2 t1_1 -> Seq Scan on prt1_m_p3 t1_2 -(11 rows) + Settings: enable_partitionwise_join = 'on' +(12 rows) -- equi-join between out-of-order partition key columns does not qualify for -- partitionwise join @@ -1899,7 +1941,8 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_m t1 LEFT JOIN prt2_m t2 ON t1.a = t2.b; -> Seq Scan on prt2_m_p1 t2 -> Seq Scan on prt2_m_p2 t2_1 -> Seq Scan on prt2_m_p3 t2_2 -(11 rows) + Settings: enable_partitionwise_join = 'on' +(12 rows) -- equi-join between non-key columns does not qualify for partitionwise join EXPLAIN (COSTS OFF) @@ -1917,7 +1960,8 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_m t1 LEFT JOIN prt2_m t2 ON t1.c = t2.c; -> Seq Scan on prt2_m_p1 t2 -> Seq Scan on prt2_m_p2 t2_1 -> Seq Scan on prt2_m_p3 t2_2 -(11 rows) + Settings: enable_partitionwise_join = 'on' +(12 rows) -- partitionwise join can not be applied between tables with different -- partition lists @@ -1934,7 +1978,8 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_n t1 LEFT JOIN prt2_n t2 ON (t1.c = t2.c -> Append -> Seq Scan on prt1_n_p1 t1 -> Seq Scan on prt1_n_p2 t1_1 -(9 rows) + Settings: enable_partitionwise_join = 'on' +(10 rows) EXPLAIN (COSTS OFF) SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_n t1 JOIN prt2_n t2 ON (t1.c = t2.c) JOIN plt1 t3 ON (t1.c = t3.c); @@ -1956,7 +2001,8 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_n t1 JOIN prt2_n t2 ON (t1.c = t2.c) JOI -> Append -> Seq Scan on prt1_n_p1 t1 -> Seq Scan on prt1_n_p2 t1_1 -(16 rows) + Settings: enable_partitionwise_join = 'on' +(17 rows) -- partitionwise join can not be applied for a join between list and range -- partitioned table @@ -1974,7 +2020,8 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_n t1 FULL JOIN prt1 t2 ON (t1.c = t2.c); -> Append -> Seq Scan on prt1_n_p1 t1 -> Seq Scan on prt1_n_p2 t1_1 -(10 rows) + Settings: enable_partitionwise_join = 'on' +(11 rows) -- partitionwise join can not be applied if only one of joining table has -- default partition @@ -2001,5 +2048,6 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = Filter: (b = 0) -> Seq Scan on prt1_p3 t1_2 Filter: (b = 0) -(16 rows) + Settings: enable_partitionwise_join = 'on' +(17 rows) diff --git a/src/test/regress/expected/partition_prune.out b/src/test/regress/expected/partition_prune.out index bd64bed8fc..a0eb3f62d5 100644 --- a/src/test/regress/expected/partition_prune.out +++ b/src/test/regress/expected/partition_prune.out @@ -1623,7 +1623,7 @@ create table ab_a3_b1 partition of ab_a3 for values in (1); create table ab_a3_b2 partition of ab_a3 for values in (2); create table ab_a3_b3 partition of ab_a3 for values in (3); -- Disallow index only scans as concurrent transactions may stop visibility --- bits being set causing "Heap Fetches" to be unstable in the EXPLAIN ANALYZE +-- bits being set causing "Heap Fetches" to be unstable in the EXPLAIN EXEC -- output. set enable_indexonlyscan = off; prepare ab_q1 (int, int, int) as @@ -1655,7 +1655,7 @@ execute ab_q1 (1, 8, 3); ---+--- (0 rows) -explain (analyze, costs off, summary off, timing off) execute ab_q1 (2, 2, 3); +explain (exec, costs off, summary off, timing off) execute ab_q1 (2, 2, 3); QUERY PLAN --------------------------------------------------------- Append (actual rows=0 loops=1) @@ -1666,9 +1666,10 @@ explain (analyze, costs off, summary off, timing off) execute ab_q1 (2, 2, 3); Filter: ((a >= $1) AND (a <= $2) AND (b <= $3)) -> Seq Scan on ab_a2_b3 (actual rows=0 loops=1) Filter: ((a >= $1) AND (a <= $2) AND (b <= $3)) -(8 rows) + Settings: enable_indexonlyscan = 'off' +(9 rows) -explain (analyze, costs off, summary off, timing off) execute ab_q1 (1, 2, 3); +explain (exec, costs off, summary off, timing off) execute ab_q1 (1, 2, 3); QUERY PLAN --------------------------------------------------------- Append (actual rows=0 loops=1) @@ -1685,7 +1686,8 @@ explain (analyze, costs off, summary off, timing off) execute ab_q1 (1, 2, 3); Filter: ((a >= $1) AND (a <= $2) AND (b <= $3)) -> Seq Scan on ab_a2_b3 (actual rows=0 loops=1) Filter: ((a >= $1) AND (a <= $2) AND (b <= $3)) -(14 rows) + Settings: enable_indexonlyscan = 'off' +(15 rows) deallocate ab_q1; -- Runtime pruning after optimizer pruning @@ -1718,7 +1720,7 @@ execute ab_q1 (1, 8); --- (0 rows) -explain (analyze, costs off, summary off, timing off) execute ab_q1 (2, 2); +explain (exec, costs off, summary off, timing off) execute ab_q1 (2, 2); QUERY PLAN ------------------------------------------------------- Append (actual rows=0 loops=1) @@ -1727,9 +1729,10 @@ explain (analyze, costs off, summary off, timing off) execute ab_q1 (2, 2); Filter: ((a >= $1) AND (a <= $2) AND (b < 3)) -> Seq Scan on ab_a2_b2 (actual rows=0 loops=1) Filter: ((a >= $1) AND (a <= $2) AND (b < 3)) -(6 rows) + Settings: enable_indexonlyscan = 'off' +(7 rows) -explain (analyze, costs off, summary off, timing off) execute ab_q1 (2, 4); +explain (exec, costs off, summary off, timing off) execute ab_q1 (2, 4); QUERY PLAN ------------------------------------------------------- Append (actual rows=0 loops=1) @@ -1742,7 +1745,8 @@ explain (analyze, costs off, summary off, timing off) execute ab_q1 (2, 4); Filter: ((a >= $1) AND (a <= $2) AND (b < 3)) -> Seq Scan on ab_a3_b2 (actual rows=0 loops=1) Filter: ((a >= $1) AND (a <= $2) AND (b < 3)) -(10 rows) + Settings: enable_indexonlyscan = 'off' +(11 rows) -- Ensure a mix of PARAM_EXTERN and PARAM_EXEC Params work together at -- different levels of partitioning. @@ -1773,7 +1777,7 @@ execute ab_q2 (1, 8); --- (0 rows) -explain (analyze, costs off, summary off, timing off) execute ab_q2 (2, 2); +explain (exec, costs off, summary off, timing off) execute ab_q2 (2, 2); QUERY PLAN -------------------------------------------------------- Append (actual rows=0 loops=1) @@ -1786,7 +1790,8 @@ explain (analyze, costs off, summary off, timing off) execute ab_q2 (2, 2); Filter: ((a >= $1) AND (a <= $2) AND (b < $0)) -> Seq Scan on ab_a2_b3 (never executed) Filter: ((a >= $1) AND (a <= $2) AND (b < $0)) -(10 rows) + Settings: enable_indexonlyscan = 'off' +(11 rows) -- As above, but swap the PARAM_EXEC Param to the first partition level prepare ab_q3 (int, int) as @@ -1816,7 +1821,7 @@ execute ab_q3 (1, 8); --- (0 rows) -explain (analyze, costs off, summary off, timing off) execute ab_q3 (2, 2); +explain (exec, costs off, summary off, timing off) execute ab_q3 (2, 2); QUERY PLAN -------------------------------------------------------- Append (actual rows=0 loops=1) @@ -1829,7 +1834,8 @@ explain (analyze, costs off, summary off, timing off) execute ab_q3 (2, 2); Filter: ((b >= $1) AND (b <= $2) AND (a < $0)) -> Seq Scan on ab_a3_b2 (never executed) Filter: ((b >= $1) AND (b <= $2) AND (a < $0)) -(10 rows) + Settings: enable_indexonlyscan = 'off' +(11 rows) -- Test a backwards Append scan create table list_part (a int) partition by list (a); @@ -1857,48 +1863,63 @@ begin; -- Test run-time pruning using stable functions 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) select * from list_part where a = list_part_fn(1); +explain (exec, costs off, summary off, timing off) select * from list_part where a = list_part_fn(1); QUERY PLAN ------------------------------------------------------ Append (actual rows=1 loops=1) + Buffers: shared hit=1 Subplans Removed: 3 -> Seq Scan on list_part1 (actual rows=1 loops=1) Filter: (a = list_part_fn(1)) -(4 rows) + Buffers: shared hit=1 + Settings: enable_indexonlyscan = 'off' +(7 rows) -- Ensure pruning does not take place when the function has a Var parameter -explain (analyze, costs off, summary off, timing off) select * from list_part where a = list_part_fn(a); +explain (exec, costs off, summary off, timing off) select * from list_part where a = list_part_fn(a); QUERY PLAN ------------------------------------------------------ Append (actual rows=4 loops=1) + Buffers: shared hit=4 -> Seq Scan on list_part1 (actual rows=1 loops=1) Filter: (a = list_part_fn(a)) + Buffers: shared hit=1 -> Seq Scan on list_part2 (actual rows=1 loops=1) Filter: (a = list_part_fn(a)) + Buffers: shared hit=1 -> Seq Scan on list_part3 (actual rows=1 loops=1) Filter: (a = list_part_fn(a)) + Buffers: shared hit=1 -> Seq Scan on list_part4 (actual rows=1 loops=1) Filter: (a = list_part_fn(a)) -(9 rows) + Buffers: shared hit=1 + Settings: enable_indexonlyscan = 'off' +(15 rows) -- Ensure pruning does not take place when the expression contains a Var. -explain (analyze, costs off, summary off, timing off) select * from list_part where a = list_part_fn(1) + a; +explain (exec, costs off, summary off, timing off) select * from list_part where a = list_part_fn(1) + a; QUERY PLAN ------------------------------------------------------ Append (actual rows=0 loops=1) + Buffers: shared hit=4 -> Seq Scan on list_part1 (actual rows=0 loops=1) Filter: (a = (list_part_fn(1) + a)) Rows Removed by Filter: 1 + Buffers: shared hit=1 -> Seq Scan on list_part2 (actual rows=0 loops=1) Filter: (a = (list_part_fn(1) + a)) Rows Removed by Filter: 1 + Buffers: shared hit=1 -> Seq Scan on list_part3 (actual rows=0 loops=1) Filter: (a = (list_part_fn(1) + a)) Rows Removed by Filter: 1 + Buffers: shared hit=1 -> Seq Scan on list_part4 (actual rows=0 loops=1) Filter: (a = (list_part_fn(1) + a)) Rows Removed by Filter: 1 -(13 rows) + Buffers: shared hit=1 + Settings: enable_indexonlyscan = 'off' +(19 rows) rollback; drop table list_part; @@ -1913,7 +1934,7 @@ declare ln text; begin for ln in - execute format('explain (analyze, costs off, summary off, timing off) %s', + execute format('explain (exec, costs off, summary off, timing off) %s', $1) loop if ln like '%Parallel%' then @@ -1963,8 +1984,8 @@ execute ab_q4 (1, 8); (1 row) select explain_parallel_append('execute ab_q4 (2, 2)'); - explain_parallel_append -------------------------------------------------------------------------------- + explain_parallel_append +---------------------------------------------------------------------------------------------------------------------------------- Finalize Aggregate (actual rows=1 loops=1) -> Gather (actual rows=3 loops=1) Workers Planned: 2 @@ -1978,7 +1999,8 @@ select explain_parallel_append('execute ab_q4 (2, 2)'); Filter: ((a >= $1) AND (a <= $2) AND (b < 4)) -> Parallel Seq Scan on ab_a2_b3 (actual rows=0 loops=N) Filter: ((a >= $1) AND (a <= $2) AND (b < 4)) -(13 rows) + Settings: enable_indexonlyscan = 'off', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(14 rows) -- Test run-time pruning with IN lists. prepare ab_q5 (int, int, int) as @@ -2016,8 +2038,8 @@ execute ab_q5 (1, 2, 3); (1 row) select explain_parallel_append('execute ab_q5 (1, 1, 1)'); - explain_parallel_append -------------------------------------------------------------------------------- + explain_parallel_append +---------------------------------------------------------------------------------------------------------------------------------- Finalize Aggregate (actual rows=1 loops=1) -> Gather (actual rows=3 loops=1) Workers Planned: 2 @@ -2031,11 +2053,12 @@ select explain_parallel_append('execute ab_q5 (1, 1, 1)'); Filter: ((b < 4) AND (a = ANY (ARRAY[$1, $2, $3]))) -> Parallel Seq Scan on ab_a1_b3 (actual rows=0 loops=N) Filter: ((b < 4) AND (a = ANY (ARRAY[$1, $2, $3]))) -(13 rows) + Settings: enable_indexonlyscan = 'off', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(14 rows) select explain_parallel_append('execute ab_q5 (2, 3, 3)'); - explain_parallel_append -------------------------------------------------------------------------------- + explain_parallel_append +---------------------------------------------------------------------------------------------------------------------------------- Finalize Aggregate (actual rows=1 loops=1) -> Gather (actual rows=3 loops=1) Workers Planned: 2 @@ -2055,13 +2078,14 @@ select explain_parallel_append('execute ab_q5 (2, 3, 3)'); Filter: ((b < 4) AND (a = ANY (ARRAY[$1, $2, $3]))) -> Parallel Seq Scan on ab_a3_b3 (actual rows=0 loops=N) Filter: ((b < 4) AND (a = ANY (ARRAY[$1, $2, $3]))) -(19 rows) + Settings: enable_indexonlyscan = 'off', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(20 rows) -- Try some params whose values do not belong to any partition. -- We'll still get a single subplan in this case, but it should not be scanned. select explain_parallel_append('execute ab_q5 (33, 44, 55)'); - explain_parallel_append -------------------------------------------------------------------------------- + explain_parallel_append +---------------------------------------------------------------------------------------------------------------------------------- Finalize Aggregate (actual rows=1 loops=1) -> Gather (actual rows=3 loops=1) Workers Planned: 2 @@ -2071,12 +2095,13 @@ select explain_parallel_append('execute ab_q5 (33, 44, 55)'); Subplans Removed: 8 -> Parallel Seq Scan on ab_a1_b1 (never executed) Filter: ((b < 4) AND (a = ANY (ARRAY[$1, $2, $3]))) -(9 rows) + Settings: enable_indexonlyscan = 'off', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(10 rows) -- Test Parallel Append with PARAM_EXEC Params select explain_parallel_append('select count(*) from ab where (a = (select 1) or a = (select 3)) and b = 2'); - explain_parallel_append -------------------------------------------------------------------------- + explain_parallel_append +---------------------------------------------------------------------------------------------------------------------------------- Aggregate (actual rows=1 loops=1) InitPlan 1 (returns $0) -> Result (actual rows=1 loops=1) @@ -2093,7 +2118,8 @@ select explain_parallel_append('select count(*) from ab where (a = (select 1) or Filter: ((b = 2) AND ((a = $0) OR (a = $1))) -> Parallel Seq Scan on ab_a3_b2 (actual rows=0 loops=N) Filter: ((b = 2) AND ((a = $0) OR (a = $1))) -(16 rows) + Settings: enable_indexonlyscan = 'off', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(17 rows) -- Test pruning during parallel nested loop query create table lprt_a (a int not null); @@ -2114,23 +2140,32 @@ create index ab_a3_b3_a_idx on ab_a3_b3 (a); set enable_hashjoin = 0; set enable_mergejoin = 0; select explain_parallel_append('select avg(ab.a) from ab inner join lprt_a a on ab.a = a.a where a.a in(0, 0, 1)'); - explain_parallel_append ---------------------------------------------------------------------------------------------------- + explain_parallel_append +------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Finalize Aggregate (actual rows=1 loops=1) + Buffers: shared hit=13 -> Gather (actual rows=2 loops=1) Workers Planned: 1 Workers Launched: 1 + Buffers: shared hit=13 -> Partial Aggregate (actual rows=1 loops=2) + Buffers: shared hit=13 -> Nested Loop (actual rows=0 loops=2) + Buffers: shared hit=13 -> Parallel Seq Scan on lprt_a a (actual rows=51 loops=N) Filter: (a = ANY ('{0,0,1}'::integer[])) + Buffers: shared hit=1 -> Append (actual rows=0 loops=102) + Buffers: shared hit=12 -> Index Scan using ab_a1_b1_a_idx on ab_a1_b1 (actual rows=0 loops=2) Index Cond: (a = a.a) + Buffers: shared hit=4 -> Index Scan using ab_a1_b2_a_idx on ab_a1_b2 (actual rows=0 loops=2) Index Cond: (a = a.a) + Buffers: shared hit=4 -> Index Scan using ab_a1_b3_a_idx on ab_a1_b3 (actual rows=0 loops=2) Index Cond: (a = a.a) + Buffers: shared hit=4 -> Index Scan using ab_a2_b1_a_idx on ab_a2_b1 (never executed) Index Cond: (a = a.a) -> Index Scan using ab_a2_b2_a_idx on ab_a2_b2 (never executed) @@ -2143,28 +2178,38 @@ select explain_parallel_append('select avg(ab.a) from ab inner join lprt_a a on Index Cond: (a = a.a) -> Index Scan using ab_a3_b3_a_idx on ab_a3_b3 (never executed) Index Cond: (a = a.a) -(27 rows) + Settings: enable_hashjoin = 'off', enable_indexonlyscan = 'off', enable_mergejoin = 'off', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(37 rows) -- Ensure the same partitions are pruned when we make the nested loop -- parameter an Expr rather than a plain Param. select explain_parallel_append('select avg(ab.a) from ab inner join lprt_a a on ab.a = a.a + 0 where a.a in(0, 0, 1)'); - explain_parallel_append ---------------------------------------------------------------------------------------------------- + explain_parallel_append +------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Finalize Aggregate (actual rows=1 loops=1) + Buffers: shared hit=13 -> Gather (actual rows=2 loops=1) Workers Planned: 1 Workers Launched: 1 + Buffers: shared hit=13 -> Partial Aggregate (actual rows=1 loops=2) + Buffers: shared hit=13 -> Nested Loop (actual rows=0 loops=2) + Buffers: shared hit=13 -> Parallel Seq Scan on lprt_a a (actual rows=51 loops=N) Filter: (a = ANY ('{0,0,1}'::integer[])) + Buffers: shared hit=1 -> Append (actual rows=0 loops=102) + Buffers: shared hit=12 -> Index Scan using ab_a1_b1_a_idx on ab_a1_b1 (actual rows=0 loops=2) Index Cond: (a = (a.a + 0)) + Buffers: shared hit=4 -> Index Scan using ab_a1_b2_a_idx on ab_a1_b2 (actual rows=0 loops=2) Index Cond: (a = (a.a + 0)) + Buffers: shared hit=4 -> Index Scan using ab_a1_b3_a_idx on ab_a1_b3 (actual rows=0 loops=2) Index Cond: (a = (a.a + 0)) + Buffers: shared hit=4 -> Index Scan using ab_a2_b1_a_idx on ab_a2_b1 (never executed) Index Cond: (a = (a.a + 0)) -> Index Scan using ab_a2_b2_a_idx on ab_a2_b2 (never executed) @@ -2177,27 +2222,37 @@ select explain_parallel_append('select avg(ab.a) from ab inner join lprt_a a on Index Cond: (a = (a.a + 0)) -> Index Scan using ab_a3_b3_a_idx on ab_a3_b3 (never executed) Index Cond: (a = (a.a + 0)) -(27 rows) + Settings: enable_hashjoin = 'off', enable_indexonlyscan = 'off', enable_mergejoin = 'off', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(37 rows) insert into lprt_a values(3),(3); select explain_parallel_append('select avg(ab.a) from ab inner join lprt_a a on ab.a = a.a where a.a in(1, 0, 3)'); - explain_parallel_append ---------------------------------------------------------------------------------------------------- + explain_parallel_append +------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Finalize Aggregate (actual rows=1 loops=1) + Buffers: shared hit=25 -> Gather (actual rows=2 loops=1) Workers Planned: 1 Workers Launched: 1 + Buffers: shared hit=25 -> Partial Aggregate (actual rows=1 loops=2) + Buffers: shared hit=25 -> Nested Loop (actual rows=0 loops=2) + Buffers: shared hit=25 -> Parallel Seq Scan on lprt_a a (actual rows=52 loops=N) Filter: (a = ANY ('{1,0,3}'::integer[])) + Buffers: shared hit=1 -> Append (actual rows=0 loops=104) + Buffers: shared hit=24 -> Index Scan using ab_a1_b1_a_idx on ab_a1_b1 (actual rows=0 loops=2) Index Cond: (a = a.a) + Buffers: shared hit=4 -> Index Scan using ab_a1_b2_a_idx on ab_a1_b2 (actual rows=0 loops=2) Index Cond: (a = a.a) + Buffers: shared hit=4 -> Index Scan using ab_a1_b3_a_idx on ab_a1_b3 (actual rows=0 loops=2) Index Cond: (a = a.a) + Buffers: shared hit=4 -> Index Scan using ab_a2_b1_a_idx on ab_a2_b1 (never executed) Index Cond: (a = a.a) -> Index Scan using ab_a2_b2_a_idx on ab_a2_b2 (never executed) @@ -2206,31 +2261,44 @@ select explain_parallel_append('select avg(ab.a) from ab inner join lprt_a a on Index Cond: (a = a.a) -> Index Scan using ab_a3_b1_a_idx on ab_a3_b1 (actual rows=0 loops=2) Index Cond: (a = a.a) + Buffers: shared hit=4 -> Index Scan using ab_a3_b2_a_idx on ab_a3_b2 (actual rows=0 loops=2) Index Cond: (a = a.a) + Buffers: shared hit=4 -> Index Scan using ab_a3_b3_a_idx on ab_a3_b3 (actual rows=0 loops=2) Index Cond: (a = a.a) -(27 rows) + Buffers: shared hit=4 + Settings: enable_hashjoin = 'off', enable_indexonlyscan = 'off', enable_mergejoin = 'off', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(40 rows) select explain_parallel_append('select avg(ab.a) from ab inner join lprt_a a on ab.a = a.a where a.a in(1, 0, 0)'); - explain_parallel_append ---------------------------------------------------------------------------------------------------- + explain_parallel_append +------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Finalize Aggregate (actual rows=1 loops=1) + Buffers: shared hit=13 -> Gather (actual rows=2 loops=1) Workers Planned: 1 Workers Launched: 1 + Buffers: shared hit=13 -> Partial Aggregate (actual rows=1 loops=2) + Buffers: shared hit=13 -> Nested Loop (actual rows=0 loops=2) + Buffers: shared hit=13 -> Parallel Seq Scan on lprt_a a (actual rows=51 loops=N) Filter: (a = ANY ('{1,0,0}'::integer[])) Rows Removed by Filter: 1 + Buffers: shared hit=1 -> Append (actual rows=0 loops=102) + Buffers: shared hit=12 -> Index Scan using ab_a1_b1_a_idx on ab_a1_b1 (actual rows=0 loops=2) Index Cond: (a = a.a) + Buffers: shared hit=4 -> Index Scan using ab_a1_b2_a_idx on ab_a1_b2 (actual rows=0 loops=2) Index Cond: (a = a.a) + Buffers: shared hit=4 -> Index Scan using ab_a1_b3_a_idx on ab_a1_b3 (actual rows=0 loops=2) Index Cond: (a = a.a) + Buffers: shared hit=4 -> Index Scan using ab_a2_b1_a_idx on ab_a2_b1 (never executed) Index Cond: (a = a.a) -> Index Scan using ab_a2_b2_a_idx on ab_a2_b2 (never executed) @@ -2243,21 +2311,27 @@ select explain_parallel_append('select avg(ab.a) from ab inner join lprt_a a on Index Cond: (a = a.a) -> Index Scan using ab_a3_b3_a_idx on ab_a3_b3 (never executed) Index Cond: (a = a.a) -(28 rows) + Settings: enable_hashjoin = 'off', enable_indexonlyscan = 'off', enable_mergejoin = 'off', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(38 rows) delete from lprt_a where a = 1; select explain_parallel_append('select avg(ab.a) from ab inner join lprt_a a on ab.a = a.a where a.a in(1, 0, 0)'); - explain_parallel_append --------------------------------------------------------------------------------------------- + explain_parallel_append +------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Finalize Aggregate (actual rows=1 loops=1) + Buffers: shared hit=1 -> Gather (actual rows=2 loops=1) Workers Planned: 1 Workers Launched: 1 + Buffers: shared hit=1 -> Partial Aggregate (actual rows=1 loops=2) + Buffers: shared hit=1 -> Nested Loop (actual rows=0 loops=2) + Buffers: shared hit=1 -> Parallel Seq Scan on lprt_a a (actual rows=50 loops=N) Filter: (a = ANY ('{1,0,0}'::integer[])) Rows Removed by Filter: 1 + Buffers: shared hit=1 -> Append (actual rows=0 loops=100) -> Index Scan using ab_a1_b1_a_idx on ab_a1_b1 (never executed) Index Cond: (a = a.a) @@ -2277,7 +2351,8 @@ select explain_parallel_append('select avg(ab.a) from ab inner join lprt_a a on Index Cond: (a = a.a) -> Index Scan using ab_a3_b3_a_idx on ab_a3_b3 (never executed) Index Cond: (a = a.a) -(28 rows) + Settings: enable_hashjoin = 'off', enable_indexonlyscan = 'off', enable_mergejoin = 'off', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(34 rows) reset enable_hashjoin; reset enable_mergejoin; @@ -2286,17 +2361,22 @@ reset parallel_tuple_cost; reset min_parallel_table_scan_size; reset max_parallel_workers_per_gather; -- Test run-time partition pruning with an initplan -explain (analyze, costs off, summary off, timing off) +explain (exec, costs off, summary off, timing 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) + Buffers: shared hit=4 InitPlan 1 (returns $0) -> Aggregate (actual rows=1 loops=1) + Buffers: shared hit=1 -> Seq Scan on lprt_a (actual rows=102 loops=1) + Buffers: shared hit=1 InitPlan 2 (returns $1) -> Aggregate (actual rows=1 loops=1) + Buffers: shared hit=1 -> Seq Scan on lprt_a lprt_a_1 (actual rows=102 loops=1) + Buffers: shared hit=1 -> Bitmap Heap Scan on ab_a1_b1 (never executed) Recheck Cond: (a = $0) Filter: (b = $1) @@ -2335,29 +2415,36 @@ select * from ab where a = (select max(a) from lprt_a) and b = (select max(a)-1 -> Bitmap Heap Scan on ab_a3_b2 (actual rows=0 loops=1) Recheck Cond: (a = $0) Filter: (b = $1) + Buffers: shared hit=2 -> Bitmap Index Scan on ab_a3_b2_a_idx (actual rows=0 loops=1) Index Cond: (a = $0) + Buffers: shared hit=2 -> Bitmap Heap Scan on ab_a3_b3 (never executed) Recheck Cond: (a = $0) Filter: (b = $1) -> Bitmap Index Scan on ab_a3_b3_a_idx (never executed) Index Cond: (a = $0) -(52 rows) + Settings: enable_indexonlyscan = 'off' +(60 rows) -- Test run-time partition pruning with UNION ALL parents -explain (analyze, costs off, summary off, timing off) +explain (exec, costs off, summary off, timing 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) + Buffers: shared hit=2 InitPlan 1 (returns $0) -> Result (actual rows=1 loops=1) -> Append (actual rows=0 loops=1) + Buffers: shared hit=2 -> Bitmap Heap Scan on ab_a1_b1 ab_a1_b1_1 (actual rows=0 loops=1) Recheck Cond: (a = 1) Filter: (b = $0) + Buffers: shared hit=2 -> Bitmap Index Scan on ab_a1_b1_a_idx (actual rows=0 loops=1) Index Cond: (a = 1) + Buffers: shared hit=2 -> Bitmap Heap Scan on ab_a1_b2 ab_a1_b2_1 (never executed) Recheck Cond: (a = 1) Filter: (b = $0) @@ -2386,22 +2473,27 @@ select * from (select * from ab where a = 1 union all select * from ab) ab where Filter: (b = $0) -> Seq Scan on ab_a3_b3 (never executed) Filter: (b = $0) -(37 rows) + Settings: enable_indexonlyscan = 'off' +(42 rows) -- A case containing a UNION ALL with a non-partitioned child. -explain (analyze, costs off, summary off, timing off) +explain (exec, costs off, summary off, timing 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) + Buffers: shared hit=2 InitPlan 1 (returns $0) -> Result (actual rows=1 loops=1) -> Append (actual rows=0 loops=1) + Buffers: shared hit=2 -> Bitmap Heap Scan on ab_a1_b1 ab_a1_b1_1 (actual rows=0 loops=1) Recheck Cond: (a = 1) Filter: (b = $0) + Buffers: shared hit=2 -> Bitmap Index Scan on ab_a1_b1_a_idx (actual rows=0 loops=1) Index Cond: (a = 1) + Buffers: shared hit=2 -> Bitmap Heap Scan on ab_a1_b2 ab_a1_b2_1 (never executed) Recheck Cond: (a = 1) Filter: (b = $0) @@ -2432,7 +2524,8 @@ select * from (select * from ab where a = 1 union all (values(10,5)) union all s Filter: (b = $0) -> Seq Scan on ab_a3_b3 (never executed) Filter: (b = $0) -(39 rows) + Settings: enable_indexonlyscan = 'off' +(44 rows) -- Another UNION ALL test, but containing a mix of exec init and exec run-time pruning. create table xy_1 (x int, y int); @@ -2449,10 +2542,11 @@ union all select tableoid::regclass,a,b from ab ) ab where a = $1 and b = (select -10); -- Ensure the xy_1 subplan is not pruned. -explain (analyze, costs off, summary off, timing off) execute ab_q6(1); - QUERY PLAN --------------------------------------------------------- +explain (exec, costs off, summary off, timing off) execute ab_q6(1); + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------- Append (actual rows=0 loops=1) + Buffers: shared hit=1 InitPlan 1 (returns $0) -> Result (actual rows=1 loops=1) Subplans Removed: 12 @@ -2465,13 +2559,15 @@ explain (analyze, costs off, summary off, timing off) execute ab_q6(1); -> Seq Scan on xy_1 (actual rows=0 loops=1) Filter: ((x = $1) AND (y = $0)) Rows Removed by Filter: 1 + Buffers: shared hit=1 -> Seq Scan on ab_a1_b1 ab_a1_b1_1 (never executed) Filter: ((a = $1) AND (b = $0)) -> Seq Scan on ab_a1_b2 ab_a1_b2_1 (never executed) Filter: ((a = $1) AND (b = $0)) -> Seq Scan on ab_a1_b3 ab_a1_b3_1 (never executed) Filter: ((a = $1) AND (b = $0)) -(19 rows) + Settings: enable_bitmapscan = 'off', enable_indexonlyscan = 'off', enable_indexscan = 'off', plan_cache_mode = 'force_generic_plan' +(22 rows) -- Ensure we see just the xy_1 row. execute ab_q6(100); @@ -2491,7 +2587,7 @@ deallocate ab_q5; deallocate ab_q6; -- UPDATE on a partition subtree has been seen to have problems. insert into ab values (1,2); -explain (analyze, costs off, summary off, timing off) +explain (exec, costs off, summary off, timing off) update ab_a1 set b = 3 from ab where ab.a = 1 and ab.a = ab_a1.a; QUERY PLAN ------------------------------------------------------------------------------------- @@ -2499,68 +2595,103 @@ update ab_a1 set b = 3 from ab where ab.a = 1 and ab.a = ab_a1.a; Update on ab_a1_b1 Update on ab_a1_b2 Update on ab_a1_b3 + Buffers: shared hit=25 dirtied=3 written=2 -> Nested Loop (actual rows=0 loops=1) + Buffers: shared hit=8 -> Append (actual rows=1 loops=1) + Buffers: shared hit=6 -> Bitmap Heap Scan on ab_a1_b1 ab_a1_b1_1 (actual rows=0 loops=1) Recheck Cond: (a = 1) + Buffers: shared hit=2 -> Bitmap Index Scan on ab_a1_b1_a_idx (actual rows=0 loops=1) Index Cond: (a = 1) + Buffers: shared hit=2 -> Bitmap Heap Scan on ab_a1_b2 ab_a1_b2_1 (actual rows=1 loops=1) Recheck Cond: (a = 1) Heap Blocks: exact=1 + Buffers: shared hit=2 -> Bitmap Index Scan on ab_a1_b2_a_idx (actual rows=1 loops=1) Index Cond: (a = 1) + Buffers: shared hit=1 -> Bitmap Heap Scan on ab_a1_b3 ab_a1_b3_1 (actual rows=0 loops=1) Recheck Cond: (a = 1) + Buffers: shared hit=2 -> Bitmap Index Scan on ab_a1_b3_a_idx (actual rows=0 loops=1) Index Cond: (a = 1) + Buffers: shared hit=2 -> Materialize (actual rows=0 loops=1) + Buffers: shared hit=2 -> Bitmap Heap Scan on ab_a1_b1 (actual rows=0 loops=1) Recheck Cond: (a = 1) + Buffers: shared hit=2 -> Bitmap Index Scan on ab_a1_b1_a_idx (actual rows=0 loops=1) Index Cond: (a = 1) + Buffers: shared hit=2 -> Nested Loop (actual rows=1 loops=1) + Buffers: shared hit=8 -> Append (actual rows=1 loops=1) + Buffers: shared hit=6 -> Bitmap Heap Scan on ab_a1_b1 ab_a1_b1_1 (actual rows=0 loops=1) Recheck Cond: (a = 1) + Buffers: shared hit=2 -> Bitmap Index Scan on ab_a1_b1_a_idx (actual rows=0 loops=1) Index Cond: (a = 1) + Buffers: shared hit=2 -> Bitmap Heap Scan on ab_a1_b2 ab_a1_b2_1 (actual rows=1 loops=1) Recheck Cond: (a = 1) Heap Blocks: exact=1 + Buffers: shared hit=2 -> Bitmap Index Scan on ab_a1_b2_a_idx (actual rows=1 loops=1) Index Cond: (a = 1) + Buffers: shared hit=1 -> Bitmap Heap Scan on ab_a1_b3 ab_a1_b3_1 (actual rows=0 loops=1) Recheck Cond: (a = 1) + Buffers: shared hit=2 -> Bitmap Index Scan on ab_a1_b3_a_idx (actual rows=1 loops=1) Index Cond: (a = 1) + Buffers: shared hit=2 -> Materialize (actual rows=1 loops=1) + Buffers: shared hit=2 -> Bitmap Heap Scan on ab_a1_b2 (actual rows=1 loops=1) Recheck Cond: (a = 1) Heap Blocks: exact=1 + Buffers: shared hit=2 -> Bitmap Index Scan on ab_a1_b2_a_idx (actual rows=1 loops=1) Index Cond: (a = 1) + Buffers: shared hit=1 -> Nested Loop (actual rows=0 loops=1) + Buffers: shared hit=6 -> Append (actual rows=1 loops=1) + Buffers: shared hit=5 -> Bitmap Heap Scan on ab_a1_b1 ab_a1_b1_1 (actual rows=0 loops=1) Recheck Cond: (a = 1) + Buffers: shared hit=2 -> Bitmap Index Scan on ab_a1_b1_a_idx (actual rows=0 loops=1) Index Cond: (a = 1) + Buffers: shared hit=2 -> Bitmap Heap Scan on ab_a1_b2 ab_a1_b2_1 (actual rows=1 loops=1) Recheck Cond: (a = 1) Heap Blocks: exact=1 + Buffers: shared hit=2 -> Bitmap Index Scan on ab_a1_b2_a_idx (actual rows=1 loops=1) Index Cond: (a = 1) + Buffers: shared hit=1 -> Bitmap Heap Scan on ab_a1_b3 ab_a1_b3_1 (actual rows=0 loops=1) Recheck Cond: (a = 1) + Buffers: shared hit=1 -> Bitmap Index Scan on ab_a1_b3_a_idx (actual rows=1 loops=1) Index Cond: (a = 1) + Buffers: shared hit=1 -> Materialize (actual rows=0 loops=1) + Buffers: shared hit=1 -> Bitmap Heap Scan on ab_a1_b3 (actual rows=0 loops=1) Recheck Cond: (a = 1) + Buffers: shared hit=1 -> Bitmap Index Scan on ab_a1_b3_a_idx (actual rows=1 loops=1) Index Cond: (a = 1) -(65 rows) + Buffers: shared hit=1 + Settings: enable_indexonlyscan = 'off' +(100 rows) table ab; a | b @@ -2571,7 +2702,7 @@ table ab; -- Test UPDATE where source relation has run-time pruning enabled truncate ab; insert into ab values (1, 1), (1, 2), (1, 3), (2, 1); -explain (analyze, costs off, summary off, timing off) +explain (exec, costs off, summary off, timing off) update ab_a1 set b = 3 from ab_a2 where ab_a2.b = (select 1); QUERY PLAN ---------------------------------------------------------------------- @@ -2579,39 +2710,56 @@ update ab_a1 set b = 3 from ab_a2 where ab_a2.b = (select 1); Update on ab_a1_b1 Update on ab_a1_b2 Update on ab_a1_b3 + Buffers: shared hit=13 InitPlan 1 (returns $0) -> Result (actual rows=1 loops=1) -> Nested Loop (actual rows=1 loops=1) + Buffers: shared hit=2 -> Seq Scan on ab_a1_b1 (actual rows=1 loops=1) + Buffers: shared hit=1 -> Materialize (actual rows=1 loops=1) + Buffers: shared hit=1 -> Append (actual rows=1 loops=1) + Buffers: shared hit=1 -> Seq Scan on ab_a2_b1 (actual rows=1 loops=1) Filter: (b = $0) + Buffers: shared hit=1 -> Seq Scan on ab_a2_b2 (never executed) Filter: (b = $0) -> Seq Scan on ab_a2_b3 (never executed) Filter: (b = $0) -> Nested Loop (actual rows=1 loops=1) + Buffers: shared hit=2 -> Seq Scan on ab_a1_b2 (actual rows=1 loops=1) + Buffers: shared hit=1 -> Materialize (actual rows=1 loops=1) + Buffers: shared hit=1 -> Append (actual rows=1 loops=1) + Buffers: shared hit=1 -> Seq Scan on ab_a2_b1 (actual rows=1 loops=1) Filter: (b = $0) + Buffers: shared hit=1 -> Seq Scan on ab_a2_b2 (never executed) Filter: (b = $0) -> Seq Scan on ab_a2_b3 (never executed) Filter: (b = $0) -> Nested Loop (actual rows=1 loops=1) + Buffers: shared hit=2 -> Seq Scan on ab_a1_b3 (actual rows=1 loops=1) + Buffers: shared hit=1 -> Materialize (actual rows=1 loops=1) + Buffers: shared hit=1 -> Append (actual rows=1 loops=1) + Buffers: shared hit=1 -> Seq Scan on ab_a2_b1 (actual rows=1 loops=1) Filter: (b = $0) + Buffers: shared hit=1 -> Seq Scan on ab_a2_b2 (never executed) Filter: (b = $0) -> Seq Scan on ab_a2_b3 (never executed) Filter: (b = $0) -(36 rows) + Settings: enable_indexonlyscan = 'off' +(53 rows) select tableoid::regclass, * from ab; tableoid | a | b @@ -2643,17 +2791,22 @@ create index tprt6_idx on tprt_6 (col1); insert into tprt values (10), (20), (501), (502), (505), (1001), (4500); set enable_hashjoin = off; set enable_mergejoin = off; -explain (analyze, costs off, summary off, timing off) +explain (exec, costs off, summary off, timing off) select * from tbl1 join tprt on tbl1.col1 > tprt.col1; - QUERY PLAN --------------------------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------------------------------------- Nested Loop (actual rows=6 loops=1) + Buffers: shared hit=7 -> Seq Scan on tbl1 (actual rows=2 loops=1) + Buffers: shared hit=1 -> Append (actual rows=3 loops=2) + Buffers: shared hit=6 -> Index Scan using tprt1_idx on tprt_1 (actual rows=2 loops=2) Index Cond: (col1 < tbl1.col1) + Buffers: shared hit=4 -> Index Scan using tprt2_idx on tprt_2 (actual rows=2 loops=1) Index Cond: (col1 < tbl1.col1) + Buffers: shared hit=2 -> Index Scan using tprt3_idx on tprt_3 (never executed) Index Cond: (col1 < tbl1.col1) -> Index Scan using tprt4_idx on tprt_4 (never executed) @@ -2662,19 +2815,24 @@ select * from tbl1 join tprt on tbl1.col1 > tprt.col1; Index Cond: (col1 < tbl1.col1) -> Index Scan using tprt6_idx on tprt_6 (never executed) Index Cond: (col1 < tbl1.col1) -(15 rows) + Settings: enable_hashjoin = 'off', enable_indexonlyscan = 'off', enable_mergejoin = 'off' +(21 rows) -explain (analyze, costs off, summary off, timing off) +explain (exec, costs off, summary off, timing off) select * from tbl1 join tprt on tbl1.col1 = tprt.col1; - QUERY PLAN --------------------------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------------------------------------- Nested Loop (actual rows=2 loops=1) + Buffers: shared hit=5 -> Seq Scan on tbl1 (actual rows=2 loops=1) + Buffers: shared hit=1 -> Append (actual rows=1 loops=2) + Buffers: shared hit=4 -> Index Scan using tprt1_idx on tprt_1 (never executed) Index Cond: (col1 = tbl1.col1) -> Index Scan using tprt2_idx on tprt_2 (actual rows=1 loops=2) Index Cond: (col1 = tbl1.col1) + Buffers: shared hit=4 -> Index Scan using tprt3_idx on tprt_3 (never executed) Index Cond: (col1 = tbl1.col1) -> Index Scan using tprt4_idx on tprt_4 (never executed) @@ -2683,7 +2841,8 @@ select * from tbl1 join tprt on tbl1.col1 = tprt.col1; Index Cond: (col1 = tbl1.col1) -> Index Scan using tprt6_idx on tprt_6 (never executed) Index Cond: (col1 = tbl1.col1) -(15 rows) + Settings: enable_hashjoin = 'off', enable_indexonlyscan = 'off', enable_mergejoin = 'off' +(20 rows) select tbl1.col1, tprt.col1 from tbl1 inner join tprt on tbl1.col1 > tprt.col1 @@ -2709,47 +2868,60 @@ order by tbl1.col1, tprt.col1; -- Multiple partitions insert into tbl1 values (1001), (1010), (1011); -explain (analyze, costs off, summary off, timing off) +explain (exec, costs off, summary off, timing off) select * from tbl1 inner join tprt on tbl1.col1 > tprt.col1; - QUERY PLAN --------------------------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------------------------------------- Nested Loop (actual rows=23 loops=1) + Buffers: shared hit=23 -> Seq Scan on tbl1 (actual rows=5 loops=1) + Buffers: shared hit=1 -> Append (actual rows=5 loops=5) + Buffers: shared hit=22 -> Index Scan using tprt1_idx on tprt_1 (actual rows=2 loops=5) Index Cond: (col1 < tbl1.col1) + Buffers: shared hit=10 -> Index Scan using tprt2_idx on tprt_2 (actual rows=3 loops=4) Index Cond: (col1 < tbl1.col1) + Buffers: shared hit=8 -> Index Scan using tprt3_idx on tprt_3 (actual rows=1 loops=2) Index Cond: (col1 < tbl1.col1) + Buffers: shared hit=4 -> Index Scan using tprt4_idx on tprt_4 (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 (never executed) Index Cond: (col1 < tbl1.col1) -(15 rows) + Settings: enable_hashjoin = 'off', enable_indexonlyscan = 'off', enable_mergejoin = 'off' +(22 rows) -explain (analyze, costs off, summary off, timing off) +explain (exec, costs off, summary off, timing off) select * from tbl1 inner join tprt on tbl1.col1 = tprt.col1; - QUERY PLAN --------------------------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------------------------------------- Nested Loop (actual rows=3 loops=1) + Buffers: shared hit=9 -> Seq Scan on tbl1 (actual rows=5 loops=1) + Buffers: shared hit=1 -> Append (actual rows=1 loops=5) + Buffers: shared hit=8 -> Index Scan using tprt1_idx on tprt_1 (never executed) Index Cond: (col1 = tbl1.col1) -> Index Scan using tprt2_idx on tprt_2 (actual rows=1 loops=2) Index Cond: (col1 = tbl1.col1) + Buffers: shared hit=4 -> Index Scan using tprt3_idx on tprt_3 (actual rows=0 loops=3) Index Cond: (col1 = tbl1.col1) + Buffers: shared hit=4 -> Index Scan using tprt4_idx on tprt_4 (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 (never executed) Index Cond: (col1 = tbl1.col1) -(15 rows) + Settings: enable_hashjoin = 'off', enable_indexonlyscan = 'off', enable_mergejoin = 'off' +(21 rows) select tbl1.col1, tprt.col1 from tbl1 inner join tprt on tbl1.col1 > tprt.col1 @@ -2794,13 +2966,16 @@ order by tbl1.col1, tprt.col1; -- Last partition delete from tbl1; insert into tbl1 values (4400); -explain (analyze, costs off, summary off, timing off) +explain (exec, costs off, summary off, timing off) select * from tbl1 join tprt on tbl1.col1 < tprt.col1; - QUERY PLAN --------------------------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------------------------------------- Nested Loop (actual rows=1 loops=1) + Buffers: shared hit=3 -> Seq Scan on tbl1 (actual rows=1 loops=1) + Buffers: shared hit=1 -> Append (actual rows=1 loops=1) + Buffers: shared hit=2 -> 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) @@ -2813,7 +2988,9 @@ select * from tbl1 join tprt on tbl1.col1 < tprt.col1; Index Cond: (col1 > tbl1.col1) -> Index Scan using tprt6_idx on tprt_6 (actual rows=1 loops=1) Index Cond: (col1 > tbl1.col1) -(15 rows) + Buffers: shared hit=2 + Settings: enable_hashjoin = 'off', enable_indexonlyscan = 'off', enable_mergejoin = 'off' +(20 rows) select tbl1.col1, tprt.col1 from tbl1 inner join tprt on tbl1.col1 < tprt.col1 @@ -2826,12 +3003,14 @@ order by tbl1.col1, tprt.col1; -- No matching partition delete from tbl1; insert into tbl1 values (10000); -explain (analyze, costs off, summary off, timing off) +explain (exec, costs off, summary off, timing off) select * from tbl1 join tprt on tbl1.col1 = tprt.col1; - QUERY PLAN -------------------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------------------------------------- Nested Loop (actual rows=0 loops=1) + Buffers: shared hit=1 -> Seq Scan on tbl1 (actual rows=1 loops=1) + Buffers: shared hit=1 -> Append (actual rows=0 loops=1) -> Index Scan using tprt1_idx on tprt_1 (never executed) Index Cond: (col1 = tbl1.col1) @@ -2845,7 +3024,8 @@ select * from tbl1 join tprt on tbl1.col1 = tprt.col1; Index Cond: (col1 = tbl1.col1) -> Index Scan using tprt6_idx on tprt_6 (never executed) Index Cond: (col1 = tbl1.col1) -(15 rows) + Settings: enable_hashjoin = 'off', enable_indexonlyscan = 'off', enable_mergejoin = 'off' +(18 rows) select tbl1.col1, tprt.col1 from tbl1 inner join tprt on tbl1.col1 = tprt.col1 @@ -2893,12 +3073,13 @@ execute part_abc_q1 (1, 2, 3); (0 rows) -- Single partition should be scanned. -explain (analyze, costs off, summary off, timing off) execute part_abc_q1 (1, 2, 3); - QUERY PLAN -------------------------------------------------- +explain (exec, costs off, summary off, timing off) execute part_abc_q1 (1, 2, 3); + QUERY PLAN +------------------------------------------------------------------------------------------- Seq Scan on part_abc_p1 (actual rows=0 loops=1) Filter: ((a = $1) AND (b = $2) AND (c = $3)) -(2 rows) + Settings: enable_hashjoin = 'off', enable_indexonlyscan = 'off', enable_mergejoin = 'off' +(3 rows) deallocate part_abc_q1; drop table part_abc; @@ -2943,34 +3124,37 @@ execute q1 (1,2); ---+--- (0 rows) -explain (analyze, costs off, summary off, timing off) execute q1 (1,1); - QUERY PLAN ------------------------------------------------------ +explain (exec, costs off, summary off, timing off) execute q1 (1,1); + QUERY PLAN +------------------------------------------------------------------------------------------- Append (actual rows=0 loops=1) Subplans Removed: 1 -> Seq Scan on listp_1_1 (actual rows=0 loops=1) Filter: (b = ANY (ARRAY[$1, $2])) -(4 rows) + Settings: enable_hashjoin = 'off', enable_indexonlyscan = 'off', enable_mergejoin = 'off' +(5 rows) -explain (analyze, costs off, summary off, timing off) execute q1 (2,2); - QUERY PLAN ------------------------------------------------------ +explain (exec, costs off, summary off, timing off) execute q1 (2,2); + QUERY PLAN +------------------------------------------------------------------------------------------- Append (actual rows=0 loops=1) Subplans Removed: 1 -> Seq Scan on listp_2_1 (actual rows=0 loops=1) Filter: (b = ANY (ARRAY[$1, $2])) -(4 rows) + Settings: enable_hashjoin = 'off', enable_indexonlyscan = 'off', enable_mergejoin = 'off' +(5 rows) -- Try with no matching partitions. One subplan should remain in this case, -- but it shouldn't be executed. -explain (analyze, costs off, summary off, timing off) execute q1 (0,0); - QUERY PLAN ----------------------------------------------- +explain (exec, costs off, summary off, timing off) execute q1 (0,0); + QUERY PLAN +------------------------------------------------------------------------------------------- Append (actual rows=0 loops=1) Subplans Removed: 1 -> Seq Scan on listp_1_1 (never executed) Filter: (b = ANY (ARRAY[$1, $2])) -(4 rows) + Settings: enable_hashjoin = 'off', enable_indexonlyscan = 'off', enable_mergejoin = 'off' +(5 rows) deallocate q1; -- Test more complex cases where a not-equal condition further eliminates partitions. @@ -3001,31 +3185,33 @@ execute q1 (1,2,3,4); (0 rows) -- Both partitions allowed by IN clause, but one disallowed by <> clause -explain (analyze, costs off, summary off, timing off) execute q1 (1,2,2,0); - QUERY PLAN -------------------------------------------------------------------------- +explain (exec, costs off, summary off, timing off) execute q1 (1,2,2,0); + QUERY PLAN +------------------------------------------------------------------------------------------- Append (actual rows=0 loops=1) Subplans Removed: 1 -> Seq Scan on listp_1_1 (actual rows=0 loops=1) Filter: ((b = ANY (ARRAY[$1, $2])) AND ($3 <> b) AND ($4 <> b)) -(4 rows) + Settings: enable_hashjoin = 'off', enable_indexonlyscan = 'off', enable_mergejoin = 'off' +(5 rows) -- Both partitions allowed by IN clause, then both excluded again by <> clauses. -- One subplan will remain in this case, but it should not be executed. -explain (analyze, costs off, summary off, timing off) execute q1 (1,2,2,1); - QUERY PLAN -------------------------------------------------------------------------- +explain (exec, costs off, summary off, timing off) execute q1 (1,2,2,1); + QUERY PLAN +------------------------------------------------------------------------------------------- Append (actual rows=0 loops=1) Subplans Removed: 1 -> Seq Scan on listp_1_1 (never executed) Filter: ((b = ANY (ARRAY[$1, $2])) AND ($3 <> b) AND ($4 <> b)) -(4 rows) + Settings: enable_hashjoin = 'off', enable_indexonlyscan = 'off', enable_mergejoin = 'off' +(5 rows) -- Ensure Params that evaluate to NULL properly prune away all partitions -explain (analyze, costs off, summary off, timing off) +explain (exec, costs off, summary off, timing off) select * from listp where a = (select null::int); - QUERY PLAN ----------------------------------------------- + QUERY PLAN +------------------------------------------------------------------------------------------- Append (actual rows=0 loops=1) InitPlan 1 (returns $0) -> Result (actual rows=1 loops=1) @@ -3033,7 +3219,8 @@ select * from listp where a = (select null::int); Filter: (a = $0) -> Seq Scan on listp_2_1 (never executed) Filter: (a = $0) -(7 rows) + Settings: enable_hashjoin = 'off', enable_indexonlyscan = 'off', enable_mergejoin = 'off' +(8 rows) drop table listp; -- Ensure runtime pruning works with initplans params with boolean types @@ -3042,35 +3229,41 @@ insert into boolvalues values('t'),('f'); create table boolp (a bool) partition by list (a); create table boolp_t partition of boolp for values in('t'); create table boolp_f partition of boolp for values in('f'); -explain (analyze, costs off, summary off, timing off) +explain (exec, costs off, summary off, timing off) select * from boolp where a = (select value from boolvalues where value); - QUERY PLAN --------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------------------------------------- Append (actual rows=0 loops=1) + Buffers: shared hit=1 InitPlan 1 (returns $0) -> Seq Scan on boolvalues (actual rows=1 loops=1) Filter: value Rows Removed by Filter: 1 + Buffers: shared hit=1 -> Seq Scan on boolp_f (never executed) Filter: (a = $0) -> Seq Scan on boolp_t (actual rows=0 loops=1) Filter: (a = $0) -(9 rows) + Settings: enable_hashjoin = 'off', enable_indexonlyscan = 'off', enable_mergejoin = 'off' +(12 rows) -explain (analyze, costs off, summary off, timing off) +explain (exec, costs off, summary off, timing off) select * from boolp where a = (select value from boolvalues where not value); - QUERY PLAN --------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------------------------------------- Append (actual rows=0 loops=1) + Buffers: shared hit=1 InitPlan 1 (returns $0) -> Seq Scan on boolvalues (actual rows=1 loops=1) Filter: (NOT value) Rows Removed by Filter: 1 + Buffers: shared hit=1 -> Seq Scan on boolp_f (actual rows=0 loops=1) Filter: (a = $0) -> Seq Scan on boolp_t (never executed) Filter: (a = $0) -(9 rows) + Settings: enable_hashjoin = 'off', enable_indexonlyscan = 'off', enable_mergejoin = 'off' +(12 rows) drop table boolp; -- @@ -3128,19 +3321,23 @@ execute mt_q1(0); 25 (3 rows) -explain (analyze, costs off, summary off, timing off) execute mt_q1(15); - QUERY PLAN -------------------------------------------------------------------------------- +explain (exec, costs off, summary off, timing off) execute mt_q1(15); + QUERY PLAN +---------------------------------------------------------------------------------------------------------------------------------------- Merge Append (actual rows=2 loops=1) Sort Key: ma_test_p2.b + Buffers: shared hit=4 Subplans Removed: 1 -> Index Scan using ma_test_p2_b_idx on ma_test_p2 (actual rows=1 loops=1) Filter: ((a >= $1) AND ((a % 10) = 5)) Rows Removed by Filter: 9 + Buffers: shared hit=2 -> Index Scan using ma_test_p3_b_idx on ma_test_p3 (actual rows=1 loops=1) Filter: ((a >= $1) AND ((a % 10) = 5)) Rows Removed by Filter: 9 -(9 rows) + Buffers: shared hit=2 + Settings: enable_hashjoin = 'off', enable_indexonlyscan = 'off', enable_mergejoin = 'off', enable_seqscan = 'off', enable_sort = 'off' +(13 rows) execute mt_q1(15); a @@ -3149,16 +3346,19 @@ execute mt_q1(15); 25 (2 rows) -explain (analyze, costs off, summary off, timing off) execute mt_q1(25); - QUERY PLAN -------------------------------------------------------------------------------- +explain (exec, costs off, summary off, timing off) execute mt_q1(25); + QUERY PLAN +---------------------------------------------------------------------------------------------------------------------------------------- Merge Append (actual rows=1 loops=1) Sort Key: ma_test_p3.b + Buffers: shared hit=2 Subplans Removed: 2 -> Index Scan using ma_test_p3_b_idx on ma_test_p3 (actual rows=1 loops=1) Filter: ((a >= $1) AND ((a % 10) = 5)) Rows Removed by Filter: 9 -(6 rows) + Buffers: shared hit=2 + Settings: enable_hashjoin = 'off', enable_indexonlyscan = 'off', enable_mergejoin = 'off', enable_seqscan = 'off', enable_sort = 'off' +(9 rows) execute mt_q1(25); a @@ -3167,15 +3367,16 @@ execute mt_q1(25); (1 row) -- Ensure MergeAppend behaves correctly when no subplans match -explain (analyze, costs off, summary off, timing off) execute mt_q1(35); - QUERY PLAN ------------------------------------------------------------------------- +explain (exec, costs off, summary off, timing off) execute mt_q1(35); + QUERY PLAN +---------------------------------------------------------------------------------------------------------------------------------------- Merge Append (actual rows=0 loops=1) Sort Key: ma_test_p1.b Subplans Removed: 2 -> Index Scan using ma_test_p1_b_idx on ma_test_p1 (never executed) Filter: ((a >= $1) AND ((a % 10) = 5)) -(5 rows) + Settings: enable_hashjoin = 'off', enable_indexonlyscan = 'off', enable_mergejoin = 'off', enable_seqscan = 'off', enable_sort = 'off' +(6 rows) execute mt_q1(35); a @@ -3184,24 +3385,31 @@ execute mt_q1(35); deallocate mt_q1; -- ensure initplan params properly prune partitions -explain (analyze, costs off, summary off, timing off) select * from ma_test where a >= (select min(b) from ma_test_p2) order by b; - QUERY PLAN ------------------------------------------------------------------------------------------------------------- +explain (exec, costs off, summary off, timing 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) Sort Key: ma_test_p1.b + Buffers: shared hit=6 InitPlan 2 (returns $1) -> Result (actual rows=1 loops=1) + Buffers: shared hit=2 InitPlan 1 (returns $0) -> Limit (actual rows=1 loops=1) + Buffers: shared hit=2 -> Index Scan using ma_test_p2_b_idx on ma_test_p2 ma_test_p2_1 (actual rows=1 loops=1) Index Cond: (b IS NOT NULL) + Buffers: shared hit=2 -> Index Scan using ma_test_p1_b_idx on ma_test_p1 (never executed) Filter: (a >= $1) -> Index Scan using ma_test_p2_b_idx on ma_test_p2 (actual rows=10 loops=1) Filter: (a >= $1) + Buffers: shared hit=2 -> Index Scan using ma_test_p3_b_idx on ma_test_p3 (actual rows=10 loops=1) Filter: (a >= $1) -(14 rows) + Buffers: shared hit=2 + Settings: enable_hashjoin = 'off', enable_indexonlyscan = 'off', enable_mergejoin = 'off', enable_seqscan = 'off', enable_sort = 'off' +(21 rows) reset enable_seqscan; reset enable_sort; @@ -3216,18 +3424,20 @@ create table pp_arrpart (a int[]) partition by list (a); create table pp_arrpart1 partition of pp_arrpart for values in ('{1}'); create table pp_arrpart2 partition of pp_arrpart for values in ('{2, 3}', '{4, 5}'); explain (costs off) select * from pp_arrpart where a = '{1}'; - QUERY PLAN ----------------------------------- + QUERY PLAN +------------------------------------------------------------- Seq Scan on pp_arrpart1 Filter: (a = '{1}'::integer[]) -(2 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off' +(3 rows) explain (costs off) select * from pp_arrpart where a = '{1, 2}'; - QUERY PLAN --------------------------- + QUERY PLAN +------------------------------------------------------------- Result One-Time Filter: false -(2 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off' +(3 rows) explain (costs off) select * from pp_arrpart where a in ('{4, 5}', '{1}'); QUERY PLAN @@ -3237,25 +3447,28 @@ explain (costs off) select * from pp_arrpart where a in ('{4, 5}', '{1}'); Filter: ((a = '{4,5}'::integer[]) OR (a = '{1}'::integer[])) -> Seq Scan on pp_arrpart2 Filter: ((a = '{4,5}'::integer[]) OR (a = '{1}'::integer[])) -(5 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off' +(6 rows) explain (costs off) update pp_arrpart set a = a where a = '{1}'; - QUERY PLAN ----------------------------------------- + QUERY PLAN +------------------------------------------------------------- Update on pp_arrpart Update on pp_arrpart1 -> Seq Scan on pp_arrpart1 Filter: (a = '{1}'::integer[]) -(4 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off' +(5 rows) explain (costs off) delete from pp_arrpart where a = '{1}'; - QUERY PLAN ----------------------------------------- + QUERY PLAN +------------------------------------------------------------- Delete on pp_arrpart Delete on pp_arrpart1 -> Seq Scan on pp_arrpart1 Filter: (a = '{1}'::integer[]) -(4 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off' +(5 rows) drop table pp_arrpart; -- array type hash partition key @@ -3272,18 +3485,20 @@ select tableoid::regclass, * from pph_arrpart order by 1; (3 rows) explain (costs off) select * from pph_arrpart where a = '{1}'; - QUERY PLAN ----------------------------------- + QUERY PLAN +------------------------------------------------------------- Seq Scan on pph_arrpart2 Filter: (a = '{1}'::integer[]) -(2 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off' +(3 rows) explain (costs off) select * from pph_arrpart where a = '{1, 2}'; - QUERY PLAN ------------------------------------- + QUERY PLAN +------------------------------------------------------------- Seq Scan on pph_arrpart1 Filter: (a = '{1,2}'::integer[]) -(2 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off' +(3 rows) explain (costs off) select * from pph_arrpart where a in ('{4, 5}', '{1}'); QUERY PLAN @@ -3293,7 +3508,8 @@ explain (costs off) select * from pph_arrpart where a in ('{4, 5}', '{1}'); Filter: ((a = '{4,5}'::integer[]) OR (a = '{1}'::integer[])) -> Seq Scan on pph_arrpart2 Filter: ((a = '{4,5}'::integer[]) OR (a = '{1}'::integer[])) -(5 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off' +(6 rows) drop table pph_arrpart; -- enum type list partition key @@ -3302,18 +3518,20 @@ create table pp_enumpart (a pp_colors) partition by list (a); create table pp_enumpart_green partition of pp_enumpart for values in ('green'); create table pp_enumpart_blue partition of pp_enumpart for values in ('blue'); explain (costs off) select * from pp_enumpart where a = 'blue'; - QUERY PLAN ------------------------------------ + QUERY PLAN +------------------------------------------------------------- Seq Scan on pp_enumpart_blue Filter: (a = 'blue'::pp_colors) -(2 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off' +(3 rows) explain (costs off) select * from pp_enumpart where a = 'black'; - QUERY PLAN --------------------------- + QUERY PLAN +------------------------------------------------------------- Result One-Time Filter: false -(2 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off' +(3 rows) drop table pp_enumpart; drop type pp_colors; @@ -3323,18 +3541,20 @@ create table pp_recpart (a pp_rectype) partition by list (a); create table pp_recpart_11 partition of pp_recpart for values in ('(1,1)'); create table pp_recpart_23 partition of pp_recpart for values in ('(2,3)'); explain (costs off) select * from pp_recpart where a = '(1,1)'::pp_rectype; - QUERY PLAN -------------------------------------- + QUERY PLAN +------------------------------------------------------------- Seq Scan on pp_recpart_11 Filter: (a = '(1,1)'::pp_rectype) -(2 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off' +(3 rows) explain (costs off) select * from pp_recpart where a = '(1,2)'::pp_rectype; - QUERY PLAN --------------------------- + QUERY PLAN +------------------------------------------------------------- Result One-Time Filter: false -(2 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off' +(3 rows) drop table pp_recpart; drop type pp_rectype; @@ -3343,18 +3563,20 @@ create table pp_intrangepart (a int4range) partition by list (a); create table pp_intrangepart12 partition of pp_intrangepart for values in ('[1,2]'); create table pp_intrangepart2inf partition of pp_intrangepart for values in ('[2,)'); explain (costs off) select * from pp_intrangepart where a = '[1,2]'::int4range; - QUERY PLAN ------------------------------------- + QUERY PLAN +------------------------------------------------------------- Seq Scan on pp_intrangepart12 Filter: (a = '[1,3)'::int4range) -(2 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off' +(3 rows) explain (costs off) select * from pp_intrangepart where a = '(1,2)'::int4range; - QUERY PLAN --------------------------- + QUERY PLAN +------------------------------------------------------------- Result One-Time Filter: false -(2 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off' +(3 rows) drop table pp_intrangepart; -- @@ -3364,45 +3586,49 @@ create table pp_lp (a int, value int) partition by list (a); create table pp_lp1 partition of pp_lp for values in(1); create table pp_lp2 partition of pp_lp for values in(2); explain (costs off) select * from pp_lp where a = 1; - QUERY PLAN --------------------- + QUERY PLAN +------------------------------------------------------------- Seq Scan on pp_lp1 Filter: (a = 1) -(2 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off' +(3 rows) explain (costs off) update pp_lp set value = 10 where a = 1; - QUERY PLAN --------------------------- + QUERY PLAN +------------------------------------------------------------- Update on pp_lp Update on pp_lp1 -> Seq Scan on pp_lp1 Filter: (a = 1) -(4 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off' +(5 rows) explain (costs off) delete from pp_lp where a = 1; - QUERY PLAN --------------------------- + QUERY PLAN +------------------------------------------------------------- Delete on pp_lp Delete on pp_lp1 -> Seq Scan on pp_lp1 Filter: (a = 1) -(4 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off' +(5 rows) set enable_partition_pruning = off; set constraint_exclusion = 'partition'; -- this should not affect the result. explain (costs off) select * from pp_lp where a = 1; - QUERY PLAN --------------------------- + QUERY PLAN +----------------------------------------------------------------------------------------------- Append -> Seq Scan on pp_lp1 Filter: (a = 1) -> Seq Scan on pp_lp2 Filter: (a = 1) -(5 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off', enable_partition_pruning = 'off' +(6 rows) explain (costs off) update pp_lp set value = 10 where a = 1; - QUERY PLAN --------------------------- + QUERY PLAN +----------------------------------------------------------------------------------------------- Update on pp_lp Update on pp_lp1 Update on pp_lp2 @@ -3410,11 +3636,12 @@ explain (costs off) update pp_lp set value = 10 where a = 1; Filter: (a = 1) -> Seq Scan on pp_lp2 Filter: (a = 1) -(7 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off', enable_partition_pruning = 'off' +(8 rows) explain (costs off) delete from pp_lp where a = 1; - QUERY PLAN --------------------------- + QUERY PLAN +----------------------------------------------------------------------------------------------- Delete on pp_lp Delete on pp_lp1 Delete on pp_lp2 @@ -3422,22 +3649,24 @@ explain (costs off) delete from pp_lp where a = 1; Filter: (a = 1) -> Seq Scan on pp_lp2 Filter: (a = 1) -(7 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off', enable_partition_pruning = 'off' +(8 rows) set constraint_exclusion = 'off'; -- this should not affect the result. explain (costs off) select * from pp_lp where a = 1; - QUERY PLAN --------------------------- + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------- Append -> Seq Scan on pp_lp1 Filter: (a = 1) -> Seq Scan on pp_lp2 Filter: (a = 1) -(5 rows) + Settings: constraint_exclusion = 'off', enable_hashjoin = 'off', enable_mergejoin = 'off', enable_partition_pruning = 'off' +(6 rows) explain (costs off) update pp_lp set value = 10 where a = 1; - QUERY PLAN --------------------------- + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------- Update on pp_lp Update on pp_lp1 Update on pp_lp2 @@ -3445,11 +3674,12 @@ explain (costs off) update pp_lp set value = 10 where a = 1; Filter: (a = 1) -> Seq Scan on pp_lp2 Filter: (a = 1) -(7 rows) + Settings: constraint_exclusion = 'off', enable_hashjoin = 'off', enable_mergejoin = 'off', enable_partition_pruning = 'off' +(8 rows) explain (costs off) delete from pp_lp where a = 1; - QUERY PLAN --------------------------- + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------- Delete on pp_lp Delete on pp_lp1 Delete on pp_lp2 @@ -3457,7 +3687,8 @@ explain (costs off) delete from pp_lp where a = 1; Filter: (a = 1) -> Seq Scan on pp_lp2 Filter: (a = 1) -(7 rows) + Settings: constraint_exclusion = 'off', enable_hashjoin = 'off', enable_mergejoin = 'off', enable_partition_pruning = 'off' +(8 rows) drop table pp_lp; -- Ensure enable_partition_prune does not affect non-partitioned tables. @@ -3471,18 +3702,19 @@ NOTICE: merging column "value" with inherited definition set constraint_exclusion = 'partition'; -- inh_lp2 should be removed in the following 3 cases. explain (costs off) select * from inh_lp where a = 1; - QUERY PLAN ---------------------------- + QUERY PLAN +----------------------------------------------------------------------------------------------- Append -> Seq Scan on inh_lp Filter: (a = 1) -> Seq Scan on inh_lp1 Filter: (a = 1) -(5 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off', enable_partition_pruning = 'off' +(6 rows) explain (costs off) update inh_lp set value = 10 where a = 1; - QUERY PLAN ---------------------------- + QUERY PLAN +----------------------------------------------------------------------------------------------- Update on inh_lp Update on inh_lp Update on inh_lp1 @@ -3490,11 +3722,12 @@ explain (costs off) update inh_lp set value = 10 where a = 1; Filter: (a = 1) -> Seq Scan on inh_lp1 Filter: (a = 1) -(7 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off', enable_partition_pruning = 'off' +(8 rows) explain (costs off) delete from inh_lp where a = 1; - QUERY PLAN ---------------------------- + QUERY PLAN +----------------------------------------------------------------------------------------------- Delete on inh_lp Delete on inh_lp Delete on inh_lp1 @@ -3502,17 +3735,19 @@ explain (costs off) delete from inh_lp where a = 1; Filter: (a = 1) -> Seq Scan on inh_lp1 Filter: (a = 1) -(7 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off', enable_partition_pruning = 'off' +(8 rows) -- Ensure we don't exclude normal relations when we only expect to exclude -- inheritance children explain (costs off) update inh_lp1 set value = 10 where a = 2; - QUERY PLAN ---------------------------- + QUERY PLAN +----------------------------------------------------------------------------------------------- Update on inh_lp1 -> Seq Scan on inh_lp1 Filter: (a = 2) -(3 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off', enable_partition_pruning = 'off' +(4 rows) drop table inh_lp cascade; NOTICE: drop cascades to 2 other objects @@ -3525,19 +3760,21 @@ create temp table pp_temp_parent (a int) partition by list (a); create temp table pp_temp_part_1 partition of pp_temp_parent for values in (1); create temp table pp_temp_part_def partition of pp_temp_parent default; explain (costs off) select * from pp_temp_parent where true; - QUERY PLAN ------------------------------------- + QUERY PLAN +------------------------------------------------------------- Append -> Seq Scan on pp_temp_part_1 -> Seq Scan on pp_temp_part_def -(3 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off' +(4 rows) explain (costs off) select * from pp_temp_parent where a = 2; - QUERY PLAN ------------------------------- + QUERY PLAN +------------------------------------------------------------- Seq Scan on pp_temp_part_def Filter: (a = 2) -(2 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off' +(3 rows) drop table pp_temp_parent; -- Stress run-time partition pruning a bit more, per bug reports @@ -3562,8 +3799,8 @@ from ( select 1, 1, 1 ) s(a, b, c) where s.a = 1 and s.b = 1 and s.c = (select 1); - QUERY PLAN ----------------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Append InitPlan 1 (returns $0) -> Result @@ -3573,7 +3810,8 @@ where s.a = 1 and s.b = 1 and s.c = (select 1); Filter: ((a = 1) AND (b = 1) AND (c = $0)) -> Result One-Time Filter: (1 = $0) -(9 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off' +(10 rows) select * from ( @@ -3601,8 +3839,8 @@ from ( where s.a = $1 and s.b = $2 and s.c = (select 1); set plan_cache_mode to force_generic_plan; explain (costs off) execute q (1, 1); - QUERY PLAN ---------------------------------------------------------------- + QUERY PLAN +----------------------------------------------------------------------------------------------------- Append InitPlan 1 (returns $0) -> Result @@ -3613,7 +3851,8 @@ explain (costs off) execute q (1, 1); Filter: ((a = $1) AND (b = $2) AND (c = $0)) -> Result One-Time Filter: ((1 = $1) AND (1 = $2) AND (1 = $0)) -(10 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off', plan_cache_mode = 'force_generic_plan' +(11 rows) execute q (1, 1); a | b | c @@ -3629,15 +3868,16 @@ create table listp (a int, b int) partition by list (a); create table listp1 partition of listp for values in(1); create table listp2 partition of listp for values in(2) partition by list(b); create table listp2_10 partition of listp2 for values in (10); -explain (analyze, costs off, summary off, timing off) +explain (exec, costs off, summary off, timing off) select * from listp where a = (select 2) and b <> 10; - QUERY PLAN --------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Seq Scan on listp1 (actual rows=0 loops=1) Filter: ((b <> 10) AND (a = $0)) InitPlan 1 (returns $0) -> Result (never executed) -(4 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off' +(5 rows) -- -- check that a partition directly accessed in a query is excluded with @@ -3648,36 +3888,40 @@ set enable_partition_pruning to off; -- setting constraint_exclusion to 'partition' disables exclusion set constraint_exclusion to 'partition'; explain (costs off) select * from listp1 where a = 2; - QUERY PLAN --------------------- + QUERY PLAN +----------------------------------------------------------------------------------------------- Seq Scan on listp1 Filter: (a = 2) -(2 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off', enable_partition_pruning = 'off' +(3 rows) explain (costs off) update listp1 set a = 1 where a = 2; - QUERY PLAN --------------------------- + QUERY PLAN +----------------------------------------------------------------------------------------------- Update on listp1 -> Seq Scan on listp1 Filter: (a = 2) -(3 rows) + Settings: enable_hashjoin = 'off', enable_mergejoin = 'off', enable_partition_pruning = 'off' +(4 rows) -- constraint exclusion enabled set constraint_exclusion to 'on'; explain (costs off) select * from listp1 where a = 2; - QUERY PLAN --------------------------- + QUERY PLAN +---------------------------------------------------------------------------------------------------------------------------- Result One-Time Filter: false -(2 rows) + Settings: constraint_exclusion = 'on', enable_hashjoin = 'off', enable_mergejoin = 'off', enable_partition_pruning = 'off' +(3 rows) explain (costs off) update listp1 set a = 1 where a = 2; - QUERY PLAN --------------------------------- + QUERY PLAN +---------------------------------------------------------------------------------------------------------------------------- Update on listp1 -> Result One-Time Filter: false -(3 rows) + Settings: constraint_exclusion = 'on', enable_hashjoin = 'off', enable_mergejoin = 'off', enable_partition_pruning = 'off' +(4 rows) reset constraint_exclusion; reset enable_partition_pruning; diff --git a/src/test/regress/expected/plancache.out b/src/test/regress/expected/plancache.out index 7d289b8c5e..0dd5de5078 100644 --- a/src/test/regress/expected/plancache.out +++ b/src/test/regress/expected/plancache.out @@ -296,12 +296,13 @@ explain (costs off) execute test_mode_pp(2); -- force generic plan set plan_cache_mode to force_generic_plan; explain (costs off) execute test_mode_pp(2); - QUERY PLAN ------------------------------ + QUERY PLAN +-------------------------------------------------- Aggregate -> Seq Scan on test_mode Filter: (a = $1) -(3 rows) + Settings: plan_cache_mode = 'force_generic_plan' +(4 rows) -- get to generic plan by 5 executions set plan_cache_mode to auto; @@ -352,6 +353,7 @@ explain (costs off) execute test_mode_pp(2); Aggregate -> Index Only Scan using test_mode_a_idx on test_mode Index Cond: (a = 2) -(3 rows) + Settings: plan_cache_mode = 'force_custom_plan' +(4 rows) drop table test_mode; diff --git a/src/test/regress/expected/polygon.out b/src/test/regress/expected/polygon.out index f319239b2e..8d654c6289 100644 --- a/src/test/regress/expected/polygon.out +++ b/src/test/regress/expected/polygon.out @@ -82,7 +82,8 @@ SELECT count(*) FROM quad_poly_tbl WHERE p << polygon '((300,300),(400,600),(600 Recheck Cond: (p << '((300,300),(400,600),(600,500),(700,200))'::polygon) -> Bitmap Index Scan on quad_poly_tbl_idx Index Cond: (p << '((300,300),(400,600),(600,500),(700,200))'::polygon) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM quad_poly_tbl WHERE p << polygon '((300,300),(400,600),(600,500),(700,200))'; count @@ -99,7 +100,8 @@ SELECT count(*) FROM quad_poly_tbl WHERE p &< polygon '((300,300),(400,600),(600 Recheck Cond: (p &< '((300,300),(400,600),(600,500),(700,200))'::polygon) -> Bitmap Index Scan on quad_poly_tbl_idx Index Cond: (p &< '((300,300),(400,600),(600,500),(700,200))'::polygon) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM quad_poly_tbl WHERE p &< polygon '((300,300),(400,600),(600,500),(700,200))'; count @@ -116,7 +118,8 @@ SELECT count(*) FROM quad_poly_tbl WHERE p && polygon '((300,300),(400,600),(600 Recheck Cond: (p && '((300,300),(400,600),(600,500),(700,200))'::polygon) -> Bitmap Index Scan on quad_poly_tbl_idx Index Cond: (p && '((300,300),(400,600),(600,500),(700,200))'::polygon) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM quad_poly_tbl WHERE p && polygon '((300,300),(400,600),(600,500),(700,200))'; count @@ -133,7 +136,8 @@ SELECT count(*) FROM quad_poly_tbl WHERE p &> polygon '((300,300),(400,600),(600 Recheck Cond: (p &> '((300,300),(400,600),(600,500),(700,200))'::polygon) -> Bitmap Index Scan on quad_poly_tbl_idx Index Cond: (p &> '((300,300),(400,600),(600,500),(700,200))'::polygon) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM quad_poly_tbl WHERE p &> polygon '((300,300),(400,600),(600,500),(700,200))'; count @@ -150,7 +154,8 @@ SELECT count(*) FROM quad_poly_tbl WHERE p >> polygon '((300,300),(400,600),(600 Recheck Cond: (p >> '((300,300),(400,600),(600,500),(700,200))'::polygon) -> Bitmap Index Scan on quad_poly_tbl_idx Index Cond: (p >> '((300,300),(400,600),(600,500),(700,200))'::polygon) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM quad_poly_tbl WHERE p >> polygon '((300,300),(400,600),(600,500),(700,200))'; count @@ -167,7 +172,8 @@ SELECT count(*) FROM quad_poly_tbl WHERE p <<| polygon '((300,300),(400,600),(60 Recheck Cond: (p <<| '((300,300),(400,600),(600,500),(700,200))'::polygon) -> Bitmap Index Scan on quad_poly_tbl_idx Index Cond: (p <<| '((300,300),(400,600),(600,500),(700,200))'::polygon) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM quad_poly_tbl WHERE p <<| polygon '((300,300),(400,600),(600,500),(700,200))'; count @@ -184,7 +190,8 @@ SELECT count(*) FROM quad_poly_tbl WHERE p &<| polygon '((300,300),(400,600),(60 Recheck Cond: (p &<| '((300,300),(400,600),(600,500),(700,200))'::polygon) -> Bitmap Index Scan on quad_poly_tbl_idx Index Cond: (p &<| '((300,300),(400,600),(600,500),(700,200))'::polygon) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM quad_poly_tbl WHERE p &<| polygon '((300,300),(400,600),(600,500),(700,200))'; count @@ -201,7 +208,8 @@ SELECT count(*) FROM quad_poly_tbl WHERE p |&> polygon '((300,300),(400,600),(60 Recheck Cond: (p |&> '((300,300),(400,600),(600,500),(700,200))'::polygon) -> Bitmap Index Scan on quad_poly_tbl_idx Index Cond: (p |&> '((300,300),(400,600),(600,500),(700,200))'::polygon) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM quad_poly_tbl WHERE p |&> polygon '((300,300),(400,600),(600,500),(700,200))'; count @@ -218,7 +226,8 @@ SELECT count(*) FROM quad_poly_tbl WHERE p |>> polygon '((300,300),(400,600),(60 Recheck Cond: (p |>> '((300,300),(400,600),(600,500),(700,200))'::polygon) -> Bitmap Index Scan on quad_poly_tbl_idx Index Cond: (p |>> '((300,300),(400,600),(600,500),(700,200))'::polygon) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM quad_poly_tbl WHERE p |>> polygon '((300,300),(400,600),(600,500),(700,200))'; count @@ -235,7 +244,8 @@ SELECT count(*) FROM quad_poly_tbl WHERE p <@ polygon '((300,300),(400,600),(600 Recheck Cond: (p <@ '((300,300),(400,600),(600,500),(700,200))'::polygon) -> Bitmap Index Scan on quad_poly_tbl_idx Index Cond: (p <@ '((300,300),(400,600),(600,500),(700,200))'::polygon) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM quad_poly_tbl WHERE p <@ polygon '((300,300),(400,600),(600,500),(700,200))'; count @@ -252,7 +262,8 @@ SELECT count(*) FROM quad_poly_tbl WHERE p @> polygon '((340,550),(343,552),(341 Recheck Cond: (p @> '((340,550),(343,552),(341,553))'::polygon) -> Bitmap Index Scan on quad_poly_tbl_idx Index Cond: (p @> '((340,550),(343,552),(341,553))'::polygon) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM quad_poly_tbl WHERE p @> polygon '((340,550),(343,552),(341,553))'; count @@ -269,7 +280,8 @@ SELECT count(*) FROM quad_poly_tbl WHERE p ~= polygon '((200, 300),(210, 310),(2 Recheck Cond: (p ~= '((200,300),(210,310),(230,290))'::polygon) -> Bitmap Index Scan on quad_poly_tbl_idx Index Cond: (p ~= '((200,300),(210,310),(230,290))'::polygon) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM quad_poly_tbl WHERE p ~= polygon '((200, 300),(210, 310),(230, 290))'; count @@ -289,7 +301,8 @@ FROM quad_poly_tbl WHERE p <@ polygon '((300,300),(400,600),(600,500),(700,200)) -> Index Scan using quad_poly_tbl_idx on quad_poly_tbl Index Cond: (p <@ '((300,300),(400,600),(600,500),(700,200))'::polygon) Order By: (p <-> '(123,456)'::point) -(4 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(5 rows) CREATE TEMP TABLE quad_poly_tbl_ord_idx2 AS SELECT rank() OVER (ORDER BY p <-> point '123,456') n, p <-> point '123,456' dist, id diff --git a/src/test/regress/expected/rangetypes.out b/src/test/regress/expected/rangetypes.out index accf1e0d9e..cb3f968dc5 100644 --- a/src/test/regress/expected/rangetypes.out +++ b/src/test/regress/expected/rangetypes.out @@ -1099,7 +1099,8 @@ select ir from test_range_spgist where ir -|- int4range(10,20) order by ir; Sort Key: ir -> Index Only Scan using test_range_spgist_idx on test_range_spgist Index Cond: (ir -|- '[10,20)'::int4range) -(4 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(5 rows) select ir from test_range_spgist where ir -|- int4range(10,20) order by ir; ir diff --git a/src/test/regress/expected/rowsecurity.out b/src/test/regress/expected/rowsecurity.out index aa3b083ee3..6abd169172 100644 --- a/src/test/regress/expected/rowsecurity.out +++ b/src/test/regress/expected/rowsecurity.out @@ -272,7 +272,8 @@ EXPLAIN (COSTS OFF) SELECT * FROM document WHERE f_leak(dtitle); InitPlan 1 (returns $0) -> Index Scan using uaccount_pkey on uaccount Index Cond: (pguser = CURRENT_USER) -(5 rows) + Settings: search_path = 'regress_rls_schema' +(6 rows) EXPLAIN (COSTS OFF) SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle); QUERY PLAN @@ -286,7 +287,8 @@ EXPLAIN (COSTS OFF) SELECT * FROM document NATURAL JOIN category WHERE f_leak(dt -> Hash -> Seq Scan on document Filter: ((dlevel <= $0) AND f_leak(dtitle)) -(9 rows) + Settings: search_path = 'regress_rls_schema' +(10 rows) -- viewpoint from regress_rls_dave SET SESSION AUTHORIZATION regress_rls_dave; @@ -336,7 +338,8 @@ EXPLAIN (COSTS OFF) SELECT * FROM document WHERE f_leak(dtitle); InitPlan 1 (returns $0) -> Index Scan using uaccount_pkey on uaccount Index Cond: (pguser = CURRENT_USER) -(5 rows) + Settings: search_path = 'regress_rls_schema' +(6 rows) EXPLAIN (COSTS OFF) SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle); QUERY PLAN @@ -350,7 +353,8 @@ EXPLAIN (COSTS OFF) SELECT * FROM document NATURAL JOIN category WHERE f_leak(dt -> Hash -> Seq Scan on document Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= $0) AND f_leak(dtitle)) -(9 rows) + Settings: search_path = 'regress_rls_schema' +(10 rows) -- 44 would technically fail for both p2r and p1r, but we should get an error -- back from p1r for this because it sorts first @@ -427,7 +431,8 @@ EXPLAIN (COSTS OFF) SELECT * FROM document WHERE f_leak(dtitle); --------------------------------------------------------- Seq Scan on document Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -(2 rows) + Settings: search_path = 'regress_rls_schema' +(3 rows) EXPLAIN (COSTS OFF) SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle); QUERY PLAN @@ -437,7 +442,8 @@ EXPLAIN (COSTS OFF) SELECT * FROM document NATURAL JOIN category WHERE f_leak(dt Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Index Scan using category_pkey on category Index Cond: (cid = document.cid) -(5 rows) + Settings: search_path = 'regress_rls_schema' +(6 rows) -- interaction of FK/PK constraints SET SESSION AUTHORIZATION regress_rls_alice; @@ -659,8 +665,8 @@ SELECT * FROM t1; (5 rows) EXPLAIN (COSTS OFF) SELECT * FROM t1; - QUERY PLAN -------------------------------- + QUERY PLAN +---------------------------------------------- Append -> Seq Scan on t1 Filter: ((a % 2) = 0) @@ -668,7 +674,8 @@ EXPLAIN (COSTS OFF) SELECT * FROM t1; Filter: ((a % 2) = 0) -> Seq Scan on t3 Filter: ((a % 2) = 0) -(7 rows) + Settings: search_path = 'regress_rls_schema' +(8 rows) SELECT * FROM t1 WHERE f_leak(b); NOTICE: f_leak => bbb @@ -695,7 +702,8 @@ EXPLAIN (COSTS OFF) SELECT * FROM t1 WHERE f_leak(b); Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t3 Filter: (((a % 2) = 0) AND f_leak(b)) -(7 rows) + Settings: search_path = 'regress_rls_schema' +(8 rows) -- reference to system column SELECT tableoid::regclass, * FROM t1; @@ -709,8 +717,8 @@ SELECT tableoid::regclass, * FROM t1; (5 rows) EXPLAIN (COSTS OFF) SELECT *, t1 FROM t1; - QUERY PLAN -------------------------------- + QUERY PLAN +---------------------------------------------- Append -> Seq Scan on t1 Filter: ((a % 2) = 0) @@ -718,7 +726,8 @@ EXPLAIN (COSTS OFF) SELECT *, t1 FROM t1; Filter: ((a % 2) = 0) -> Seq Scan on t3 Filter: ((a % 2) = 0) -(7 rows) + Settings: search_path = 'regress_rls_schema' +(8 rows) -- reference to whole-row reference SELECT *, t1 FROM t1; @@ -732,8 +741,8 @@ SELECT *, t1 FROM t1; (5 rows) EXPLAIN (COSTS OFF) SELECT *, t1 FROM t1; - QUERY PLAN -------------------------------- + QUERY PLAN +---------------------------------------------- Append -> Seq Scan on t1 Filter: ((a % 2) = 0) @@ -741,7 +750,8 @@ EXPLAIN (COSTS OFF) SELECT *, t1 FROM t1; Filter: ((a % 2) = 0) -> Seq Scan on t3 Filter: ((a % 2) = 0) -(7 rows) + Settings: search_path = 'regress_rls_schema' +(8 rows) -- for share/update lock SELECT * FROM t1 FOR SHARE; @@ -755,8 +765,8 @@ SELECT * FROM t1 FOR SHARE; (5 rows) EXPLAIN (COSTS OFF) SELECT * FROM t1 FOR SHARE; - QUERY PLAN -------------------------------------- + QUERY PLAN +---------------------------------------------- LockRows -> Append -> Seq Scan on t1 @@ -765,7 +775,8 @@ EXPLAIN (COSTS OFF) SELECT * FROM t1 FOR SHARE; Filter: ((a % 2) = 0) -> Seq Scan on t3 Filter: ((a % 2) = 0) -(8 rows) + Settings: search_path = 'regress_rls_schema' +(9 rows) SELECT * FROM t1 WHERE f_leak(b) FOR SHARE; NOTICE: f_leak => bbb @@ -793,7 +804,8 @@ EXPLAIN (COSTS OFF) SELECT * FROM t1 WHERE f_leak(b) FOR SHARE; Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t3 Filter: (((a % 2) = 0) AND f_leak(b)) -(8 rows) + Settings: search_path = 'regress_rls_schema' +(9 rows) -- union all query SELECT a, b, tableoid::regclass FROM t2 UNION ALL SELECT a, b, tableoid::regclass FROM t3; @@ -807,13 +819,14 @@ SELECT a, b, tableoid::regclass FROM t2 UNION ALL SELECT a, b, tableoid::regclas (5 rows) EXPLAIN (COSTS OFF) SELECT a, b, tableoid::regclass FROM t2 UNION ALL SELECT a, b, tableoid::regclass FROM t3; - QUERY PLAN -------------------------------- + QUERY PLAN +---------------------------------------------- Append -> Seq Scan on t2 Filter: ((a % 2) = 1) -> Seq Scan on t3 -(4 rows) + Settings: search_path = 'regress_rls_schema' +(5 rows) -- superuser is allowed to bypass RLS checks RESET SESSION AUTHORIZATION; @@ -846,8 +859,8 @@ NOTICE: f_leak => zzz (11 rows) EXPLAIN (COSTS OFF) SELECT * FROM t1 WHERE f_leak(b); - QUERY PLAN ---------------------------- + QUERY PLAN +---------------------------------------------- Append -> Seq Scan on t1 Filter: f_leak(b) @@ -855,7 +868,8 @@ EXPLAIN (COSTS OFF) SELECT * FROM t1 WHERE f_leak(b); Filter: f_leak(b) -> Seq Scan on t3 Filter: f_leak(b) -(7 rows) + Settings: search_path = 'regress_rls_schema' +(8 rows) -- non-superuser with bypass privilege can bypass RLS policy when disabled SET SESSION AUTHORIZATION regress_rls_exempt_user; @@ -888,8 +902,8 @@ NOTICE: f_leak => zzz (11 rows) EXPLAIN (COSTS OFF) SELECT * FROM t1 WHERE f_leak(b); - QUERY PLAN ---------------------------- + QUERY PLAN +---------------------------------------------- Append -> Seq Scan on t1 Filter: f_leak(b) @@ -897,7 +911,8 @@ EXPLAIN (COSTS OFF) SELECT * FROM t1 WHERE f_leak(b); Filter: f_leak(b) -> Seq Scan on t3 Filter: f_leak(b) -(7 rows) + Settings: search_path = 'regress_rls_schema' +(8 rows) -- -- Partitioned Tables @@ -997,7 +1012,8 @@ EXPLAIN (COSTS OFF) SELECT * FROM part_document WHERE f_leak(dtitle); Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on part_document_nonfiction Filter: ((dlevel <= $0) AND f_leak(dtitle)) -(10 rows) + Settings: search_path = 'regress_rls_schema' +(11 rows) -- viewpoint from regress_rls_carol SET SESSION AUTHORIZATION regress_rls_carol; @@ -1039,7 +1055,8 @@ EXPLAIN (COSTS OFF) SELECT * FROM part_document WHERE f_leak(dtitle); Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on part_document_nonfiction Filter: ((dlevel <= $0) AND f_leak(dtitle)) -(10 rows) + Settings: search_path = 'regress_rls_schema' +(11 rows) -- viewpoint from regress_rls_dave SET SESSION AUTHORIZATION regress_rls_dave; @@ -1064,7 +1081,8 @@ EXPLAIN (COSTS OFF) SELECT * FROM part_document WHERE f_leak(dtitle); InitPlan 1 (returns $0) -> Index Scan using uaccount_pkey on uaccount Index Cond: (pguser = CURRENT_USER) -(5 rows) + Settings: search_path = 'regress_rls_schema' +(6 rows) -- pp1 ERROR INSERT INTO part_document VALUES (100, 11, 5, 'regress_rls_dave', 'testing pp1'); -- fail @@ -1142,7 +1160,8 @@ EXPLAIN (COSTS OFF) SELECT * FROM part_document WHERE f_leak(dtitle); InitPlan 1 (returns $0) -> Index Scan using uaccount_pkey on uaccount Index Cond: (pguser = CURRENT_USER) -(5 rows) + Settings: search_path = 'regress_rls_schema' +(6 rows) -- viewpoint from regress_rls_carol SET SESSION AUTHORIZATION regress_rls_carol; @@ -1186,7 +1205,8 @@ EXPLAIN (COSTS OFF) SELECT * FROM part_document WHERE f_leak(dtitle); Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on part_document_nonfiction Filter: ((dlevel <= $0) AND f_leak(dtitle)) -(10 rows) + Settings: search_path = 'regress_rls_schema' +(11 rows) -- only owner can change policies ALTER POLICY pp1 ON part_document USING (true); --fail @@ -1235,7 +1255,8 @@ EXPLAIN (COSTS OFF) SELECT * FROM part_document WHERE f_leak(dtitle); Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on part_document_nonfiction Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -(7 rows) + Settings: search_path = 'regress_rls_schema' +(8 rows) -- database superuser does bypass RLS policy when enabled RESET SESSION AUTHORIZATION; @@ -1348,10 +1369,11 @@ HINT: Use DROP ... CASCADE to drop the dependent objects too. DROP TABLE dependee CASCADE; NOTICE: drop cascades to policy d1 on table dependent EXPLAIN (COSTS OFF) SELECT * FROM dependent; -- After drop, should be unqualified - QUERY PLAN ------------------------ + QUERY PLAN +---------------------------------------------- Seq Scan on dependent -(1 row) + Settings: search_path = 'regress_rls_schema' +(2 rows) ----- RECURSION ---- -- @@ -1444,7 +1466,8 @@ EXPLAIN (COSTS OFF) SELECT * FROM only s1 WHERE f_leak(b); SubPlan 1 -> Seq Scan on s2 Filter: (((x % 2) = 0) AND (y ~~ '%2f%'::text)) -(5 rows) + Settings: search_path = 'regress_rls_schema' +(6 rows) SET SESSION AUTHORIZATION regress_rls_alice; ALTER POLICY p1 ON s1 USING (a in (select x from v2)); -- using VIEW in RLS policy @@ -1466,7 +1489,8 @@ EXPLAIN (COSTS OFF) SELECT * FROM s1 WHERE f_leak(b); SubPlan 1 -> Seq Scan on s2 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -(5 rows) + Settings: search_path = 'regress_rls_schema' +(6 rows) SELECT (SELECT x FROM s1 LIMIT 1) xx, * FROM s2 WHERE y like '%28%'; xx | x | y @@ -1488,7 +1512,8 @@ EXPLAIN (COSTS OFF) SELECT (SELECT x FROM s1 LIMIT 1) xx, * FROM s2 WHERE y like SubPlan 1 -> Seq Scan on s2 s2_1 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -(9 rows) + Settings: search_path = 'regress_rls_schema' +(10 rows) SET SESSION AUTHORIZATION regress_rls_alice; ALTER POLICY p2 ON s2 USING (x in (select a from s1 where b like '%d2%')); @@ -1515,7 +1540,8 @@ EXPLAIN (COSTS OFF) EXECUTE p1(2); Filter: ((a <= 2) AND ((a % 2) = 0)) -> Seq Scan on t3 Filter: ((a <= 2) AND ((a % 2) = 0)) -(7 rows) + Settings: search_path = 'regress_rls_schema' +(8 rows) -- superuser is allowed to bypass RLS checks RESET SESSION AUTHORIZATION; @@ -1548,8 +1574,8 @@ NOTICE: f_leak => zzz (11 rows) EXPLAIN (COSTS OFF) SELECT * FROM t1 WHERE f_leak(b); - QUERY PLAN ---------------------------- + QUERY PLAN +---------------------------------------------- Append -> Seq Scan on t1 Filter: f_leak(b) @@ -1557,7 +1583,8 @@ EXPLAIN (COSTS OFF) SELECT * FROM t1 WHERE f_leak(b); Filter: f_leak(b) -> Seq Scan on t3 Filter: f_leak(b) -(7 rows) + Settings: search_path = 'regress_rls_schema' +(8 rows) -- plan cache should be invalidated EXECUTE p1(2); @@ -1572,8 +1599,8 @@ EXECUTE p1(2); (6 rows) EXPLAIN (COSTS OFF) EXECUTE p1(2); - QUERY PLAN --------------------------- + QUERY PLAN +---------------------------------------------- Append -> Seq Scan on t1 Filter: (a <= 2) @@ -1581,7 +1608,8 @@ EXPLAIN (COSTS OFF) EXECUTE p1(2); Filter: (a <= 2) -> Seq Scan on t3 Filter: (a <= 2) -(7 rows) + Settings: search_path = 'regress_rls_schema' +(8 rows) PREPARE p2(int) AS SELECT * FROM t1 WHERE a = $1; EXECUTE p2(2); @@ -1593,8 +1621,8 @@ EXECUTE p2(2); (3 rows) EXPLAIN (COSTS OFF) EXECUTE p2(2); - QUERY PLAN -------------------------- + QUERY PLAN +---------------------------------------------- Append -> Seq Scan on t1 Filter: (a = 2) @@ -1602,7 +1630,8 @@ EXPLAIN (COSTS OFF) EXECUTE p2(2); Filter: (a = 2) -> Seq Scan on t3 Filter: (a = 2) -(7 rows) + Settings: search_path = 'regress_rls_schema' +(8 rows) -- also, case when privilege switch from superuser SET SESSION AUTHORIZATION regress_rls_bob; @@ -1616,8 +1645,8 @@ EXECUTE p2(2); (3 rows) EXPLAIN (COSTS OFF) EXECUTE p2(2); - QUERY PLAN ---------------------------------------------- + QUERY PLAN +---------------------------------------------- Append -> Seq Scan on t1 Filter: ((a = 2) AND ((a % 2) = 0)) @@ -1625,7 +1654,8 @@ EXPLAIN (COSTS OFF) EXECUTE p2(2); Filter: ((a = 2) AND ((a % 2) = 0)) -> Seq Scan on t3 Filter: ((a = 2) AND ((a % 2) = 0)) -(7 rows) + Settings: search_path = 'regress_rls_schema' +(8 rows) -- -- UPDATE / DELETE and Row-level security @@ -1644,7 +1674,8 @@ EXPLAIN (COSTS OFF) UPDATE t1 SET b = b || b WHERE f_leak(b); Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t3 Filter: (((a % 2) = 0) AND f_leak(b)) -(10 rows) + Settings: search_path = 'regress_rls_schema' +(11 rows) UPDATE t1 SET b = b || b WHERE f_leak(b); NOTICE: f_leak => bbb @@ -1658,7 +1689,8 @@ EXPLAIN (COSTS OFF) UPDATE only t1 SET b = b || '_updt' WHERE f_leak(b); Update on t1 -> Seq Scan on t1 Filter: (((a % 2) = 0) AND f_leak(b)) -(3 rows) + Settings: search_path = 'regress_rls_schema' +(4 rows) UPDATE only t1 SET b = b || '_updt' WHERE f_leak(b); NOTICE: f_leak => bbbbbb @@ -1714,7 +1746,8 @@ WHERE t2.a = 3 and t3.a = 2 AND f_leak(t2.b) AND f_leak(t3.b); Filter: ((a = 3) AND ((a % 2) = 1) AND f_leak(b)) -> Seq Scan on t3 Filter: ((a = 2) AND f_leak(b)) -(6 rows) + Settings: search_path = 'regress_rls_schema' +(7 rows) UPDATE t2 SET b=t2.b FROM t3 WHERE t2.a = 3 and t3.a = 2 AND f_leak(t2.b) AND f_leak(t3.b); @@ -1743,7 +1776,8 @@ WHERE t1.a = 3 and t2.a = 3 AND f_leak(t1.b) AND f_leak(t2.b); Filter: ((a = 3) AND ((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t2 Filter: ((a = 3) AND ((a % 2) = 1) AND f_leak(b)) -(19 rows) + Settings: search_path = 'regress_rls_schema' +(20 rows) UPDATE t1 SET b=t1.b FROM t2 WHERE t1.a = 3 and t2.a = 3 AND f_leak(t1.b) AND f_leak(t2.b); @@ -1762,7 +1796,8 @@ WHERE t1.a = 3 and t2.a = 3 AND f_leak(t1.b) AND f_leak(t2.b); Filter: ((a = 3) AND ((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t3 Filter: ((a = 3) AND ((a % 2) = 0) AND f_leak(b)) -(11 rows) + Settings: search_path = 'regress_rls_schema' +(12 rows) UPDATE t2 SET b=t2.b FROM t1 WHERE t1.a = 3 and t2.a = 3 AND f_leak(t1.b) AND f_leak(t2.b); @@ -1780,7 +1815,8 @@ AND f_leak(t2_1.b) AND f_leak(t2_2.b) RETURNING *, t2_1, t2_2; Filter: ((a = 3) AND ((a % 2) = 1) AND f_leak(b)) -> Seq Scan on t2 t2_2 Filter: ((a = 3) AND ((a % 2) = 1) AND f_leak(b)) -(7 rows) + Settings: search_path = 'regress_rls_schema' +(8 rows) UPDATE t2 t2_1 SET b = t2_2.b FROM t2 t2_2 WHERE t2_1.a = 3 AND t2_2.a = t2_1.a AND t2_2.b = t2_1.b @@ -1834,7 +1870,8 @@ AND f_leak(t1_1.b) AND f_leak(t1_2.b) RETURNING *, t1_1, t1_2; Filter: ((a = 4) AND ((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t3 t1_2_2 Filter: ((a = 4) AND ((a % 2) = 0) AND f_leak(b)) -(37 rows) + Settings: search_path = 'regress_rls_schema' +(38 rows) UPDATE t1 t1_1 SET b = t1_2.b FROM t1 t1_2 WHERE t1_1.a = 4 AND t1_2.a = t1_1.a AND t1_2.b = t1_1.b @@ -1877,7 +1914,8 @@ EXPLAIN (COSTS OFF) DELETE FROM only t1 WHERE f_leak(b); Delete on t1 -> Seq Scan on t1 Filter: (((a % 2) = 0) AND f_leak(b)) -(3 rows) + Settings: search_path = 'regress_rls_schema' +(4 rows) EXPLAIN (COSTS OFF) DELETE FROM t1 WHERE f_leak(b); QUERY PLAN @@ -1892,7 +1930,8 @@ EXPLAIN (COSTS OFF) DELETE FROM t1 WHERE f_leak(b); Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t3 Filter: (((a % 2) = 0) AND f_leak(b)) -(10 rows) + Settings: search_path = 'regress_rls_schema' +(11 rows) DELETE FROM only t1 WHERE f_leak(b) RETURNING tableoid::regclass, *, t1; NOTICE: f_leak => bbbbbb_updt @@ -1928,13 +1967,14 @@ CREATE VIEW bv1 WITH (security_barrier) AS SELECT * FROM b1 WHERE a > 0 WITH CHE GRANT ALL ON bv1 TO regress_rls_carol; SET SESSION AUTHORIZATION regress_rls_carol; EXPLAIN (COSTS OFF) SELECT * FROM bv1 WHERE f_leak(b); - QUERY PLAN ---------------------------------------------- + QUERY PLAN +---------------------------------------------- Subquery Scan on bv1 Filter: f_leak(bv1.b) -> Seq Scan on b1 Filter: ((a > 0) AND ((a % 2) = 0)) -(4 rows) + Settings: search_path = 'regress_rls_schema' +(5 rows) SELECT * FROM bv1 WHERE f_leak(b); NOTICE: f_leak => c81e728d9d4c2f636f067f89cc14862c @@ -1962,7 +2002,8 @@ EXPLAIN (COSTS OFF) UPDATE bv1 SET b = 'yyy' WHERE a = 4 AND f_leak(b); Update on b1 -> Seq Scan on b1 Filter: ((a > 0) AND (a = 4) AND ((a % 2) = 0) AND f_leak(b)) -(3 rows) + Settings: search_path = 'regress_rls_schema' +(4 rows) UPDATE bv1 SET b = 'yyy' WHERE a = 4 AND f_leak(b); NOTICE: f_leak => a87ff679a2f3e71d9181a67b7542122c @@ -1972,7 +2013,8 @@ EXPLAIN (COSTS OFF) DELETE FROM bv1 WHERE a = 6 AND f_leak(b); Delete on b1 -> Seq Scan on b1 Filter: ((a > 0) AND (a = 6) AND ((a % 2) = 0) AND f_leak(b)) -(3 rows) + Settings: search_path = 'regress_rls_schema' +(4 rows) DELETE FROM bv1 WHERE a = 6 AND f_leak(b); NOTICE: f_leak => 1679091c5a880faf6fb5e6087eb1b2dc @@ -2163,19 +2205,21 @@ NOTICE: f_leak => dad (2 rows) EXPLAIN (COSTS OFF) SELECT * FROM z1 WHERE f_leak(b); - QUERY PLAN ------------------------------------------ + QUERY PLAN +---------------------------------------------- Seq Scan on z1 Filter: (((a % 2) = 0) AND f_leak(b)) -(2 rows) + Settings: search_path = 'regress_rls_schema' +(3 rows) PREPARE plancache_test AS SELECT * FROM z1 WHERE f_leak(b); EXPLAIN (COSTS OFF) EXECUTE plancache_test; - QUERY PLAN ------------------------------------------ + QUERY PLAN +---------------------------------------------- Seq Scan on z1 Filter: (((a % 2) = 0) AND f_leak(b)) -(2 rows) + Settings: search_path = 'regress_rls_schema' +(3 rows) PREPARE plancache_test2 AS WITH q AS MATERIALIZED (SELECT * FROM z1 WHERE f_leak(b)) SELECT * FROM q,z2; EXPLAIN (COSTS OFF) EXECUTE plancache_test2; @@ -2188,7 +2232,8 @@ EXPLAIN (COSTS OFF) EXECUTE plancache_test2; -> CTE Scan on q -> Materialize -> Seq Scan on z2 -(7 rows) + Settings: search_path = 'regress_rls_schema' +(8 rows) PREPARE plancache_test3 AS WITH q AS MATERIALIZED (SELECT * FROM z2) SELECT * FROM q,z1 WHERE f_leak(z1.b); EXPLAIN (COSTS OFF) EXECUTE plancache_test3; @@ -2201,7 +2246,8 @@ EXPLAIN (COSTS OFF) EXECUTE plancache_test3; -> Materialize -> Seq Scan on z1 Filter: (((a % 2) = 0) AND f_leak(b)) -(7 rows) + Settings: search_path = 'regress_rls_schema' +(8 rows) SET ROLE regress_rls_group1; SELECT * FROM z1 WHERE f_leak(b); @@ -2214,18 +2260,20 @@ NOTICE: f_leak => dad (2 rows) EXPLAIN (COSTS OFF) SELECT * FROM z1 WHERE f_leak(b); - QUERY PLAN ------------------------------------------ + QUERY PLAN +---------------------------------------------- Seq Scan on z1 Filter: (((a % 2) = 0) AND f_leak(b)) -(2 rows) + Settings: search_path = 'regress_rls_schema' +(3 rows) EXPLAIN (COSTS OFF) EXECUTE plancache_test; - QUERY PLAN ------------------------------------------ + QUERY PLAN +---------------------------------------------- Seq Scan on z1 Filter: (((a % 2) = 0) AND f_leak(b)) -(2 rows) + Settings: search_path = 'regress_rls_schema' +(3 rows) EXPLAIN (COSTS OFF) EXECUTE plancache_test2; QUERY PLAN @@ -2237,7 +2285,8 @@ EXPLAIN (COSTS OFF) EXECUTE plancache_test2; -> CTE Scan on q -> Materialize -> Seq Scan on z2 -(7 rows) + Settings: search_path = 'regress_rls_schema' +(8 rows) EXPLAIN (COSTS OFF) EXECUTE plancache_test3; QUERY PLAN @@ -2249,7 +2298,8 @@ EXPLAIN (COSTS OFF) EXECUTE plancache_test3; -> Materialize -> Seq Scan on z1 Filter: (((a % 2) = 0) AND f_leak(b)) -(7 rows) + Settings: search_path = 'regress_rls_schema' +(8 rows) SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM z1 WHERE f_leak(b); @@ -2262,18 +2312,20 @@ NOTICE: f_leak => ccc (2 rows) EXPLAIN (COSTS OFF) SELECT * FROM z1 WHERE f_leak(b); - QUERY PLAN ------------------------------------------ + QUERY PLAN +---------------------------------------------- Seq Scan on z1 Filter: (((a % 2) = 1) AND f_leak(b)) -(2 rows) + Settings: search_path = 'regress_rls_schema' +(3 rows) EXPLAIN (COSTS OFF) EXECUTE plancache_test; - QUERY PLAN ------------------------------------------ + QUERY PLAN +---------------------------------------------- Seq Scan on z1 Filter: (((a % 2) = 1) AND f_leak(b)) -(2 rows) + Settings: search_path = 'regress_rls_schema' +(3 rows) EXPLAIN (COSTS OFF) EXECUTE plancache_test2; QUERY PLAN @@ -2285,7 +2337,8 @@ EXPLAIN (COSTS OFF) EXECUTE plancache_test2; -> CTE Scan on q -> Materialize -> Seq Scan on z2 -(7 rows) + Settings: search_path = 'regress_rls_schema' +(8 rows) EXPLAIN (COSTS OFF) EXECUTE plancache_test3; QUERY PLAN @@ -2297,7 +2350,8 @@ EXPLAIN (COSTS OFF) EXECUTE plancache_test3; -> Materialize -> Seq Scan on z1 Filter: (((a % 2) = 1) AND f_leak(b)) -(7 rows) + Settings: search_path = 'regress_rls_schema' +(8 rows) SET ROLE regress_rls_group2; SELECT * FROM z1 WHERE f_leak(b); @@ -2310,18 +2364,20 @@ NOTICE: f_leak => ccc (2 rows) EXPLAIN (COSTS OFF) SELECT * FROM z1 WHERE f_leak(b); - QUERY PLAN ------------------------------------------ + QUERY PLAN +---------------------------------------------- Seq Scan on z1 Filter: (((a % 2) = 1) AND f_leak(b)) -(2 rows) + Settings: search_path = 'regress_rls_schema' +(3 rows) EXPLAIN (COSTS OFF) EXECUTE plancache_test; - QUERY PLAN ------------------------------------------ + QUERY PLAN +---------------------------------------------- Seq Scan on z1 Filter: (((a % 2) = 1) AND f_leak(b)) -(2 rows) + Settings: search_path = 'regress_rls_schema' +(3 rows) EXPLAIN (COSTS OFF) EXECUTE plancache_test2; QUERY PLAN @@ -2333,7 +2389,8 @@ EXPLAIN (COSTS OFF) EXECUTE plancache_test2; -> CTE Scan on q -> Materialize -> Seq Scan on z2 -(7 rows) + Settings: search_path = 'regress_rls_schema' +(8 rows) EXPLAIN (COSTS OFF) EXECUTE plancache_test3; QUERY PLAN @@ -2345,7 +2402,8 @@ EXPLAIN (COSTS OFF) EXECUTE plancache_test3; -> Materialize -> Seq Scan on z1 Filter: (((a % 2) = 1) AND f_leak(b)) -(7 rows) + Settings: search_path = 'regress_rls_schema' +(8 rows) -- -- Views should follow policy for view owner. @@ -2370,11 +2428,12 @@ NOTICE: f_leak => dad (4 rows) EXPLAIN (COSTS OFF) SELECT * FROM rls_view; - QUERY PLAN ---------------------- + QUERY PLAN +---------------------------------------------- Seq Scan on z1 Filter: f_leak(b) -(2 rows) + Settings: search_path = 'regress_rls_schema' +(3 rows) -- Query as view/table owner. Should return all records. SET SESSION AUTHORIZATION regress_rls_alice; @@ -2392,11 +2451,12 @@ NOTICE: f_leak => dad (4 rows) EXPLAIN (COSTS OFF) SELECT * FROM rls_view; - QUERY PLAN ---------------------- + QUERY PLAN +---------------------------------------------- Seq Scan on z1 Filter: f_leak(b) -(2 rows) + Settings: search_path = 'regress_rls_schema' +(3 rows) DROP VIEW rls_view; -- View and Table owners are different. @@ -2416,11 +2476,12 @@ NOTICE: f_leak => dad (2 rows) EXPLAIN (COSTS OFF) SELECT * FROM rls_view; - QUERY PLAN ------------------------------------------ + QUERY PLAN +---------------------------------------------- Seq Scan on z1 Filter: (((a % 2) = 0) AND f_leak(b)) -(2 rows) + Settings: search_path = 'regress_rls_schema' +(3 rows) -- Query as role that is not owner of table but is owner of view. -- Should return records based on view owner policies. @@ -2435,11 +2496,12 @@ NOTICE: f_leak => dad (2 rows) EXPLAIN (COSTS OFF) SELECT * FROM rls_view; - QUERY PLAN ------------------------------------------ + QUERY PLAN +---------------------------------------------- Seq Scan on z1 Filter: (((a % 2) = 0) AND f_leak(b)) -(2 rows) + Settings: search_path = 'regress_rls_schema' +(3 rows) -- Query as role that is not the owner of the table or view without permissions. SET SESSION AUTHORIZATION regress_rls_carol; @@ -2460,11 +2522,12 @@ NOTICE: f_leak => dad (2 rows) EXPLAIN (COSTS OFF) SELECT * FROM rls_view; - QUERY PLAN ------------------------------------------ + QUERY PLAN +---------------------------------------------- Seq Scan on z1 Filter: (((a % 2) = 0) AND f_leak(b)) -(2 rows) + Settings: search_path = 'regress_rls_schema' +(3 rows) SET SESSION AUTHORIZATION regress_rls_bob; DROP VIEW rls_view; @@ -2598,11 +2661,12 @@ SET SESSION AUTHORIZATION regress_rls_alice; CREATE VIEW rls_sbv WITH (security_barrier) AS SELECT * FROM y1 WHERE f_leak(b); EXPLAIN (COSTS OFF) SELECT * FROM rls_sbv WHERE (a = 1); - QUERY PLAN ------------------------------------ + QUERY PLAN +---------------------------------------------- Seq Scan on y1 Filter: (f_leak(b) AND (a = 1)) -(2 rows) + Settings: search_path = 'regress_rls_schema' +(3 rows) DROP VIEW rls_sbv; -- Create view as role that does not own table. RLS should be applied. @@ -2614,7 +2678,8 @@ EXPLAIN (COSTS OFF) SELECT * FROM rls_sbv WHERE (a = 1); ------------------------------------------------------------------ Seq Scan on y1 Filter: ((a = 1) AND ((a > 2) OR ((a % 2) = 0)) AND f_leak(b)) -(2 rows) + Settings: search_path = 'regress_rls_schema' +(3 rows) DROP VIEW rls_sbv; -- @@ -2663,7 +2728,8 @@ EXPLAIN (COSTS OFF) SELECT * FROM y2 WHERE f_leak(b); ----------------------------------------------------------------------------- Seq Scan on y2 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -(2 rows) + Settings: search_path = 'regress_rls_schema' +(3 rows) -- -- Qual push-down of leaky functions, when not referring to table @@ -2713,7 +2779,8 @@ EXPLAIN (COSTS OFF) SELECT * FROM y2 WHERE f_leak('abc'); --------------------------------------------------------------------------------------- Seq Scan on y2 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -(2 rows) + Settings: search_path = 'regress_rls_schema' +(3 rows) CREATE TABLE test_qual_pushdown ( abc text @@ -2736,7 +2803,8 @@ EXPLAIN (COSTS OFF) SELECT * FROM y2 JOIN test_qual_pushdown ON (b = abc) WHERE -> Hash -> Seq Scan on y2 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -(7 rows) + Settings: search_path = 'regress_rls_schema' +(8 rows) SELECT * FROM y2 JOIN test_qual_pushdown ON (b = abc) WHERE f_leak(b); NOTICE: f_leak => cfcd208495d565ef66e7dff9f98764da @@ -2766,7 +2834,8 @@ EXPLAIN (COSTS OFF) SELECT * FROM y2 JOIN test_qual_pushdown ON (b = abc) WHERE -> Hash -> Seq Scan on y2 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -(6 rows) + Settings: search_path = 'regress_rls_schema' +(7 rows) DROP TABLE test_qual_pushdown; -- @@ -2787,31 +2856,34 @@ SET ROLE regress_rls_bob; PREPARE role_inval AS SELECT * FROM t1; -- Check plan EXPLAIN (COSTS OFF) EXECUTE role_inval; - QUERY PLAN -------------------------- + QUERY PLAN +---------------------------------------------- Seq Scan on t1 Filter: ((a % 2) = 0) -(2 rows) + Settings: search_path = 'regress_rls_schema' +(3 rows) -- Change to regress_rls_carol SET ROLE regress_rls_carol; -- Check plan- should be different EXPLAIN (COSTS OFF) EXECUTE role_inval; - QUERY PLAN -------------------------- + QUERY PLAN +---------------------------------------------- Seq Scan on t1 Filter: ((a % 4) = 0) -(2 rows) + Settings: search_path = 'regress_rls_schema' +(3 rows) -- Change back to regress_rls_bob SET ROLE regress_rls_bob; -- Check plan- should be back to original EXPLAIN (COSTS OFF) EXECUTE role_inval; - QUERY PLAN -------------------------- + QUERY PLAN +---------------------------------------------- Seq Scan on t1 Filter: ((a % 2) = 0) -(2 rows) + Settings: search_path = 'regress_rls_schema' +(3 rows) -- -- CTE and RLS @@ -2859,7 +2931,8 @@ WITH cte1 AS MATERIALIZED (SELECT * FROM t1 WHERE f_leak(b)) SELECT * FROM cte1; CTE cte1 -> Seq Scan on t1 Filter: (((a % 2) = 0) AND f_leak(b)) -(4 rows) + Settings: search_path = 'regress_rls_schema' +(5 rows) WITH cte1 AS (UPDATE t1 SET a = a + 1 RETURNING *) SELECT * FROM cte1; --fail ERROR: new row violates row-level security policy for table "t1" @@ -2919,12 +2992,13 @@ SET SESSION AUTHORIZATION regress_rls_bob; CREATE TABLE t2 (a integer, b text); INSERT INTO t2 (SELECT * FROM t1); EXPLAIN (COSTS OFF) INSERT INTO t2 (SELECT * FROM t1); - QUERY PLAN -------------------------------- + QUERY PLAN +---------------------------------------------- Insert on t2 -> Seq Scan on t1 Filter: ((a % 2) = 0) -(3 rows) + Settings: search_path = 'regress_rls_schema' +(4 rows) SELECT * FROM t2; a | b @@ -2944,10 +3018,11 @@ SELECT * FROM t2; (12 rows) EXPLAIN (COSTS OFF) SELECT * FROM t2; - QUERY PLAN ----------------- + QUERY PLAN +---------------------------------------------- Seq Scan on t2 -(1 row) + Settings: search_path = 'regress_rls_schema' +(2 rows) CREATE TABLE t3 AS SELECT * FROM t1; SELECT * FROM t3; @@ -3079,10 +3154,11 @@ SELECT * FROM t1; (22 rows) EXPLAIN (COSTS OFF) SELECT * FROM t1; - QUERY PLAN ----------------- + QUERY PLAN +---------------------------------------------- Seq Scan on t1 -(1 row) + Settings: search_path = 'regress_rls_schema' +(2 rows) -- Check that default deny does not apply to table owner. SET SESSION AUTHORIZATION regress_rls_alice; @@ -3114,10 +3190,11 @@ SELECT * FROM t1; (22 rows) EXPLAIN (COSTS OFF) SELECT * FROM t1; - QUERY PLAN ----------------- + QUERY PLAN +---------------------------------------------- Seq Scan on t1 -(1 row) + Settings: search_path = 'regress_rls_schema' +(2 rows) -- Check that default deny applies to non-owner/non-superuser when RLS on. SET SESSION AUTHORIZATION regress_rls_bob; @@ -3128,11 +3205,12 @@ SELECT * FROM t1; (0 rows) EXPLAIN (COSTS OFF) SELECT * FROM t1; - QUERY PLAN --------------------------- + QUERY PLAN +---------------------------------------------- Result One-Time Filter: false -(2 rows) + Settings: search_path = 'regress_rls_schema' +(3 rows) SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM t1; @@ -3141,11 +3219,12 @@ SELECT * FROM t1; (0 rows) EXPLAIN (COSTS OFF) SELECT * FROM t1; - QUERY PLAN --------------------------- + QUERY PLAN +---------------------------------------------- Result One-Time Filter: false -(2 rows) + Settings: search_path = 'regress_rls_schema' +(3 rows) -- -- COPY TO/FROM @@ -3376,7 +3455,8 @@ EXPLAIN (COSTS OFF) UPDATE current_check SET payload = payload WHERE CURRENT OF -> Tid Scan on current_check TID Cond: CURRENT OF current_check_cursor Filter: ((currentid = 4) AND ((currentid % 2) = 0)) -(4 rows) + Settings: search_path = 'regress_rls_schema' +(5 rows) -- Similarly can only delete row 4 FETCH ABSOLUTE 1 FROM current_check_cursor; diff --git a/src/test/regress/expected/rowtypes.out b/src/test/regress/expected/rowtypes.out index ffccaa5c9d..3c39450839 100644 --- a/src/test/regress/expected/rowtypes.out +++ b/src/test/regress/expected/rowtypes.out @@ -406,7 +406,8 @@ select a,b from test_table where (a,b) > ('a','a') order by a,b; -------------------------------------------------------- Index Only Scan using test_table_a_b_idx on test_table Index Cond: (ROW(a, b) > ROW('a'::text, 'a'::text)) -(2 rows) + Settings: enable_sort = 'off' +(3 rows) select a,b from test_table where (a,b) > ('a','a') order by a,b; a | b diff --git a/src/test/regress/expected/select.out b/src/test/regress/expected/select.out index c441049f41..da4c1b8202 100644 --- a/src/test/regress/expected/select.out +++ b/src/test/regress/expected/select.out @@ -744,7 +744,8 @@ select * from onek2 where unique2 = 11 and stringu1 = 'ATAAAA'; Index Scan using onek2_u2_prtl on onek2 Index Cond: (unique2 = 11) Filter: (stringu1 = 'ATAAAA'::name) -(3 rows) + Settings: enable_sort = 'off' +(4 rows) select * from onek2 where unique2 = 11 and stringu1 = 'ATAAAA'; unique1 | unique2 | two | four | ten | twenty | hundred | thousand | twothousand | fivethous | tenthous | odd | even | stringu1 | stringu2 | string4 @@ -753,14 +754,16 @@ select * from onek2 where unique2 = 11 and stringu1 = 'ATAAAA'; (1 row) -- actually run the query with an analyze to use the partial index -explain (costs off, analyze on, timing off, summary off) +explain (costs off, exec on, timing off, summary 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) Index Cond: (unique2 = 11) Filter: (stringu1 = 'ATAAAA'::name) -(3 rows) + Buffers: shared hit=2 + Settings: enable_sort = 'off' +(5 rows) explain (costs off) select unique2 from onek2 where unique2 = 11 and stringu1 = 'ATAAAA'; @@ -769,7 +772,8 @@ select unique2 from onek2 where unique2 = 11 and stringu1 = 'ATAAAA'; Index Scan using onek2_u2_prtl on onek2 Index Cond: (unique2 = 11) Filter: (stringu1 = 'ATAAAA'::name) -(3 rows) + Settings: enable_sort = 'off' +(4 rows) select unique2 from onek2 where unique2 = 11 and stringu1 = 'ATAAAA'; unique2 @@ -784,7 +788,8 @@ select * from onek2 where unique2 = 11 and stringu1 < 'B'; ----------------------------------------- Index Scan using onek2_u2_prtl on onek2 Index Cond: (unique2 = 11) -(2 rows) + Settings: enable_sort = 'off' +(3 rows) select * from onek2 where unique2 = 11 and stringu1 < 'B'; unique1 | unique2 | two | four | ten | twenty | hundred | thousand | twothousand | fivethous | tenthous | odd | even | stringu1 | stringu2 | string4 @@ -798,7 +803,8 @@ select unique2 from onek2 where unique2 = 11 and stringu1 < 'B'; ---------------------------------------------- Index Only Scan using onek2_u2_prtl on onek2 Index Cond: (unique2 = 11) -(2 rows) + Settings: enable_sort = 'off' +(3 rows) select unique2 from onek2 where unique2 = 11 and stringu1 < 'B'; unique2 @@ -815,7 +821,8 @@ select unique2 from onek2 where unique2 = 11 and stringu1 < 'B' for update; -> Index Scan using onek2_u2_prtl on onek2 Index Cond: (unique2 = 11) Filter: (stringu1 < 'B'::name) -(4 rows) + Settings: enable_sort = 'off' +(5 rows) select unique2 from onek2 where unique2 = 11 and stringu1 < 'B' for update; unique2 @@ -830,7 +837,8 @@ select unique2 from onek2 where unique2 = 11 and stringu1 < 'C'; ------------------------------------------------------- Seq Scan on onek2 Filter: ((stringu1 < 'C'::name) AND (unique2 = 11)) -(2 rows) + Settings: enable_sort = 'off' +(3 rows) select unique2 from onek2 where unique2 = 11 and stringu1 < 'C'; unique2 @@ -848,7 +856,8 @@ select unique2 from onek2 where unique2 = 11 and stringu1 < 'B'; Recheck Cond: ((unique2 = 11) AND (stringu1 < 'B'::name)) -> Bitmap Index Scan on onek2_u2_prtl Index Cond: (unique2 = 11) -(4 rows) + Settings: enable_indexscan = 'off', enable_sort = 'off' +(5 rows) select unique2 from onek2 where unique2 = 11 and stringu1 < 'B'; unique2 @@ -871,30 +880,32 @@ select unique1, unique2 from onek2 Index Cond: (unique2 = 11) -> Bitmap Index Scan on onek2_u1_prtl Index Cond: (unique1 = 0) + Settings: enable_sort = 'off' +(9 rows) + +select unique1, unique2 from onek2 + where (unique2 = 11 or unique1 = 0) and stringu1 < 'B'; + unique1 | unique2 +---------+--------- + 494 | 11 + 0 | 998 +(2 rows) + +explain (costs off) +select unique1, unique2 from onek2 + where (unique2 = 11 and stringu1 < 'B') or unique1 = 0; + QUERY PLAN +-------------------------------------------------------------------------------- + Bitmap Heap Scan on onek2 + Recheck Cond: (((unique2 = 11) AND (stringu1 < 'B'::name)) OR (unique1 = 0)) + -> BitmapOr + -> Bitmap Index Scan on onek2_u2_prtl + Index Cond: (unique2 = 11) + -> Bitmap Index Scan on onek2_u1_prtl + Index Cond: (unique1 = 0) + Settings: enable_sort = 'off' (8 rows) -select unique1, unique2 from onek2 - where (unique2 = 11 or unique1 = 0) and stringu1 < 'B'; - unique1 | unique2 ----------+--------- - 494 | 11 - 0 | 998 -(2 rows) - -explain (costs off) -select unique1, unique2 from onek2 - where (unique2 = 11 and stringu1 < 'B') or unique1 = 0; - QUERY PLAN --------------------------------------------------------------------------------- - Bitmap Heap Scan on onek2 - Recheck Cond: (((unique2 = 11) AND (stringu1 < 'B'::name)) OR (unique1 = 0)) - -> BitmapOr - -> Bitmap Index Scan on onek2_u2_prtl - Index Cond: (unique2 = 11) - -> Bitmap Index Scan on onek2_u1_prtl - Index Cond: (unique1 = 0) -(7 rows) - select unique1, unique2 from onek2 where (unique2 = 11 and stringu1 < 'B') or unique1 = 0; unique1 | unique2 @@ -957,10 +968,11 @@ create table list_parted_tbl (a int,b int) partition by list (a); create table list_parted_tbl1 partition of list_parted_tbl for values in (1) partition by list(b); explain (costs off) select * from list_parted_tbl; - QUERY PLAN --------------------------- + QUERY PLAN +------------------------------- Result One-Time Filter: false -(2 rows) + Settings: enable_sort = 'off' +(3 rows) drop table list_parted_tbl; diff --git a/src/test/regress/expected/select_into.out b/src/test/regress/expected/select_into.out index f373fae679..3ddb485965 100644 --- a/src/test/regress/expected/select_into.out +++ b/src/test/regress/expected/select_into.out @@ -112,15 +112,21 @@ SELECT * FROM created_table; 4567890123456789 | -4567890123456789 (5 rows) --- Try EXPLAIN ANALYZE SELECT INTO and EXPLAIN ANALYZE CREATE TABLE AS +-- Try EXPLAIN EXEC SELECT INTO and EXPLAIN EXEC CREATE TABLE AS -- WITH NO DATA, but hide the outputs since they won't be stable. DO $$ BEGIN - EXECUTE 'EXPLAIN ANALYZE SELECT * INTO TABLE easi FROM int8_tbl'; - EXECUTE 'EXPLAIN ANALYZE CREATE TABLE easi2 AS SELECT * FROM int8_tbl WITH NO DATA'; + EXECUTE 'EXPLAIN EXEC SELECT * INTO TABLE easi FROM int8_tbl'; + EXECUTE 'EXPLAIN EXEC CREATE TABLE easi2 AS SELECT * FROM int8_tbl WITH NO DATA'; END$$; +ERROR: syntax error at or near "EXEC" +LINE 1: EXPLAIN EXEC SELECT * INTO TABLE easi FROM int8_tbl + ^ +QUERY: EXPLAIN EXEC SELECT * INTO TABLE easi FROM int8_tbl +CONTEXT: PL/pgSQL function inline_code_block line 3 at EXECUTE DROP TABLE created_table; DROP TABLE easi, easi2; +ERROR: table "easi" does not exist -- -- Disallowed uses of SELECT ... INTO. All should fail -- diff --git a/src/test/regress/expected/select_parallel.out b/src/test/regress/expected/select_parallel.out index 0eca76cb41..5787360a23 100644 --- a/src/test/regress/expected/select_parallel.out +++ b/src/test/regress/expected/select_parallel.out @@ -14,8 +14,8 @@ set max_parallel_workers_per_gather=4; -- Parallel Append with partial-subplans explain (costs off) select round(avg(aa)), sum(aa) from a_star; - QUERY PLAN ------------------------------------------------------ + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------- Finalize Aggregate -> Gather Workers Planned: 3 @@ -27,7 +27,8 @@ explain (costs off) -> Parallel Seq Scan on b_star -> Parallel Seq Scan on c_star -> Parallel Seq Scan on a_star -(11 rows) + Settings: max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(12 rows) select round(avg(aa)), sum(aa) from a_star a1; round | sum @@ -40,8 +41,8 @@ alter table c_star set (parallel_workers = 0); alter table d_star set (parallel_workers = 0); explain (costs off) select round(avg(aa)), sum(aa) from a_star; - QUERY PLAN ------------------------------------------------------ + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------- Finalize Aggregate -> Gather Workers Planned: 3 @@ -53,7 +54,8 @@ explain (costs off) -> Parallel Seq Scan on e_star -> Parallel Seq Scan on b_star -> Parallel Seq Scan on a_star -(11 rows) + Settings: max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(12 rows) select round(avg(aa)), sum(aa) from a_star a2; round | sum @@ -68,8 +70,8 @@ alter table e_star set (parallel_workers = 0); alter table f_star set (parallel_workers = 0); explain (costs off) select round(avg(aa)), sum(aa) from a_star; - QUERY PLAN --------------------------------------------- + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------- Finalize Aggregate -> Gather Workers Planned: 3 @@ -81,7 +83,8 @@ explain (costs off) -> Seq Scan on b_star -> Seq Scan on c_star -> Seq Scan on a_star -(11 rows) + Settings: max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(12 rows) select round(avg(aa)), sum(aa) from a_star a3; round | sum @@ -99,8 +102,8 @@ alter table f_star reset (parallel_workers); set enable_parallel_append to off; explain (costs off) select round(avg(aa)), sum(aa) from a_star; - QUERY PLAN ------------------------------------------------------ + QUERY PLAN +--------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Finalize Aggregate -> Gather Workers Planned: 1 @@ -112,7 +115,8 @@ explain (costs off) -> Parallel Seq Scan on d_star -> Parallel Seq Scan on e_star -> Parallel Seq Scan on f_star -(11 rows) + Settings: enable_parallel_append = 'off', max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(12 rows) select round(avg(aa)), sum(aa) from a_star a4; round | sum @@ -139,8 +143,8 @@ create table part_pa_test_p2 partition of part_pa_test for values from (0) to (m explain (costs off) select (select max((select pa1.b from part_pa_test pa1 where pa1.a = pa2.a))) from part_pa_test pa2; - QUERY PLAN --------------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------- Aggregate -> Gather Workers Planned: 3 @@ -155,22 +159,24 @@ explain (costs off) Filter: (a = pa2.a) -> Seq Scan on part_pa_test_p2 pa1_1 Filter: (a = pa2.a) -(14 rows) + Settings: max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(15 rows) drop table part_pa_test; -- test with leader participation disabled set parallel_leader_participation = off; explain (costs off) select count(*) from tenk1 where stringu1 = 'GRAAAA'; - QUERY PLAN ---------------------------------------------------------- + QUERY PLAN +---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Finalize Aggregate -> Gather Workers Planned: 4 -> Partial Aggregate -> Parallel Seq Scan on tenk1 Filter: (stringu1 = 'GRAAAA'::name) -(6 rows) + Settings: max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_leader_participation = 'off', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(7 rows) select count(*) from tenk1 where stringu1 = 'GRAAAA'; count @@ -183,15 +189,16 @@ select count(*) from tenk1 where stringu1 = 'GRAAAA'; set max_parallel_workers = 0; explain (costs off) select count(*) from tenk1 where stringu1 = 'GRAAAA'; - QUERY PLAN ---------------------------------------------------------- + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Finalize Aggregate -> Gather Workers Planned: 4 -> Partial Aggregate -> Parallel Seq Scan on tenk1 Filter: (stringu1 = 'GRAAAA'::name) -(6 rows) + Settings: max_parallel_workers = '0', max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_leader_participation = 'off', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(7 rows) select count(*) from tenk1 where stringu1 = 'GRAAAA'; count @@ -206,8 +213,8 @@ alter table tenk1 set (parallel_workers = 4); explain (verbose, costs off) select sp_parallel_restricted(unique1) from tenk1 where stringu1 = 'GRAAAA' order by 1; - QUERY PLAN ---------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------- Sort Output: (sp_parallel_restricted(unique1)) Sort Key: (sp_parallel_restricted(tenk1.unique1)) @@ -217,13 +224,14 @@ select sp_parallel_restricted(unique1) from tenk1 -> Parallel Seq Scan on public.tenk1 Output: unique1 Filter: (tenk1.stringu1 = 'GRAAAA'::name) -(9 rows) + Settings: max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(10 rows) -- test parallel plan when group by expression is in target list. explain (costs off) select length(stringu1) from tenk1 group by length(stringu1); - QUERY PLAN ---------------------------------------------------- + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------- Finalize HashAggregate Group Key: (length((stringu1)::text)) -> Gather @@ -231,7 +239,8 @@ explain (costs off) -> Partial HashAggregate Group Key: length((stringu1)::text) -> Parallel Seq Scan on tenk1 -(7 rows) + Settings: max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(8 rows) select length(stringu1) from tenk1 group by length(stringu1); length @@ -241,8 +250,8 @@ select length(stringu1) from tenk1 group by length(stringu1); explain (costs off) select stringu1, count(*) from tenk1 group by stringu1 order by stringu1; - QUERY PLAN ----------------------------------------------------- + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------- Sort Sort Key: stringu1 -> Finalize HashAggregate @@ -252,34 +261,37 @@ explain (costs off) -> Partial HashAggregate Group Key: stringu1 -> Parallel Seq Scan on tenk1 -(9 rows) + Settings: max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(10 rows) -- test that parallel plan for aggregates is not selected when -- target list contains parallel restricted clause. explain (costs off) select sum(sp_parallel_restricted(unique1)) from tenk1 group by(sp_parallel_restricted(unique1)); - QUERY PLAN -------------------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------- HashAggregate Group Key: sp_parallel_restricted(unique1) -> Gather Workers Planned: 4 -> Parallel Index Only Scan using tenk1_unique1 on tenk1 -(5 rows) + Settings: max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(6 rows) -- test prepared statement prepare tenk1_count(integer) As select count((unique1)) from tenk1 where hundred > $1; explain (costs off) execute tenk1_count(1); - QUERY PLAN ----------------------------------------------- + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------- Finalize Aggregate -> Gather Workers Planned: 4 -> Partial Aggregate -> Parallel Seq Scan on tenk1 Filter: (hundred > 1) -(6 rows) + Settings: max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(7 rows) execute tenk1_count(1); count @@ -293,8 +305,8 @@ alter table tenk2 set (parallel_workers = 0); explain (costs off) select count(*) from tenk1 where (two, four) not in (select hundred, thousand from tenk2 where thousand > 100); - QUERY PLAN ------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------- Finalize Aggregate -> Gather Workers Planned: 4 @@ -304,7 +316,8 @@ explain (costs off) SubPlan 1 -> Seq Scan on tenk2 Filter: (thousand > 100) -(9 rows) + Settings: max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(10 rows) select count(*) from tenk1 where (two, four) not in (select hundred, thousand from tenk2 where thousand > 100); @@ -317,13 +330,14 @@ select count(*) from tenk1 where (two, four) not in explain (costs off) select * from tenk1 where (unique1 + random())::integer not in (select ten from tenk2); - QUERY PLAN ------------------------------------- + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------- Seq Scan on tenk1 Filter: (NOT (hashed SubPlan 1)) SubPlan 1 -> Seq Scan on tenk2 -(4 rows) + Settings: max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(5 rows) alter table tenk2 reset (parallel_workers); -- test parallel plan for a query containing initplan. @@ -334,8 +348,8 @@ alter table tenk2 set (parallel_workers = 2); explain (costs off) select count(*) from tenk1 where tenk1.unique1 = (Select max(tenk2.unique1) from tenk2); - QUERY PLAN ------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ Aggregate InitPlan 1 (returns $2) -> Finalize Aggregate @@ -348,7 +362,8 @@ explain (costs off) Params Evaluated: $2 -> Parallel Seq Scan on tenk1 Filter: (unique1 = $2) -(12 rows) + Settings: enable_bitmapscan = 'off', enable_indexonlyscan = 'off', enable_indexscan = 'off', max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(13 rows) select count(*) from tenk1 where tenk1.unique1 = (Select max(tenk2.unique1) from tenk2); @@ -366,15 +381,16 @@ set enable_seqscan to off; set enable_bitmapscan to off; explain (costs off) select count((unique1)) from tenk1 where hundred > 1; - QUERY PLAN --------------------------------------------------------------------- + QUERY PLAN +---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Finalize Aggregate -> Gather Workers Planned: 4 -> Partial Aggregate -> Parallel Index Scan using tenk1_hundred on tenk1 Index Cond: (hundred > 1) -(6 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off', max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(7 rows) select count((unique1)) from tenk1 where hundred > 1; count @@ -385,15 +401,16 @@ select count((unique1)) from tenk1 where hundred > 1; -- test parallel index-only scans. explain (costs off) select count(*) from tenk1 where thousand > 95; - QUERY PLAN --------------------------------------------------------------------------------- + QUERY PLAN +---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Finalize Aggregate -> Gather Workers Planned: 4 -> Partial Aggregate -> Parallel Index Only Scan using tenk1_thous_tenthous on tenk1 Index Cond: (thousand > 95) -(6 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off', max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(7 rows) select count(*) from tenk1 where thousand > 95; count @@ -407,8 +424,8 @@ explain (costs off) select * from (select count(unique1) from tenk1 where hundred > 10) ss right join (values (1),(2),(3)) v(x) on true; - QUERY PLAN --------------------------------------------------------------------------- + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Nested Loop Left Join -> Values Scan on "*VALUES*" -> Finalize Aggregate @@ -417,7 +434,8 @@ select * from -> Partial Aggregate -> Parallel Index Scan using tenk1_hundred on tenk1 Index Cond: (hundred > 10) -(8 rows) + Settings: enable_bitmapscan = 'off', enable_material = 'off', enable_seqscan = 'off', max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(9 rows) select * from (select count(unique1) from tenk1 where hundred > 10) ss @@ -433,8 +451,8 @@ explain (costs off) select * from (select count(*) from tenk1 where thousand > 99) ss right join (values (1),(2),(3)) v(x) on true; - QUERY PLAN --------------------------------------------------------------------------------------- + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Nested Loop Left Join -> Values Scan on "*VALUES*" -> Finalize Aggregate @@ -443,7 +461,8 @@ select * from -> Partial Aggregate -> Parallel Index Only Scan using tenk1_thous_tenthous on tenk1 Index Cond: (thousand > 99) -(8 rows) + Settings: enable_bitmapscan = 'off', enable_material = 'off', enable_seqscan = 'off', max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(9 rows) select * from (select count(*) from tenk1 where thousand > 99) ss @@ -473,8 +492,8 @@ END $$; set work_mem='64kB'; --set small work mem to force lossy pages explain (costs off) select count(*) from tenk1, tenk2 where tenk1.hundred > 1 and tenk2.thousand=0; - QUERY PLAN ------------------------------------------------------------- + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Aggregate -> Nested Loop -> Seq Scan on tenk2 @@ -485,7 +504,8 @@ explain (costs off) Recheck Cond: (hundred > 1) -> Bitmap Index Scan on tenk1_hundred Index Cond: (hundred > 1) -(10 rows) + Settings: effective_io_concurrency = '50', enable_hashjoin = 'off', enable_indexscan = 'off', enable_material = 'off', enable_mergejoin = 'off', enable_seqscan = 'off', max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0', work_mem = '64kB' +(11 rows) select count(*) from tenk1, tenk2 where tenk1.hundred > 1 and tenk2.thousand=0; count @@ -505,23 +525,29 @@ select count(*) from bmscantest where a>1; -- test accumulation of stats for parallel nodes reset enable_seqscan; alter table tenk2 set (parallel_workers = 0); -explain (analyze, timing off, summary off, costs off) +explain (exec, timing off, summary off, costs off) select count(*) from tenk1, tenk2 where tenk1.hundred > 1 and tenk2.thousand=0; - QUERY PLAN --------------------------------------------------------------------------- + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Aggregate (actual rows=1 loops=1) + Buffers: shared hit=3795 -> Nested Loop (actual rows=98000 loops=1) + Buffers: shared hit=3795 -> Seq Scan on tenk2 (actual rows=10 loops=1) Filter: (thousand = 0) Rows Removed by Filter: 9990 + Buffers: shared hit=345 -> Gather (actual rows=9800 loops=10) Workers Planned: 4 Workers Launched: 4 + Buffers: shared hit=3450 -> Parallel Seq Scan on tenk1 (actual rows=1960 loops=50) Filter: (hundred > 1) Rows Removed by Filter: 40 -(11 rows) + Buffers: shared hit=3450 + Settings: effective_io_concurrency = '50', enable_hashjoin = 'off', enable_indexscan = 'off', enable_material = 'off', enable_mergejoin = 'off', max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0', work_mem = '64kB' +(17 rows) alter table tenk2 reset (parallel_workers); reset work_mem; @@ -531,7 +557,7 @@ $$ declare ln text; begin for ln in - explain (analyze, timing off, summary off, costs off) + explain (exec, timing off, summary off, costs off) select * from (select ten from tenk1 where ten < 100 order by ten) ss right join (values (1),(2),(3)) v(x) on true @@ -542,13 +568,15 @@ begin end; $$; select * from explain_parallel_sort_stats(); - explain_parallel_sort_stats --------------------------------------------------------------------------- + explain_parallel_sort_stats +---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Nested Loop Left Join (actual rows=30000 loops=1) + Buffers: shared hit=1427 -> Values Scan on "*VALUES*" (actual rows=3 loops=1) -> Gather Merge (actual rows=10000 loops=3) Workers Planned: 4 Workers Launched: 4 + Buffers: shared hit=1231 -> Sort (actual rows=2000 loops=15) Sort Key: tenk1.ten Sort Method: quicksort Memory: xxx @@ -556,9 +584,12 @@ select * from explain_parallel_sort_stats(); Worker 1: Sort Method: quicksort Memory: xxx Worker 2: Sort Method: quicksort Memory: xxx Worker 3: Sort Method: quicksort Memory: xxx + Buffers: shared hit=1623 -> Parallel Seq Scan on tenk1 (actual rows=2000 loops=15) Filter: (ten < 100) -(14 rows) + Buffers: shared hit=1035 + Settings: effective_io_concurrency = '50', enable_hashjoin = 'off', enable_indexscan = 'off', enable_material = 'off', enable_mergejoin = 'off', max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(19 rows) reset enable_indexscan; reset enable_hashjoin; @@ -572,8 +603,8 @@ set enable_hashjoin to off; set enable_nestloop to off; explain (costs off) select count(*) from tenk1, tenk2 where tenk1.unique1 = tenk2.unique1; - QUERY PLAN -------------------------------------------------------------------------------- + QUERY PLAN +--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Finalize Aggregate -> Gather Workers Planned: 4 @@ -582,7 +613,8 @@ explain (costs off) Merge Cond: (tenk1.unique1 = tenk2.unique1) -> Parallel Index Only Scan using tenk1_unique1 on tenk1 -> Index Only Scan using tenk2_unique1 on tenk2 -(8 rows) + Settings: enable_hashjoin = 'off', enable_nestloop = 'off', max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(9 rows) select count(*) from tenk1, tenk2 where tenk1.unique1 = tenk2.unique1; count @@ -596,8 +628,8 @@ reset enable_nestloop; set enable_hashagg = false; explain (costs off) select count(*) from tenk1 group by twenty; - QUERY PLAN ----------------------------------------------------- + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------------------------------- Finalize GroupAggregate Group Key: twenty -> Gather Merge @@ -607,7 +639,8 @@ explain (costs off) -> Sort Sort Key: twenty -> Parallel Seq Scan on tenk1 -(9 rows) + Settings: enable_hashagg = 'off', max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(10 rows) select count(*) from tenk1 group by twenty; count @@ -643,8 +676,8 @@ end; $$ language plpgsql PARALLEL SAFE; explain (costs off, verbose) select ten, sp_simple_func(ten) from tenk1 where ten < 100 order by ten; - QUERY PLAN ------------------------------------------------------ + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------------------------------- Gather Merge Output: ten, (sp_simple_func(ten)) Workers Planned: 4 @@ -656,14 +689,15 @@ explain (costs off, verbose) -> Parallel Seq Scan on public.tenk1 Output: ten Filter: (tenk1.ten < 100) -(11 rows) + Settings: enable_hashagg = 'off', max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(12 rows) drop function sp_simple_func(integer); -- test handling of SRFs in targetlist (bug in 10.0) explain (costs off) select count(*), generate_series(1,2) from tenk1 group by twenty; - QUERY PLAN ----------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------------------------------- ProjectSet -> Finalize GroupAggregate Group Key: twenty @@ -674,7 +708,8 @@ explain (costs off) -> Sort Sort Key: twenty -> Parallel Seq Scan on tenk1 -(10 rows) + Settings: enable_hashagg = 'off', max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(11 rows) select count(*), generate_series(1,2) from tenk1 group by twenty; count | generate_series @@ -725,8 +760,8 @@ select count(*), generate_series(1,2) from tenk1 group by twenty; set parallel_leader_participation = off; explain (costs off) select count(*) from tenk1 group by twenty; - QUERY PLAN ----------------------------------------------------- + QUERY PLAN +---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Finalize GroupAggregate Group Key: twenty -> Gather Merge @@ -736,7 +771,8 @@ explain (costs off) -> Sort Sort Key: twenty -> Parallel Seq Scan on tenk1 -(9 rows) + Settings: enable_hashagg = 'off', max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_leader_participation = 'off', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(10 rows) select count(*) from tenk1 group by twenty; count @@ -771,8 +807,8 @@ select * from (select string4, count(unique2) from tenk1 group by string4 order by string4) ss right join (values (1),(2),(3)) v(x) on true; - QUERY PLAN ----------------------------------------------------------- + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Nested Loop Left Join -> Values Scan on "*VALUES*" -> Finalize GroupAggregate @@ -784,7 +820,8 @@ select * from -> Sort Sort Key: tenk1.string4 -> Parallel Seq Scan on tenk1 -(11 rows) + Settings: enable_hashagg = 'off', enable_material = 'off', max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(12 rows) select * from (select string4, count(unique2) @@ -811,14 +848,15 @@ reset enable_hashagg; -- check parallelized int8 aggregate (bug #14897) explain (costs off) select avg(unique1::int8) from tenk1; - QUERY PLAN -------------------------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------- Finalize Aggregate -> Gather Workers Planned: 4 -> Partial Aggregate -> Parallel Index Only Scan using tenk1_unique1 on tenk1 -(5 rows) + Settings: max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(6 rows) select avg(unique1::int8) from tenk1; avg @@ -829,15 +867,16 @@ select avg(unique1::int8) from tenk1; -- gather merge test with a LIMIT explain (costs off) select fivethous from tenk1 order by fivethous limit 4; - QUERY PLAN ----------------------------------------------- + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------- Limit -> Gather Merge Workers Planned: 4 -> Sort Sort Key: fivethous -> Parallel Seq Scan on tenk1 -(6 rows) + Settings: max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(7 rows) select fivethous from tenk1 order by fivethous limit 4; fivethous @@ -852,15 +891,16 @@ select fivethous from tenk1 order by fivethous limit 4; set max_parallel_workers = 0; explain (costs off) select string4 from tenk1 order by string4 limit 5; - QUERY PLAN ----------------------------------------------- + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------------------------------------------------- Limit -> Gather Merge Workers Planned: 4 -> Sort Sort Key: string4 -> Parallel Seq Scan on tenk1 -(6 rows) + Settings: max_parallel_workers = '0', max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(7 rows) select string4 from tenk1 order by string4 limit 5; string4 @@ -878,15 +918,16 @@ select string4 from tenk1 order by string4 limit 5; set parallel_leader_participation = off; explain (costs off) select string4 from tenk1 order by string4 limit 5; - QUERY PLAN ----------------------------------------------- + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Limit -> Gather Merge Workers Planned: 4 -> Sort Sort Key: string4 -> Parallel Seq Scan on tenk1 -(6 rows) + Settings: max_parallel_workers = '0', max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_leader_participation = 'off', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(7 rows) select string4 from tenk1 order by string4 limit 5; string4 @@ -904,14 +945,15 @@ SAVEPOINT settings; SET LOCAL force_parallel_mode = 1; explain (costs off) select stringu1::int2 from tenk1 where unique1 = 1; - QUERY PLAN ------------------------------------------------ + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------------------------------------------------- Gather Workers Planned: 1 Single Copy: true -> Index Scan using tenk1_unique1 on tenk1 Index Cond: (unique1 = 1) -(5 rows) + Settings: force_parallel_mode = 'on', max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(6 rows) ROLLBACK TO SAVEPOINT settings; -- exercise record typmod remapping between backends @@ -962,8 +1004,8 @@ reset role; explain (costs off, verbose) select count(*) from tenk1 a where (unique1, two) in (select unique1, row_number() over() from tenk1 b); - QUERY PLAN ----------------------------------------------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------- Aggregate Output: count(*) -> Hash Semi Join @@ -982,14 +1024,15 @@ explain (costs off, verbose) Workers Planned: 4 -> Parallel Index Only Scan using tenk1_unique1 on public.tenk1 b Output: b.unique1 -(18 rows) + Settings: max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(19 rows) -- LIMIT/OFFSET within sub-selects can't be pushed to workers. explain (costs off) select * from tenk1 a where two in (select two from tenk1 b where stringu1 like '%AAAA' limit 3); - QUERY PLAN ---------------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------- Hash Semi Join Hash Cond: (a.two = b.two) -> Gather @@ -1001,19 +1044,23 @@ explain (costs off) Workers Planned: 4 -> Parallel Seq Scan on tenk1 b Filter: (stringu1 ~~ '%AAAA'::text) -(11 rows) + Settings: max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(12 rows) -- to increase the parallel query test coverage SAVEPOINT settings; SET LOCAL force_parallel_mode = 1; -EXPLAIN (analyze, timing off, summary off, costs off) SELECT * FROM tenk1; - QUERY PLAN -------------------------------------------------------------- +EXPLAIN (exec, timing off, summary off, costs off) SELECT * FROM tenk1; + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------------------------------------------------- Gather (actual rows=10000 loops=1) Workers Planned: 4 Workers Launched: 4 + Buffers: shared hit=345 -> Parallel Seq Scan on tenk1 (actual rows=2000 loops=5) -(4 rows) + Buffers: shared hit=345 + Settings: force_parallel_mode = 'on', max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(7 rows) ROLLBACK TO SAVEPOINT settings; -- provoke error in worker @@ -1032,8 +1079,8 @@ EXPLAIN (COSTS OFF) SELECT unique1 FROM tenk1 WHERE fivethous = tenthous + 1 UNION ALL SELECT unique1 FROM tenk1 WHERE fivethous = tenthous + 1; - QUERY PLAN ----------------------------------------------------- + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------------------------- Gather Workers Planned: 4 -> Parallel Append @@ -1041,7 +1088,8 @@ SELECT unique1 FROM tenk1 WHERE fivethous = tenthous + 1; Filter: (fivethous = (tenthous + 1)) -> Parallel Seq Scan on tenk1 tenk1_1 Filter: (fivethous = (tenthous + 1)) -(7 rows) + Settings: max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_setup_cost = '10', parallel_tuple_cost = '0' +(8 rows) ROLLBACK TO SAVEPOINT settings; -- can't use multiple subqueries under a single Gather node due to initPlans @@ -1052,8 +1100,8 @@ UNION ALL SELECT unique1 FROM tenk1 WHERE fivethous = (SELECT unique2 FROM tenk1 WHERE fivethous = 1 LIMIT 1) ORDER BY 1; - QUERY PLAN --------------------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------- Sort Sort Key: tenk1.unique1 -> Append @@ -1079,7 +1127,8 @@ ORDER BY 1; Filter: (fivethous = 1) -> Parallel Seq Scan on tenk1 tenk1_1 Filter: (fivethous = $3) -(25 rows) + Settings: max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(26 rows) -- test interaction with SRFs SELECT * FROM information_schema.foreign_data_wrapper_options @@ -1100,13 +1149,14 @@ CREATE TABLE fooarr(f1 text, f2 int[], f3 text); INSERT INTO fooarr VALUES('1', ARRAY[1,2], 'one'); PREPARE pstmt(text, int[]) AS SELECT * FROM fooarr WHERE f1 = $1 AND f2 = $2; EXPLAIN (COSTS OFF) EXECUTE pstmt('1', make_some_array(1,2)); - QUERY PLAN ------------------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------- Gather Workers Planned: 3 -> Parallel Seq Scan on fooarr Filter: ((f1 = '1'::text) AND (f2 = '{1,2}'::integer[])) -(4 rows) + Settings: max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(5 rows) EXECUTE pstmt('1', make_some_array(1,2)); f1 | f2 | f3 @@ -1120,8 +1170,8 @@ CREATE VIEW tenk1_vw_sec WITH (security_barrier) AS SELECT * FROM tenk1; EXPLAIN (COSTS OFF) SELECT 1 FROM tenk1_vw_sec WHERE (SELECT sum(f1) FROM int4_tbl WHERE f1 < unique1) < 100; - QUERY PLAN -------------------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------- Subquery Scan on tenk1_vw_sec Filter: ((SubPlan 1) < 100) -> Gather @@ -1131,6 +1181,7 @@ SELECT 1 FROM tenk1_vw_sec -> Aggregate -> Seq Scan on int4_tbl Filter: (f1 < tenk1_vw_sec.unique1) -(9 rows) + Settings: max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(10 rows) rollback; diff --git a/src/test/regress/expected/stats_ext.out b/src/test/regress/expected/stats_ext.out index 6dfca7a606..836ee928a0 100644 --- a/src/test/regress/expected/stats_ext.out +++ b/src/test/regress/expected/stats_ext.out @@ -12,7 +12,7 @@ declare first_row bool := true; begin for ln in - execute format('explain analyze %s', $1) + execute format('explain exec %s', $1) loop if first_row then first_row := false; @@ -167,35 +167,35 @@ INSERT INTO ndistinct (a, b, c, filler1) ANALYZE ndistinct; -- Group Aggregate, due to over-estimate of the number of groups SELECT * FROM check_estimated_rows('SELECT COUNT(*) FROM ndistinct GROUP BY a, b'); - estimated | actual ------------+-------- - 100 | 11 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT COUNT(*) FROM ndistinct GROUP BY a, b + ^ +QUERY: explain exec SELECT COUNT(*) FROM ndistinct GROUP BY a, b +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement SELECT * FROM check_estimated_rows('SELECT COUNT(*) FROM ndistinct GROUP BY b, c'); - estimated | actual ------------+-------- - 100 | 11 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT COUNT(*) FROM ndistinct GROUP BY b, c + ^ +QUERY: explain exec SELECT COUNT(*) FROM ndistinct GROUP BY b, c +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement SELECT * FROM check_estimated_rows('SELECT COUNT(*) FROM ndistinct GROUP BY a, b, c'); - estimated | actual ------------+-------- - 100 | 11 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT COUNT(*) FROM ndistinct GROUP BY a, b, c + ^ +QUERY: explain exec SELECT COUNT(*) FROM ndistinct GROUP BY a, b, c +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement SELECT * FROM check_estimated_rows('SELECT COUNT(*) FROM ndistinct GROUP BY a, b, c, d'); - estimated | actual ------------+-------- - 200 | 11 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT COUNT(*) FROM ndistinct GROUP BY a, b, c... + ^ +QUERY: explain exec SELECT COUNT(*) FROM ndistinct GROUP BY a, b, c, d +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement SELECT * FROM check_estimated_rows('SELECT COUNT(*) FROM ndistinct GROUP BY b, c, d'); - estimated | actual ------------+-------- - 200 | 11 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT COUNT(*) FROM ndistinct GROUP BY b, c, d + ^ +QUERY: explain exec SELECT COUNT(*) FROM ndistinct GROUP BY b, c, d +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement -- correct command CREATE STATISTICS s10 ON a, b, c FROM ndistinct; ANALYZE ndistinct; @@ -208,37 +208,37 @@ SELECT stxkind, stxndistinct -- Hash Aggregate, thanks to estimates improved by the statistic SELECT * FROM check_estimated_rows('SELECT COUNT(*) FROM ndistinct GROUP BY a, b'); - estimated | actual ------------+-------- - 11 | 11 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT COUNT(*) FROM ndistinct GROUP BY a, b + ^ +QUERY: explain exec SELECT COUNT(*) FROM ndistinct GROUP BY a, b +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement SELECT * FROM check_estimated_rows('SELECT COUNT(*) FROM ndistinct GROUP BY b, c'); - estimated | actual ------------+-------- - 11 | 11 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT COUNT(*) FROM ndistinct GROUP BY b, c + ^ +QUERY: explain exec SELECT COUNT(*) FROM ndistinct GROUP BY b, c +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement SELECT * FROM check_estimated_rows('SELECT COUNT(*) FROM ndistinct GROUP BY a, b, c'); - estimated | actual ------------+-------- - 11 | 11 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT COUNT(*) FROM ndistinct GROUP BY a, b, c + ^ +QUERY: explain exec SELECT COUNT(*) FROM ndistinct GROUP BY a, b, c +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement -- last two plans keep using Group Aggregate, because 'd' is not covered -- by the statistic and while it's NULL-only we assume 200 values for it SELECT * FROM check_estimated_rows('SELECT COUNT(*) FROM ndistinct GROUP BY a, b, c, d'); - estimated | actual ------------+-------- - 200 | 11 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT COUNT(*) FROM ndistinct GROUP BY a, b, c... + ^ +QUERY: explain exec SELECT COUNT(*) FROM ndistinct GROUP BY a, b, c, d +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement SELECT * FROM check_estimated_rows('SELECT COUNT(*) FROM ndistinct GROUP BY b, c, d'); - estimated | actual ------------+-------- - 200 | 11 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT COUNT(*) FROM ndistinct GROUP BY b, c, d + ^ +QUERY: explain exec SELECT COUNT(*) FROM ndistinct GROUP BY b, c, d +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement TRUNCATE TABLE ndistinct; -- under-estimates when using only per-column statistics INSERT INTO ndistinct (a, b, c, filler1) @@ -255,35 +255,35 @@ SELECT stxkind, stxndistinct -- correct esimates SELECT * FROM check_estimated_rows('SELECT COUNT(*) FROM ndistinct GROUP BY a, b'); - estimated | actual ------------+-------- - 2550 | 2550 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT COUNT(*) FROM ndistinct GROUP BY a, b + ^ +QUERY: explain exec SELECT COUNT(*) FROM ndistinct GROUP BY a, b +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement SELECT * FROM check_estimated_rows('SELECT COUNT(*) FROM ndistinct GROUP BY a, b, c'); - estimated | actual ------------+-------- - 5000 | 5000 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT COUNT(*) FROM ndistinct GROUP BY a, b, c + ^ +QUERY: explain exec SELECT COUNT(*) FROM ndistinct GROUP BY a, b, c +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement SELECT * FROM check_estimated_rows('SELECT COUNT(*) FROM ndistinct GROUP BY a, b, c, d'); - estimated | actual ------------+-------- - 5000 | 5000 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT COUNT(*) FROM ndistinct GROUP BY a, b, c... + ^ +QUERY: explain exec SELECT COUNT(*) FROM ndistinct GROUP BY a, b, c, d +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement SELECT * FROM check_estimated_rows('SELECT COUNT(*) FROM ndistinct GROUP BY b, c, d'); - estimated | actual ------------+-------- - 1632 | 1632 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT COUNT(*) FROM ndistinct GROUP BY b, c, d + ^ +QUERY: explain exec SELECT COUNT(*) FROM ndistinct GROUP BY b, c, d +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement SELECT * FROM check_estimated_rows('SELECT COUNT(*) FROM ndistinct GROUP BY a, d'); - estimated | actual ------------+-------- - 500 | 50 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT COUNT(*) FROM ndistinct GROUP BY a, d + ^ +QUERY: explain exec SELECT COUNT(*) FROM ndistinct GROUP BY a, d +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement DROP STATISTICS s10; SELECT stxkind, stxndistinct FROM pg_statistic_ext WHERE stxrelid = 'ndistinct'::regclass; @@ -293,35 +293,35 @@ SELECT stxkind, stxndistinct -- dropping the statistics results in under-estimates SELECT * FROM check_estimated_rows('SELECT COUNT(*) FROM ndistinct GROUP BY a, b'); - estimated | actual ------------+-------- - 500 | 2550 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT COUNT(*) FROM ndistinct GROUP BY a, b + ^ +QUERY: explain exec SELECT COUNT(*) FROM ndistinct GROUP BY a, b +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement SELECT * FROM check_estimated_rows('SELECT COUNT(*) FROM ndistinct GROUP BY a, b, c'); - estimated | actual ------------+-------- - 500 | 5000 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT COUNT(*) FROM ndistinct GROUP BY a, b, c + ^ +QUERY: explain exec SELECT COUNT(*) FROM ndistinct GROUP BY a, b, c +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement SELECT * FROM check_estimated_rows('SELECT COUNT(*) FROM ndistinct GROUP BY a, b, c, d'); - estimated | actual ------------+-------- - 500 | 5000 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT COUNT(*) FROM ndistinct GROUP BY a, b, c... + ^ +QUERY: explain exec SELECT COUNT(*) FROM ndistinct GROUP BY a, b, c, d +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement SELECT * FROM check_estimated_rows('SELECT COUNT(*) FROM ndistinct GROUP BY b, c, d'); - estimated | actual ------------+-------- - 500 | 1632 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT COUNT(*) FROM ndistinct GROUP BY b, c, d + ^ +QUERY: explain exec SELECT COUNT(*) FROM ndistinct GROUP BY b, c, d +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement SELECT * FROM check_estimated_rows('SELECT COUNT(*) FROM ndistinct GROUP BY a, d'); - estimated | actual ------------+-------- - 500 | 50 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT COUNT(*) FROM ndistinct GROUP BY a, d + ^ +QUERY: explain exec SELECT COUNT(*) FROM ndistinct GROUP BY a, d +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement -- functional dependencies tests CREATE TABLE functional_dependencies ( filler1 TEXT, @@ -339,32 +339,32 @@ INSERT INTO functional_dependencies (a, b, c, filler1) SELECT mod(i, 23), mod(i, 29), mod(i, 31), i FROM generate_series(1,5000) s(i); ANALYZE functional_dependencies; SELECT * FROM check_estimated_rows('SELECT * FROM functional_dependencies WHERE a = 1 AND b = ''1'''); - estimated | actual ------------+-------- - 8 | 8 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT * FROM functional_dependencies WHERE a =... + ^ +QUERY: explain exec SELECT * FROM functional_dependencies WHERE a = 1 AND b = '1' +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement SELECT * FROM check_estimated_rows('SELECT * FROM functional_dependencies WHERE a = 1 AND b = ''1'' AND c = 1'); - estimated | actual ------------+-------- - 1 | 1 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT * FROM functional_dependencies WHERE a =... + ^ +QUERY: explain exec SELECT * FROM functional_dependencies WHERE a = 1 AND b = '1' AND c = 1 +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement -- create statistics CREATE STATISTICS func_deps_stat (dependencies) ON a, b, c FROM functional_dependencies; ANALYZE functional_dependencies; SELECT * FROM check_estimated_rows('SELECT * FROM functional_dependencies WHERE a = 1 AND b = ''1'''); - estimated | actual ------------+-------- - 8 | 8 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT * FROM functional_dependencies WHERE a =... + ^ +QUERY: explain exec SELECT * FROM functional_dependencies WHERE a = 1 AND b = '1' +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement SELECT * FROM check_estimated_rows('SELECT * FROM functional_dependencies WHERE a = 1 AND b = ''1'' AND c = 1'); - estimated | actual ------------+-------- - 1 | 1 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT * FROM functional_dependencies WHERE a =... + ^ +QUERY: explain exec SELECT * FROM functional_dependencies WHERE a = 1 AND b = '1' AND c = 1 +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement -- a => b, a => c, b => c TRUNCATE functional_dependencies; DROP STATISTICS func_deps_stat; @@ -372,47 +372,47 @@ INSERT INTO functional_dependencies (a, b, c, filler1) SELECT mod(i,100), mod(i,50), mod(i,25), i FROM generate_series(1,5000) s(i); ANALYZE functional_dependencies; SELECT * FROM check_estimated_rows('SELECT * FROM functional_dependencies WHERE a = 1 AND b = ''1'''); - estimated | actual ------------+-------- - 1 | 50 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT * FROM functional_dependencies WHERE a =... + ^ +QUERY: explain exec SELECT * FROM functional_dependencies WHERE a = 1 AND b = '1' +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement SELECT * FROM check_estimated_rows('SELECT * FROM functional_dependencies WHERE a = 1 AND b = ''1'' AND c = 1'); - estimated | actual ------------+-------- - 1 | 50 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT * FROM functional_dependencies WHERE a =... + ^ +QUERY: explain exec SELECT * FROM functional_dependencies WHERE a = 1 AND b = '1' AND c = 1 +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement -- create statistics CREATE STATISTICS func_deps_stat (dependencies) ON a, b, c FROM functional_dependencies; ANALYZE functional_dependencies; SELECT * FROM check_estimated_rows('SELECT * FROM functional_dependencies WHERE a = 1 AND b = ''1'''); - estimated | actual ------------+-------- - 50 | 50 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT * FROM functional_dependencies WHERE a =... + ^ +QUERY: explain exec SELECT * FROM functional_dependencies WHERE a = 1 AND b = '1' +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement SELECT * FROM check_estimated_rows('SELECT * FROM functional_dependencies WHERE a = 1 AND b = ''1'' AND c = 1'); - estimated | actual ------------+-------- - 50 | 50 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT * FROM functional_dependencies WHERE a =... + ^ +QUERY: explain exec SELECT * FROM functional_dependencies WHERE a = 1 AND b = '1' AND c = 1 +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement -- check change of column type doesn't break it ALTER TABLE functional_dependencies ALTER COLUMN c TYPE numeric; SELECT * FROM check_estimated_rows('SELECT * FROM functional_dependencies WHERE a = 1 AND b = ''1'' AND c = 1'); - estimated | actual ------------+-------- - 50 | 50 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT * FROM functional_dependencies WHERE a =... + ^ +QUERY: explain exec SELECT * FROM functional_dependencies WHERE a = 1 AND b = '1' AND c = 1 +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement ANALYZE functional_dependencies; SELECT * FROM check_estimated_rows('SELECT * FROM functional_dependencies WHERE a = 1 AND b = ''1'' AND c = 1'); - estimated | actual ------------+-------- - 50 | 50 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT * FROM functional_dependencies WHERE a =... + ^ +QUERY: explain exec SELECT * FROM functional_dependencies WHERE a = 1 AND b = '1' AND c = 1 +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement -- MCV lists CREATE TABLE mcv_lists ( filler1 TEXT, @@ -428,32 +428,32 @@ INSERT INTO mcv_lists (a, b, c, filler1) SELECT mod(i,37), mod(i,41), mod(i,43), mod(i,47) FROM generate_series(1,5000) s(i); ANALYZE mcv_lists; SELECT * FROM check_estimated_rows('SELECT * FROM mcv_lists WHERE a = 1 AND b = ''1'''); - estimated | actual ------------+-------- - 3 | 4 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT * FROM mcv_lists WHERE a = 1 AND b = '1' + ^ +QUERY: explain exec SELECT * FROM mcv_lists WHERE a = 1 AND b = '1' +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement SELECT * FROM check_estimated_rows('SELECT * FROM mcv_lists WHERE a = 1 AND b = ''1'' AND c = 1'); - estimated | actual ------------+-------- - 1 | 1 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT * FROM mcv_lists WHERE a = 1 AND b = '1'... + ^ +QUERY: explain exec SELECT * FROM mcv_lists WHERE a = 1 AND b = '1' AND c = 1 +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement -- create statistics CREATE STATISTICS mcv_lists_stats (mcv) ON a, b, c FROM mcv_lists; ANALYZE mcv_lists; SELECT * FROM check_estimated_rows('SELECT * FROM mcv_lists WHERE a = 1 AND b = ''1'''); - estimated | actual ------------+-------- - 3 | 4 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT * FROM mcv_lists WHERE a = 1 AND b = '1' + ^ +QUERY: explain exec SELECT * FROM mcv_lists WHERE a = 1 AND b = '1' +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement SELECT * FROM check_estimated_rows('SELECT * FROM mcv_lists WHERE a = 1 AND b = ''1'' AND c = 1'); - estimated | actual ------------+-------- - 1 | 1 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT * FROM mcv_lists WHERE a = 1 AND b = '1'... + ^ +QUERY: explain exec SELECT * FROM mcv_lists WHERE a = 1 AND b = '1' AND c = 1 +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement -- 100 distinct combinations, all in the MCV list TRUNCATE mcv_lists; DROP STATISTICS mcv_lists_stats; @@ -461,80 +461,80 @@ INSERT INTO mcv_lists (a, b, c, filler1) SELECT mod(i,100), mod(i,50), mod(i,25), i FROM generate_series(1,5000) s(i); ANALYZE mcv_lists; SELECT * FROM check_estimated_rows('SELECT * FROM mcv_lists WHERE a = 1 AND b = ''1'''); - estimated | actual ------------+-------- - 1 | 50 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT * FROM mcv_lists WHERE a = 1 AND b = '1' + ^ +QUERY: explain exec SELECT * FROM mcv_lists WHERE a = 1 AND b = '1' +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement SELECT * FROM check_estimated_rows('SELECT * FROM mcv_lists WHERE a < 1 AND b < ''1'''); - estimated | actual ------------+-------- - 1 | 50 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT * FROM mcv_lists WHERE a < 1 AND b < '1' + ^ +QUERY: explain exec SELECT * FROM mcv_lists WHERE a < 1 AND b < '1' +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement SELECT * FROM check_estimated_rows('SELECT * FROM mcv_lists WHERE a <= 0 AND b <= ''0'''); - estimated | actual ------------+-------- - 1 | 50 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT * FROM mcv_lists WHERE a <= 0 AND b <= '... + ^ +QUERY: explain exec SELECT * FROM mcv_lists WHERE a <= 0 AND b <= '0' +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement SELECT * FROM check_estimated_rows('SELECT * FROM mcv_lists WHERE a = 1 AND b = ''1'' AND c = 1'); - estimated | actual ------------+-------- - 1 | 50 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT * FROM mcv_lists WHERE a = 1 AND b = '1'... + ^ +QUERY: explain exec SELECT * FROM mcv_lists WHERE a = 1 AND b = '1' AND c = 1 +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement SELECT * FROM check_estimated_rows('SELECT * FROM mcv_lists WHERE a < 5 AND b < ''1'' AND c < 5'); - estimated | actual ------------+-------- - 1 | 50 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT * FROM mcv_lists WHERE a < 5 AND b < '1'... + ^ +QUERY: explain exec SELECT * FROM mcv_lists WHERE a < 5 AND b < '1' AND c < 5 +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement SELECT * FROM check_estimated_rows('SELECT * FROM mcv_lists WHERE a <= 4 AND b <= ''0'' AND c <= 4'); - estimated | actual ------------+-------- - 1 | 50 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT * FROM mcv_lists WHERE a <= 4 AND b <= '... + ^ +QUERY: explain exec SELECT * FROM mcv_lists WHERE a <= 4 AND b <= '0' AND c <= 4 +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement -- create statistics CREATE STATISTICS mcv_lists_stats (mcv) ON a, b, c FROM mcv_lists; ANALYZE mcv_lists; SELECT * FROM check_estimated_rows('SELECT * FROM mcv_lists WHERE a = 1 AND b = ''1'''); - estimated | actual ------------+-------- - 50 | 50 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT * FROM mcv_lists WHERE a = 1 AND b = '1' + ^ +QUERY: explain exec SELECT * FROM mcv_lists WHERE a = 1 AND b = '1' +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement SELECT * FROM check_estimated_rows('SELECT * FROM mcv_lists WHERE a < 1 AND b < ''1'''); - estimated | actual ------------+-------- - 50 | 50 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT * FROM mcv_lists WHERE a < 1 AND b < '1' + ^ +QUERY: explain exec SELECT * FROM mcv_lists WHERE a < 1 AND b < '1' +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement SELECT * FROM check_estimated_rows('SELECT * FROM mcv_lists WHERE a <= 0 AND b <= ''0'''); - estimated | actual ------------+-------- - 50 | 50 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT * FROM mcv_lists WHERE a <= 0 AND b <= '... + ^ +QUERY: explain exec SELECT * FROM mcv_lists WHERE a <= 0 AND b <= '0' +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement SELECT * FROM check_estimated_rows('SELECT * FROM mcv_lists WHERE a = 1 AND b = ''1'' AND c = 1'); - estimated | actual ------------+-------- - 50 | 50 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT * FROM mcv_lists WHERE a = 1 AND b = '1'... + ^ +QUERY: explain exec SELECT * FROM mcv_lists WHERE a = 1 AND b = '1' AND c = 1 +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement SELECT * FROM check_estimated_rows('SELECT * FROM mcv_lists WHERE a < 5 AND b < ''1'' AND c < 5'); - estimated | actual ------------+-------- - 50 | 50 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT * FROM mcv_lists WHERE a < 5 AND b < '1'... + ^ +QUERY: explain exec SELECT * FROM mcv_lists WHERE a < 5 AND b < '1' AND c < 5 +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement SELECT * FROM check_estimated_rows('SELECT * FROM mcv_lists WHERE a <= 4 AND b <= ''0'' AND c <= 4'); - estimated | actual ------------+-------- - 50 | 50 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT * FROM mcv_lists WHERE a <= 4 AND b <= '... + ^ +QUERY: explain exec SELECT * FROM mcv_lists WHERE a <= 4 AND b <= '0' AND c <= 4 +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement -- check change of unrelated column type does not reset the MCV statistics ALTER TABLE mcv_lists ALTER COLUMN d TYPE VARCHAR(64); SELECT stxmcv IS NOT NULL FROM pg_statistic_ext WHERE stxname = 'mcv_lists_stats'; @@ -546,18 +546,18 @@ SELECT stxmcv IS NOT NULL FROM pg_statistic_ext WHERE stxname = 'mcv_lists_stats -- check change of column type resets the MCV statistics ALTER TABLE mcv_lists ALTER COLUMN c TYPE numeric; SELECT * FROM check_estimated_rows('SELECT * FROM mcv_lists WHERE a = 1 AND b = ''1'''); - estimated | actual ------------+-------- - 1 | 50 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT * FROM mcv_lists WHERE a = 1 AND b = '1' + ^ +QUERY: explain exec SELECT * FROM mcv_lists WHERE a = 1 AND b = '1' +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement ANALYZE mcv_lists; SELECT * FROM check_estimated_rows('SELECT * FROM mcv_lists WHERE a = 1 AND b = ''1'''); - estimated | actual ------------+-------- - 50 | 50 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT * FROM mcv_lists WHERE a = 1 AND b = '1' + ^ +QUERY: explain exec SELECT * FROM mcv_lists WHERE a = 1 AND b = '1' +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement -- 100 distinct combinations with NULL values, all in the MCV list TRUNCATE mcv_lists; DROP STATISTICS mcv_lists_stats; @@ -570,32 +570,32 @@ INSERT INTO mcv_lists (a, b, c, filler1) FROM generate_series(1,5000) s(i); ANALYZE mcv_lists; SELECT * FROM check_estimated_rows('SELECT * FROM mcv_lists WHERE a IS NULL AND b IS NULL'); - estimated | actual ------------+-------- - 1 | 50 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT * FROM mcv_lists WHERE a IS NULL AND b I... + ^ +QUERY: explain exec SELECT * FROM mcv_lists WHERE a IS NULL AND b IS NULL +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement SELECT * FROM check_estimated_rows('SELECT * FROM mcv_lists WHERE a IS NULL AND b IS NULL AND c IS NULL'); - estimated | actual ------------+-------- - 1 | 50 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT * FROM mcv_lists WHERE a IS NULL AND b I... + ^ +QUERY: explain exec SELECT * FROM mcv_lists WHERE a IS NULL AND b IS NULL AND c IS NULL +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement -- create statistics CREATE STATISTICS mcv_lists_stats (mcv) ON a, b, c FROM mcv_lists; ANALYZE mcv_lists; SELECT * FROM check_estimated_rows('SELECT * FROM mcv_lists WHERE a IS NULL AND b IS NULL'); - estimated | actual ------------+-------- - 50 | 50 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT * FROM mcv_lists WHERE a IS NULL AND b I... + ^ +QUERY: explain exec SELECT * FROM mcv_lists WHERE a IS NULL AND b IS NULL +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement SELECT * FROM check_estimated_rows('SELECT * FROM mcv_lists WHERE a IS NULL AND b IS NULL AND c IS NULL'); - estimated | actual ------------+-------- - 50 | 50 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT * FROM mcv_lists WHERE a IS NULL AND b I... + ^ +QUERY: explain exec SELECT * FROM mcv_lists WHERE a IS NULL AND b IS NULL AND c IS NULL +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement -- test pg_mcv_list_items with a very simple (single item) MCV list TRUNCATE mcv_lists; INSERT INTO mcv_lists (a, b, c) SELECT 1, 2, 3 FROM generate_series(1,1000) s(i); @@ -634,53 +634,53 @@ INSERT INTO mcv_lists_bool (a, b, c) FROM generate_series(1,10000) s(i); ANALYZE mcv_lists_bool; SELECT * FROM check_estimated_rows('SELECT * FROM mcv_lists_bool WHERE a AND b AND c'); - estimated | actual ------------+-------- - 156 | 1250 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT * FROM mcv_lists_bool WHERE a AND b AND ... + ^ +QUERY: explain exec SELECT * FROM mcv_lists_bool WHERE a AND b AND c +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement SELECT * FROM check_estimated_rows('SELECT * FROM mcv_lists_bool WHERE NOT a AND b AND c'); - estimated | actual ------------+-------- - 156 | 0 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT * FROM mcv_lists_bool WHERE NOT a AND b ... + ^ +QUERY: explain exec SELECT * FROM mcv_lists_bool WHERE NOT a AND b AND c +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement SELECT * FROM check_estimated_rows('SELECT * FROM mcv_lists_bool WHERE NOT a AND NOT b AND c'); - estimated | actual ------------+-------- - 469 | 0 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT * FROM mcv_lists_bool WHERE NOT a AND NO... + ^ +QUERY: explain exec SELECT * FROM mcv_lists_bool WHERE NOT a AND NOT b AND c +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement SELECT * FROM check_estimated_rows('SELECT * FROM mcv_lists_bool WHERE NOT a AND b AND NOT c'); - estimated | actual ------------+-------- - 1094 | 0 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT * FROM mcv_lists_bool WHERE NOT a AND b ... + ^ +QUERY: explain exec SELECT * FROM mcv_lists_bool WHERE NOT a AND b AND NOT c +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement CREATE STATISTICS mcv_lists_bool_stats (mcv) ON a, b, c FROM mcv_lists_bool; ANALYZE mcv_lists_bool; SELECT * FROM check_estimated_rows('SELECT * FROM mcv_lists_bool WHERE a AND b AND c'); - estimated | actual ------------+-------- - 1250 | 1250 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT * FROM mcv_lists_bool WHERE a AND b AND ... + ^ +QUERY: explain exec SELECT * FROM mcv_lists_bool WHERE a AND b AND c +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement SELECT * FROM check_estimated_rows('SELECT * FROM mcv_lists_bool WHERE NOT a AND b AND c'); - estimated | actual ------------+-------- - 1 | 0 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT * FROM mcv_lists_bool WHERE NOT a AND b ... + ^ +QUERY: explain exec SELECT * FROM mcv_lists_bool WHERE NOT a AND b AND c +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement SELECT * FROM check_estimated_rows('SELECT * FROM mcv_lists_bool WHERE NOT a AND NOT b AND c'); - estimated | actual ------------+-------- - 1 | 0 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT * FROM mcv_lists_bool WHERE NOT a AND NO... + ^ +QUERY: explain exec SELECT * FROM mcv_lists_bool WHERE NOT a AND NOT b AND c +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement SELECT * FROM check_estimated_rows('SELECT * FROM mcv_lists_bool WHERE NOT a AND b AND NOT c'); - estimated | actual ------------+-------- - 1 | 0 -(1 row) - +ERROR: syntax error at or near "exec" +LINE 1: explain exec SELECT * FROM mcv_lists_bool WHERE NOT a AND b ... + ^ +QUERY: explain exec SELECT * FROM mcv_lists_bool WHERE NOT a AND b AND NOT c +CONTEXT: PL/pgSQL function check_estimated_rows(text) line 7 at FOR over EXECUTE statement diff --git a/src/test/regress/expected/subselect.out b/src/test/regress/expected/subselect.out index 2d1963d12a..fcbffe71f5 100644 --- a/src/test/regress/expected/subselect.out +++ b/src/test/regress/expected/subselect.out @@ -1120,8 +1120,8 @@ drop function tattle(x int, y int); -- -- Test that LIMIT can be pushed to SORT through a subquery that just projects -- columns. We check for that having happened by looking to see if EXPLAIN --- ANALYZE shows that a top-N sort was used. We must suppress or filter away --- all the non-invariant parts of the EXPLAIN ANALYZE output. +-- EXEC shows that a top-N sort was used. We must suppress or filter away +-- all the non-invariant parts of the EXPLAIN EXEC output. -- create table sq_limit (pk int primary key, c1 int, c2 int); insert into sq_limit values @@ -1138,7 +1138,7 @@ $$ declare ln text; begin for ln in - explain (analyze, summary off, timing off, costs off) + explain (exec, summary off, timing off, costs off) select * from (select pk,c2 from sq_limit order by c1,pk) as x limit 3 loop ln := regexp_replace(ln, 'Memory: \S*', 'Memory: xxx'); @@ -1152,12 +1152,16 @@ select * from explain_sq_limit(); explain_sq_limit ---------------------------------------------------------------- Limit (actual rows=3 loops=1) + Buffers: shared hit=1 -> Subquery Scan on x (actual rows=3 loops=1) + Buffers: shared hit=1 -> Sort (actual rows=3 loops=1) Sort Key: sq_limit.c1, sq_limit.pk Sort Method: top-N heapsort Memory: xxx + Buffers: shared hit=1 -> Seq Scan on sq_limit (actual rows=8 loops=1) -(6 rows) + Buffers: shared hit=1 +(10 rows) select * from (select pk,c2 from sq_limit order by c1,pk) as x limit 3; pk | c2 diff --git a/src/test/regress/expected/tidscan.out b/src/test/regress/expected/tidscan.out index 9b5eb04bfd..b19516e39b 100644 --- a/src/test/regress/expected/tidscan.out +++ b/src/test/regress/expected/tidscan.out @@ -120,7 +120,8 @@ FROM tidscan t1 JOIN tidscan t2 ON t1.ctid = t2.ctid WHERE t1.id = 1; Filter: (id = 1) -> Tid Scan on tidscan t2 TID Cond: (ctid = t1.ctid) -(5 rows) + Settings: enable_hashjoin = 'off' +(6 rows) SELECT t1.ctid, t1.*, t2.ctid, t2.* FROM tidscan t1 JOIN tidscan t2 ON t1.ctid = t2.ctid WHERE t1.id = 1; @@ -139,7 +140,8 @@ FROM tidscan t1 LEFT JOIN tidscan t2 ON t1.ctid = t2.ctid WHERE t1.id = 1; Filter: (id = 1) -> Tid Scan on tidscan t2 TID Cond: (t1.ctid = ctid) -(5 rows) + Settings: enable_hashjoin = 'off' +(6 rows) SELECT t1.ctid, t1.*, t2.ctid, t2.* FROM tidscan t1 LEFT JOIN tidscan t2 ON t1.ctid = t2.ctid WHERE t1.id = 1; @@ -189,14 +191,16 @@ FETCH NEXT FROM c; (1 row) -- perform update -EXPLAIN (ANALYZE, COSTS OFF, SUMMARY OFF, TIMING OFF) +EXPLAIN (EXEC, COSTS OFF, SUMMARY OFF, TIMING OFF) UPDATE tidscan SET id = -id WHERE CURRENT OF c RETURNING *; QUERY PLAN --------------------------------------------------- Update on tidscan (actual rows=1 loops=1) + Buffers: shared hit=3 -> Tid Scan on tidscan (actual rows=1 loops=1) TID Cond: CURRENT OF c -(3 rows) + Buffers: shared hit=2 +(5 rows) FETCH NEXT FROM c; ctid | id @@ -205,14 +209,16 @@ FETCH NEXT FROM c; (1 row) -- perform update -EXPLAIN (ANALYZE, COSTS OFF, SUMMARY OFF, TIMING OFF) +EXPLAIN (EXEC, COSTS OFF, SUMMARY OFF, TIMING OFF) UPDATE tidscan SET id = -id WHERE CURRENT OF c RETURNING *; QUERY PLAN --------------------------------------------------- Update on tidscan (actual rows=1 loops=1) + Buffers: shared hit=3 -> Tid Scan on tidscan (actual rows=1 loops=1) TID Cond: CURRENT OF c -(3 rows) + Buffers: shared hit=2 +(5 rows) SELECT * FROM tidscan; id @@ -229,7 +235,7 @@ FETCH NEXT FROM c; (0 rows) -- should error out -EXPLAIN (ANALYZE, COSTS OFF, SUMMARY OFF, TIMING OFF) +EXPLAIN (EXEC, COSTS OFF, SUMMARY OFF, TIMING OFF) UPDATE tidscan SET id = -id WHERE CURRENT OF c RETURNING *; ERROR: cursor "c" is not positioned on a row ROLLBACK; @@ -268,7 +274,8 @@ SELECT count(*) FROM tenk1 t1 JOIN tenk1 t2 ON t1.ctid = t2.ctid; -> Sort Sort Key: t2.ctid -> Seq Scan on tenk1 t2 -(9 rows) + Settings: enable_hashjoin = 'off' +(10 rows) SELECT count(*) FROM tenk1 t1 JOIN tenk1 t2 ON t1.ctid = t2.ctid; count diff --git a/src/test/regress/expected/tsearch.out b/src/test/regress/expected/tsearch.out index 6f61acc1ed..b61af4bed4 100644 --- a/src/test/regress/expected/tsearch.out +++ b/src/test/regress/expected/tsearch.out @@ -121,12 +121,13 @@ SET enable_seqscan=OFF; SET enable_indexscan=ON; SET enable_bitmapscan=OFF; explain (costs off) SELECT count(*) FROM test_tsvector WHERE a @@ 'wr|qh'; - QUERY PLAN -------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Aggregate -> Index Scan using wowidx on test_tsvector Index Cond: (a @@ '''wr'' | ''qh'''::tsquery) -(3 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(4 rows) SELECT count(*) FROM test_tsvector WHERE a @@ 'wr|qh'; count @@ -198,7 +199,8 @@ explain (costs off) SELECT count(*) FROM test_tsvector WHERE a @@ 'wr|qh'; Recheck Cond: (a @@ '''wr'' | ''qh'''::tsquery) -> Bitmap Index Scan on wowidx Index Cond: (a @@ '''wr'' | ''qh'''::tsquery) -(5 rows) + Settings: enable_indexscan = 'off', enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM test_tsvector WHERE a @@ 'wr|qh'; count @@ -275,7 +277,8 @@ explain (costs off) SELECT count(*) FROM test_tsvector WHERE a @@ 'wr|qh'; Recheck Cond: (a @@ '''wr'' | ''qh'''::tsquery) -> Bitmap Index Scan on wowidx Index Cond: (a @@ '''wr'' | ''qh'''::tsquery) -(5 rows) + Settings: enable_seqscan = 'off' +(6 rows) SELECT count(*) FROM test_tsvector WHERE a @@ 'wr|qh'; count diff --git a/src/test/regress/expected/union.out b/src/test/regress/expected/union.out index 7189f5bd3d..828563ad87 100644 --- a/src/test/regress/expected/union.out +++ b/src/test/regress/expected/union.out @@ -404,7 +404,8 @@ select count(*) from -> Seq Scan on tenk1 -> Subquery Scan on "*SELECT* 1" -> Index Only Scan using tenk1_unique1 on tenk1 tenk1_1 -(10 rows) + Settings: enable_hashagg = 'off' +(11 rows) select count(*) from ( select unique1 from tenk1 intersect select fivethous from tenk1 ) ss; @@ -426,7 +427,8 @@ select unique1 from tenk1 except select unique2 from tenk1 where unique2 != 10; -> Subquery Scan on "*SELECT* 2" -> Index Only Scan using tenk1_unique2 on tenk1 tenk1_1 Filter: (unique2 <> 10) -(9 rows) + Settings: enable_hashagg = 'off' +(10 rows) select unique1 from tenk1 except select unique2 from tenk1 where unique2 != 10; unique1 @@ -578,7 +580,8 @@ select from generate_series(1,5) union select from generate_series(1,3); -> Append -> Function Scan on generate_series -> Function Scan on generate_series generate_series_1 -(4 rows) + Settings: enable_sort = 'off' +(5 rows) explain (costs off) select from generate_series(1,5) intersect select from generate_series(1,3); @@ -590,7 +593,8 @@ select from generate_series(1,5) intersect select from generate_series(1,3); -> Function Scan on generate_series -> Subquery Scan on "*SELECT* 2" -> Function Scan on generate_series generate_series_1 -(6 rows) + Settings: enable_sort = 'off' +(7 rows) select from generate_series(1,5) union select from generate_series(1,3); -- @@ -627,7 +631,8 @@ select from generate_series(1,5) union select from generate_series(1,3); -> Append -> Function Scan on generate_series -> Function Scan on generate_series generate_series_1 -(4 rows) + Settings: enable_hashagg = 'off' +(5 rows) explain (costs off) select from generate_series(1,5) intersect select from generate_series(1,3); @@ -639,7 +644,8 @@ select from generate_series(1,5) intersect select from generate_series(1,3); -> Function Scan on generate_series -> Subquery Scan on "*SELECT* 2" -> Function Scan on generate_series generate_series_1 -(6 rows) + Settings: enable_hashagg = 'off' +(7 rows) select from generate_series(1,5) union select from generate_series(1,3); -- @@ -707,14 +713,15 @@ explain (costs off) UNION ALL SELECT * FROM t2) t WHERE ab = 'ab'; - QUERY PLAN ---------------------------------------------- + QUERY PLAN +------------------------------------------------------------- Append -> Index Scan using t1_ab_idx on t1 Index Cond: ((a || b) = 'ab'::text) -> Index Only Scan using t2_pkey on t2 Index Cond: (ab = 'ab'::text) -(5 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(6 rows) explain (costs off) SELECT * FROM @@ -722,8 +729,8 @@ explain (costs off) UNION SELECT * FROM t2) t WHERE ab = 'ab'; - QUERY PLAN ---------------------------------------------------- + QUERY PLAN +------------------------------------------------------------- HashAggregate Group Key: ((t1.a || t1.b)) -> Append @@ -731,7 +738,8 @@ explain (costs off) Index Cond: ((a || b) = 'ab'::text) -> Index Only Scan using t2_pkey on t2 Index Cond: (ab = 'ab'::text) -(7 rows) + Settings: enable_bitmapscan = 'off', enable_seqscan = 'off' +(8 rows) -- -- Test that ORDER BY for UNION ALL can be pushed down to inheritance @@ -751,8 +759,8 @@ explain (costs off) UNION ALL SELECT ab FROM t2) t ORDER BY 1 LIMIT 8; - QUERY PLAN ------------------------------------------------- + QUERY PLAN +------------------------------------------------------------------- Limit -> Merge Append Sort Key: ((t1.a || t1.b)) @@ -760,7 +768,8 @@ explain (costs off) -> Index Scan using t1c_ab_idx on t1c -> Index Scan using t2_pkey on t2 -> Index Scan using t2c_pkey on t2c -(7 rows) + Settings: enable_bitmapscan = 'off', enable_indexonlyscan = 'off' +(8 rows) SELECT * FROM (SELECT a || b AS ab FROM t1 @@ -801,7 +810,8 @@ select event_id Sort Key: events_child.event_id -> Seq Scan on events_child -> Index Scan using other_events_pkey on other_events -(7 rows) + Settings: enable_indexonlyscan = 'off' +(8 rows) drop table events_child, events, other_events; reset enable_indexonlyscan; diff --git a/src/test/regress/expected/write_parallel.out b/src/test/regress/expected/write_parallel.out index 0c4da2591a..51e8380cdf 100644 --- a/src/test/regress/expected/write_parallel.out +++ b/src/test/regress/expected/write_parallel.out @@ -15,8 +15,8 @@ set max_parallel_workers_per_gather=4; -- explain (costs off) create table parallel_write as select length(stringu1) from tenk1 group by length(stringu1); - QUERY PLAN ---------------------------------------------------- + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------- Finalize HashAggregate Group Key: (length((stringu1)::text)) -> Gather @@ -24,15 +24,16 @@ explain (costs off) create table parallel_write as -> Partial HashAggregate Group Key: length((stringu1)::text) -> Parallel Seq Scan on tenk1 -(7 rows) + Settings: max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(8 rows) create table parallel_write as select length(stringu1) from tenk1 group by length(stringu1); drop table parallel_write; explain (costs off) select length(stringu1) into parallel_write from tenk1 group by length(stringu1); - QUERY PLAN ---------------------------------------------------- + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------- Finalize HashAggregate Group Key: (length((stringu1)::text)) -> Gather @@ -40,15 +41,16 @@ explain (costs off) select length(stringu1) into parallel_write -> Partial HashAggregate Group Key: length((stringu1)::text) -> Parallel Seq Scan on tenk1 -(7 rows) + Settings: max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(8 rows) select length(stringu1) into parallel_write from tenk1 group by length(stringu1); drop table parallel_write; explain (costs off) create materialized view parallel_mat_view as select length(stringu1) from tenk1 group by length(stringu1); - QUERY PLAN ---------------------------------------------------- + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------- Finalize HashAggregate Group Key: (length((stringu1)::text)) -> Gather @@ -56,15 +58,16 @@ explain (costs off) create materialized view parallel_mat_view as -> Partial HashAggregate Group Key: length((stringu1)::text) -> Parallel Seq Scan on tenk1 -(7 rows) + Settings: max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(8 rows) create materialized view parallel_mat_view as select length(stringu1) from tenk1 group by length(stringu1); drop materialized view parallel_mat_view; prepare prep_stmt as select length(stringu1) from tenk1 group by length(stringu1); explain (costs off) create table parallel_write as execute prep_stmt; - QUERY PLAN ---------------------------------------------------- + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------- Finalize HashAggregate Group Key: (length((stringu1)::text)) -> Gather @@ -72,7 +75,8 @@ explain (costs off) create table parallel_write as execute prep_stmt; -> Partial HashAggregate Group Key: length((stringu1)::text) -> Parallel Seq Scan on tenk1 -(7 rows) + Settings: max_parallel_workers_per_gather = '4', min_parallel_table_scan_size = '0', parallel_setup_cost = '0', parallel_tuple_cost = '0' +(8 rows) create table parallel_write as execute prep_stmt; drop table parallel_write; diff --git a/src/test/regress/sql/join_hash.sql b/src/test/regress/sql/join_hash.sql index ae352e9b0b..b44d705d57 100644 --- a/src/test/regress/sql/join_hash.sql +++ b/src/test/regress/sql/join_hash.sql @@ -7,7 +7,7 @@ begin; set local min_parallel_table_scan_size = 0; set local parallel_setup_cost = 0; --- Extract bucket and batch counts from an explain analyze plan. In +-- Extract bucket and batch counts from an explain exec plan. In -- general we can't make assertions about how many batches (or -- buckets) will be required because it can vary, but we can in some -- special cases and we can check for growth. @@ -42,7 +42,7 @@ declare hash_node json; begin for whole_plan in - execute 'explain (analyze, format ''json'') ' || query + execute 'explain (exec, format ''json'') ' || query loop hash_node := find_hash(json_extract_path(whole_plan, '0', 'Plan')); original := hash_node->>'Original Hash Batches'; @@ -280,7 +280,7 @@ rollback to settings; -- A couple of other hash join tests unrelated to work_mem management. --- Check that EXPLAIN ANALYZE has data even if the leader doesn't participate +-- Check that EXPLAIN EXEC has data even if the leader doesn't participate savepoint settings; set local max_parallel_workers_per_gather = 2; set local work_mem = '4MB'; diff --git a/src/test/regress/sql/partition_prune.sql b/src/test/regress/sql/partition_prune.sql index 246c6274af..684aa3c464 100644 --- a/src/test/regress/sql/partition_prune.sql +++ b/src/test/regress/sql/partition_prune.sql @@ -327,7 +327,7 @@ create table ab_a3_b2 partition of ab_a3 for values in (2); create table ab_a3_b3 partition of ab_a3 for values in (3); -- Disallow index only scans as concurrent transactions may stop visibility --- bits being set causing "Heap Fetches" to be unstable in the EXPLAIN ANALYZE +-- bits being set causing "Heap Fetches" to be unstable in the EXPLAIN EXEC -- output. set enable_indexonlyscan = off; @@ -342,8 +342,8 @@ execute ab_q1 (1, 8, 3); execute ab_q1 (1, 8, 3); execute ab_q1 (1, 8, 3); -explain (analyze, costs off, summary off, timing off) execute ab_q1 (2, 2, 3); -explain (analyze, costs off, summary off, timing off) execute ab_q1 (1, 2, 3); +explain (exec, costs off, summary off, timing off) execute ab_q1 (2, 2, 3); +explain (exec, costs off, summary off, timing off) execute ab_q1 (1, 2, 3); deallocate ab_q1; @@ -359,8 +359,8 @@ execute ab_q1 (1, 8); execute ab_q1 (1, 8); execute ab_q1 (1, 8); -explain (analyze, costs off, summary off, timing off) execute ab_q1 (2, 2); -explain (analyze, costs off, summary off, timing off) execute ab_q1 (2, 4); +explain (exec, costs off, summary off, timing off) execute ab_q1 (2, 2); +explain (exec, costs off, summary off, timing off) execute ab_q1 (2, 4); -- Ensure a mix of PARAM_EXTERN and PARAM_EXEC Params work together at -- different levels of partitioning. @@ -373,7 +373,7 @@ execute ab_q2 (1, 8); execute ab_q2 (1, 8); execute ab_q2 (1, 8); -explain (analyze, costs off, summary off, timing off) execute ab_q2 (2, 2); +explain (exec, costs off, summary off, timing off) execute ab_q2 (2, 2); -- As above, but swap the PARAM_EXEC Param to the first partition level prepare ab_q3 (int, int) as @@ -385,7 +385,7 @@ execute ab_q3 (1, 8); execute ab_q3 (1, 8); execute ab_q3 (1, 8); -explain (analyze, costs off, summary off, timing off) execute ab_q3 (2, 2); +explain (exec, costs off, summary off, timing off) execute ab_q3 (2, 2); -- Test a backwards Append scan create table list_part (a int) partition by list (a); @@ -416,13 +416,13 @@ begin; 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) select * from list_part where a = list_part_fn(1); +explain (exec, costs off, summary off, timing off) select * from list_part where a = list_part_fn(1); -- Ensure pruning does not take place when the function has a Var parameter -explain (analyze, costs off, summary off, timing off) select * from list_part where a = list_part_fn(a); +explain (exec, costs off, summary off, timing off) select * from list_part where a = list_part_fn(a); -- Ensure pruning does not take place when the expression contains a Var. -explain (analyze, costs off, summary off, timing off) select * from list_part where a = list_part_fn(1) + a; +explain (exec, costs off, summary off, timing off) select * from list_part where a = list_part_fn(1) + a; rollback; @@ -440,7 +440,7 @@ declare ln text; begin for ln in - execute format('explain (analyze, costs off, summary off, timing off) %s', + execute format('explain (exec, costs off, summary off, timing off) %s', $1) loop if ln like '%Parallel%' then @@ -537,15 +537,15 @@ reset min_parallel_table_scan_size; reset max_parallel_workers_per_gather; -- Test run-time partition pruning with an initplan -explain (analyze, costs off, summary off, timing off) +explain (exec, costs off, summary off, timing off) select * from ab where a = (select max(a) from lprt_a) and b = (select max(a)-1 from lprt_a); -- Test run-time partition pruning with UNION ALL parents -explain (analyze, costs off, summary off, timing off) +explain (exec, costs off, summary off, timing off) select * from (select * from ab where a = 1 union all select * from ab) ab where b = (select 1); -- A case containing a UNION ALL with a non-partitioned child. -explain (analyze, costs off, summary off, timing off) +explain (exec, costs off, summary off, timing off) select * from (select * from ab where a = 1 union all (values(10,5)) union all select * from ab) ab where b = (select 1); -- Another UNION ALL test, but containing a mix of exec init and exec run-time pruning. @@ -566,7 +566,7 @@ union all ) ab where a = $1 and b = (select -10); -- Ensure the xy_1 subplan is not pruned. -explain (analyze, costs off, summary off, timing off) execute ab_q6(1); +explain (exec, costs off, summary off, timing off) execute ab_q6(1); -- Ensure we see just the xy_1 row. execute ab_q6(100); @@ -584,14 +584,14 @@ deallocate ab_q6; -- UPDATE on a partition subtree has been seen to have problems. insert into ab values (1,2); -explain (analyze, costs off, summary off, timing off) +explain (exec, costs off, summary off, timing off) update ab_a1 set b = 3 from ab where ab.a = 1 and ab.a = ab_a1.a; table ab; -- Test UPDATE where source relation has run-time pruning enabled truncate ab; insert into ab values (1, 1), (1, 2), (1, 3), (2, 1); -explain (analyze, costs off, summary off, timing off) +explain (exec, costs off, summary off, timing off) update ab_a1 set b = 3 from ab_a2 where ab_a2.b = (select 1); select tableoid::regclass, * from ab; @@ -622,10 +622,10 @@ insert into tprt values (10), (20), (501), (502), (505), (1001), (4500); set enable_hashjoin = off; set enable_mergejoin = off; -explain (analyze, costs off, summary off, timing off) +explain (exec, costs off, summary off, timing off) select * from tbl1 join tprt on tbl1.col1 > tprt.col1; -explain (analyze, costs off, summary off, timing off) +explain (exec, costs off, summary off, timing off) select * from tbl1 join tprt on tbl1.col1 = tprt.col1; select tbl1.col1, tprt.col1 from tbl1 @@ -638,10 +638,10 @@ order by tbl1.col1, tprt.col1; -- Multiple partitions insert into tbl1 values (1001), (1010), (1011); -explain (analyze, costs off, summary off, timing off) +explain (exec, costs off, summary off, timing off) select * from tbl1 inner join tprt on tbl1.col1 > tprt.col1; -explain (analyze, costs off, summary off, timing off) +explain (exec, costs off, summary off, timing off) select * from tbl1 inner join tprt on tbl1.col1 = tprt.col1; select tbl1.col1, tprt.col1 from tbl1 @@ -655,7 +655,7 @@ order by tbl1.col1, tprt.col1; -- Last partition delete from tbl1; insert into tbl1 values (4400); -explain (analyze, costs off, summary off, timing off) +explain (exec, costs off, summary off, timing off) select * from tbl1 join tprt on tbl1.col1 < tprt.col1; select tbl1.col1, tprt.col1 from tbl1 @@ -665,7 +665,7 @@ order by tbl1.col1, tprt.col1; -- No matching partition delete from tbl1; insert into tbl1 values (10000); -explain (analyze, costs off, summary off, timing off) +explain (exec, costs off, summary off, timing off) select * from tbl1 join tprt on tbl1.col1 = tprt.col1; select tbl1.col1, tprt.col1 from tbl1 @@ -696,7 +696,7 @@ execute part_abc_q1 (1, 2, 3); execute part_abc_q1 (1, 2, 3); -- Single partition should be scanned. -explain (analyze, costs off, summary off, timing off) execute part_abc_q1 (1, 2, 3); +explain (exec, costs off, summary off, timing off) execute part_abc_q1 (1, 2, 3); deallocate part_abc_q1; @@ -722,13 +722,13 @@ execute q1 (1,2); execute q1 (1,2); execute q1 (1,2); -explain (analyze, costs off, summary off, timing off) execute q1 (1,1); +explain (exec, costs off, summary off, timing off) execute q1 (1,1); -explain (analyze, costs off, summary off, timing off) execute q1 (2,2); +explain (exec, costs off, summary off, timing off) execute q1 (2,2); -- Try with no matching partitions. One subplan should remain in this case, -- but it shouldn't be executed. -explain (analyze, costs off, summary off, timing off) execute q1 (0,0); +explain (exec, costs off, summary off, timing off) execute q1 (0,0); deallocate q1; @@ -742,14 +742,14 @@ execute q1 (1,2,3,4); execute q1 (1,2,3,4); -- Both partitions allowed by IN clause, but one disallowed by <> clause -explain (analyze, costs off, summary off, timing off) execute q1 (1,2,2,0); +explain (exec, costs off, summary off, timing off) execute q1 (1,2,2,0); -- Both partitions allowed by IN clause, then both excluded again by <> clauses. -- One subplan will remain in this case, but it should not be executed. -explain (analyze, costs off, summary off, timing off) execute q1 (1,2,2,1); +explain (exec, costs off, summary off, timing off) execute q1 (1,2,2,1); -- Ensure Params that evaluate to NULL properly prune away all partitions -explain (analyze, costs off, summary off, timing off) +explain (exec, costs off, summary off, timing off) select * from listp where a = (select null::int); drop table listp; @@ -762,10 +762,10 @@ create table boolp (a bool) partition by list (a); create table boolp_t partition of boolp for values in('t'); create table boolp_f partition of boolp for values in('f'); -explain (analyze, costs off, summary off, timing off) +explain (exec, costs off, summary off, timing off) select * from boolp where a = (select value from boolvalues where value); -explain (analyze, costs off, summary off, timing off) +explain (exec, costs off, summary off, timing off) select * from boolp where a = (select value from boolvalues where not value); drop table boolp; @@ -793,18 +793,18 @@ execute mt_q1(0); execute mt_q1(0); execute mt_q1(0); -explain (analyze, costs off, summary off, timing off) execute mt_q1(15); +explain (exec, costs off, summary off, timing off) execute mt_q1(15); execute mt_q1(15); -explain (analyze, costs off, summary off, timing off) execute mt_q1(25); +explain (exec, costs off, summary off, timing off) execute mt_q1(25); execute mt_q1(25); -- Ensure MergeAppend behaves correctly when no subplans match -explain (analyze, costs off, summary off, timing off) execute mt_q1(35); +explain (exec, costs off, summary off, timing off) execute mt_q1(35); execute mt_q1(35); deallocate mt_q1; -- ensure initplan params properly prune partitions -explain (analyze, costs off, summary off, timing off) select * from ma_test where a >= (select min(b) from ma_test_p2) order by b; +explain (exec, costs off, summary off, timing off) select * from ma_test where a >= (select min(b) from ma_test_p2) order by b; reset enable_seqscan; reset enable_sort; @@ -987,7 +987,7 @@ create table listp1 partition of listp for values in(1); create table listp2 partition of listp for values in(2) partition by list(b); create table listp2_10 partition of listp2 for values in (10); -explain (analyze, costs off, summary off, timing off) +explain (exec, costs off, summary off, timing off) select * from listp where a = (select 2) and b <> 10; -- diff --git a/src/test/regress/sql/select.sql b/src/test/regress/sql/select.sql index b5929b2eca..f573dfa921 100644 --- a/src/test/regress/sql/select.sql +++ b/src/test/regress/sql/select.sql @@ -196,7 +196,7 @@ explain (costs off) select * from onek2 where unique2 = 11 and stringu1 = 'ATAAAA'; select * from onek2 where unique2 = 11 and stringu1 = 'ATAAAA'; -- actually run the query with an analyze to use the partial index -explain (costs off, analyze on, timing off, summary off) +explain (costs off, exec on, timing off, summary off) select * from onek2 where unique2 = 11 and stringu1 = 'ATAAAA'; explain (costs off) select unique2 from onek2 where unique2 = 11 and stringu1 = 'ATAAAA'; diff --git a/src/test/regress/sql/select_into.sql b/src/test/regress/sql/select_into.sql index a708fef0ea..bd2f918294 100644 --- a/src/test/regress/sql/select_into.sql +++ b/src/test/regress/sql/select_into.sql @@ -85,12 +85,12 @@ SELECT make_table(); SELECT * FROM created_table; --- Try EXPLAIN ANALYZE SELECT INTO and EXPLAIN ANALYZE CREATE TABLE AS +-- Try EXPLAIN EXEC SELECT INTO and EXPLAIN EXEC CREATE TABLE AS -- WITH NO DATA, but hide the outputs since they won't be stable. DO $$ BEGIN - EXECUTE 'EXPLAIN ANALYZE SELECT * INTO TABLE easi FROM int8_tbl'; - EXECUTE 'EXPLAIN ANALYZE CREATE TABLE easi2 AS SELECT * FROM int8_tbl WITH NO DATA'; + EXECUTE 'EXPLAIN EXEC SELECT * INTO TABLE easi FROM int8_tbl'; + EXECUTE 'EXPLAIN EXEC CREATE TABLE easi2 AS SELECT * FROM int8_tbl WITH NO DATA'; END$$; DROP TABLE created_table; diff --git a/src/test/regress/sql/select_parallel.sql b/src/test/regress/sql/select_parallel.sql index 03c056b8b7..de8ef80ecf 100644 --- a/src/test/regress/sql/select_parallel.sql +++ b/src/test/regress/sql/select_parallel.sql @@ -197,7 +197,7 @@ select count(*) from bmscantest where a>1; -- test accumulation of stats for parallel nodes reset enable_seqscan; alter table tenk2 set (parallel_workers = 0); -explain (analyze, timing off, summary off, costs off) +explain (exec, timing off, summary off, costs off) select count(*) from tenk1, tenk2 where tenk1.hundred > 1 and tenk2.thousand=0; alter table tenk2 reset (parallel_workers); @@ -209,7 +209,7 @@ $$ declare ln text; begin for ln in - explain (analyze, timing off, summary off, costs off) + explain (exec, timing off, summary off, costs off) select * from (select ten from tenk1 where ten < 100 order by ten) ss right join (values (1),(2),(3)) v(x) on true @@ -376,7 +376,7 @@ explain (costs off) -- to increase the parallel query test coverage SAVEPOINT settings; SET LOCAL force_parallel_mode = 1; -EXPLAIN (analyze, timing off, summary off, costs off) SELECT * FROM tenk1; +EXPLAIN (exec, timing off, summary off, costs off) SELECT * FROM tenk1; ROLLBACK TO SAVEPOINT settings; -- provoke error in worker diff --git a/src/test/regress/sql/stats_ext.sql b/src/test/regress/sql/stats_ext.sql index c6a5776120..6492cd7c37 100644 --- a/src/test/regress/sql/stats_ext.sql +++ b/src/test/regress/sql/stats_ext.sql @@ -14,7 +14,7 @@ declare first_row bool := true; begin for ln in - execute format('explain analyze %s', $1) + execute format('explain exec %s', $1) loop if first_row then first_row := false; diff --git a/src/test/regress/sql/subselect.sql b/src/test/regress/sql/subselect.sql index 99ca69791e..b1d89228d2 100644 --- a/src/test/regress/sql/subselect.sql +++ b/src/test/regress/sql/subselect.sql @@ -598,8 +598,8 @@ drop function tattle(x int, y int); -- -- Test that LIMIT can be pushed to SORT through a subquery that just projects -- columns. We check for that having happened by looking to see if EXPLAIN --- ANALYZE shows that a top-N sort was used. We must suppress or filter away --- all the non-invariant parts of the EXPLAIN ANALYZE output. +-- EXEC shows that a top-N sort was used. We must suppress or filter away +-- all the non-invariant parts of the EXPLAIN EXEC output. -- create table sq_limit (pk int primary key, c1 int, c2 int); insert into sq_limit values @@ -617,7 +617,7 @@ $$ declare ln text; begin for ln in - explain (analyze, summary off, timing off, costs off) + explain (exec, summary off, timing off, costs off) select * from (select pk,c2 from sq_limit order by c1,pk) as x limit 3 loop ln := regexp_replace(ln, 'Memory: \S*', 'Memory: xxx'); diff --git a/src/test/regress/sql/tidscan.sql b/src/test/regress/sql/tidscan.sql index ef05c09842..65e222681e 100644 --- a/src/test/regress/sql/tidscan.sql +++ b/src/test/regress/sql/tidscan.sql @@ -68,17 +68,17 @@ DECLARE c CURSOR FOR SELECT ctid, * FROM tidscan; FETCH NEXT FROM c; -- skip one row FETCH NEXT FROM c; -- perform update -EXPLAIN (ANALYZE, COSTS OFF, SUMMARY OFF, TIMING OFF) +EXPLAIN (EXEC, COSTS OFF, SUMMARY OFF, TIMING OFF) UPDATE tidscan SET id = -id WHERE CURRENT OF c RETURNING *; FETCH NEXT FROM c; -- perform update -EXPLAIN (ANALYZE, COSTS OFF, SUMMARY OFF, TIMING OFF) +EXPLAIN (EXEC, COSTS OFF, SUMMARY OFF, TIMING OFF) UPDATE tidscan SET id = -id WHERE CURRENT OF c RETURNING *; SELECT * FROM tidscan; -- position cursor past any rows FETCH NEXT FROM c; -- should error out -EXPLAIN (ANALYZE, COSTS OFF, SUMMARY OFF, TIMING OFF) +EXPLAIN (EXEC, COSTS OFF, SUMMARY OFF, TIMING OFF) UPDATE tidscan SET id = -id WHERE CURRENT OF c RETURNING *; ROLLBACK; --------------2.21.0--