Skip to content

P
Postgres FD Implementation
Commit 55a1954d authored by Tom Lane's avatar Tom Lane
Browse files
Options

Fix EXPLAIN's column alias output for mismatched child tables. 

If an inheritance/partitioning parent table is assigned some column
alias names in the query, EXPLAIN mapped those aliases onto the
child tables' columns by physical position, resulting in bogus output
if a child table's columns aren't one-for-one with the parent's.

To fix, make expand_single_inheritance_child() generate a correctly
re-mapped column alias list, rather than just copying the parent
RTE's alias node.  (We have to fill the alias field, not just
adjust the eref field, because ruleutils.c will ignore eref in
favor of looking at the real column names.)

This means that child tables will now always have alias fields in
plan rtables, where before they might not have.  That results in
a rather substantial set of regression test output changes:
EXPLAIN will now always show child tables with aliases that match
the parent table (usually with "_N" appended for uniqueness).
But that seems like a net positive for understandability, since
the parent alias corresponds to something that actually appeared
in the original query, while the child table names didn't.
(Note that this does not change anything for cases where an explicit
table alias was written in the query for the parent table; it
just makes cases without such aliases behave similarly to that.)
Hence, while we could avoid these subsidiary changes if we made
inherit.c more complicated, we choose not to.

Discussion: https://postgr.es/m/12424.1575168015@sss.pgh.pa.us
parent ce76c0ba
Hide whitespace changes
Inline Side-by-side
Showing with 2072 additions and 1982 deletions
contrib/postgres_fdw/expected/postgres_fdw.out
View file @ 55a1954d
...@@ -6260,10 +6260,10 @@ UPDATE rw_view SET b = b + 5; ...@@ -6260,10 +6260,10 @@ UPDATE rw_view SET b = b + 5;
QUERY PLAN QUERY PLAN
---------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------
Update on public.parent_tbl Update on public.parent_tbl
Foreign Update on public.foreign_tbl Foreign Update on public.foreign_tbl parent_tbl_1
Remote SQL: UPDATE public.child_tbl SET b = $2 WHERE ctid = $1 RETURNING a, b Remote SQL: UPDATE public.child_tbl SET b = $2 WHERE ctid = $1 RETURNING a, b
-> Foreign Scan on public.foreign_tbl -> Foreign Scan on public.foreign_tbl parent_tbl_1
Output: foreign_tbl.a, (foreign_tbl.b + 5), foreign_tbl.ctid Output: parent_tbl_1.a, (parent_tbl_1.b + 5), parent_tbl_1.ctid
Remote SQL: SELECT a, b, ctid FROM public.child_tbl WHERE ((a < b)) FOR UPDATE Remote SQL: SELECT a, b, ctid FROM public.child_tbl WHERE ((a < b)) FOR UPDATE
(6 rows) (6 rows)
...@@ -6275,10 +6275,10 @@ UPDATE rw_view SET b = b + 15; ...@@ -6275,10 +6275,10 @@ UPDATE rw_view SET b = b + 15;
QUERY PLAN QUERY PLAN
---------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------
Update on public.parent_tbl Update on public.parent_tbl
Foreign Update on public.foreign_tbl Foreign Update on public.foreign_tbl parent_tbl_1
Remote SQL: UPDATE public.child_tbl SET b = $2 WHERE ctid = $1 RETURNING a, b Remote SQL: UPDATE public.child_tbl SET b = $2 WHERE ctid = $1 RETURNING a, b
-> Foreign Scan on public.foreign_tbl -> Foreign Scan on public.foreign_tbl parent_tbl_1
Output: foreign_tbl.a, (foreign_tbl.b + 15), foreign_tbl.ctid Output: parent_tbl_1.a, (parent_tbl_1.b + 15), parent_tbl_1.ctid
Remote SQL: SELECT a, b, ctid FROM public.child_tbl WHERE ((a < b)) FOR UPDATE Remote SQL: SELECT a, b, ctid FROM public.child_tbl WHERE ((a < b)) FOR UPDATE
(6 rows) (6 rows)
...@@ -7066,8 +7066,8 @@ select * from bar where f1 in (select f1 from foo) for update; ...@@ -7066,8 +7066,8 @@ select * from bar where f1 in (select f1 from foo) for update;
-> Append -> Append
-> Seq Scan on public.bar -> Seq Scan on public.bar
Output: bar.f1, bar.f2, bar.ctid, bar.*, bar.tableoid Output: bar.f1, bar.f2, bar.ctid, bar.*, bar.tableoid
-> Foreign Scan on public.bar2 -> Foreign Scan on public.bar2 bar_1
Output: bar2.f1, bar2.f2, bar2.ctid, bar2.*, bar2.tableoid Output: bar_1.f1, bar_1.f2, bar_1.ctid, bar_1.*, bar_1.tableoid
Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR UPDATE Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR UPDATE
-> Hash -> Hash
Output: foo.ctid, foo.f1, foo.*, foo.tableoid Output: foo.ctid, foo.f1, foo.*, foo.tableoid
...@@ -7077,8 +7077,8 @@ select * from bar where f1 in (select f1 from foo) for update; ...@@ -7077,8 +7077,8 @@ select * from bar where f1 in (select f1 from foo) for update;
-> Append -> Append
-> Seq Scan on public.foo -> Seq Scan on public.foo
Output: foo.ctid, foo.f1, foo.*, foo.tableoid Output: foo.ctid, foo.f1, foo.*, foo.tableoid
-> Foreign Scan on public.foo2 -> Foreign Scan on public.foo2 foo_1
Output: foo2.ctid, foo2.f1, foo2.*, foo2.tableoid Output: foo_1.ctid, foo_1.f1, foo_1.*, foo_1.tableoid
Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1 Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
(23 rows) (23 rows)
...@@ -7104,8 +7104,8 @@ select * from bar where f1 in (select f1 from foo) for share; ...@@ -7104,8 +7104,8 @@ select * from bar where f1 in (select f1 from foo) for share;
-> Append -> Append
-> Seq Scan on public.bar -> Seq Scan on public.bar
Output: bar.f1, bar.f2, bar.ctid, bar.*, bar.tableoid Output: bar.f1, bar.f2, bar.ctid, bar.*, bar.tableoid
-> Foreign Scan on public.bar2 -> Foreign Scan on public.bar2 bar_1
Output: bar2.f1, bar2.f2, bar2.ctid, bar2.*, bar2.tableoid Output: bar_1.f1, bar_1.f2, bar_1.ctid, bar_1.*, bar_1.tableoid
Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR SHARE Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR SHARE
-> Hash -> Hash
Output: foo.ctid, foo.f1, foo.*, foo.tableoid Output: foo.ctid, foo.f1, foo.*, foo.tableoid
...@@ -7115,8 +7115,8 @@ select * from bar where f1 in (select f1 from foo) for share; ...@@ -7115,8 +7115,8 @@ select * from bar where f1 in (select f1 from foo) for share;
-> Append -> Append
-> Seq Scan on public.foo -> Seq Scan on public.foo
Output: foo.ctid, foo.f1, foo.*, foo.tableoid Output: foo.ctid, foo.f1, foo.*, foo.tableoid
-> Foreign Scan on public.foo2 -> Foreign Scan on public.foo2 foo_1
Output: foo2.ctid, foo2.f1, foo2.*, foo2.tableoid Output: foo_1.ctid, foo_1.f1, foo_1.*, foo_1.tableoid
Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1 Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
(23 rows) (23 rows)
...@@ -7132,11 +7132,11 @@ select * from bar where f1 in (select f1 from foo) for share; ...@@ -7132,11 +7132,11 @@ select * from bar where f1 in (select f1 from foo) for share;
-- Check UPDATE with inherited target and an inherited source table -- Check UPDATE with inherited target and an inherited source table
explain (verbose, costs off) explain (verbose, costs off)
update bar set f2 = f2 + 100 where f1 in (select f1 from foo); update bar set f2 = f2 + 100 where f1 in (select f1 from foo);
QUERY PLAN QUERY PLAN
--------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------
Update on public.bar Update on public.bar
Update on public.bar Update on public.bar
Foreign Update on public.bar2 Foreign Update on public.bar2 bar_1
Remote SQL: UPDATE public.loct2 SET f2 = $2 WHERE ctid = $1 Remote SQL: UPDATE public.loct2 SET f2 = $2 WHERE ctid = $1
-> Hash Join -> Hash Join
Output: bar.f1, (bar.f2 + 100), bar.ctid, foo.ctid, foo.*, foo.tableoid Output: bar.f1, (bar.f2 + 100), bar.ctid, foo.ctid, foo.*, foo.tableoid
...@@ -7152,15 +7152,15 @@ update bar set f2 = f2 + 100 where f1 in (select f1 from foo); ...@@ -7152,15 +7152,15 @@ update bar set f2 = f2 + 100 where f1 in (select f1 from foo);
-> Append -> Append
-> Seq Scan on public.foo -> Seq Scan on public.foo
Output: foo.ctid, foo.f1, foo.*, foo.tableoid Output: foo.ctid, foo.f1, foo.*, foo.tableoid
-> Foreign Scan on public.foo2 -> Foreign Scan on public.foo2 foo_1
Output: foo2.ctid, foo2.f1, foo2.*, foo2.tableoid Output: foo_1.ctid, foo_1.f1, foo_1.*, foo_1.tableoid
Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1 Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
-> Hash Join -> Hash Join
Output: bar2.f1, (bar2.f2 + 100), bar2.f3, bar2.ctid, foo.ctid, foo.*, foo.tableoid Output: bar_1.f1, (bar_1.f2 + 100), bar_1.f3, bar_1.ctid, foo.ctid, foo.*, foo.tableoid
Inner Unique: true Inner Unique: true
Hash Cond: (bar2.f1 = foo.f1) Hash Cond: (bar_1.f1 = foo.f1)
-> Foreign Scan on public.bar2 -> Foreign Scan on public.bar2 bar_1
Output: bar2.f1, bar2.f2, bar2.f3, bar2.ctid Output: bar_1.f1, bar_1.f2, bar_1.f3, bar_1.ctid
Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR UPDATE Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR UPDATE
-> Hash -> Hash
Output: foo.ctid, foo.f1, foo.*, foo.tableoid Output: foo.ctid, foo.f1, foo.*, foo.tableoid
...@@ -7170,8 +7170,8 @@ update bar set f2 = f2 + 100 where f1 in (select f1 from foo); ...@@ -7170,8 +7170,8 @@ update bar set f2 = f2 + 100 where f1 in (select f1 from foo);
-> Append -> Append
-> Seq Scan on public.foo -> Seq Scan on public.foo
Output: foo.ctid, foo.f1, foo.*, foo.tableoid Output: foo.ctid, foo.f1, foo.*, foo.tableoid
-> Foreign Scan on public.foo2 -> Foreign Scan on public.foo2 foo_1
Output: foo2.ctid, foo2.f1, foo2.*, foo2.tableoid Output: foo_1.ctid, foo_1.f1, foo_1.*, foo_1.tableoid
Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1 Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
(39 rows) (39 rows)
...@@ -7197,7 +7197,7 @@ where bar.f1 = ss.f1; ...@@ -7197,7 +7197,7 @@ where bar.f1 = ss.f1;
-------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------
Update on public.bar Update on public.bar
Update on public.bar Update on public.bar
Foreign Update on public.bar2 Foreign Update on public.bar2 bar_1
Remote SQL: UPDATE public.loct2 SET f2 = $2 WHERE ctid = $1 Remote SQL: UPDATE public.loct2 SET f2 = $2 WHERE ctid = $1
-> Hash Join -> Hash Join
Output: bar.f1, (bar.f2 + 100), bar.ctid, (ROW(foo.f1)) Output: bar.f1, (bar.f2 + 100), bar.ctid, (ROW(foo.f1))
...@@ -7205,26 +7205,26 @@ where bar.f1 = ss.f1; ...@@ -7205,26 +7205,26 @@ where bar.f1 = ss.f1;
-> Append -> Append
-> Seq Scan on public.foo -> Seq Scan on public.foo
Output: ROW(foo.f1), foo.f1 Output: ROW(foo.f1), foo.f1
-> Foreign Scan on public.foo2 -> Foreign Scan on public.foo2 foo_1
Output: ROW(foo2.f1), foo2.f1 Output: ROW(foo_1.f1), foo_1.f1
Remote SQL: SELECT f1 FROM public.loct1 Remote SQL: SELECT f1 FROM public.loct1
-> Seq Scan on public.foo foo_1 -> Seq Scan on public.foo foo_2
Output: ROW((foo_1.f1 + 3)), (foo_1.f1 + 3) Output: ROW((foo_2.f1 + 3)), (foo_2.f1 + 3)
-> Foreign Scan on public.foo2 foo2_1 -> Foreign Scan on public.foo2 foo_3
Output: ROW((foo2_1.f1 + 3)), (foo2_1.f1 + 3) Output: ROW((foo_3.f1 + 3)), (foo_3.f1 + 3)
Remote SQL: SELECT f1 FROM public.loct1 Remote SQL: SELECT f1 FROM public.loct1
-> Hash -> Hash
Output: bar.f1, bar.f2, bar.ctid Output: bar.f1, bar.f2, bar.ctid
-> Seq Scan on public.bar -> Seq Scan on public.bar
Output: bar.f1, bar.f2, bar.ctid Output: bar.f1, bar.f2, bar.ctid
-> Merge Join -> Merge Join
Output: bar2.f1, (bar2.f2 + 100), bar2.f3, bar2.ctid, (ROW(foo.f1)) Output: bar_1.f1, (bar_1.f2 + 100), bar_1.f3, bar_1.ctid, (ROW(foo.f1))
Merge Cond: (bar2.f1 = foo.f1) Merge Cond: (bar_1.f1 = foo.f1)
-> Sort -> Sort
Output: bar2.f1, bar2.f2, bar2.f3, bar2.ctid Output: bar_1.f1, bar_1.f2, bar_1.f3, bar_1.ctid
Sort Key: bar2.f1 Sort Key: bar_1.f1
-> Foreign Scan on public.bar2 -> Foreign Scan on public.bar2 bar_1
Output: bar2.f1, bar2.f2, bar2.f3, bar2.ctid Output: bar_1.f1, bar_1.f2, bar_1.f3, bar_1.ctid
Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR UPDATE Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR UPDATE
-> Sort -> Sort
Output: (ROW(foo.f1)), foo.f1 Output: (ROW(foo.f1)), foo.f1
...@@ -7232,13 +7232,13 @@ where bar.f1 = ss.f1; ...@@ -7232,13 +7232,13 @@ where bar.f1 = ss.f1;
-> Append -> Append
-> Seq Scan on public.foo -> Seq Scan on public.foo
Output: ROW(foo.f1), foo.f1 Output: ROW(foo.f1), foo.f1
-> Foreign Scan on public.foo2 -> Foreign Scan on public.foo2 foo_1
Output: ROW(foo2.f1), foo2.f1 Output: ROW(foo_1.f1), foo_1.f1
Remote SQL: SELECT f1 FROM public.loct1 Remote SQL: SELECT f1 FROM public.loct1
-> Seq Scan on public.foo foo_1 -> Seq Scan on public.foo foo_2
Output: ROW((foo_1.f1 + 3)), (foo_1.f1 + 3) Output: ROW((foo_2.f1 + 3)), (foo_2.f1 + 3)
-> Foreign Scan on public.foo2 foo2_1 -> Foreign Scan on public.foo2 foo_3
Output: ROW((foo2_1.f1 + 3)), (foo2_1.f1 + 3) Output: ROW((foo_3.f1 + 3)), (foo_3.f1 + 3)
Remote SQL: SELECT f1 FROM public.loct1 Remote SQL: SELECT f1 FROM public.loct1
(45 rows) (45 rows)
...@@ -7288,8 +7288,8 @@ explain (verbose, costs off) ...@@ -7288,8 +7288,8 @@ explain (verbose, costs off)
Sort Key: foo.f1 Sort Key: foo.f1
-> Index Scan using i_foo_f1 on public.foo -> Index Scan using i_foo_f1 on public.foo
Output: foo.f1, foo.f2 Output: foo.f1, foo.f2
-> Foreign Scan on public.foo2 -> Foreign Scan on public.foo2 foo_1
Output: foo2.f1, foo2.f2 Output: foo_1.f1, foo_1.f2
Remote SQL: SELECT f1, f2 FROM public.loct1 ORDER BY f1 ASC NULLS LAST Remote SQL: SELECT f1, f2 FROM public.loct1 ORDER BY f1 ASC NULLS LAST
-> Index Only Scan using i_loct1_f1 on public.loct1 -> Index Only Scan using i_loct1_f1 on public.loct1
Output: loct1.f1 Output: loct1.f1
...@@ -7328,8 +7328,8 @@ explain (verbose, costs off) ...@@ -7328,8 +7328,8 @@ explain (verbose, costs off)
Sort Key: foo.f1 Sort Key: foo.f1
-> Index Scan using i_foo_f1 on public.foo -> Index Scan using i_foo_f1 on public.foo
Output: foo.f1, foo.f2 Output: foo.f1, foo.f2
-> Foreign Scan on public.foo2 -> Foreign Scan on public.foo2 foo_1
Output: foo2.f1, foo2.f2 Output: foo_1.f1, foo_1.f2
Remote SQL: SELECT f1, f2 FROM public.loct1 ORDER BY f1 ASC NULLS LAST Remote SQL: SELECT f1, f2 FROM public.loct1 ORDER BY f1 ASC NULLS LAST
-> Index Only Scan using i_loct1_f1 on public.loct1 -> Index Only Scan using i_loct1_f1 on public.loct1
Output: loct1.f1 Output: loct1.f1
...@@ -7371,11 +7371,11 @@ delete from foo where f1 < 5 returning *; ...@@ -7371,11 +7371,11 @@ delete from foo where f1 < 5 returning *;
Delete on public.foo Delete on public.foo
Output: foo.f1, foo.f2 Output: foo.f1, foo.f2
Delete on public.foo Delete on public.foo
Foreign Delete on public.foo2 Foreign Delete on public.foo2 foo_1
-> Index Scan using i_foo_f1 on public.foo -> Index Scan using i_foo_f1 on public.foo
Output: foo.ctid Output: foo.ctid
Index Cond: (foo.f1 < 5) Index Cond: (foo.f1 < 5)
-> Foreign Delete on public.foo2 -> Foreign Delete on public.foo2 foo_1
Remote SQL: DELETE FROM public.loct1 WHERE ((f1 < 5)) RETURNING f1, f2 Remote SQL: DELETE FROM public.loct1 WHERE ((f1 < 5)) RETURNING f1, f2
(9 rows) (9 rows)
...@@ -7396,10 +7396,10 @@ update bar set f2 = f2 + 100 returning *; ...@@ -7396,10 +7396,10 @@ update bar set f2 = f2 + 100 returning *;
Update on public.bar Update on public.bar
Output: bar.f1, bar.f2 Output: bar.f1, bar.f2
Update on public.bar Update on public.bar
Foreign Update on public.bar2 Foreign Update on public.bar2 bar_1
-> Seq Scan on public.bar -> Seq Scan on public.bar
Output: bar.f1, (bar.f2 + 100), bar.ctid Output: bar.f1, (bar.f2 + 100), bar.ctid
-> Foreign Update on public.bar2 -> Foreign Update on public.bar2 bar_1
Remote SQL: UPDATE public.loct2 SET f2 = (f2 + 100) RETURNING f1, f2 Remote SQL: UPDATE public.loct2 SET f2 = (f2 + 100) RETURNING f1, f2
(8 rows) (8 rows)
...@@ -7427,12 +7427,12 @@ update bar set f2 = f2 + 100; ...@@ -7427,12 +7427,12 @@ update bar set f2 = f2 + 100;
-------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------------
Update on public.bar Update on public.bar
Update on public.bar Update on public.bar
Foreign Update on public.bar2 Foreign Update on public.bar2 bar_1
Remote SQL: UPDATE public.loct2 SET f1 = $2, f2 = $3, f3 = $4 WHERE ctid = $1 RETURNING f1, f2, f3 Remote SQL: UPDATE public.loct2 SET f1 = $2, f2 = $3, f3 = $4 WHERE ctid = $1 RETURNING f1, f2, f3
-> Seq Scan on public.bar -> Seq Scan on public.bar
Output: bar.f1, (bar.f2 + 100), bar.ctid Output: bar.f1, (bar.f2 + 100), bar.ctid
-> Foreign Scan on public.bar2 -> Foreign Scan on public.bar2 bar_1
Output: bar2.f1, (bar2.f2 + 100), bar2.f3, bar2.ctid, bar2.* Output: bar_1.f1, (bar_1.f2 + 100), bar_1.f3, bar_1.ctid, bar_1.*
Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR UPDATE Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR UPDATE
(9 rows) (9 rows)
...@@ -7455,13 +7455,13 @@ delete from bar where f2 < 400; ...@@ -7455,13 +7455,13 @@ delete from bar where f2 < 400;
--------------------------------------------------------------------------------------------- ---------------------------------------------------------------------------------------------
Delete on public.bar Delete on public.bar
Delete on public.bar Delete on public.bar
Foreign Delete on public.bar2 Foreign Delete on public.bar2 bar_1
Remote SQL: DELETE FROM public.loct2 WHERE ctid = $1 RETURNING f1, f2, f3 Remote SQL: DELETE FROM public.loct2 WHERE ctid = $1 RETURNING f1, f2, f3
-> Seq Scan on public.bar -> Seq Scan on public.bar
Output: bar.ctid Output: bar.ctid
Filter: (bar.f2 < 400) Filter: (bar.f2 < 400)
-> Foreign Scan on public.bar2 -> Foreign Scan on public.bar2 bar_1
Output: bar2.ctid, bar2.* Output: bar_1.ctid, bar_1.*
Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 WHERE ((f2 < 400)) FOR UPDATE Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 WHERE ((f2 < 400)) FOR UPDATE
(10 rows) (10 rows)
...@@ -7499,7 +7499,7 @@ update parent set b = parent.b || remt2.b from remt2 where parent.a = remt2.a re ...@@ -7499,7 +7499,7 @@ update parent set b = parent.b || remt2.b from remt2 where parent.a = remt2.a re
Update on public.parent Update on public.parent
Output: parent.a, parent.b, remt2.a, remt2.b Output: parent.a, parent.b, remt2.a, remt2.b
Update on public.parent Update on public.parent
Foreign Update on public.remt1 Foreign Update on public.remt1 parent_1
-> Nested Loop -> Nested Loop
Output: parent.a, (parent.b || remt2.b), parent.ctid, remt2.*, remt2.a, remt2.b Output: parent.a, (parent.b || remt2.b), parent.ctid, remt2.*, remt2.a, remt2.b
Join Filter: (parent.a = remt2.a) Join Filter: (parent.a = remt2.a)
...@@ -7526,7 +7526,7 @@ delete from parent using remt2 where parent.a = remt2.a returning parent; ...@@ -7526,7 +7526,7 @@ delete from parent using remt2 where parent.a = remt2.a returning parent;
Delete on public.parent Delete on public.parent
Output: parent.* Output: parent.*
Delete on public.parent Delete on public.parent
Foreign Delete on public.remt1 Foreign Delete on public.remt1 parent_1
-> Nested Loop -> Nested Loop
Output: parent.ctid, remt2.* Output: parent.ctid, remt2.*
Join Filter: (parent.a = remt2.a) Join Filter: (parent.a = remt2.a)
...@@ -7753,14 +7753,14 @@ update utrtest set a = 1 where a = 1 or a = 2 returning *; ...@@ -7753,14 +7753,14 @@ update utrtest set a = 1 where a = 1 or a = 2 returning *;
QUERY PLAN QUERY PLAN
---------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------
Update on public.utrtest Update on public.utrtest
Output: remp.a, remp.b Output: utrtest_1.a, utrtest_1.b
Foreign Update on public.remp Foreign Update on public.remp utrtest_1
Update on public.locp Update on public.locp utrtest_2
-> Foreign Update on public.remp -> Foreign Update on public.remp utrtest_1
Remote SQL: UPDATE public.loct SET a = 1 WHERE (((a = 1) OR (a = 2))) RETURNING a, b Remote SQL: UPDATE public.loct SET a = 1 WHERE (((a = 1) OR (a = 2))) RETURNING a, b
-> Seq Scan on public.locp -> Seq Scan on public.locp utrtest_2
Output: 1, locp.b, locp.ctid Output: 1, utrtest_2.b, utrtest_2.ctid
Filter: ((locp.a = 1) OR (locp.a = 2)) Filter: ((utrtest_2.a = 1) OR (utrtest_2.a = 2))
(9 rows) (9 rows)
-- The new values are concatenated with ' triggered !' -- The new values are concatenated with ' triggered !'
...@@ -7775,14 +7775,14 @@ insert into utrtest values (2, 'qux'); ...@@ -7775,14 +7775,14 @@ insert into utrtest values (2, 'qux');
-- Check case where the foreign partition isn't a subplan target rel -- Check case where the foreign partition isn't a subplan target rel
explain (verbose, costs off) explain (verbose, costs off)
update utrtest set a = 1 where a = 2 returning *; update utrtest set a = 1 where a = 2 returning *;
QUERY PLAN QUERY PLAN
-------------------------------------- ------------------------------------------------
Update on public.utrtest Update on public.utrtest
Output: locp.a, locp.b Output: utrtest_1.a, utrtest_1.b
Update on public.locp Update on public.locp utrtest_1
-> Seq Scan on public.locp -> Seq Scan on public.locp utrtest_1
Output: 1, locp.b, locp.ctid Output: 1, utrtest_1.b, utrtest_1.ctid
Filter: (locp.a = 2) Filter: (utrtest_1.a = 2)
(6 rows) (6 rows)
-- The new values are concatenated with ' triggered !' -- The new values are concatenated with ' triggered !'
...@@ -7805,13 +7805,13 @@ update utrtest set a = 1 returning *; ...@@ -7805,13 +7805,13 @@ update utrtest set a = 1 returning *;
QUERY PLAN QUERY PLAN
----------------------------------------------------------------- -----------------------------------------------------------------
Update on public.utrtest Update on public.utrtest
Output: remp.a, remp.b Output: utrtest_1.a, utrtest_1.b
Foreign Update on public.remp Foreign Update on public.remp utrtest_1
Update on public.locp Update on public.locp utrtest_2
-> Foreign Update on public.remp -> Foreign Update on public.remp utrtest_1
Remote SQL: UPDATE public.loct SET a = 1 RETURNING a, b Remote SQL: UPDATE public.loct SET a = 1 RETURNING a, b
-> Seq Scan on public.locp -> Seq Scan on public.locp utrtest_2
Output: 1, locp.b, locp.ctid Output: 1, utrtest_2.b, utrtest_2.ctid
(8 rows) (8 rows)
update utrtest set a = 1 returning *; update utrtest set a = 1 returning *;
...@@ -7827,28 +7827,28 @@ insert into utrtest values (2, 'qux'); ...@@ -7827,28 +7827,28 @@ insert into utrtest values (2, 'qux');
-- with a non-direct modification plan -- with a non-direct modification plan
explain (verbose, costs off) explain (verbose, costs off)
update utrtest set a = 1 from (values (1), (2)) s(x) where a = s.x returning *; update utrtest set a = 1 from (values (1), (2)) s(x) where a = s.x returning *;
QUERY PLAN QUERY PLAN
------------------------------------------------------------------------------ ----------------------------------------------------------------------------------
Update on public.utrtest Update on public.utrtest
Output: remp.a, remp.b, "*VALUES*".column1 Output: utrtest_1.a, utrtest_1.b, "*VALUES*".column1
Foreign Update on public.remp Foreign Update on public.remp utrtest_1
Remote SQL: UPDATE public.loct SET a = $2 WHERE ctid = $1 RETURNING a, b Remote SQL: UPDATE public.loct SET a = $2 WHERE ctid = $1 RETURNING a, b
Update on public.locp Update on public.locp utrtest_2
-> Hash Join -> Hash Join
Output: 1, remp.b, remp.ctid, "*VALUES*".*, "*VALUES*".column1 Output: 1, utrtest_1.b, utrtest_1.ctid, "*VALUES*".*, "*VALUES*".column1
Hash Cond: (remp.a = "*VALUES*".column1) Hash Cond: (utrtest_1.a = "*VALUES*".column1)
-> Foreign Scan on public.remp -> Foreign Scan on public.remp utrtest_1
Output: remp.b, remp.ctid, remp.a Output: utrtest_1.b, utrtest_1.ctid, utrtest_1.a
Remote SQL: SELECT a, b, ctid FROM public.loct FOR UPDATE Remote SQL: SELECT a, b, ctid FROM public.loct FOR UPDATE
-> Hash -> Hash
Output: "*VALUES*".*, "*VALUES*".column1 Output: "*VALUES*".*, "*VALUES*".column1
-> Values Scan on "*VALUES*" -> Values Scan on "*VALUES*"
Output: "*VALUES*".*, "*VALUES*".column1 Output: "*VALUES*".*, "*VALUES*".column1
-> Hash Join -> Hash Join
Output: 1, locp.b, locp.ctid, "*VALUES*".*, "*VALUES*".column1 Output: 1, utrtest_2.b, utrtest_2.ctid, "*VALUES*".*, "*VALUES*".column1
Hash Cond: (locp.a = "*VALUES*".column1) Hash Cond: (utrtest_2.a = "*VALUES*".column1)
-> Seq Scan on public.locp -> Seq Scan on public.locp utrtest_2
Output: locp.b, locp.ctid, locp.a Output: utrtest_2.b, utrtest_2.ctid, utrtest_2.a
-> Hash -> Hash
Output: "*VALUES*".*, "*VALUES*".column1 Output: "*VALUES*".*, "*VALUES*".column1
-> Values Scan on "*VALUES*" -> Values Scan on "*VALUES*"
...@@ -7880,12 +7880,12 @@ update utrtest set a = 3 returning *; ...@@ -7880,12 +7880,12 @@ update utrtest set a = 3 returning *;
QUERY PLAN QUERY PLAN
----------------------------------------------------------------- -----------------------------------------------------------------
Update on public.utrtest Update on public.utrtest
Output: locp.a, locp.b Output: utrtest_1.a, utrtest_1.b
Update on public.locp Update on public.locp utrtest_1
Foreign Update on public.remp Foreign Update on public.remp utrtest_2
-> Seq Scan on public.locp -> Seq Scan on public.locp utrtest_1
Output: 3, locp.b, locp.ctid Output: 3, utrtest_1.b, utrtest_1.ctid
-> Foreign Update on public.remp -> Foreign Update on public.remp utrtest_2
Remote SQL: UPDATE public.loct SET a = 3 RETURNING a, b Remote SQL: UPDATE public.loct SET a = 3 RETURNING a, b
(8 rows) (8 rows)
...@@ -7894,27 +7894,27 @@ ERROR: cannot route tuples into foreign table to be updated "remp" ...@@ -7894,27 +7894,27 @@ ERROR: cannot route tuples into foreign table to be updated "remp"
-- with a non-direct modification plan -- with a non-direct modification plan
explain (verbose, costs off) explain (verbose, costs off)
update utrtest set a = 3 from (values (2), (3)) s(x) where a = s.x returning *; update utrtest set a = 3 from (values (2), (3)) s(x) where a = s.x returning *;
QUERY PLAN QUERY PLAN
------------------------------------------------------------------------------ ----------------------------------------------------------------------------------
Update on public.utrtest Update on public.utrtest
Output: locp.a, locp.b, "*VALUES*".column1 Output: utrtest_1.a, utrtest_1.b, "*VALUES*".column1
Update on public.locp Update on public.locp utrtest_1
Foreign Update on public.remp Foreign Update on public.remp utrtest_2
Remote SQL: UPDATE public.loct SET a = $2 WHERE ctid = $1 RETURNING a, b Remote SQL: UPDATE public.loct SET a = $2 WHERE ctid = $1 RETURNING a, b
-> Hash Join -> Hash Join
Output: 3, locp.b, locp.ctid, "*VALUES*".*, "*VALUES*".column1 Output: 3, utrtest_1.b, utrtest_1.ctid, "*VALUES*".*, "*VALUES*".column1
Hash Cond: (locp.a = "*VALUES*".column1) Hash Cond: (utrtest_1.a = "*VALUES*".column1)
-> Seq Scan on public.locp -> Seq Scan on public.locp utrtest_1
Output: locp.b, locp.ctid, locp.a Output: utrtest_1.b, utrtest_1.ctid, utrtest_1.a
-> Hash -> Hash
Output: "*VALUES*".*, "*VALUES*".column1 Output: "*VALUES*".*, "*VALUES*".column1
-> Values Scan on "*VALUES*" -> Values Scan on "*VALUES*"
Output: "*VALUES*".*, "*VALUES*".column1 Output: "*VALUES*".*, "*VALUES*".column1
-> Hash Join -> Hash Join
Output: 3, remp.b, remp.ctid, "*VALUES*".*, "*VALUES*".column1 Output: 3, utrtest_2.b, utrtest_2.ctid, "*VALUES*".*, "*VALUES*".column1
Hash Cond: (remp.a = "*VALUES*".column1) Hash Cond: (utrtest_2.a = "*VALUES*".column1)
-> Foreign Scan on public.remp -> Foreign Scan on public.remp utrtest_2
Output: remp.b, remp.ctid, remp.a Output: utrtest_2.b, utrtest_2.ctid, utrtest_2.a
Remote SQL: SELECT a, b, ctid FROM public.loct FOR UPDATE Remote SQL: SELECT a, b, ctid FROM public.loct FOR UPDATE
-> Hash -> Hash
Output: "*VALUES*".*, "*VALUES*".column1 Output: "*VALUES*".*, "*VALUES*".column1
...@@ -8506,8 +8506,8 @@ SELECT t1.a,t2.b,t2.c FROM fprt1 t1 LEFT JOIN (SELECT * FROM fprt2 WHERE a < 10) ...@@ -8506,8 +8506,8 @@ SELECT t1.a,t2.b,t2.c FROM fprt1 t1 LEFT JOIN (SELECT * FROM fprt2 WHERE a < 10)
QUERY PLAN QUERY PLAN
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Foreign Scan Foreign Scan
Output: t1.a, ftprt2_p1.b, ftprt2_p1.c Output: t1.a, fprt2.b, fprt2.c
Relations: (public.ftprt1_p1 t1) LEFT JOIN (public.ftprt2_p1) Relations: (public.ftprt1_p1 t1) LEFT JOIN (public.ftprt2_p1 fprt2)
Remote SQL: SELECT r5.a, r6.b, r6.c FROM (public.fprt1_p1 r5 LEFT JOIN public.fprt2_p1 r6 ON (((r5.a = r6.b)) AND ((r5.b = r6.a)) AND ((r6.a < 10)))) WHERE ((r5.a < 10)) ORDER BY r5.a ASC NULLS LAST, r6.b ASC NULLS LAST, r6.c ASC NULLS LAST Remote SQL: SELECT r5.a, r6.b, r6.c FROM (public.fprt1_p1 r5 LEFT JOIN public.fprt2_p1 r6 ON (((r5.a = r6.b)) AND ((r5.b = r6.a)) AND ((r6.a < 10)))) WHERE ((r5.a < 10)) ORDER BY r5.a ASC NULLS LAST, r6.b ASC NULLS LAST, r6.c ASC NULLS LAST
(4 rows) (4 rows)
...@@ -8584,21 +8584,21 @@ SELECT t1.a,t1.b FROM fprt1 t1, LATERAL (SELECT t2.a, t2.b FROM fprt2 t2 WHERE t ...@@ -8584,21 +8584,21 @@ SELECT t1.a,t1.b FROM fprt1 t1, LATERAL (SELECT t2.a, t2.b FROM fprt2 t2 WHERE t
-- with PHVs, partitionwise join selected but no join pushdown -- with PHVs, partitionwise join selected but no join pushdown
EXPLAIN (COSTS OFF) EXPLAIN (COSTS OFF)
SELECT t1.a, t1.phv, t2.b, t2.phv FROM (SELECT 't1_phv' phv, * FROM fprt1 WHERE a % 25 = 0) t1 FULL JOIN (SELECT 't2_phv' phv, * FROM fprt2 WHERE b % 25 = 0) t2 ON (t1.a = t2.b) ORDER BY t1.a, t2.b; SELECT t1.a, t1.phv, t2.b, t2.phv FROM (SELECT 't1_phv' phv, * FROM fprt1 WHERE a % 25 = 0) t1 FULL JOIN (SELECT 't2_phv' phv, * FROM fprt2 WHERE b % 25 = 0) t2 ON (t1.a = t2.b) ORDER BY t1.a, t2.b;
QUERY PLAN QUERY PLAN
------------------------------------------------------ -----------------------------------------------------------
Sort Sort
Sort Key: ftprt1_p1.a, ftprt2_p1.b Sort Key: fprt1.a, fprt2.b
-> Append -> Append
-> Hash Full Join -> Hash Full Join
Hash Cond: (ftprt1_p1.a = ftprt2_p1.b) Hash Cond: (fprt1.a = fprt2.b)
-> Foreign Scan on ftprt1_p1 -> Foreign Scan on ftprt1_p1 fprt1
-> Hash -> Hash
-> Foreign Scan on ftprt2_p1 -> Foreign Scan on ftprt2_p1 fprt2
-> Hash Full Join -> Hash Full Join
Hash Cond: (ftprt1_p2.a = ftprt2_p2.b) Hash Cond: (fprt1_1.a = fprt2_1.b)
-> Foreign Scan on ftprt1_p2 -> Foreign Scan on ftprt1_p2 fprt1_1
-> Hash -> Hash
-> Foreign Scan on ftprt2_p2 -> Foreign Scan on ftprt2_p2 fprt2_1
(13 rows) (13 rows)
SELECT t1.a, t1.phv, t2.b, t2.phv FROM (SELECT 't1_phv' phv, * FROM fprt1 WHERE a % 25 = 0) t1 FULL JOIN (SELECT 't2_phv' phv, * FROM fprt2 WHERE b % 25 = 0) t2 ON (t1.a = t2.b) ORDER BY t1.a, t2.b; SELECT t1.a, t1.phv, t2.b, t2.phv FROM (SELECT 't1_phv' phv, * FROM fprt1 WHERE a % 25 = 0) t1 FULL JOIN (SELECT 't2_phv' phv, * FROM fprt2 WHERE b % 25 = 0) t2 ON (t1.a = t2.b) ORDER BY t1.a, t2.b;
...@@ -8672,34 +8672,34 @@ ANALYZE fpagg_tab_p3; ...@@ -8672,34 +8672,34 @@ ANALYZE fpagg_tab_p3;
SET enable_partitionwise_aggregate TO false; SET enable_partitionwise_aggregate TO false;
EXPLAIN (COSTS OFF) EXPLAIN (COSTS OFF)
SELECT a, sum(b), min(b), count(*) FROM pagg_tab GROUP BY a HAVING avg(b) < 22 ORDER BY 1; SELECT a, sum(b), min(b), count(*) FROM pagg_tab GROUP BY a HAVING avg(b) < 22 ORDER BY 1;
QUERY PLAN QUERY PLAN
------------------------------------------------------- -----------------------------------------------------------
Sort Sort
Sort Key: fpagg_tab_p1.a Sort Key: pagg_tab.a
-> HashAggregate -> HashAggregate
Group Key: fpagg_tab_p1.a Group Key: pagg_tab.a
Filter: (avg(fpagg_tab_p1.b) < '22'::numeric) Filter: (avg(pagg_tab.b) < '22'::numeric)
-> Append -> Append
-> Foreign Scan on fpagg_tab_p1 -> Foreign Scan on fpagg_tab_p1 pagg_tab
-> Foreign Scan on fpagg_tab_p2 -> Foreign Scan on fpagg_tab_p2 pagg_tab_1
-> Foreign Scan on fpagg_tab_p3 -> Foreign Scan on fpagg_tab_p3 pagg_tab_2
(9 rows) (9 rows)
-- Plan with partitionwise aggregates is enabled -- Plan with partitionwise aggregates is enabled
SET enable_partitionwise_aggregate TO true; SET enable_partitionwise_aggregate TO true;
EXPLAIN (COSTS OFF) EXPLAIN (COSTS OFF)
SELECT a, sum(b), min(b), count(*) FROM pagg_tab GROUP BY a HAVING avg(b) < 22 ORDER BY 1; SELECT a, sum(b), min(b), count(*) FROM pagg_tab GROUP BY a HAVING avg(b) < 22 ORDER BY 1;
QUERY PLAN QUERY PLAN
------------------------------------------------------------- ------------------------------------------------------------------------
Sort Sort
Sort Key: fpagg_tab_p1.a Sort Key: pagg_tab.a
-> Append -> Append
-> Foreign Scan -> Foreign Scan
Relations: Aggregate on (public.fpagg_tab_p1) Relations: Aggregate on (public.fpagg_tab_p1 pagg_tab)
-> Foreign Scan -> Foreign Scan
Relations: Aggregate on (public.fpagg_tab_p2) Relations: Aggregate on (public.fpagg_tab_p2 pagg_tab_1)
-> Foreign Scan -> Foreign Scan
Relations: Aggregate on (public.fpagg_tab_p3) Relations: Aggregate on (public.fpagg_tab_p3 pagg_tab_2)
(9 rows) (9 rows)
SELECT a, sum(b), min(b), count(*) FROM pagg_tab GROUP BY a HAVING avg(b) < 22 ORDER BY 1; SELECT a, sum(b), min(b), count(*) FROM pagg_tab GROUP BY a HAVING avg(b) < 22 ORDER BY 1;
...@@ -8760,23 +8760,23 @@ SELECT a, count(t1) FROM pagg_tab t1 GROUP BY a HAVING avg(b) < 22 ORDER BY 1; ...@@ -8760,23 +8760,23 @@ SELECT a, count(t1) FROM pagg_tab t1 GROUP BY a HAVING avg(b) < 22 ORDER BY 1;
-- When GROUP BY clause does not match with PARTITION KEY. -- When GROUP BY clause does not match with PARTITION KEY.
EXPLAIN (COSTS OFF) EXPLAIN (COSTS OFF)
SELECT b, avg(a), max(a), count(*) FROM pagg_tab GROUP BY b HAVING sum(a) < 700 ORDER BY 1; SELECT b, avg(a), max(a), count(*) FROM pagg_tab GROUP BY b HAVING sum(a) < 700 ORDER BY 1;
QUERY PLAN QUERY PLAN
------------------------------------------------------ -----------------------------------------------------------------
Sort Sort
Sort Key: fpagg_tab_p1.b Sort Key: pagg_tab.b
-> Finalize HashAggregate -> Finalize HashAggregate
Group Key: fpagg_tab_p1.b Group Key: pagg_tab.b
Filter: (sum(fpagg_tab_p1.a) < 700) Filter: (sum(pagg_tab.a) < 700)
-> Append -> Append
-> Partial HashAggregate -> Partial HashAggregate
Group Key: fpagg_tab_p1.b Group Key: pagg_tab.b
-> Foreign Scan on fpagg_tab_p1 -> Foreign Scan on fpagg_tab_p1 pagg_tab
-> Partial HashAggregate -> Partial HashAggregate
Group Key: fpagg_tab_p2.b Group Key: pagg_tab_1.b
-> Foreign Scan on fpagg_tab_p2 -> Foreign Scan on fpagg_tab_p2 pagg_tab_1
-> Partial HashAggregate -> Partial HashAggregate
Group Key: fpagg_tab_p3.b Group Key: pagg_tab_2.b
-> Foreign Scan on fpagg_tab_p3 -> Foreign Scan on fpagg_tab_p3 pagg_tab_2
(15 rows) (15 rows)
-- Clean-up -- Clean-up
......
src/backend/optimizer/util/inherit.c
View file @ 55a1954d
...@@ -421,10 +421,13 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte, ...@@ -421,10 +421,13 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
RangeTblEntry *childrte; RangeTblEntry *childrte;
Index childRTindex; Index childRTindex;
AppendRelInfo *appinfo; AppendRelInfo *appinfo;
TupleDesc child_tupdesc;
List *parent_colnames;
List *child_colnames;
/* /*
* Build an RTE for the child, and attach to query's rangetable list. We * Build an RTE for the child, and attach to query's rangetable list. We
* copy most fields of the parent's RTE, but replace relation OID, * copy most scalar fields of the parent's RTE, but replace relation OID,
* relkind, and inh for the child. Also, set requiredPerms to zero since * relkind, and inh for the child. Also, set requiredPerms to zero since
* all required permissions checks are done on the original RTE. Likewise, * all required permissions checks are done on the original RTE. Likewise,
* set the child's securityQuals to empty, because we only want to apply * set the child's securityQuals to empty, because we only want to apply
...@@ -432,10 +435,14 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte, ...@@ -432,10 +435,14 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
* individual children may have. (This is an intentional choice to make * individual children may have. (This is an intentional choice to make
* inherited RLS work like regular permissions checks.) The parent * inherited RLS work like regular permissions checks.) The parent
* securityQuals will be propagated to children along with other base * securityQuals will be propagated to children along with other base
* restriction clauses, so we don't need to do it here. * restriction clauses, so we don't need to do it here. Other
* infrastructure of the parent RTE has to be translated to match the
* child table's column ordering, which we do below, so a "flat" copy is
* sufficient to start with.
*/ */
childrte = copyObject(parentrte); childrte = makeNode(RangeTblEntry);
*childrte_p = childrte; memcpy(childrte, parentrte, sizeof(RangeTblEntry));
Assert(parentrte->rtekind == RTE_RELATION); /* else this is dubious */
childrte->relid = childOID; childrte->relid = childOID;
childrte->relkind = childrel->rd_rel->relkind; childrte->relkind = childrel->rd_rel->relkind;
/* A partitioned child will need to be expanded further. */ /* A partitioned child will need to be expanded further. */
...@@ -448,8 +455,11 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte, ...@@ -448,8 +455,11 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
childrte->inh = false; childrte->inh = false;
childrte->requiredPerms = 0; childrte->requiredPerms = 0;
childrte->securityQuals = NIL; childrte->securityQuals = NIL;
/* Link not-yet-fully-filled child RTE into data structures */
parse->rtable = lappend(parse->rtable, childrte); parse->rtable = lappend(parse->rtable, childrte);
childRTindex = list_length(parse->rtable); childRTindex = list_length(parse->rtable);
*childrte_p = childrte;
*childRTindex_p = childRTindex; *childRTindex_p = childRTindex;
/* /*
...@@ -459,10 +469,57 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte, ...@@ -459,10 +469,57 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
parentRTindex, childRTindex); parentRTindex, childRTindex);
root->append_rel_list = lappend(root->append_rel_list, appinfo); root->append_rel_list = lappend(root->append_rel_list, appinfo);
/* tablesample is probably null, but copy it */
childrte->tablesample = copyObject(parentrte->tablesample);
/*
* Construct an alias clause for the child, which we can also use as eref.
* This is important so that EXPLAIN will print the right column aliases
* for child-table columns. (Since ruleutils.c doesn't have any easy way
* to reassociate parent and child columns, we must get the child column
* aliases right to start with. Note that setting childrte->alias forces
* ruleutils.c to use these column names, which it otherwise would not.)
*/
child_tupdesc = RelationGetDescr(childrel);
parent_colnames = parentrte->eref->colnames;
child_colnames = NIL;
for (int cattno = 0; cattno < child_tupdesc->natts; cattno++)
{
Form_pg_attribute att = TupleDescAttr(child_tupdesc, cattno);
const char *attname;
if (att->attisdropped)
{
/* Always insert an empty string for a dropped column */
attname = "";
}
else if (appinfo->parent_colnos[cattno] > 0 &&
appinfo->parent_colnos[cattno] <= list_length(parent_colnames))
{
/* Duplicate the query-assigned name for the parent column */
attname = strVal(list_nth(parent_colnames,
appinfo->parent_colnos[cattno] - 1));
}
else
{
/* New column, just use its real name */
attname = NameStr(att->attname);
}
child_colnames = lappend(child_colnames, makeString(pstrdup(attname)));
}
/*
* We just duplicate the parent's table alias name for each child. If the
* plan gets printed, ruleutils.c has to sort out unique table aliases to
* use, which it can handle.
*/
childrte->alias = childrte->eref = makeAlias(parentrte->eref->aliasname,
child_colnames);
/* /*
* Translate the column permissions bitmaps to the child's attnums (we * Translate the column permissions bitmaps to the child's attnums (we
* have to build the translated_vars list before we can do this). But if * have to build the translated_vars list before we can do this). But if
* this is the parent table, we can leave copyObject's result alone. * this is the parent table, we can just duplicate the parent's bitmaps.
* *
* Note: we need to do this even though the executor won't run any * Note: we need to do this even though the executor won't run any
* permissions checks on the child RTE. The insertedCols/updatedCols * permissions checks on the child RTE. The insertedCols/updatedCols
...@@ -479,6 +536,13 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte, ...@@ -479,6 +536,13 @@ expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
childrte->extraUpdatedCols = translate_col_privs(parentrte->extraUpdatedCols, childrte->extraUpdatedCols = translate_col_privs(parentrte->extraUpdatedCols,
appinfo->translated_vars); appinfo->translated_vars);
} }
else
{
childrte->selectedCols = bms_copy(parentrte->selectedCols);
childrte->insertedCols = bms_copy(parentrte->insertedCols);
childrte->updatedCols = bms_copy(parentrte->updatedCols);
childrte->extraUpdatedCols = bms_copy(parentrte->extraUpdatedCols);
}
/* /*
* Store the RTE and appinfo in the respective PlannerInfo arrays, which * Store the RTE and appinfo in the respective PlannerInfo arrays, which
......
src/test/regress/expected/aggregates.out
View file @ 55a1954d
...@@ -998,8 +998,8 @@ insert into minmaxtest2 values(15), (16); ...@@ -998,8 +998,8 @@ insert into minmaxtest2 values(15), (16);
insert into minmaxtest3 values(17), (18); insert into minmaxtest3 values(17), (18);
explain (costs off) explain (costs off)
select min(f1), max(f1) from minmaxtest; select min(f1), max(f1) from minmaxtest;
QUERY PLAN QUERY PLAN
---------------------------------------------------------------------------------------------- ---------------------------------------------------------------------------------------------
Result Result
InitPlan 1 (returns $0) InitPlan 1 (returns $0)
-> Limit -> Limit
...@@ -1007,22 +1007,22 @@ explain (costs off) ...@@ -1007,22 +1007,22 @@ explain (costs off)
Sort Key: minmaxtest.f1 Sort Key: minmaxtest.f1
-> Index Only Scan using minmaxtesti on minmaxtest -> Index Only Scan using minmaxtesti on minmaxtest
Index Cond: (f1 IS NOT NULL) Index Cond: (f1 IS NOT NULL)
-> Index Only Scan using minmaxtest1i on minmaxtest1 -> Index Only Scan using minmaxtest1i on minmaxtest1 minmaxtest_1
Index Cond: (f1 IS NOT NULL) Index Cond: (f1 IS NOT NULL)
-> Index Only Scan Backward using minmaxtest2i on minmaxtest2 -> Index Only Scan Backward using minmaxtest2i on minmaxtest2 minmaxtest_2
Index Cond: (f1 IS NOT NULL) Index Cond: (f1 IS NOT NULL)
-> Index Only Scan using minmaxtest3i on minmaxtest3 -> Index Only Scan using minmaxtest3i on minmaxtest3 minmaxtest_3
InitPlan 2 (returns $1) InitPlan 2 (returns $1)
-> Limit -> Limit
-> Merge Append -> Merge Append
Sort Key: minmaxtest_1.f1 DESC Sort Key: minmaxtest_4.f1 DESC
-> Index Only Scan Backward using minmaxtesti on minmaxtest minmaxtest_1 -> Index Only Scan Backward using minmaxtesti on minmaxtest minmaxtest_4
Index Cond: (f1 IS NOT NULL) Index Cond: (f1 IS NOT NULL)
-> Index Only Scan Backward using minmaxtest1i on minmaxtest1 minmaxtest1_1 -> Index Only Scan Backward using minmaxtest1i on minmaxtest1 minmaxtest_5
Index Cond: (f1 IS NOT NULL) Index Cond: (f1 IS NOT NULL)
-> Index Only Scan using minmaxtest2i on minmaxtest2 minmaxtest2_1 -> Index Only Scan using minmaxtest2i on minmaxtest2 minmaxtest_6
Index Cond: (f1 IS NOT NULL) Index Cond: (f1 IS NOT NULL)
-> Index Only Scan Backward using minmaxtest3i on minmaxtest3 minmaxtest3_1 -> Index Only Scan Backward using minmaxtest3i on minmaxtest3 minmaxtest_7
(23 rows) (23 rows)
select min(f1), max(f1) from minmaxtest; select min(f1), max(f1) from minmaxtest;
...@@ -1034,8 +1034,8 @@ select min(f1), max(f1) from minmaxtest; ...@@ -1034,8 +1034,8 @@ select min(f1), max(f1) from minmaxtest;
-- DISTINCT doesn't do anything useful here, but it shouldn't fail -- DISTINCT doesn't do anything useful here, but it shouldn't fail
explain (costs off) explain (costs off)
select distinct min(f1), max(f1) from minmaxtest; select distinct min(f1), max(f1) from minmaxtest;
QUERY PLAN QUERY PLAN
---------------------------------------------------------------------------------------------- ---------------------------------------------------------------------------------------------
Unique Unique
InitPlan 1 (returns $0) InitPlan 1 (returns $0)
-> Limit -> Limit
...@@ -1043,22 +1043,22 @@ explain (costs off) ...@@ -1043,22 +1043,22 @@ explain (costs off)
Sort Key: minmaxtest.f1 Sort Key: minmaxtest.f1
-> Index Only Scan using minmaxtesti on minmaxtest -> Index Only Scan using minmaxtesti on minmaxtest
Index Cond: (f1 IS NOT NULL) Index Cond: (f1 IS NOT NULL)
-> Index Only Scan using minmaxtest1i on minmaxtest1 -> Index Only Scan using minmaxtest1i on minmaxtest1 minmaxtest_1
Index Cond: (f1 IS NOT NULL) Index Cond: (f1 IS NOT NULL)
-> Index Only Scan Backward using minmaxtest2i on minmaxtest2 -> Index Only Scan Backward using minmaxtest2i on minmaxtest2 minmaxtest_2
Index Cond: (f1 IS NOT NULL) Index Cond: (f1 IS NOT NULL)
-> Index Only Scan using minmaxtest3i on minmaxtest3 -> Index Only Scan using minmaxtest3i on minmaxtest3 minmaxtest_3
InitPlan 2 (returns $1) InitPlan 2 (returns $1)
-> Limit -> Limit
-> Merge Append -> Merge Append
Sort Key: minmaxtest_1.f1 DESC Sort Key: minmaxtest_4.f1 DESC
-> Index Only Scan Backward using minmaxtesti on minmaxtest minmaxtest_1 -> Index Only Scan Backward using minmaxtesti on minmaxtest minmaxtest_4
Index Cond: (f1 IS NOT NULL) Index Cond: (f1 IS NOT NULL)
-> Index Only Scan Backward using minmaxtest1i on minmaxtest1 minmaxtest1_1 -> Index Only Scan Backward using minmaxtest1i on minmaxtest1 minmaxtest_5
Index Cond: (f1 IS NOT NULL) Index Cond: (f1 IS NOT NULL)
-> Index Only Scan using minmaxtest2i on minmaxtest2 minmaxtest2_1 -> Index Only Scan using minmaxtest2i on minmaxtest2 minmaxtest_6
Index Cond: (f1 IS NOT NULL) Index Cond: (f1 IS NOT NULL)
-> Index Only Scan Backward using minmaxtest3i on minmaxtest3 minmaxtest3_1 -> Index Only Scan Backward using minmaxtest3i on minmaxtest3 minmaxtest_7
-> Sort -> Sort
Sort Key: ($0), ($1) Sort Key: ($0), ($1)
-> Result -> Result
...@@ -1156,7 +1156,7 @@ explain (costs off) select * from t1 group by a,b,c,d; ...@@ -1156,7 +1156,7 @@ explain (costs off) select * from t1 group by a,b,c,d;
Group Key: t1.a, t1.b, t1.c, t1.d Group Key: t1.a, t1.b, t1.c, t1.d
-> Append -> Append
-> Seq Scan on t1 -> Seq Scan on t1
-> Seq Scan on t1c -> Seq Scan on t1c t1_1
(5 rows) (5 rows)
-- Okay to remove columns if we're only querying the parent. -- Okay to remove columns if we're only querying the parent.
...@@ -1179,13 +1179,13 @@ create temp table p_t1_1 partition of p_t1 for values in(1); ...@@ -1179,13 +1179,13 @@ create temp table p_t1_1 partition of p_t1 for values in(1);
create temp table p_t1_2 partition of p_t1 for values in(2); create temp table p_t1_2 partition of p_t1 for values in(2);
-- Ensure we can remove non-PK columns for partitioned tables. -- Ensure we can remove non-PK columns for partitioned tables.
explain (costs off) select * from p_t1 group by a,b,c,d; explain (costs off) select * from p_t1 group by a,b,c,d;
QUERY PLAN QUERY PLAN
--------------------------------- ---------------------------------------
HashAggregate HashAggregate
Group Key: p_t1_1.a, p_t1_1.b Group Key: p_t1.a, p_t1.b
-> Append -> Append
-> Seq Scan on p_t1_1 -> Seq Scan on p_t1_1 p_t1
-> Seq Scan on p_t1_2 -> Seq Scan on p_t1_2 p_t1_1
(5 rows) (5 rows)
drop table t1 cascade; drop table t1 cascade;
......
src/test/regress/expected/alter_table.out
View file @ 55a1954d
...@@ -542,9 +542,9 @@ explain (costs off) select * from nv_parent where d between '2011-08-01' and '20 ...@@ -542,9 +542,9 @@ explain (costs off) select * from nv_parent where d between '2011-08-01' and '20
Append Append
-> Seq Scan on nv_parent -> Seq Scan on nv_parent
Filter: ((d >= '08-01-2011'::date) AND (d <= '08-31-2011'::date)) Filter: ((d >= '08-01-2011'::date) AND (d <= '08-31-2011'::date))
-> Seq Scan on nv_child_2010 -> Seq Scan on nv_child_2010 nv_parent_1
Filter: ((d >= '08-01-2011'::date) AND (d <= '08-31-2011'::date)) Filter: ((d >= '08-01-2011'::date) AND (d <= '08-31-2011'::date))
-> Seq Scan on nv_child_2011 -> Seq Scan on nv_child_2011 nv_parent_2
Filter: ((d >= '08-01-2011'::date) AND (d <= '08-31-2011'::date)) Filter: ((d >= '08-01-2011'::date) AND (d <= '08-31-2011'::date))
(7 rows) (7 rows)
...@@ -555,9 +555,9 @@ explain (costs off) select * from nv_parent where d between '2011-08-01'::date a ...@@ -555,9 +555,9 @@ explain (costs off) select * from nv_parent where d between '2011-08-01'::date a
Append Append
-> Seq Scan on nv_parent -> Seq Scan on nv_parent
Filter: ((d >= '08-01-2011'::date) AND (d <= '08-31-2011'::date)) Filter: ((d >= '08-01-2011'::date) AND (d <= '08-31-2011'::date))
-> Seq Scan on nv_child_2010 -> Seq Scan on nv_child_2010 nv_parent_1
Filter: ((d >= '08-01-2011'::date) AND (d <= '08-31-2011'::date)) Filter: ((d >= '08-01-2011'::date) AND (d <= '08-31-2011'::date))
-> Seq Scan on nv_child_2011 -> Seq Scan on nv_child_2011 nv_parent_2
Filter: ((d >= '08-01-2011'::date) AND (d <= '08-31-2011'::date)) Filter: ((d >= '08-01-2011'::date) AND (d <= '08-31-2011'::date))
(7 rows) (7 rows)
...@@ -567,11 +567,11 @@ explain (costs off) select * from nv_parent where d between '2009-08-01'::date a ...@@ -567,11 +567,11 @@ explain (costs off) select * from nv_parent where d between '2009-08-01'::date a
Append Append
-> Seq Scan on nv_parent -> Seq Scan on nv_parent
Filter: ((d >= '08-01-2009'::date) AND (d <= '08-31-2009'::date)) Filter: ((d >= '08-01-2009'::date) AND (d <= '08-31-2009'::date))
-> Seq Scan on nv_child_2010 -> Seq Scan on nv_child_2010 nv_parent_1
Filter: ((d >= '08-01-2009'::date) AND (d <= '08-31-2009'::date)) Filter: ((d >= '08-01-2009'::date) AND (d <= '08-31-2009'::date))
-> Seq Scan on nv_child_2011 -> Seq Scan on nv_child_2011 nv_parent_2
Filter: ((d >= '08-01-2009'::date) AND (d <= '08-31-2009'::date)) Filter: ((d >= '08-01-2009'::date) AND (d <= '08-31-2009'::date))
-> Seq Scan on nv_child_2009 -> Seq Scan on nv_child_2009 nv_parent_3
Filter: ((d >= '08-01-2009'::date) AND (d <= '08-31-2009'::date)) Filter: ((d >= '08-01-2009'::date) AND (d <= '08-31-2009'::date))
(9 rows) (9 rows)
...@@ -583,9 +583,9 @@ explain (costs off) select * from nv_parent where d between '2009-08-01'::date a ...@@ -583,9 +583,9 @@ explain (costs off) select * from nv_parent where d between '2009-08-01'::date a
Append Append
-> Seq Scan on nv_parent -> Seq Scan on nv_parent
Filter: ((d >= '08-01-2009'::date) AND (d <= '08-31-2009'::date)) Filter: ((d >= '08-01-2009'::date) AND (d <= '08-31-2009'::date))
-> Seq Scan on nv_child_2010 -> Seq Scan on nv_child_2010 nv_parent_1
Filter: ((d >= '08-01-2009'::date) AND (d <= '08-31-2009'::date)) Filter: ((d >= '08-01-2009'::date) AND (d <= '08-31-2009'::date))
-> Seq Scan on nv_child_2009 -> Seq Scan on nv_child_2009 nv_parent_2
Filter: ((d >= '08-01-2009'::date) AND (d <= '08-31-2009'::date)) Filter: ((d >= '08-01-2009'::date) AND (d <= '08-31-2009'::date))
(7 rows) (7 rows)
......
src/test/regress/expected/inherit.out
View file @ 55a1954d
...@@ -1332,17 +1332,17 @@ analyze patest1; ...@@ -1332,17 +1332,17 @@ analyze patest1;
analyze patest2; analyze patest2;
explain (costs off) explain (costs off)
select * from patest0 join (select f1 from int4_tbl limit 1) ss on id = f1; select * from patest0 join (select f1 from int4_tbl limit 1) ss on id = f1;
QUERY PLAN QUERY PLAN
-------------------------------------------------- ------------------------------------------------------------
Nested Loop Nested Loop
-> Limit -> Limit
-> Seq Scan on int4_tbl -> Seq Scan on int4_tbl
-> Append -> Append
-> Index Scan using patest0i on patest0 -> Index Scan using patest0i on patest0
Index Cond: (id = int4_tbl.f1) Index Cond: (id = int4_tbl.f1)
-> Index Scan using patest1i on patest1 -> Index Scan using patest1i on patest1 patest0_1
Index Cond: (id = int4_tbl.f1) Index Cond: (id = int4_tbl.f1)
-> Index Scan using patest2i on patest2 -> Index Scan using patest2i on patest2 patest0_2
Index Cond: (id = int4_tbl.f1) Index Cond: (id = int4_tbl.f1)
(10 rows) (10 rows)
...@@ -1357,17 +1357,17 @@ select * from patest0 join (select f1 from int4_tbl limit 1) ss on id = f1; ...@@ -1357,17 +1357,17 @@ select * from patest0 join (select f1 from int4_tbl limit 1) ss on id = f1;
drop index patest2i; drop index patest2i;
explain (costs off) explain (costs off)
select * from patest0 join (select f1 from int4_tbl limit 1) ss on id = f1; select * from patest0 join (select f1 from int4_tbl limit 1) ss on id = f1;
QUERY PLAN QUERY PLAN
-------------------------------------------------- ------------------------------------------------------------
Nested Loop Nested Loop
-> Limit -> Limit
-> Seq Scan on int4_tbl -> Seq Scan on int4_tbl
-> Append -> Append
-> Index Scan using patest0i on patest0 -> Index Scan using patest0i on patest0
Index Cond: (id = int4_tbl.f1) Index Cond: (id = int4_tbl.f1)
-> Index Scan using patest1i on patest1 -> Index Scan using patest1i on patest1 patest0_1
Index Cond: (id = int4_tbl.f1) Index Cond: (id = int4_tbl.f1)
-> Seq Scan on patest2 -> Seq Scan on patest2 patest0_2
Filter: (int4_tbl.f1 = id) Filter: (int4_tbl.f1 = id)
(10 rows) (10 rows)
...@@ -1415,12 +1415,12 @@ explain (verbose, costs off) select * from matest0 order by 1-id; ...@@ -1415,12 +1415,12 @@ explain (verbose, costs off) select * from matest0 order by 1-id;
-> Append -> Append
-> Seq Scan on public.matest0 -> Seq Scan on public.matest0
Output: matest0.id, matest0.name Output: matest0.id, matest0.name
-> Seq Scan on public.matest1 -> Seq Scan on public.matest1 matest0_1
Output: matest1.id, matest1.name Output: matest0_1.id, matest0_1.name
-> Seq Scan on public.matest2 -> Seq Scan on public.matest2 matest0_2
Output: matest2.id, matest2.name Output: matest0_2.id, matest0_2.name
-> Seq Scan on public.matest3 -> Seq Scan on public.matest3 matest0_3
Output: matest3.id, matest3.name Output: matest0_3.id, matest0_3.name
(14 rows) (14 rows)
select * from matest0 order by 1-id; select * from matest0 order by 1-id;
...@@ -1435,19 +1435,19 @@ select * from matest0 order by 1-id; ...@@ -1435,19 +1435,19 @@ select * from matest0 order by 1-id;
(6 rows) (6 rows)
explain (verbose, costs off) select min(1-id) from matest0; explain (verbose, costs off) select min(1-id) from matest0;
QUERY PLAN QUERY PLAN
---------------------------------------- --------------------------------------------------
Aggregate Aggregate
Output: min((1 - matest0.id)) Output: min((1 - matest0.id))
-> Append -> Append
-> Seq Scan on public.matest0 -> Seq Scan on public.matest0
Output: matest0.id Output: matest0.id
-> Seq Scan on public.matest1 -> Seq Scan on public.matest1 matest0_1
Output: matest1.id Output: matest0_1.id
-> Seq Scan on public.matest2 -> Seq Scan on public.matest2 matest0_2
Output: matest2.id Output: matest0_2.id
-> Seq Scan on public.matest3 -> Seq Scan on public.matest3 matest0_3
Output: matest3.id Output: matest0_3.id
(11 rows) (11 rows)
select min(1-id) from matest0; select min(1-id) from matest0;
...@@ -1460,21 +1460,21 @@ reset enable_indexscan; ...@@ -1460,21 +1460,21 @@ reset enable_indexscan;
set enable_seqscan = off; -- plan with fewest seqscans should be merge set enable_seqscan = off; -- plan with fewest seqscans should be merge
set enable_parallel_append = off; -- Don't let parallel-append interfere set enable_parallel_append = off; -- Don't let parallel-append interfere
explain (verbose, costs off) select * from matest0 order by 1-id; explain (verbose, costs off) select * from matest0 order by 1-id;
QUERY PLAN QUERY PLAN
------------------------------------------------------------------ ------------------------------------------------------------------------
Merge Append Merge Append
Sort Key: ((1 - matest0.id)) Sort Key: ((1 - matest0.id))
-> Index Scan using matest0i on public.matest0 -> Index Scan using matest0i on public.matest0
Output: matest0.id, matest0.name, (1 - matest0.id) Output: matest0.id, matest0.name, (1 - matest0.id)
-> Index Scan using matest1i on public.matest1 -> Index Scan using matest1i on public.matest1 matest0_1
Output: matest1.id, matest1.name, (1 - matest1.id) Output: matest0_1.id, matest0_1.name, (1 - matest0_1.id)
-> Sort -> Sort
Output: matest2.id, matest2.name, ((1 - matest2.id)) Output: matest0_2.id, matest0_2.name, ((1 - matest0_2.id))
Sort Key: ((1 - matest2.id)) Sort Key: ((1 - matest0_2.id))
-> Seq Scan on public.matest2 -> Seq Scan on public.matest2 matest0_2
Output: matest2.id, matest2.name, (1 - matest2.id) Output: matest0_2.id, matest0_2.name, (1 - matest0_2.id)
-> Index Scan using matest3i on public.matest3 -> Index Scan using matest3i on public.matest3 matest0_3
Output: matest3.id, matest3.name, (1 - matest3.id) Output: matest0_3.id, matest0_3.name, (1 - matest0_3.id)
(13 rows) (13 rows)
select * from matest0 order by 1-id; select * from matest0 order by 1-id;
...@@ -1489,8 +1489,8 @@ select * from matest0 order by 1-id; ...@@ -1489,8 +1489,8 @@ select * from matest0 order by 1-id;
(6 rows) (6 rows)
explain (verbose, costs off) select min(1-id) from matest0; explain (verbose, costs off) select min(1-id) from matest0;
QUERY PLAN QUERY PLAN
-------------------------------------------------------------------------- ---------------------------------------------------------------------------------
Result Result
Output: $0 Output: $0
InitPlan 1 (returns $0) InitPlan 1 (returns $0)
...@@ -1503,19 +1503,19 @@ explain (verbose, costs off) select min(1-id) from matest0; ...@@ -1503,19 +1503,19 @@ explain (verbose, costs off) select min(1-id) from matest0;
-> Index Scan using matest0i on public.matest0 -> Index Scan using matest0i on public.matest0
Output: matest0.id, (1 - matest0.id) Output: matest0.id, (1 - matest0.id)
Index Cond: ((1 - matest0.id) IS NOT NULL) Index Cond: ((1 - matest0.id) IS NOT NULL)
-> Index Scan using matest1i on public.matest1 -> Index Scan using matest1i on public.matest1 matest0_1
Output: matest1.id, (1 - matest1.id) Output: matest0_1.id, (1 - matest0_1.id)
Index Cond: ((1 - matest1.id) IS NOT NULL) Index Cond: ((1 - matest0_1.id) IS NOT NULL)
-> Sort -> Sort
Output: matest2.id, ((1 - matest2.id)) Output: matest0_2.id, ((1 - matest0_2.id))
Sort Key: ((1 - matest2.id)) Sort Key: ((1 - matest0_2.id))
-> Bitmap Heap Scan on public.matest2 -> Bitmap Heap Scan on public.matest2 matest0_2
Output: matest2.id, (1 - matest2.id) Output: matest0_2.id, (1 - matest0_2.id)
Filter: ((1 - matest2.id) IS NOT NULL) Filter: ((1 - matest0_2.id) IS NOT NULL)
-> Bitmap Index Scan on matest2_pkey -> Bitmap Index Scan on matest2_pkey
-> Index Scan using matest3i on public.matest3 -> Index Scan using matest3i on public.matest3 matest0_3
Output: matest3.id, (1 - matest3.id) Output: matest0_3.id, (1 - matest0_3.id)
Index Cond: ((1 - matest3.id) IS NOT NULL) Index Cond: ((1 - matest0_3.id) IS NOT NULL)
(25 rows) (25 rows)
select min(1-id) from matest0; select min(1-id) from matest0;
...@@ -1780,30 +1780,30 @@ create table part_ab_cd partition of list_parted for values in ('ab', 'cd'); ...@@ -1780,30 +1780,30 @@ create table part_ab_cd partition of list_parted for values in ('ab', 'cd');
create table part_ef_gh partition of list_parted for values in ('ef', 'gh'); create table part_ef_gh partition of list_parted for values in ('ef', 'gh');
create table part_null_xy partition of list_parted for values in (null, 'xy'); create table part_null_xy partition of list_parted for values in (null, 'xy');
explain (costs off) select * from list_parted; explain (costs off) select * from list_parted;
QUERY PLAN QUERY PLAN
-------------------------------- ----------------------------------------------
Append Append
-> Seq Scan on part_ab_cd -> Seq Scan on part_ab_cd list_parted
-> Seq Scan on part_ef_gh -> Seq Scan on part_ef_gh list_parted_1
-> Seq Scan on part_null_xy -> Seq Scan on part_null_xy list_parted_2
(4 rows) (4 rows)
explain (costs off) select * from list_parted where a is null; explain (costs off) select * from list_parted where a is null;
QUERY PLAN QUERY PLAN
-------------------------- --------------------------------------
Seq Scan on part_null_xy Seq Scan on part_null_xy list_parted
Filter: (a IS NULL) Filter: (a IS NULL)
(2 rows) (2 rows)
explain (costs off) select * from list_parted where a is not null; explain (costs off) select * from list_parted where a is not null;
QUERY PLAN QUERY PLAN
--------------------------------- ----------------------------------------------
Append Append
-> Seq Scan on part_ab_cd -> Seq Scan on part_ab_cd list_parted
Filter: (a IS NOT NULL) Filter: (a IS NOT NULL)
-> Seq Scan on part_ef_gh -> Seq Scan on part_ef_gh list_parted_1
Filter: (a IS NOT NULL) Filter: (a IS NOT NULL)
-> Seq Scan on part_null_xy -> Seq Scan on part_null_xy list_parted_2
Filter: (a IS NOT NULL) Filter: (a IS NOT NULL)
(7 rows) (7 rows)
...@@ -1811,23 +1811,23 @@ explain (costs off) select * from list_parted where a in ('ab', 'cd', 'ef'); ...@@ -1811,23 +1811,23 @@ explain (costs off) select * from list_parted where a in ('ab', 'cd', 'ef');
QUERY PLAN QUERY PLAN
---------------------------------------------------------- ----------------------------------------------------------
Append Append
-> Seq Scan on part_ab_cd -> Seq Scan on part_ab_cd list_parted
Filter: ((a)::text = ANY ('{ab,cd,ef}'::text[])) Filter: ((a)::text = ANY ('{ab,cd,ef}'::text[]))
-> Seq Scan on part_ef_gh -> Seq Scan on part_ef_gh list_parted_1
Filter: ((a)::text = ANY ('{ab,cd,ef}'::text[])) Filter: ((a)::text = ANY ('{ab,cd,ef}'::text[]))
(5 rows) (5 rows)
explain (costs off) select * from list_parted where a = 'ab' or a in (null, 'cd'); explain (costs off) select * from list_parted where a = 'ab' or a in (null, 'cd');
QUERY PLAN QUERY PLAN
--------------------------------------------------------------------------------- ---------------------------------------------------------------------------------
Seq Scan on part_ab_cd Seq Scan on part_ab_cd list_parted
Filter: (((a)::text = 'ab'::text) OR ((a)::text = ANY ('{NULL,cd}'::text[]))) Filter: (((a)::text = 'ab'::text) OR ((a)::text = ANY ('{NULL,cd}'::text[])))
(2 rows) (2 rows)
explain (costs off) select * from list_parted where a = 'ab'; explain (costs off) select * from list_parted where a = 'ab';
QUERY PLAN QUERY PLAN
------------------------------------ ------------------------------------
Seq Scan on part_ab_cd Seq Scan on part_ab_cd list_parted
Filter: ((a)::text = 'ab'::text) Filter: ((a)::text = 'ab'::text)
(2 rows) (2 rows)
...@@ -1849,41 +1849,41 @@ create table part_40_inf_ab partition of part_40_inf for values in ('ab'); ...@@ -1849,41 +1849,41 @@ create table part_40_inf_ab partition of part_40_inf for values in ('ab');
create table part_40_inf_cd partition of part_40_inf for values in ('cd'); create table part_40_inf_cd partition of part_40_inf for values in ('cd');
create table part_40_inf_null partition of part_40_inf for values in (null); create table part_40_inf_null partition of part_40_inf for values in (null);
explain (costs off) select * from range_list_parted; explain (costs off) select * from range_list_parted;
QUERY PLAN QUERY PLAN
------------------------------------ --------------------------------------------------------
Append Append
-> Seq Scan on part_1_10_ab -> Seq Scan on part_1_10_ab range_list_parted
-> Seq Scan on part_1_10_cd -> Seq Scan on part_1_10_cd range_list_parted_1
-> Seq Scan on part_10_20_ab -> Seq Scan on part_10_20_ab range_list_parted_2
-> Seq Scan on part_10_20_cd -> Seq Scan on part_10_20_cd range_list_parted_3
-> Seq Scan on part_21_30_ab -> Seq Scan on part_21_30_ab range_list_parted_4
-> Seq Scan on part_21_30_cd -> Seq Scan on part_21_30_cd range_list_parted_5
-> Seq Scan on part_40_inf_ab -> Seq Scan on part_40_inf_ab range_list_parted_6
-> Seq Scan on part_40_inf_cd -> Seq Scan on part_40_inf_cd range_list_parted_7
-> Seq Scan on part_40_inf_null -> Seq Scan on part_40_inf_null range_list_parted_8
(10 rows) (10 rows)
explain (costs off) select * from range_list_parted where a = 5; explain (costs off) select * from range_list_parted where a = 5;
QUERY PLAN QUERY PLAN
-------------------------------- ----------------------------------------------------
Append Append
-> Seq Scan on part_1_10_ab -> Seq Scan on part_1_10_ab range_list_parted
Filter: (a = 5) Filter: (a = 5)
-> Seq Scan on part_1_10_cd -> Seq Scan on part_1_10_cd range_list_parted_1
Filter: (a = 5) Filter: (a = 5)
(5 rows) (5 rows)
explain (costs off) select * from range_list_parted where b = 'ab'; explain (costs off) select * from range_list_parted where b = 'ab';
QUERY PLAN QUERY PLAN
------------------------------------ ------------------------------------------------------
Append Append
-> Seq Scan on part_1_10_ab -> Seq Scan on part_1_10_ab range_list_parted
Filter: (b = 'ab'::bpchar) Filter: (b = 'ab'::bpchar)
-> Seq Scan on part_10_20_ab -> Seq Scan on part_10_20_ab range_list_parted_1
Filter: (b = 'ab'::bpchar) Filter: (b = 'ab'::bpchar)
-> Seq Scan on part_21_30_ab -> Seq Scan on part_21_30_ab range_list_parted_2
Filter: (b = 'ab'::bpchar) Filter: (b = 'ab'::bpchar)
-> Seq Scan on part_40_inf_ab -> Seq Scan on part_40_inf_ab range_list_parted_3
Filter: (b = 'ab'::bpchar) Filter: (b = 'ab'::bpchar)
(9 rows) (9 rows)
...@@ -1891,11 +1891,11 @@ explain (costs off) select * from range_list_parted where a between 3 and 23 and ...@@ -1891,11 +1891,11 @@ explain (costs off) select * from range_list_parted where a between 3 and 23 and
QUERY PLAN QUERY PLAN
----------------------------------------------------------------- -----------------------------------------------------------------
Append Append
-> Seq Scan on part_1_10_ab -> Seq Scan on part_1_10_ab range_list_parted
Filter: ((a >= 3) AND (a <= 23) AND (b = 'ab'::bpchar)) Filter: ((a >= 3) AND (a <= 23) AND (b = 'ab'::bpchar))
-> Seq Scan on part_10_20_ab -> Seq Scan on part_10_20_ab range_list_parted_1
Filter: ((a >= 3) AND (a <= 23) AND (b = 'ab'::bpchar)) Filter: ((a >= 3) AND (a <= 23) AND (b = 'ab'::bpchar))
-> Seq Scan on part_21_30_ab -> Seq Scan on part_21_30_ab range_list_parted_2
Filter: ((a >= 3) AND (a <= 23) AND (b = 'ab'::bpchar)) Filter: ((a >= 3) AND (a <= 23) AND (b = 'ab'::bpchar))
(7 rows) (7 rows)
...@@ -1909,45 +1909,45 @@ explain (costs off) select * from range_list_parted where a is null; ...@@ -1909,45 +1909,45 @@ explain (costs off) select * from range_list_parted where a is null;
/* Should only select rows from the null-accepting partition */ /* Should only select rows from the null-accepting partition */
explain (costs off) select * from range_list_parted where b is null; explain (costs off) select * from range_list_parted where b is null;
QUERY PLAN QUERY PLAN
------------------------------ ------------------------------------------------
Seq Scan on part_40_inf_null Seq Scan on part_40_inf_null range_list_parted
Filter: (b IS NULL) Filter: (b IS NULL)
(2 rows) (2 rows)
explain (costs off) select * from range_list_parted where a is not null and a < 67; explain (costs off) select * from range_list_parted where a is not null and a < 67;
QUERY PLAN QUERY PLAN
------------------------------------------------ --------------------------------------------------------
Append Append
-> Seq Scan on part_1_10_ab -> Seq Scan on part_1_10_ab range_list_parted
Filter: ((a IS NOT NULL) AND (a < 67)) Filter: ((a IS NOT NULL) AND (a < 67))
-> Seq Scan on part_1_10_cd -> Seq Scan on part_1_10_cd range_list_parted_1
Filter: ((a IS NOT NULL) AND (a < 67)) Filter: ((a IS NOT NULL) AND (a < 67))
-> Seq Scan on part_10_20_ab -> Seq Scan on part_10_20_ab range_list_parted_2
Filter: ((a IS NOT NULL) AND (a < 67)) Filter: ((a IS NOT NULL) AND (a < 67))
-> Seq Scan on part_10_20_cd -> Seq Scan on part_10_20_cd range_list_parted_3
Filter: ((a IS NOT NULL) AND (a < 67)) Filter: ((a IS NOT NULL) AND (a < 67))
-> Seq Scan on part_21_30_ab -> Seq Scan on part_21_30_ab range_list_parted_4
Filter: ((a IS NOT NULL) AND (a < 67)) Filter: ((a IS NOT NULL) AND (a < 67))
-> Seq Scan on part_21_30_cd -> Seq Scan on part_21_30_cd range_list_parted_5
Filter: ((a IS NOT NULL) AND (a < 67)) Filter: ((a IS NOT NULL) AND (a < 67))
-> Seq Scan on part_40_inf_ab -> Seq Scan on part_40_inf_ab range_list_parted_6
Filter: ((a IS NOT NULL) AND (a < 67)) Filter: ((a IS NOT NULL) AND (a < 67))
-> Seq Scan on part_40_inf_cd -> Seq Scan on part_40_inf_cd range_list_parted_7
Filter: ((a IS NOT NULL) AND (a < 67)) Filter: ((a IS NOT NULL) AND (a < 67))
-> Seq Scan on part_40_inf_null -> Seq Scan on part_40_inf_null range_list_parted_8
Filter: ((a IS NOT NULL) AND (a < 67)) Filter: ((a IS NOT NULL) AND (a < 67))
(19 rows) (19 rows)
explain (costs off) select * from range_list_parted where a >= 30; explain (costs off) select * from range_list_parted where a >= 30;
QUERY PLAN QUERY PLAN
------------------------------------ --------------------------------------------------------
Append Append
-> Seq Scan on part_40_inf_ab -> Seq Scan on part_40_inf_ab range_list_parted
Filter: (a >= 30) Filter: (a >= 30)
-> Seq Scan on part_40_inf_cd -> Seq Scan on part_40_inf_cd range_list_parted_1
Filter: (a >= 30) Filter: (a >= 30)
-> Seq Scan on part_40_inf_null -> Seq Scan on part_40_inf_null range_list_parted_2
Filter: (a >= 30) Filter: (a >= 30)
(7 rows) (7 rows)
...@@ -1964,12 +1964,12 @@ create table mcrparted3 partition of mcrparted for values from (11, 1, 1) to (20 ...@@ -1964,12 +1964,12 @@ create table mcrparted3 partition of mcrparted for values from (11, 1, 1) to (20
create table mcrparted4 partition of mcrparted for values from (20, 10, 10) to (20, 20, 20); create table mcrparted4 partition of mcrparted for values from (20, 10, 10) to (20, 20, 20);
create table mcrparted5 partition of mcrparted for values from (20, 20, 20) to (maxvalue, maxvalue, maxvalue); create table mcrparted5 partition of mcrparted for values from (20, 20, 20) to (maxvalue, maxvalue, maxvalue);
explain (costs off) select * from mcrparted where a = 0; -- scans mcrparted0, mcrparted_def explain (costs off) select * from mcrparted where a = 0; -- scans mcrparted0, mcrparted_def
QUERY PLAN QUERY PLAN
--------------------------------- ---------------------------------------------
Append Append
-> Seq Scan on mcrparted0 -> Seq Scan on mcrparted0 mcrparted
Filter: (a = 0) Filter: (a = 0)
-> Seq Scan on mcrparted_def -> Seq Scan on mcrparted_def mcrparted_1
Filter: (a = 0) Filter: (a = 0)
(5 rows) (5 rows)
...@@ -1977,9 +1977,9 @@ explain (costs off) select * from mcrparted where a = 10 and abs(b) < 5; -- scan ...@@ -1977,9 +1977,9 @@ explain (costs off) select * from mcrparted where a = 10 and abs(b) < 5; -- scan
QUERY PLAN QUERY PLAN
--------------------------------------------- ---------------------------------------------
Append Append
-> Seq Scan on mcrparted1 -> Seq Scan on mcrparted1 mcrparted
Filter: ((a = 10) AND (abs(b) < 5)) Filter: ((a = 10) AND (abs(b) < 5))
-> Seq Scan on mcrparted_def -> Seq Scan on mcrparted_def mcrparted_1
Filter: ((a = 10) AND (abs(b) < 5)) Filter: ((a = 10) AND (abs(b) < 5))
(5 rows) (5 rows)
...@@ -1987,72 +1987,72 @@ explain (costs off) select * from mcrparted where a = 10 and abs(b) = 5; -- scan ...@@ -1987,72 +1987,72 @@ explain (costs off) select * from mcrparted where a = 10 and abs(b) = 5; -- scan
QUERY PLAN QUERY PLAN
--------------------------------------------- ---------------------------------------------
Append Append
-> Seq Scan on mcrparted1 -> Seq Scan on mcrparted1 mcrparted
Filter: ((a = 10) AND (abs(b) = 5)) Filter: ((a = 10) AND (abs(b) = 5))
-> Seq Scan on mcrparted2 -> Seq Scan on mcrparted2 mcrparted_1
Filter: ((a = 10) AND (abs(b) = 5)) Filter: ((a = 10) AND (abs(b) = 5))
-> Seq Scan on mcrparted_def -> Seq Scan on mcrparted_def mcrparted_2
Filter: ((a = 10) AND (abs(b) = 5)) Filter: ((a = 10) AND (abs(b) = 5))
(7 rows) (7 rows)
explain (costs off) select * from mcrparted where abs(b) = 5; -- scans all partitions explain (costs off) select * from mcrparted where abs(b) = 5; -- scans all partitions
QUERY PLAN QUERY PLAN
--------------------------------- ---------------------------------------------
Append Append
-> Seq Scan on mcrparted0 -> Seq Scan on mcrparted0 mcrparted
Filter: (abs(b) = 5) Filter: (abs(b) = 5)
-> Seq Scan on mcrparted1 -> Seq Scan on mcrparted1 mcrparted_1
Filter: (abs(b) = 5) Filter: (abs(b) = 5)
-> Seq Scan on mcrparted2 -> Seq Scan on mcrparted2 mcrparted_2
Filter: (abs(b) = 5) Filter: (abs(b) = 5)
-> Seq Scan on mcrparted3 -> Seq Scan on mcrparted3 mcrparted_3
Filter: (abs(b) = 5) Filter: (abs(b) = 5)
-> Seq Scan on mcrparted4 -> Seq Scan on mcrparted4 mcrparted_4
Filter: (abs(b) = 5) Filter: (abs(b) = 5)
-> Seq Scan on mcrparted5 -> Seq Scan on mcrparted5 mcrparted_5
Filter: (abs(b) = 5) Filter: (abs(b) = 5)
-> Seq Scan on mcrparted_def -> Seq Scan on mcrparted_def mcrparted_6
Filter: (abs(b) = 5) Filter: (abs(b) = 5)
(15 rows) (15 rows)
explain (costs off) select * from mcrparted where a > -1; -- scans all partitions explain (costs off) select * from mcrparted where a > -1; -- scans all partitions
QUERY PLAN QUERY PLAN
------------------------------------- ---------------------------------------------
Append Append
-> Seq Scan on mcrparted0 -> Seq Scan on mcrparted0 mcrparted
Filter: (a > '-1'::integer) Filter: (a > '-1'::integer)
-> Seq Scan on mcrparted1 -> Seq Scan on mcrparted1 mcrparted_1
Filter: (a > '-1'::integer) Filter: (a > '-1'::integer)
-> Seq Scan on mcrparted2 -> Seq Scan on mcrparted2 mcrparted_2
Filter: (a > '-1'::integer) Filter: (a > '-1'::integer)
-> Seq Scan on mcrparted3 -> Seq Scan on mcrparted3 mcrparted_3
Filter: (a > '-1'::integer) Filter: (a > '-1'::integer)
-> Seq Scan on mcrparted4 -> Seq Scan on mcrparted4 mcrparted_4
Filter: (a > '-1'::integer) Filter: (a > '-1'::integer)
-> Seq Scan on mcrparted5 -> Seq Scan on mcrparted5 mcrparted_5
Filter: (a > '-1'::integer) Filter: (a > '-1'::integer)
-> Seq Scan on mcrparted_def -> Seq Scan on mcrparted_def mcrparted_6
Filter: (a > '-1'::integer) Filter: (a > '-1'::integer)
(15 rows) (15 rows)
explain (costs off) select * from mcrparted where a = 20 and abs(b) = 10 and c > 10; -- scans mcrparted4 explain (costs off) select * from mcrparted where a = 20 and abs(b) = 10 and c > 10; -- scans mcrparted4
QUERY PLAN QUERY PLAN
----------------------------------------------------- -----------------------------------------------------
Seq Scan on mcrparted4 Seq Scan on mcrparted4 mcrparted
Filter: ((c > 10) AND (a = 20) AND (abs(b) = 10)) Filter: ((c > 10) AND (a = 20) AND (abs(b) = 10))
(2 rows) (2 rows)
explain (costs off) select * from mcrparted where a = 20 and c > 20; -- scans mcrparted3, mcrparte4, mcrparte5, mcrparted_def explain (costs off) select * from mcrparted where a = 20 and c > 20; -- scans mcrparted3, mcrparte4, mcrparte5, mcrparted_def
QUERY PLAN QUERY PLAN
----------------------------------------- ---------------------------------------------
Append Append
-> Seq Scan on mcrparted3 -> Seq Scan on mcrparted3 mcrparted
Filter: ((c > 20) AND (a = 20)) Filter: ((c > 20) AND (a = 20))
-> Seq Scan on mcrparted4 -> Seq Scan on mcrparted4 mcrparted_1
Filter: ((c > 20) AND (a = 20)) Filter: ((c > 20) AND (a = 20))
-> Seq Scan on mcrparted5 -> Seq Scan on mcrparted5 mcrparted_2
Filter: ((c > 20) AND (a = 20)) Filter: ((c > 20) AND (a = 20))
-> Seq Scan on mcrparted_def -> Seq Scan on mcrparted_def mcrparted_3
Filter: ((c > 20) AND (a = 20)) Filter: ((c > 20) AND (a = 20))
(9 rows) (9 rows)
...@@ -2063,16 +2063,16 @@ create table parted_minmax1 partition of parted_minmax for values from (1) to (1 ...@@ -2063,16 +2063,16 @@ create table parted_minmax1 partition of parted_minmax for values from (1) to (1
create index parted_minmax1i on parted_minmax1 (a, b); create index parted_minmax1i on parted_minmax1 (a, b);
insert into parted_minmax values (1,'12345'); insert into parted_minmax values (1,'12345');
explain (costs off) select min(a), max(a) from parted_minmax where b = '12345'; explain (costs off) select min(a), max(a) from parted_minmax where b = '12345';
QUERY PLAN QUERY PLAN
------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------
Result Result
InitPlan 1 (returns $0) InitPlan 1 (returns $0)
-> Limit -> Limit
-> Index Only Scan using parted_minmax1i on parted_minmax1 -> Index Only Scan using parted_minmax1i on parted_minmax1 parted_minmax
Index Cond: ((a IS NOT NULL) AND (b = '12345'::text)) Index Cond: ((a IS NOT NULL) AND (b = '12345'::text))
InitPlan 2 (returns $1) InitPlan 2 (returns $1)
-> Limit -> Limit
-> Index Only Scan Backward using parted_minmax1i on parted_minmax1 parted_minmax1_1 -> Index Only Scan Backward using parted_minmax1i on parted_minmax1 parted_minmax_1
Index Cond: ((a IS NOT NULL) AND (b = '12345'::text)) Index Cond: ((a IS NOT NULL) AND (b = '12345'::text))
(9 rows) (9 rows)
...@@ -2088,45 +2088,45 @@ drop table parted_minmax; ...@@ -2088,45 +2088,45 @@ drop table parted_minmax;
create index mcrparted_a_abs_c_idx on mcrparted (a, abs(b), c); create index mcrparted_a_abs_c_idx on mcrparted (a, abs(b), c);
-- MergeAppend must be used when a default partition exists -- MergeAppend must be used when a default partition exists
explain (costs off) select * from mcrparted order by a, abs(b), c; explain (costs off) select * from mcrparted order by a, abs(b), c;
QUERY PLAN QUERY PLAN
------------------------------------------------------------------- -------------------------------------------------------------------------------
Merge Append Merge Append
Sort Key: mcrparted0.a, (abs(mcrparted0.b)), mcrparted0.c Sort Key: mcrparted.a, (abs(mcrparted.b)), mcrparted.c
-> Index Scan using mcrparted0_a_abs_c_idx on mcrparted0 -> Index Scan using mcrparted0_a_abs_c_idx on mcrparted0 mcrparted
-> Index Scan using mcrparted1_a_abs_c_idx on mcrparted1 -> Index Scan using mcrparted1_a_abs_c_idx on mcrparted1 mcrparted_1
-> Index Scan using mcrparted2_a_abs_c_idx on mcrparted2 -> Index Scan using mcrparted2_a_abs_c_idx on mcrparted2 mcrparted_2
-> Index Scan using mcrparted3_a_abs_c_idx on mcrparted3 -> Index Scan using mcrparted3_a_abs_c_idx on mcrparted3 mcrparted_3
-> Index Scan using mcrparted4_a_abs_c_idx on mcrparted4 -> Index Scan using mcrparted4_a_abs_c_idx on mcrparted4 mcrparted_4
-> Index Scan using mcrparted5_a_abs_c_idx on mcrparted5 -> Index Scan using mcrparted5_a_abs_c_idx on mcrparted5 mcrparted_5
-> Index Scan using mcrparted_def_a_abs_c_idx on mcrparted_def -> Index Scan using mcrparted_def_a_abs_c_idx on mcrparted_def mcrparted_6
(9 rows) (9 rows)
drop table mcrparted_def; drop table mcrparted_def;
-- Append is used for a RANGE partitioned table with no default -- Append is used for a RANGE partitioned table with no default
-- and no subpartitions -- and no subpartitions
explain (costs off) select * from mcrparted order by a, abs(b), c; explain (costs off) select * from mcrparted order by a, abs(b), c;
QUERY PLAN QUERY PLAN
------------------------------------------------------------- -------------------------------------------------------------------------
Append Append
-> Index Scan using mcrparted0_a_abs_c_idx on mcrparted0 -> Index Scan using mcrparted0_a_abs_c_idx on mcrparted0 mcrparted
-> Index Scan using mcrparted1_a_abs_c_idx on mcrparted1 -> Index Scan using mcrparted1_a_abs_c_idx on mcrparted1 mcrparted_1
-> Index Scan using mcrparted2_a_abs_c_idx on mcrparted2 -> Index Scan using mcrparted2_a_abs_c_idx on mcrparted2 mcrparted_2
-> Index Scan using mcrparted3_a_abs_c_idx on mcrparted3 -> Index Scan using mcrparted3_a_abs_c_idx on mcrparted3 mcrparted_3
-> Index Scan using mcrparted4_a_abs_c_idx on mcrparted4 -> Index Scan using mcrparted4_a_abs_c_idx on mcrparted4 mcrparted_4
-> Index Scan using mcrparted5_a_abs_c_idx on mcrparted5 -> Index Scan using mcrparted5_a_abs_c_idx on mcrparted5 mcrparted_5
(7 rows) (7 rows)
-- Append is used with subpaths in reverse order with backwards index scans -- Append is used with subpaths in reverse order with backwards index scans
explain (costs off) select * from mcrparted order by a desc, abs(b) desc, c desc; explain (costs off) select * from mcrparted order by a desc, abs(b) desc, c desc;
QUERY PLAN QUERY PLAN
---------------------------------------------------------------------- ----------------------------------------------------------------------------------
Append Append
-> Index Scan Backward using mcrparted5_a_abs_c_idx on mcrparted5 -> Index Scan Backward using mcrparted5_a_abs_c_idx on mcrparted5 mcrparted_5
-> Index Scan Backward using mcrparted4_a_abs_c_idx on mcrparted4 -> Index Scan Backward using mcrparted4_a_abs_c_idx on mcrparted4 mcrparted_4
-> Index Scan Backward using mcrparted3_a_abs_c_idx on mcrparted3 -> Index Scan Backward using mcrparted3_a_abs_c_idx on mcrparted3 mcrparted_3
-> Index Scan Backward using mcrparted2_a_abs_c_idx on mcrparted2 -> Index Scan Backward using mcrparted2_a_abs_c_idx on mcrparted2 mcrparted_2
-> Index Scan Backward using mcrparted1_a_abs_c_idx on mcrparted1 -> Index Scan Backward using mcrparted1_a_abs_c_idx on mcrparted1 mcrparted_1
-> Index Scan Backward using mcrparted0_a_abs_c_idx on mcrparted0 -> Index Scan Backward using mcrparted0_a_abs_c_idx on mcrparted0 mcrparted
(7 rows) (7 rows)
-- check that Append plan is used containing a MergeAppend for sub-partitions -- check that Append plan is used containing a MergeAppend for sub-partitions
...@@ -2136,18 +2136,18 @@ create table mcrparted5 partition of mcrparted for values from (20, 20, 20) to ( ...@@ -2136,18 +2136,18 @@ create table mcrparted5 partition of mcrparted for values from (20, 20, 20) to (
create table mcrparted5a partition of mcrparted5 for values in(20); create table mcrparted5a partition of mcrparted5 for values in(20);
create table mcrparted5_def partition of mcrparted5 default; create table mcrparted5_def partition of mcrparted5 default;
explain (costs off) select * from mcrparted order by a, abs(b), c; explain (costs off) select * from mcrparted order by a, abs(b), c;
QUERY PLAN QUERY PLAN
--------------------------------------------------------------------------- ---------------------------------------------------------------------------------------
Append Append
-> Index Scan using mcrparted0_a_abs_c_idx on mcrparted0 -> Index Scan using mcrparted0_a_abs_c_idx on mcrparted0 mcrparted
-> Index Scan using mcrparted1_a_abs_c_idx on mcrparted1 -> Index Scan using mcrparted1_a_abs_c_idx on mcrparted1 mcrparted_1
-> Index Scan using mcrparted2_a_abs_c_idx on mcrparted2 -> Index Scan using mcrparted2_a_abs_c_idx on mcrparted2 mcrparted_2
-> Index Scan using mcrparted3_a_abs_c_idx on mcrparted3 -> Index Scan using mcrparted3_a_abs_c_idx on mcrparted3 mcrparted_3
-> Index Scan using mcrparted4_a_abs_c_idx on mcrparted4 -> Index Scan using mcrparted4_a_abs_c_idx on mcrparted4 mcrparted_4
-> Merge Append -> Merge Append
Sort Key: mcrparted5a.a, (abs(mcrparted5a.b)), mcrparted5a.c Sort Key: mcrparted_5.a, (abs(mcrparted_5.b)), mcrparted_5.c
-> Index Scan using mcrparted5a_a_abs_c_idx on mcrparted5a -> Index Scan using mcrparted5a_a_abs_c_idx on mcrparted5a mcrparted_5
-> Index Scan using mcrparted5_def_a_abs_c_idx on mcrparted5_def -> Index Scan using mcrparted5_def_a_abs_c_idx on mcrparted5_def mcrparted_6
(10 rows) (10 rows)
drop table mcrparted5_def; drop table mcrparted5_def;
...@@ -2155,30 +2155,30 @@ drop table mcrparted5_def; ...@@ -2155,30 +2155,30 @@ drop table mcrparted5_def;
-- into the main Append when the sub-partition is unordered but contains -- into the main Append when the sub-partition is unordered but contains
-- just a single sub-partition. -- just a single sub-partition.
explain (costs off) select a, abs(b) from mcrparted order by a, abs(b), c; explain (costs off) select a, abs(b) from mcrparted order by a, abs(b), c;
QUERY PLAN QUERY PLAN
--------------------------------------------------------------- ---------------------------------------------------------------------------
Append Append
-> Index Scan using mcrparted0_a_abs_c_idx on mcrparted0 -> Index Scan using mcrparted0_a_abs_c_idx on mcrparted0 mcrparted
-> Index Scan using mcrparted1_a_abs_c_idx on mcrparted1 -> Index Scan using mcrparted1_a_abs_c_idx on mcrparted1 mcrparted_1
-> Index Scan using mcrparted2_a_abs_c_idx on mcrparted2 -> Index Scan using mcrparted2_a_abs_c_idx on mcrparted2 mcrparted_2
-> Index Scan using mcrparted3_a_abs_c_idx on mcrparted3 -> Index Scan using mcrparted3_a_abs_c_idx on mcrparted3 mcrparted_3
-> Index Scan using mcrparted4_a_abs_c_idx on mcrparted4 -> Index Scan using mcrparted4_a_abs_c_idx on mcrparted4 mcrparted_4
-> Index Scan using mcrparted5a_a_abs_c_idx on mcrparted5a -> Index Scan using mcrparted5a_a_abs_c_idx on mcrparted5a mcrparted_5
(7 rows) (7 rows)
-- check that Append is used when the sub-partitioned tables are pruned -- check that Append is used when the sub-partitioned tables are pruned
-- during planning. -- during planning.
explain (costs off) select * from mcrparted where a < 20 order by a, abs(b), c; explain (costs off) select * from mcrparted where a < 20 order by a, abs(b), c;
QUERY PLAN QUERY PLAN
------------------------------------------------------------- -------------------------------------------------------------------------
Append Append
-> Index Scan using mcrparted0_a_abs_c_idx on mcrparted0 -> Index Scan using mcrparted0_a_abs_c_idx on mcrparted0 mcrparted
Index Cond: (a < 20) Index Cond: (a < 20)
-> Index Scan using mcrparted1_a_abs_c_idx on mcrparted1 -> Index Scan using mcrparted1_a_abs_c_idx on mcrparted1 mcrparted_1
Index Cond: (a < 20) Index Cond: (a < 20)
-> Index Scan using mcrparted2_a_abs_c_idx on mcrparted2 -> Index Scan using mcrparted2_a_abs_c_idx on mcrparted2 mcrparted_2
Index Cond: (a < 20) Index Cond: (a < 20)
-> Index Scan using mcrparted3_a_abs_c_idx on mcrparted3 -> Index Scan using mcrparted3_a_abs_c_idx on mcrparted3 mcrparted_3
Index Cond: (a < 20) Index Cond: (a < 20)
(9 rows) (9 rows)
...@@ -2188,11 +2188,11 @@ create table mclparted2 partition of mclparted for values in(2); ...@@ -2188,11 +2188,11 @@ create table mclparted2 partition of mclparted for values in(2);
create index on mclparted (a); create index on mclparted (a);
-- Ensure an Append is used for a list partition with an order by. -- Ensure an Append is used for a list partition with an order by.
explain (costs off) select * from mclparted order by a; explain (costs off) select * from mclparted order by a;
QUERY PLAN QUERY PLAN
------------------------------------------------------------ ------------------------------------------------------------------------
Append Append
-> Index Only Scan using mclparted1_a_idx on mclparted1 -> Index Only Scan using mclparted1_a_idx on mclparted1 mclparted
-> Index Only Scan using mclparted2_a_idx on mclparted2 -> Index Only Scan using mclparted2_a_idx on mclparted2 mclparted_1
(3 rows) (3 rows)
-- Ensure a MergeAppend is used when a partition exists with interleaved -- Ensure a MergeAppend is used when a partition exists with interleaved
...@@ -2200,14 +2200,14 @@ explain (costs off) select * from mclparted order by a; ...@@ -2200,14 +2200,14 @@ explain (costs off) select * from mclparted order by a;
create table mclparted3_5 partition of mclparted for values in(3,5); create table mclparted3_5 partition of mclparted for values in(3,5);
create table mclparted4 partition of mclparted for values in(4); create table mclparted4 partition of mclparted for values in(4);
explain (costs off) select * from mclparted order by a; explain (costs off) select * from mclparted order by a;
QUERY PLAN QUERY PLAN
---------------------------------------------------------------- ----------------------------------------------------------------------------
Merge Append Merge Append
Sort Key: mclparted1.a Sort Key: mclparted.a
-> Index Only Scan using mclparted1_a_idx on mclparted1 -> Index Only Scan using mclparted1_a_idx on mclparted1 mclparted
-> Index Only Scan using mclparted2_a_idx on mclparted2 -> Index Only Scan using mclparted2_a_idx on mclparted2 mclparted_1
-> Index Only Scan using mclparted3_5_a_idx on mclparted3_5 -> Index Only Scan using mclparted3_5_a_idx on mclparted3_5 mclparted_2
-> Index Only Scan using mclparted4_a_idx on mclparted4 -> Index Only Scan using mclparted4_a_idx on mclparted4 mclparted_3
(6 rows) (6 rows)
drop table mclparted; drop table mclparted;
...@@ -2219,19 +2219,19 @@ create index on mcrparted2 (a, abs(b), c); ...@@ -2219,19 +2219,19 @@ create index on mcrparted2 (a, abs(b), c);
create index on mcrparted3 (a, abs(b), c); create index on mcrparted3 (a, abs(b), c);
create index on mcrparted4 (a, abs(b), c); create index on mcrparted4 (a, abs(b), c);
explain (costs off) select * from mcrparted where a < 20 order by a, abs(b), c limit 1; explain (costs off) select * from mcrparted where a < 20 order by a, abs(b), c limit 1;
QUERY PLAN QUERY PLAN
------------------------------------------------------------------------- -------------------------------------------------------------------------------
Limit Limit
-> Append -> Append
-> Sort -> Sort
Sort Key: mcrparted0.a, (abs(mcrparted0.b)), mcrparted0.c Sort Key: mcrparted.a, (abs(mcrparted.b)), mcrparted.c
-> Seq Scan on mcrparted0 -> Seq Scan on mcrparted0 mcrparted
Filter: (a < 20) Filter: (a < 20)
-> Index Scan using mcrparted1_a_abs_c_idx on mcrparted1 -> Index Scan using mcrparted1_a_abs_c_idx on mcrparted1 mcrparted_1
Index Cond: (a < 20) Index Cond: (a < 20)
-> Index Scan using mcrparted2_a_abs_c_idx on mcrparted2 -> Index Scan using mcrparted2_a_abs_c_idx on mcrparted2 mcrparted_2
Index Cond: (a < 20) Index Cond: (a < 20)
-> Index Scan using mcrparted3_a_abs_c_idx on mcrparted3 -> Index Scan using mcrparted3_a_abs_c_idx on mcrparted3 mcrparted_3
Index Cond: (a < 20) Index Cond: (a < 20)
(12 rows) (12 rows)
...@@ -2239,12 +2239,12 @@ set enable_bitmapscan = 0; ...@@ -2239,12 +2239,12 @@ set enable_bitmapscan = 0;
-- Ensure Append node can be used when the partition is ordered by some -- Ensure Append node can be used when the partition is ordered by some
-- pathkeys which were deemed redundant. -- pathkeys which were deemed redundant.
explain (costs off) select * from mcrparted where a = 10 order by a, abs(b), c; explain (costs off) select * from mcrparted where a = 10 order by a, abs(b), c;
QUERY PLAN QUERY PLAN
------------------------------------------------------------- -------------------------------------------------------------------------
Append Append
-> Index Scan using mcrparted1_a_abs_c_idx on mcrparted1 -> Index Scan using mcrparted1_a_abs_c_idx on mcrparted1 mcrparted
Index Cond: (a = 10) Index Cond: (a = 10)
-> Index Scan using mcrparted2_a_abs_c_idx on mcrparted2 -> Index Scan using mcrparted2_a_abs_c_idx on mcrparted2 mcrparted_1
Index Cond: (a = 10) Index Cond: (a = 10)
(5 rows) (5 rows)
...@@ -2256,11 +2256,11 @@ create table bool_lp_true partition of bool_lp for values in(true); ...@@ -2256,11 +2256,11 @@ create table bool_lp_true partition of bool_lp for values in(true);
create table bool_lp_false partition of bool_lp for values in(false); create table bool_lp_false partition of bool_lp for values in(false);
create index on bool_lp (b); create index on bool_lp (b);
explain (costs off) select * from bool_lp order by b; explain (costs off) select * from bool_lp order by b;
QUERY PLAN QUERY PLAN
------------------------------------------------------------------ --------------------------------------------------------------------------
Append Append
-> Index Only Scan using bool_lp_false_b_idx on bool_lp_false -> Index Only Scan using bool_lp_false_b_idx on bool_lp_false bool_lp
-> Index Only Scan using bool_lp_true_b_idx on bool_lp_true -> Index Only Scan using bool_lp_true_b_idx on bool_lp_true bool_lp_1
(3 rows) (3 rows)
drop table bool_lp; drop table bool_lp;
...@@ -2272,42 +2272,42 @@ create table bool_rp_false_2k partition of bool_rp for values from (false,1000) ...@@ -2272,42 +2272,42 @@ create table bool_rp_false_2k partition of bool_rp for values from (false,1000)
create table bool_rp_true_2k partition of bool_rp for values from (true,1000) to (true,2000); create table bool_rp_true_2k partition of bool_rp for values from (true,1000) to (true,2000);
create index on bool_rp (b,a); create index on bool_rp (b,a);
explain (costs off) select * from bool_rp where b = true order by b,a; explain (costs off) select * from bool_rp where b = true order by b,a;
QUERY PLAN QUERY PLAN
------------------------------------------------------------------------ ----------------------------------------------------------------------------------
Append Append
-> Index Only Scan using bool_rp_true_1k_b_a_idx on bool_rp_true_1k -> Index Only Scan using bool_rp_true_1k_b_a_idx on bool_rp_true_1k bool_rp
Index Cond: (b = true) Index Cond: (b = true)
-> Index Only Scan using bool_rp_true_2k_b_a_idx on bool_rp_true_2k -> Index Only Scan using bool_rp_true_2k_b_a_idx on bool_rp_true_2k bool_rp_1
Index Cond: (b = true) Index Cond: (b = true)
(5 rows) (5 rows)
explain (costs off) select * from bool_rp where b = false order by b,a; explain (costs off) select * from bool_rp where b = false order by b,a;
QUERY PLAN QUERY PLAN
-------------------------------------------------------------------------- ------------------------------------------------------------------------------------
Append Append
-> Index Only Scan using bool_rp_false_1k_b_a_idx on bool_rp_false_1k -> Index Only Scan using bool_rp_false_1k_b_a_idx on bool_rp_false_1k bool_rp
Index Cond: (b = false) Index Cond: (b = false)
-> Index Only Scan using bool_rp_false_2k_b_a_idx on bool_rp_false_2k -> Index Only Scan using bool_rp_false_2k_b_a_idx on bool_rp_false_2k bool_rp_1
Index Cond: (b = false) Index Cond: (b = false)
(5 rows) (5 rows)
explain (costs off) select * from bool_rp where b = true order by a; explain (costs off) select * from bool_rp where b = true order by a;
QUERY PLAN QUERY PLAN
------------------------------------------------------------------------ ----------------------------------------------------------------------------------
Append Append
-> Index Only Scan using bool_rp_true_1k_b_a_idx on bool_rp_true_1k -> Index Only Scan using bool_rp_true_1k_b_a_idx on bool_rp_true_1k bool_rp
Index Cond: (b = true) Index Cond: (b = true)
-> Index Only Scan using bool_rp_true_2k_b_a_idx on bool_rp_true_2k -> Index Only Scan using bool_rp_true_2k_b_a_idx on bool_rp_true_2k bool_rp_1
Index Cond: (b = true) Index Cond: (b = true)
(5 rows) (5 rows)
explain (costs off) select * from bool_rp where b = false order by a; explain (costs off) select * from bool_rp where b = false order by a;
QUERY PLAN QUERY PLAN
-------------------------------------------------------------------------- ------------------------------------------------------------------------------------
Append Append
-> Index Only Scan using bool_rp_false_1k_b_a_idx on bool_rp_false_1k -> Index Only Scan using bool_rp_false_1k_b_a_idx on bool_rp_false_1k bool_rp
Index Cond: (b = false) Index Cond: (b = false)
-> Index Only Scan using bool_rp_false_2k_b_a_idx on bool_rp_false_2k -> Index Only Scan using bool_rp_false_2k_b_a_idx on bool_rp_false_2k bool_rp_1
Index Cond: (b = false) Index Cond: (b = false)
(5 rows) (5 rows)
...@@ -2319,19 +2319,19 @@ create table range_parted1 partition of range_parted for values from (0,0) to (1 ...@@ -2319,19 +2319,19 @@ create table range_parted1 partition of range_parted for values from (0,0) to (1
create table range_parted2 partition of range_parted for values from (10,10) to (20,20); create table range_parted2 partition of range_parted for values from (10,10) to (20,20);
create index on range_parted (a,b,c); create index on range_parted (a,b,c);
explain (costs off) select * from range_parted order by a,b,c; explain (costs off) select * from range_parted order by a,b,c;
QUERY PLAN QUERY PLAN
---------------------------------------------------------------------- -------------------------------------------------------------------------------------
Append Append
-> Index Only Scan using range_parted1_a_b_c_idx on range_parted1 -> Index Only Scan using range_parted1_a_b_c_idx on range_parted1 range_parted
-> Index Only Scan using range_parted2_a_b_c_idx on range_parted2 -> Index Only Scan using range_parted2_a_b_c_idx on range_parted2 range_parted_1
(3 rows) (3 rows)
explain (costs off) select * from range_parted order by a desc,b desc,c desc; explain (costs off) select * from range_parted order by a desc,b desc,c desc;
QUERY PLAN QUERY PLAN
------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------
Append Append
-> Index Only Scan Backward using range_parted2_a_b_c_idx on range_parted2 -> Index Only Scan Backward using range_parted2_a_b_c_idx on range_parted2 range_parted_1
-> Index Only Scan Backward using range_parted1_a_b_c_idx on range_parted1 -> Index Only Scan Backward using range_parted1_a_b_c_idx on range_parted1 range_parted
(3 rows) (3 rows)
drop table range_parted; drop table range_parted;
......
src/test/regress/expected/partition_aggregate.out
View file @ 55a1954d
...@@ -20,23 +20,23 @@ ANALYZE pagg_tab; ...@@ -20,23 +20,23 @@ ANALYZE pagg_tab;
-- When GROUP BY clause matches; full aggregation is performed for each partition. -- When GROUP BY clause matches; full aggregation is performed for each partition.
EXPLAIN (COSTS OFF) 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; 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
Sort Key: pagg_tab_p1.c, (sum(pagg_tab_p1.a)), (avg(pagg_tab_p1.b)) Sort Key: pagg_tab.c, (sum(pagg_tab.a)), (avg(pagg_tab.b))
-> Append -> Append
-> HashAggregate -> HashAggregate
Group Key: pagg_tab_p1.c Group Key: pagg_tab.c
Filter: (avg(pagg_tab_p1.d) < '15'::numeric) Filter: (avg(pagg_tab.d) < '15'::numeric)
-> Seq Scan on pagg_tab_p1 -> Seq Scan on pagg_tab_p1 pagg_tab
-> HashAggregate -> HashAggregate
Group Key: pagg_tab_p2.c Group Key: pagg_tab_1.c
Filter: (avg(pagg_tab_p2.d) < '15'::numeric) Filter: (avg(pagg_tab_1.d) < '15'::numeric)
-> Seq Scan on pagg_tab_p2 -> Seq Scan on pagg_tab_p2 pagg_tab_1
-> HashAggregate -> HashAggregate
Group Key: pagg_tab_p3.c Group Key: pagg_tab_2.c
Filter: (avg(pagg_tab_p3.d) < '15'::numeric) Filter: (avg(pagg_tab_2.d) < '15'::numeric)
-> Seq Scan on pagg_tab_p3 -> Seq Scan on pagg_tab_p3 pagg_tab_2
(15 rows) (15 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; 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;
...@@ -53,23 +53,23 @@ SELECT c, sum(a), avg(b), count(*), min(a), max(b) FROM pagg_tab GROUP BY c HAVI ...@@ -53,23 +53,23 @@ 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. -- When GROUP BY clause does not match; partial aggregation is performed for each partition.
EXPLAIN (COSTS OFF) 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; 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
Sort Key: pagg_tab_p1.a, (sum(pagg_tab_p1.b)), (avg(pagg_tab_p1.b)) Sort Key: pagg_tab.a, (sum(pagg_tab.b)), (avg(pagg_tab.b))
-> Finalize HashAggregate -> Finalize HashAggregate
Group Key: pagg_tab_p1.a Group Key: pagg_tab.a
Filter: (avg(pagg_tab_p1.d) < '15'::numeric) Filter: (avg(pagg_tab.d) < '15'::numeric)
-> Append -> Append
-> Partial HashAggregate -> Partial HashAggregate
Group Key: pagg_tab_p1.a Group Key: pagg_tab.a
-> Seq Scan on pagg_tab_p1 -> Seq Scan on pagg_tab_p1 pagg_tab
-> Partial HashAggregate -> Partial HashAggregate
Group Key: pagg_tab_p2.a Group Key: pagg_tab_1.a
-> Seq Scan on pagg_tab_p2 -> Seq Scan on pagg_tab_p2 pagg_tab_1
-> Partial HashAggregate -> Partial HashAggregate
Group Key: pagg_tab_p3.a Group Key: pagg_tab_2.a
-> Seq Scan on pagg_tab_p3 -> Seq Scan on pagg_tab_p3 pagg_tab_2
(15 rows) (15 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; 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;
...@@ -90,52 +90,52 @@ SELECT a, sum(b), avg(b), count(*), min(a), max(b) FROM pagg_tab GROUP BY a HAVI ...@@ -90,52 +90,52 @@ 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 -- Check with multiple columns in GROUP BY
EXPLAIN (COSTS OFF) EXPLAIN (COSTS OFF)
SELECT a, c, count(*) FROM pagg_tab GROUP BY a, c; SELECT a, c, count(*) FROM pagg_tab GROUP BY a, c;
QUERY PLAN QUERY PLAN
------------------------------------------------- ------------------------------------------------
Append Append
-> HashAggregate -> HashAggregate
Group Key: pagg_tab_p1.a, pagg_tab_p1.c Group Key: pagg_tab.a, pagg_tab.c
-> Seq Scan on pagg_tab_p1 -> Seq Scan on pagg_tab_p1 pagg_tab
-> HashAggregate -> HashAggregate
Group Key: pagg_tab_p2.a, pagg_tab_p2.c Group Key: pagg_tab_1.a, pagg_tab_1.c
-> Seq Scan on pagg_tab_p2 -> Seq Scan on pagg_tab_p2 pagg_tab_1
-> HashAggregate -> HashAggregate
Group Key: pagg_tab_p3.a, pagg_tab_p3.c Group Key: pagg_tab_2.a, pagg_tab_2.c
-> Seq Scan on pagg_tab_p3 -> Seq Scan on pagg_tab_p3 pagg_tab_2
(10 rows) (10 rows)
-- Check with multiple columns in GROUP BY, order in GROUP BY is reversed -- Check with multiple columns in GROUP BY, order in GROUP BY is reversed
EXPLAIN (COSTS OFF) EXPLAIN (COSTS OFF)
SELECT a, c, count(*) FROM pagg_tab GROUP BY c, a; SELECT a, c, count(*) FROM pagg_tab GROUP BY c, a;
QUERY PLAN QUERY PLAN
------------------------------------------------- ------------------------------------------------
Append Append
-> HashAggregate -> HashAggregate
Group Key: pagg_tab_p1.c, pagg_tab_p1.a Group Key: pagg_tab.c, pagg_tab.a
-> Seq Scan on pagg_tab_p1 -> Seq Scan on pagg_tab_p1 pagg_tab
-> HashAggregate -> HashAggregate
Group Key: pagg_tab_p2.c, pagg_tab_p2.a Group Key: pagg_tab_1.c, pagg_tab_1.a
-> Seq Scan on pagg_tab_p2 -> Seq Scan on pagg_tab_p2 pagg_tab_1
-> HashAggregate -> HashAggregate
Group Key: pagg_tab_p3.c, pagg_tab_p3.a Group Key: pagg_tab_2.c, pagg_tab_2.a
-> Seq Scan on pagg_tab_p3 -> Seq Scan on pagg_tab_p3 pagg_tab_2
(10 rows) (10 rows)
-- Check with multiple columns in GROUP BY, order in target-list is reversed -- Check with multiple columns in GROUP BY, order in target-list is reversed
EXPLAIN (COSTS OFF) EXPLAIN (COSTS OFF)
SELECT c, a, count(*) FROM pagg_tab GROUP BY a, c; SELECT c, a, count(*) FROM pagg_tab GROUP BY a, c;
QUERY PLAN QUERY PLAN
------------------------------------------------- ------------------------------------------------
Append Append
-> HashAggregate -> HashAggregate
Group Key: pagg_tab_p1.a, pagg_tab_p1.c Group Key: pagg_tab.a, pagg_tab.c
-> Seq Scan on pagg_tab_p1 -> Seq Scan on pagg_tab_p1 pagg_tab
-> HashAggregate -> HashAggregate
Group Key: pagg_tab_p2.a, pagg_tab_p2.c Group Key: pagg_tab_1.a, pagg_tab_1.c
-> Seq Scan on pagg_tab_p2 -> Seq Scan on pagg_tab_p2 pagg_tab_1
-> HashAggregate -> HashAggregate
Group Key: pagg_tab_p3.a, pagg_tab_p3.c Group Key: pagg_tab_2.a, pagg_tab_2.c
-> Seq Scan on pagg_tab_p3 -> Seq Scan on pagg_tab_p3 pagg_tab_2
(10 rows) (10 rows)
-- Test when input relation for grouping is dummy -- Test when input relation for grouping is dummy
...@@ -174,29 +174,29 @@ SET enable_hashagg TO false; ...@@ -174,29 +174,29 @@ SET enable_hashagg TO false;
-- When GROUP BY clause matches full aggregation is performed for each partition. -- When GROUP BY clause matches full aggregation is performed for each partition.
EXPLAIN (COSTS OFF) 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; 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
Sort Key: pagg_tab_p1.c, (sum(pagg_tab_p1.a)), (avg(pagg_tab_p1.b)) Sort Key: pagg_tab.c, (sum(pagg_tab.a)), (avg(pagg_tab.b))
-> Append -> Append
-> GroupAggregate -> GroupAggregate
Group Key: pagg_tab_p1.c Group Key: pagg_tab.c
Filter: (avg(pagg_tab_p1.d) < '15'::numeric) Filter: (avg(pagg_tab.d) < '15'::numeric)
-> Sort -> Sort
Sort Key: pagg_tab_p1.c Sort Key: pagg_tab.c
-> Seq Scan on pagg_tab_p1 -> Seq Scan on pagg_tab_p1 pagg_tab
-> GroupAggregate -> GroupAggregate
Group Key: pagg_tab_p2.c Group Key: pagg_tab_1.c
Filter: (avg(pagg_tab_p2.d) < '15'::numeric) Filter: (avg(pagg_tab_1.d) < '15'::numeric)
-> Sort -> Sort
Sort Key: pagg_tab_p2.c Sort Key: pagg_tab_1.c
-> Seq Scan on pagg_tab_p2 -> Seq Scan on pagg_tab_p2 pagg_tab_1
-> GroupAggregate -> GroupAggregate
Group Key: pagg_tab_p3.c Group Key: pagg_tab_2.c
Filter: (avg(pagg_tab_p3.d) < '15'::numeric) Filter: (avg(pagg_tab_2.d) < '15'::numeric)
-> Sort -> Sort
Sort Key: pagg_tab_p3.c Sort Key: pagg_tab_2.c
-> Seq Scan on pagg_tab_p3 -> Seq Scan on pagg_tab_p3 pagg_tab_2
(21 rows) (21 rows)
SELECT c, sum(a), avg(b), count(*) FROM pagg_tab GROUP BY 1 HAVING avg(d) < 15 ORDER BY 1, 2, 3; SELECT c, sum(a), avg(b), count(*) FROM pagg_tab GROUP BY 1 HAVING avg(d) < 15 ORDER BY 1, 2, 3;
...@@ -213,30 +213,30 @@ SELECT c, sum(a), avg(b), count(*) FROM pagg_tab GROUP BY 1 HAVING avg(d) < 15 O ...@@ -213,30 +213,30 @@ 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. -- When GROUP BY clause does not match; partial aggregation is performed for each partition.
EXPLAIN (COSTS OFF) 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; 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
Sort Key: pagg_tab_p1.a, (sum(pagg_tab_p1.b)), (avg(pagg_tab_p1.b)) Sort Key: pagg_tab.a, (sum(pagg_tab.b)), (avg(pagg_tab.b))
-> Finalize GroupAggregate -> Finalize GroupAggregate
Group Key: pagg_tab_p1.a Group Key: pagg_tab.a
Filter: (avg(pagg_tab_p1.d) < '15'::numeric) Filter: (avg(pagg_tab.d) < '15'::numeric)
-> Merge Append -> Merge Append
Sort Key: pagg_tab_p1.a Sort Key: pagg_tab.a
-> Partial GroupAggregate -> Partial GroupAggregate
Group Key: pagg_tab_p1.a Group Key: pagg_tab.a
-> Sort -> Sort
Sort Key: pagg_tab_p1.a Sort Key: pagg_tab.a
-> Seq Scan on pagg_tab_p1 -> Seq Scan on pagg_tab_p1 pagg_tab
-> Partial GroupAggregate -> Partial GroupAggregate
Group Key: pagg_tab_p2.a Group Key: pagg_tab_1.a
-> Sort -> Sort
Sort Key: pagg_tab_p2.a Sort Key: pagg_tab_1.a
-> Seq Scan on pagg_tab_p2 -> Seq Scan on pagg_tab_p2 pagg_tab_1
-> Partial GroupAggregate -> Partial GroupAggregate
Group Key: pagg_tab_p3.a Group Key: pagg_tab_2.a
-> Sort -> Sort
Sort Key: pagg_tab_p3.a Sort Key: pagg_tab_2.a
-> Seq Scan on pagg_tab_p3 -> Seq Scan on pagg_tab_p3 pagg_tab_2
(22 rows) (22 rows)
SELECT a, sum(b), avg(b), count(*) FROM pagg_tab GROUP BY 1 HAVING avg(d) < 15 ORDER BY 1, 2, 3; SELECT a, sum(b), avg(b), count(*) FROM pagg_tab GROUP BY 1 HAVING avg(d) < 15 ORDER BY 1, 2, 3;
...@@ -257,25 +257,25 @@ SELECT a, sum(b), avg(b), count(*) FROM pagg_tab GROUP BY 1 HAVING avg(d) < 15 O ...@@ -257,25 +257,25 @@ SELECT a, sum(b), avg(b), count(*) FROM pagg_tab GROUP BY 1 HAVING avg(d) < 15 O
-- Test partitionwise grouping without any aggregates -- Test partitionwise grouping without any aggregates
EXPLAIN (COSTS OFF) EXPLAIN (COSTS OFF)
SELECT c FROM pagg_tab GROUP BY c ORDER BY 1; SELECT c FROM pagg_tab GROUP BY c ORDER BY 1;
QUERY PLAN QUERY PLAN
------------------------------------------- ------------------------------------------------------
Merge Append Merge Append
Sort Key: pagg_tab_p1.c Sort Key: pagg_tab.c
-> Group -> Group
Group Key: pagg_tab_p1.c Group Key: pagg_tab.c
-> Sort -> Sort
Sort Key: pagg_tab_p1.c Sort Key: pagg_tab.c
-> Seq Scan on pagg_tab_p1 -> Seq Scan on pagg_tab_p1 pagg_tab
-> Group -> Group
Group Key: pagg_tab_p2.c Group Key: pagg_tab_1.c
-> Sort -> Sort
Sort Key: pagg_tab_p2.c Sort Key: pagg_tab_1.c
-> Seq Scan on pagg_tab_p2 -> Seq Scan on pagg_tab_p2 pagg_tab_1
-> Group -> Group
Group Key: pagg_tab_p3.c Group Key: pagg_tab_2.c
-> Sort -> Sort
Sort Key: pagg_tab_p3.c Sort Key: pagg_tab_2.c
-> Seq Scan on pagg_tab_p3 -> Seq Scan on pagg_tab_p3 pagg_tab_2
(17 rows) (17 rows)
SELECT c FROM pagg_tab GROUP BY c ORDER BY 1; SELECT c FROM pagg_tab GROUP BY c ORDER BY 1;
...@@ -297,29 +297,29 @@ SELECT c FROM pagg_tab GROUP BY c ORDER BY 1; ...@@ -297,29 +297,29 @@ SELECT c FROM pagg_tab GROUP BY c ORDER BY 1;
EXPLAIN (COSTS OFF) EXPLAIN (COSTS OFF)
SELECT a FROM pagg_tab WHERE a < 3 GROUP BY a ORDER BY 1; SELECT a FROM pagg_tab WHERE a < 3 GROUP BY a ORDER BY 1;
QUERY PLAN QUERY PLAN
------------------------------------------------- ------------------------------------------------------------
Group Group
Group Key: pagg_tab_p1.a Group Key: pagg_tab.a
-> Merge Append -> Merge Append
Sort Key: pagg_tab_p1.a Sort Key: pagg_tab.a
-> Group -> Group
Group Key: pagg_tab_p1.a Group Key: pagg_tab.a
-> Sort -> Sort
Sort Key: pagg_tab_p1.a Sort Key: pagg_tab.a
-> Seq Scan on pagg_tab_p1 -> Seq Scan on pagg_tab_p1 pagg_tab
Filter: (a < 3) Filter: (a < 3)
-> Group -> Group
Group Key: pagg_tab_p2.a Group Key: pagg_tab_1.a
-> Sort -> Sort
Sort Key: pagg_tab_p2.a Sort Key: pagg_tab_1.a
-> Seq Scan on pagg_tab_p2 -> Seq Scan on pagg_tab_p2 pagg_tab_1
Filter: (a < 3) Filter: (a < 3)
-> Group -> Group
Group Key: pagg_tab_p3.a Group Key: pagg_tab_2.a
-> Sort -> Sort
Sort Key: pagg_tab_p3.a Sort Key: pagg_tab_2.a
-> Seq Scan on pagg_tab_p3 -> Seq Scan on pagg_tab_p3 pagg_tab_2
Filter: (a < 3) Filter: (a < 3)
(22 rows) (22 rows)
...@@ -335,17 +335,17 @@ RESET enable_hashagg; ...@@ -335,17 +335,17 @@ RESET enable_hashagg;
-- ROLLUP, partitionwise aggregation does not apply -- ROLLUP, partitionwise aggregation does not apply
EXPLAIN (COSTS OFF) EXPLAIN (COSTS OFF)
SELECT c, sum(a) FROM pagg_tab GROUP BY rollup(c) ORDER BY 1, 2; SELECT c, sum(a) FROM pagg_tab GROUP BY rollup(c) ORDER BY 1, 2;
QUERY PLAN QUERY PLAN
------------------------------------------------- ------------------------------------------------------
Sort Sort
Sort Key: pagg_tab_p1.c, (sum(pagg_tab_p1.a)) Sort Key: pagg_tab.c, (sum(pagg_tab.a))
-> MixedAggregate -> MixedAggregate
Hash Key: pagg_tab_p1.c Hash Key: pagg_tab.c
Group Key: () Group Key: ()
-> Append -> Append
-> Seq Scan on pagg_tab_p1 -> Seq Scan on pagg_tab_p1 pagg_tab
-> Seq Scan on pagg_tab_p2 -> Seq Scan on pagg_tab_p2 pagg_tab_1
-> Seq Scan on pagg_tab_p3 -> Seq Scan on pagg_tab_p3 pagg_tab_2
(9 rows) (9 rows)
-- ORDERED SET within the aggregate. -- ORDERED SET within the aggregate.
...@@ -354,26 +354,26 @@ SELECT c, sum(a) FROM pagg_tab GROUP BY rollup(c) ORDER BY 1, 2; ...@@ -354,26 +354,26 @@ SELECT c, sum(a) FROM pagg_tab GROUP BY rollup(c) ORDER BY 1, 2;
-- make any difference. -- make any difference.
EXPLAIN (COSTS OFF) EXPLAIN (COSTS OFF)
SELECT c, sum(b order by a) FROM pagg_tab GROUP BY c ORDER BY 1, 2; SELECT c, sum(b order by a) FROM pagg_tab GROUP BY c ORDER BY 1, 2;
QUERY PLAN QUERY PLAN
------------------------------------------------------------------------ ---------------------------------------------------------------
Sort Sort
Sort Key: pagg_tab_p1.c, (sum(pagg_tab_p1.b ORDER BY pagg_tab_p1.a)) Sort Key: pagg_tab.c, (sum(pagg_tab.b ORDER BY pagg_tab.a))
-> Append -> Append
-> GroupAggregate -> GroupAggregate
Group Key: pagg_tab_p1.c Group Key: pagg_tab.c
-> Sort -> Sort
Sort Key: pagg_tab_p1.c Sort Key: pagg_tab.c
-> Seq Scan on pagg_tab_p1 -> Seq Scan on pagg_tab_p1 pagg_tab
-> GroupAggregate -> GroupAggregate
Group Key: pagg_tab_p2.c Group Key: pagg_tab_1.c
-> Sort -> Sort
Sort Key: pagg_tab_p2.c Sort Key: pagg_tab_1.c
-> Seq Scan on pagg_tab_p2 -> Seq Scan on pagg_tab_p2 pagg_tab_1
-> GroupAggregate -> GroupAggregate
Group Key: pagg_tab_p3.c Group Key: pagg_tab_2.c
-> Sort -> Sort
Sort Key: pagg_tab_p3.c Sort Key: pagg_tab_2.c
-> Seq Scan on pagg_tab_p3 -> Seq Scan on pagg_tab_p3 pagg_tab_2
(18 rows) (18 rows)
-- Since GROUP BY clause does not match with PARTITION KEY; we need to do -- Since GROUP BY clause does not match with PARTITION KEY; we need to do
...@@ -381,18 +381,18 @@ SELECT c, sum(b order by a) FROM pagg_tab GROUP BY c ORDER BY 1, 2; ...@@ -381,18 +381,18 @@ SELECT c, sum(b order by a) FROM pagg_tab GROUP BY c ORDER BY 1, 2;
-- partitionwise aggregation plan is not generated. -- partitionwise aggregation plan is not generated.
EXPLAIN (COSTS OFF) EXPLAIN (COSTS OFF)
SELECT a, sum(b order by a) FROM pagg_tab GROUP BY a ORDER BY 1, 2; SELECT a, sum(b order by a) FROM pagg_tab GROUP BY a ORDER BY 1, 2;
QUERY PLAN QUERY PLAN
------------------------------------------------------------------------ ---------------------------------------------------------------
Sort Sort
Sort Key: pagg_tab_p1.a, (sum(pagg_tab_p1.b ORDER BY pagg_tab_p1.a)) Sort Key: pagg_tab.a, (sum(pagg_tab.b ORDER BY pagg_tab.a))
-> GroupAggregate -> GroupAggregate
Group Key: pagg_tab_p1.a Group Key: pagg_tab.a
-> Sort -> Sort
Sort Key: pagg_tab_p1.a Sort Key: pagg_tab.a
-> Append -> Append
-> Seq Scan on pagg_tab_p1 -> Seq Scan on pagg_tab_p1 pagg_tab
-> Seq Scan on pagg_tab_p2 -> Seq Scan on pagg_tab_p2 pagg_tab_1
-> Seq Scan on pagg_tab_p3 -> Seq Scan on pagg_tab_p3 pagg_tab_2
(10 rows) (10 rows)
-- JOIN query -- JOIN query
...@@ -722,25 +722,25 @@ SELECT a.x, sum(b.x) FROM pagg_tab1 a FULL OUTER JOIN pagg_tab2 b ON a.x = b.y G ...@@ -722,25 +722,25 @@ 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. -- But right now we are unable to do partitionwise join in this case.
EXPLAIN (COSTS OFF) 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; 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
Sort Key: pagg_tab1_p1.x, pagg_tab2_p2.y Sort Key: pagg_tab1.x, pagg_tab2.y
-> HashAggregate -> HashAggregate
Group Key: pagg_tab1_p1.x, pagg_tab2_p2.y Group Key: pagg_tab1.x, pagg_tab2.y
-> Hash Left Join -> Hash Left Join
Hash Cond: (pagg_tab1_p1.x = pagg_tab2_p2.y) Hash Cond: (pagg_tab1.x = pagg_tab2.y)
Filter: ((pagg_tab1_p1.x > 5) OR (pagg_tab2_p2.y < 20)) Filter: ((pagg_tab1.x > 5) OR (pagg_tab2.y < 20))
-> Append -> Append
-> Seq Scan on pagg_tab1_p1 -> Seq Scan on pagg_tab1_p1 pagg_tab1
Filter: (x < 20) Filter: (x < 20)
-> Seq Scan on pagg_tab1_p2 -> Seq Scan on pagg_tab1_p2 pagg_tab1_1
Filter: (x < 20) Filter: (x < 20)
-> Hash -> Hash
-> Append -> Append
-> Seq Scan on pagg_tab2_p2 -> Seq Scan on pagg_tab2_p2 pagg_tab2
Filter: (y > 10) Filter: (y > 10)
-> Seq Scan on pagg_tab2_p3 -> Seq Scan on pagg_tab2_p3 pagg_tab2_1
Filter: (y > 10) Filter: (y > 10)
(18 rows) (18 rows)
...@@ -762,25 +762,25 @@ SELECT a.x, b.y, count(*) FROM (SELECT * FROM pagg_tab1 WHERE x < 20) a LEFT JOI ...@@ -762,25 +762,25 @@ 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. -- But right now we are unable to do partitionwise join in this case.
EXPLAIN (COSTS OFF) 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; 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
Sort Key: pagg_tab1_p1.x, pagg_tab2_p2.y Sort Key: pagg_tab1.x, pagg_tab2.y
-> HashAggregate -> HashAggregate
Group Key: pagg_tab1_p1.x, pagg_tab2_p2.y Group Key: pagg_tab1.x, pagg_tab2.y
-> Hash Full Join -> Hash Full Join
Hash Cond: (pagg_tab1_p1.x = pagg_tab2_p2.y) Hash Cond: (pagg_tab1.x = pagg_tab2.y)
Filter: ((pagg_tab1_p1.x > 5) OR (pagg_tab2_p2.y < 20)) Filter: ((pagg_tab1.x > 5) OR (pagg_tab2.y < 20))
-> Append -> Append
-> Seq Scan on pagg_tab1_p1 -> Seq Scan on pagg_tab1_p1 pagg_tab1
Filter: (x < 20) Filter: (x < 20)
-> Seq Scan on pagg_tab1_p2 -> Seq Scan on pagg_tab1_p2 pagg_tab1_1
Filter: (x < 20) Filter: (x < 20)
-> Hash -> Hash
-> Append -> Append
-> Seq Scan on pagg_tab2_p2 -> Seq Scan on pagg_tab2_p2 pagg_tab2
Filter: (y > 10) Filter: (y > 10)
-> Seq Scan on pagg_tab2_p3 -> Seq Scan on pagg_tab2_p3 pagg_tab2_1
Filter: (y > 10) Filter: (y > 10)
(18 rows) (18 rows)
...@@ -825,23 +825,23 @@ ANALYZE pagg_tab_m; ...@@ -825,23 +825,23 @@ ANALYZE pagg_tab_m;
-- Partial aggregation as GROUP BY clause does not match with PARTITION KEY -- Partial aggregation as GROUP BY clause does not match with PARTITION KEY
EXPLAIN (COSTS OFF) 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; 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
Sort Key: pagg_tab_m_p1.a, (sum(pagg_tab_m_p1.b)), (avg(pagg_tab_m_p1.c)) Sort Key: pagg_tab_m.a, (sum(pagg_tab_m.b)), (avg(pagg_tab_m.c))
-> Finalize HashAggregate -> Finalize HashAggregate
Group Key: pagg_tab_m_p1.a Group Key: pagg_tab_m.a
Filter: (avg(pagg_tab_m_p1.c) < '22'::numeric) Filter: (avg(pagg_tab_m.c) < '22'::numeric)
-> Append -> Append
-> Partial HashAggregate -> Partial HashAggregate
Group Key: pagg_tab_m_p1.a Group Key: pagg_tab_m.a
-> Seq Scan on pagg_tab_m_p1 -> Seq Scan on pagg_tab_m_p1 pagg_tab_m
-> Partial HashAggregate -> Partial HashAggregate
Group Key: pagg_tab_m_p2.a Group Key: pagg_tab_m_1.a
-> Seq Scan on pagg_tab_m_p2 -> Seq Scan on pagg_tab_m_p2 pagg_tab_m_1
-> Partial HashAggregate -> Partial HashAggregate
Group Key: pagg_tab_m_p3.a Group Key: pagg_tab_m_2.a
-> Seq Scan on pagg_tab_m_p3 -> Seq Scan on pagg_tab_m_p3 pagg_tab_m_2
(15 rows) (15 rows)
SELECT a, sum(b), avg(c), count(*) FROM pagg_tab_m GROUP BY a HAVING avg(c) < 22 ORDER BY 1, 2, 3; SELECT a, sum(b), avg(c), count(*) FROM pagg_tab_m GROUP BY a HAVING avg(c) < 22 ORDER BY 1, 2, 3;
...@@ -858,23 +858,23 @@ SELECT a, sum(b), avg(c), count(*) FROM pagg_tab_m GROUP BY a HAVING avg(c) < 22 ...@@ -858,23 +858,23 @@ 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 -- Full aggregation as GROUP BY clause matches with PARTITION KEY
EXPLAIN (COSTS OFF) 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; 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
Sort Key: pagg_tab_m_p1.a, (sum(pagg_tab_m_p1.b)), (avg(pagg_tab_m_p1.c)) Sort Key: pagg_tab_m.a, (sum(pagg_tab_m.b)), (avg(pagg_tab_m.c))
-> Append -> Append
-> HashAggregate -> HashAggregate
Group Key: pagg_tab_m_p1.a, ((pagg_tab_m_p1.a + pagg_tab_m_p1.b) / 2) Group Key: pagg_tab_m.a, ((pagg_tab_m.a + pagg_tab_m.b) / 2)
Filter: (sum(pagg_tab_m_p1.b) < 50) Filter: (sum(pagg_tab_m.b) < 50)
-> Seq Scan on pagg_tab_m_p1 -> Seq Scan on pagg_tab_m_p1 pagg_tab_m
-> HashAggregate -> HashAggregate
Group Key: pagg_tab_m_p2.a, ((pagg_tab_m_p2.a + pagg_tab_m_p2.b) / 2) Group Key: pagg_tab_m_1.a, ((pagg_tab_m_1.a + pagg_tab_m_1.b) / 2)
Filter: (sum(pagg_tab_m_p2.b) < 50) Filter: (sum(pagg_tab_m_1.b) < 50)
-> Seq Scan on pagg_tab_m_p2 -> Seq Scan on pagg_tab_m_p2 pagg_tab_m_1
-> HashAggregate -> HashAggregate
Group Key: pagg_tab_m_p3.a, ((pagg_tab_m_p3.a + pagg_tab_m_p3.b) / 2) Group Key: pagg_tab_m_2.a, ((pagg_tab_m_2.a + pagg_tab_m_2.b) / 2)
Filter: (sum(pagg_tab_m_p3.b) < 50) Filter: (sum(pagg_tab_m_2.b) < 50)
-> Seq Scan on pagg_tab_m_p3 -> Seq Scan on pagg_tab_m_p3 pagg_tab_m_2
(15 rows) (15 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; 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;
...@@ -891,23 +891,23 @@ SELECT a, sum(b), avg(c), count(*) FROM pagg_tab_m GROUP BY a, (a+b)/2 HAVING su ...@@ -891,23 +891,23 @@ 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 -- Full aggregation as PARTITION KEY is part of GROUP BY clause
EXPLAIN (COSTS OFF) 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; 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
Sort Key: pagg_tab_m_p1.a, pagg_tab_m_p1.c, (sum(pagg_tab_m_p1.b)) Sort Key: pagg_tab_m.a, pagg_tab_m.c, (sum(pagg_tab_m.b))
-> Append -> Append
-> HashAggregate -> HashAggregate
Group Key: ((pagg_tab_m_p1.a + pagg_tab_m_p1.b) / 2), pagg_tab_m_p1.c, pagg_tab_m_p1.a Group Key: ((pagg_tab_m.a + pagg_tab_m.b) / 2), pagg_tab_m.c, pagg_tab_m.a
Filter: ((sum(pagg_tab_m_p1.b) = 50) AND (avg(pagg_tab_m_p1.c) > '25'::numeric)) Filter: ((sum(pagg_tab_m.b) = 50) AND (avg(pagg_tab_m.c) > '25'::numeric))
-> Seq Scan on pagg_tab_m_p1 -> Seq Scan on pagg_tab_m_p1 pagg_tab_m
-> HashAggregate -> HashAggregate
Group Key: ((pagg_tab_m_p2.a + pagg_tab_m_p2.b) / 2), pagg_tab_m_p2.c, pagg_tab_m_p2.a Group Key: ((pagg_tab_m_1.a + pagg_tab_m_1.b) / 2), pagg_tab_m_1.c, pagg_tab_m_1.a
Filter: ((sum(pagg_tab_m_p2.b) = 50) AND (avg(pagg_tab_m_p2.c) > '25'::numeric)) Filter: ((sum(pagg_tab_m_1.b) = 50) AND (avg(pagg_tab_m_1.c) > '25'::numeric))
-> Seq Scan on pagg_tab_m_p2 -> Seq Scan on pagg_tab_m_p2 pagg_tab_m_1
-> HashAggregate -> HashAggregate
Group Key: ((pagg_tab_m_p3.a + pagg_tab_m_p3.b) / 2), pagg_tab_m_p3.c, pagg_tab_m_p3.a Group Key: ((pagg_tab_m_2.a + pagg_tab_m_2.b) / 2), pagg_tab_m_2.c, pagg_tab_m_2.a
Filter: ((sum(pagg_tab_m_p3.b) = 50) AND (avg(pagg_tab_m_p3.c) > '25'::numeric)) Filter: ((sum(pagg_tab_m_2.b) = 50) AND (avg(pagg_tab_m_2.c) > '25'::numeric))
-> Seq Scan on pagg_tab_m_p3 -> Seq Scan on pagg_tab_m_p3 pagg_tab_m_2
(15 rows) (15 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; 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;
...@@ -943,35 +943,35 @@ SET max_parallel_workers_per_gather TO 2; ...@@ -943,35 +943,35 @@ SET max_parallel_workers_per_gather TO 2;
-- is not partial agg safe. -- is not partial agg safe.
EXPLAIN (COSTS OFF) EXPLAIN (COSTS OFF)
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; 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;
QUERY PLAN QUERY PLAN
-------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------
Sort Sort
Sort Key: pagg_tab_ml_p2_s1.a, (sum(pagg_tab_ml_p2_s1.b)), (array_agg(DISTINCT pagg_tab_ml_p2_s1.c)) Sort Key: pagg_tab_ml_1.a, (sum(pagg_tab_ml_1.b)), (array_agg(DISTINCT pagg_tab_ml_1.c))
-> Gather -> Gather
Workers Planned: 2 Workers Planned: 2
-> Parallel Append -> Parallel Append
-> GroupAggregate -> GroupAggregate
Group Key: pagg_tab_ml_p2_s1.a Group Key: pagg_tab_ml_1.a
Filter: (avg(pagg_tab_ml_p2_s1.b) < '3'::numeric) Filter: (avg(pagg_tab_ml_1.b) < '3'::numeric)
-> Sort -> Sort
Sort Key: pagg_tab_ml_p2_s1.a Sort Key: pagg_tab_ml_1.a
-> Append -> Append
-> Seq Scan on pagg_tab_ml_p2_s1 -> Seq Scan on pagg_tab_ml_p2_s1 pagg_tab_ml_1
-> Seq Scan on pagg_tab_ml_p2_s2 -> Seq Scan on pagg_tab_ml_p2_s2 pagg_tab_ml_2
-> GroupAggregate -> GroupAggregate
Group Key: pagg_tab_ml_p3_s1.a Group Key: pagg_tab_ml_3.a
Filter: (avg(pagg_tab_ml_p3_s1.b) < '3'::numeric) Filter: (avg(pagg_tab_ml_3.b) < '3'::numeric)
-> Sort -> Sort
Sort Key: pagg_tab_ml_p3_s1.a Sort Key: pagg_tab_ml_3.a
-> Append -> Append
-> Seq Scan on pagg_tab_ml_p3_s1 -> Seq Scan on pagg_tab_ml_p3_s1 pagg_tab_ml_3
-> Seq Scan on pagg_tab_ml_p3_s2 -> Seq Scan on pagg_tab_ml_p3_s2 pagg_tab_ml_4
-> GroupAggregate -> GroupAggregate
Group Key: pagg_tab_ml_p1.a Group Key: pagg_tab_ml.a
Filter: (avg(pagg_tab_ml_p1.b) < '3'::numeric) Filter: (avg(pagg_tab_ml.b) < '3'::numeric)
-> Sort -> Sort
Sort Key: pagg_tab_ml_p1.a Sort Key: pagg_tab_ml.a
-> Seq Scan on pagg_tab_ml_p1 -> Seq Scan on pagg_tab_ml_p1 pagg_tab_ml
(27 rows) (27 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; 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;
...@@ -991,33 +991,33 @@ SELECT a, sum(b), array_agg(distinct c), count(*) FROM pagg_tab_ml GROUP BY a HA ...@@ -991,33 +991,33 @@ 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 -- Without ORDER BY clause, to test Gather at top-most path
EXPLAIN (COSTS OFF) EXPLAIN (COSTS OFF)
SELECT a, sum(b), array_agg(distinct c), count(*) FROM pagg_tab_ml GROUP BY a HAVING avg(b) < 3; 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 Gather
Workers Planned: 2 Workers Planned: 2
-> Parallel Append -> Parallel Append
-> GroupAggregate -> GroupAggregate
Group Key: pagg_tab_ml_p2_s1.a Group Key: pagg_tab_ml_1.a
Filter: (avg(pagg_tab_ml_p2_s1.b) < '3'::numeric) Filter: (avg(pagg_tab_ml_1.b) < '3'::numeric)
-> Sort -> Sort
Sort Key: pagg_tab_ml_p2_s1.a Sort Key: pagg_tab_ml_1.a
-> Append -> Append
-> Seq Scan on pagg_tab_ml_p2_s1 -> Seq Scan on pagg_tab_ml_p2_s1 pagg_tab_ml_1
-> Seq Scan on pagg_tab_ml_p2_s2 -> Seq Scan on pagg_tab_ml_p2_s2 pagg_tab_ml_2
-> GroupAggregate -> GroupAggregate
Group Key: pagg_tab_ml_p3_s1.a Group Key: pagg_tab_ml_3.a
Filter: (avg(pagg_tab_ml_p3_s1.b) < '3'::numeric) Filter: (avg(pagg_tab_ml_3.b) < '3'::numeric)
-> Sort -> Sort
Sort Key: pagg_tab_ml_p3_s1.a Sort Key: pagg_tab_ml_3.a
-> Append -> Append
-> Seq Scan on pagg_tab_ml_p3_s1 -> Seq Scan on pagg_tab_ml_p3_s1 pagg_tab_ml_3
-> Seq Scan on pagg_tab_ml_p3_s2 -> Seq Scan on pagg_tab_ml_p3_s2 pagg_tab_ml_4
-> GroupAggregate -> GroupAggregate
Group Key: pagg_tab_ml_p1.a Group Key: pagg_tab_ml.a
Filter: (avg(pagg_tab_ml_p1.b) < '3'::numeric) Filter: (avg(pagg_tab_ml.b) < '3'::numeric)
-> Sort -> Sort
Sort Key: pagg_tab_ml_p1.a Sort Key: pagg_tab_ml.a
-> Seq Scan on pagg_tab_ml_p1 -> Seq Scan on pagg_tab_ml_p1 pagg_tab_ml
(25 rows) (25 rows)
-- Full aggregation at level 1 as GROUP BY clause matches with PARTITION KEY -- Full aggregation at level 1 as GROUP BY clause matches with PARTITION KEY
...@@ -1025,39 +1025,39 @@ SELECT a, sum(b), array_agg(distinct c), count(*) FROM pagg_tab_ml GROUP BY a HA ...@@ -1025,39 +1025,39 @@ SELECT a, sum(b), array_agg(distinct c), count(*) FROM pagg_tab_ml GROUP BY a HA
-- PARTITION KEY, thus we will have a partial aggregation for them. -- PARTITION KEY, thus we will have a partial aggregation for them.
EXPLAIN (COSTS OFF) EXPLAIN (COSTS OFF)
SELECT a, sum(b), count(*) FROM pagg_tab_ml GROUP BY a HAVING avg(b) < 3 ORDER BY 1, 2, 3; 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
Sort Key: pagg_tab_ml_p1.a, (sum(pagg_tab_ml_p1.b)), (count(*)) Sort Key: pagg_tab_ml.a, (sum(pagg_tab_ml.b)), (count(*))
-> Append -> Append
-> HashAggregate -> HashAggregate
Group Key: pagg_tab_ml_p1.a Group Key: pagg_tab_ml.a
Filter: (avg(pagg_tab_ml_p1.b) < '3'::numeric) Filter: (avg(pagg_tab_ml.b) < '3'::numeric)
-> Seq Scan on pagg_tab_ml_p1 -> Seq Scan on pagg_tab_ml_p1 pagg_tab_ml
-> Finalize GroupAggregate -> Finalize GroupAggregate
Group Key: pagg_tab_ml_p2_s1.a Group Key: pagg_tab_ml_1.a
Filter: (avg(pagg_tab_ml_p2_s1.b) < '3'::numeric) Filter: (avg(pagg_tab_ml_1.b) < '3'::numeric)
-> Sort -> Sort
Sort Key: pagg_tab_ml_p2_s1.a Sort Key: pagg_tab_ml_1.a
-> Append -> Append
-> Partial HashAggregate -> Partial HashAggregate
Group Key: pagg_tab_ml_p2_s1.a Group Key: pagg_tab_ml_1.a
-> Seq Scan on pagg_tab_ml_p2_s1 -> Seq Scan on pagg_tab_ml_p2_s1 pagg_tab_ml_1
-> Partial HashAggregate -> Partial HashAggregate
Group Key: pagg_tab_ml_p2_s2.a Group Key: pagg_tab_ml_2.a
-> Seq Scan on pagg_tab_ml_p2_s2 -> Seq Scan on pagg_tab_ml_p2_s2 pagg_tab_ml_2
-> Finalize GroupAggregate -> Finalize GroupAggregate
Group Key: pagg_tab_ml_p3_s1.a Group Key: pagg_tab_ml_3.a
Filter: (avg(pagg_tab_ml_p3_s1.b) < '3'::numeric) Filter: (avg(pagg_tab_ml_3.b) < '3'::numeric)
-> Sort -> Sort
Sort Key: pagg_tab_ml_p3_s1.a Sort Key: pagg_tab_ml_3.a
-> Append -> Append
-> Partial HashAggregate -> Partial HashAggregate
Group Key: pagg_tab_ml_p3_s1.a Group Key: pagg_tab_ml_3.a
-> Seq Scan on pagg_tab_ml_p3_s1 -> Seq Scan on pagg_tab_ml_p3_s1 pagg_tab_ml_3
-> Partial HashAggregate -> Partial HashAggregate
Group Key: pagg_tab_ml_p3_s2.a Group Key: pagg_tab_ml_4.a
-> Seq Scan on pagg_tab_ml_p3_s2 -> Seq Scan on pagg_tab_ml_p3_s2 pagg_tab_ml_4
(31 rows) (31 rows)
SELECT a, sum(b), count(*) FROM pagg_tab_ml GROUP BY a HAVING avg(b) < 3 ORDER BY 1, 2, 3; SELECT a, sum(b), count(*) FROM pagg_tab_ml GROUP BY a HAVING avg(b) < 3 ORDER BY 1, 2, 3;
...@@ -1078,30 +1078,30 @@ SELECT a, sum(b), count(*) FROM pagg_tab_ml GROUP BY a HAVING avg(b) < 3 ORDER B ...@@ -1078,30 +1078,30 @@ SELECT a, sum(b), count(*) FROM pagg_tab_ml GROUP BY a HAVING avg(b) < 3 ORDER B
-- PARTITION KEY -- PARTITION KEY
EXPLAIN (COSTS OFF) EXPLAIN (COSTS OFF)
SELECT b, sum(a), count(*) FROM pagg_tab_ml GROUP BY b ORDER BY 1, 2, 3; SELECT b, sum(a), count(*) FROM pagg_tab_ml GROUP BY b ORDER BY 1, 2, 3;
QUERY PLAN QUERY PLAN
------------------------------------------------------------------- ---------------------------------------------------------------------------
Sort Sort
Sort Key: pagg_tab_ml_p1.b, (sum(pagg_tab_ml_p1.a)), (count(*)) Sort Key: pagg_tab_ml.b, (sum(pagg_tab_ml.a)), (count(*))
-> Finalize GroupAggregate -> Finalize GroupAggregate
Group Key: pagg_tab_ml_p1.b Group Key: pagg_tab_ml.b
-> Sort -> Sort
Sort Key: pagg_tab_ml_p1.b Sort Key: pagg_tab_ml.b
-> Append -> Append
-> Partial HashAggregate -> Partial HashAggregate
Group Key: pagg_tab_ml_p1.b Group Key: pagg_tab_ml.b
-> Seq Scan on pagg_tab_ml_p1 -> Seq Scan on pagg_tab_ml_p1 pagg_tab_ml
-> Partial HashAggregate -> Partial HashAggregate
Group Key: pagg_tab_ml_p2_s1.b Group Key: pagg_tab_ml_1.b
-> Seq Scan on pagg_tab_ml_p2_s1 -> Seq Scan on pagg_tab_ml_p2_s1 pagg_tab_ml_1
-> Partial HashAggregate -> Partial HashAggregate
Group Key: pagg_tab_ml_p2_s2.b Group Key: pagg_tab_ml_2.b
-> Seq Scan on pagg_tab_ml_p2_s2 -> Seq Scan on pagg_tab_ml_p2_s2 pagg_tab_ml_2
-> Partial HashAggregate -> Partial HashAggregate
Group Key: pagg_tab_ml_p3_s1.b Group Key: pagg_tab_ml_3.b
-> Seq Scan on pagg_tab_ml_p3_s1 -> Seq Scan on pagg_tab_ml_p3_s1 pagg_tab_ml_3
-> Partial HashAggregate -> Partial HashAggregate
Group Key: pagg_tab_ml_p3_s2.b Group Key: pagg_tab_ml_4.b
-> Seq Scan on pagg_tab_ml_p3_s2 -> Seq Scan on pagg_tab_ml_p3_s2 pagg_tab_ml_4
(22 rows) (22 rows)
SELECT b, sum(a), count(*) FROM pagg_tab_ml GROUP BY b HAVING avg(a) < 15 ORDER BY 1, 2, 3; SELECT b, sum(a), count(*) FROM pagg_tab_ml GROUP BY b HAVING avg(a) < 15 ORDER BY 1, 2, 3;
...@@ -1117,31 +1117,31 @@ SELECT b, sum(a), count(*) FROM pagg_tab_ml GROUP BY b HAVING avg(a) < 15 ORDER ...@@ -1117,31 +1117,31 @@ 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 -- Full aggregation at all levels as GROUP BY clause matches with PARTITION KEY
EXPLAIN (COSTS OFF) 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; 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
---------------------------------------------------------------------------------------- ----------------------------------------------------------------------------
Sort Sort
Sort Key: pagg_tab_ml_p1.a, (sum(pagg_tab_ml_p1.b)), (count(*)) Sort Key: pagg_tab_ml.a, (sum(pagg_tab_ml.b)), (count(*))
-> Append -> Append
-> HashAggregate -> HashAggregate
Group Key: pagg_tab_ml_p1.a, pagg_tab_ml_p1.b, pagg_tab_ml_p1.c Group Key: pagg_tab_ml.a, pagg_tab_ml.b, pagg_tab_ml.c
Filter: (avg(pagg_tab_ml_p1.b) > '7'::numeric) Filter: (avg(pagg_tab_ml.b) > '7'::numeric)
-> Seq Scan on pagg_tab_ml_p1 -> Seq Scan on pagg_tab_ml_p1 pagg_tab_ml
-> HashAggregate -> HashAggregate
Group Key: pagg_tab_ml_p2_s1.a, pagg_tab_ml_p2_s1.b, pagg_tab_ml_p2_s1.c Group Key: pagg_tab_ml_1.a, pagg_tab_ml_1.b, pagg_tab_ml_1.c
Filter: (avg(pagg_tab_ml_p2_s1.b) > '7'::numeric) Filter: (avg(pagg_tab_ml_1.b) > '7'::numeric)
-> Seq Scan on pagg_tab_ml_p2_s1 -> Seq Scan on pagg_tab_ml_p2_s1 pagg_tab_ml_1
-> HashAggregate -> HashAggregate
Group Key: pagg_tab_ml_p2_s2.a, pagg_tab_ml_p2_s2.b, pagg_tab_ml_p2_s2.c Group Key: pagg_tab_ml_2.a, pagg_tab_ml_2.b, pagg_tab_ml_2.c
Filter: (avg(pagg_tab_ml_p2_s2.b) > '7'::numeric) Filter: (avg(pagg_tab_ml_2.b) > '7'::numeric)
-> Seq Scan on pagg_tab_ml_p2_s2 -> Seq Scan on pagg_tab_ml_p2_s2 pagg_tab_ml_2
-> HashAggregate -> HashAggregate
Group Key: pagg_tab_ml_p3_s1.a, pagg_tab_ml_p3_s1.b, pagg_tab_ml_p3_s1.c Group Key: pagg_tab_ml_3.a, pagg_tab_ml_3.b, pagg_tab_ml_3.c
Filter: (avg(pagg_tab_ml_p3_s1.b) > '7'::numeric) Filter: (avg(pagg_tab_ml_3.b) > '7'::numeric)
-> Seq Scan on pagg_tab_ml_p3_s1 -> Seq Scan on pagg_tab_ml_p3_s1 pagg_tab_ml_3
-> HashAggregate -> HashAggregate
Group Key: pagg_tab_ml_p3_s2.a, pagg_tab_ml_p3_s2.b, pagg_tab_ml_p3_s2.c Group Key: pagg_tab_ml_4.a, pagg_tab_ml_4.b, pagg_tab_ml_4.c
Filter: (avg(pagg_tab_ml_p3_s2.b) > '7'::numeric) Filter: (avg(pagg_tab_ml_4.b) > '7'::numeric)
-> Seq Scan on pagg_tab_ml_p3_s2 -> Seq Scan on pagg_tab_ml_p3_s2 pagg_tab_ml_4
(23 rows) (23 rows)
SELECT a, sum(b), count(*) FROM pagg_tab_ml GROUP BY a, b, c HAVING avg(b) > 7 ORDER BY 1, 2, 3; SELECT a, sum(b), count(*) FROM pagg_tab_ml GROUP BY a, b, c HAVING avg(b) > 7 ORDER BY 1, 2, 3;
...@@ -1169,49 +1169,49 @@ SET parallel_setup_cost TO 0; ...@@ -1169,49 +1169,49 @@ SET parallel_setup_cost TO 0;
-- PARTITION KEY, thus we will have a partial aggregation for them. -- PARTITION KEY, thus we will have a partial aggregation for them.
EXPLAIN (COSTS OFF) EXPLAIN (COSTS OFF)
SELECT a, sum(b), count(*) FROM pagg_tab_ml GROUP BY a HAVING avg(b) < 3 ORDER BY 1, 2, 3; 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
Sort Key: pagg_tab_ml_p1.a, (sum(pagg_tab_ml_p1.b)), (count(*)) Sort Key: pagg_tab_ml.a, (sum(pagg_tab_ml.b)), (count(*))
-> Append -> Append
-> Finalize GroupAggregate -> Finalize GroupAggregate
Group Key: pagg_tab_ml_p1.a Group Key: pagg_tab_ml.a
Filter: (avg(pagg_tab_ml_p1.b) < '3'::numeric) Filter: (avg(pagg_tab_ml.b) < '3'::numeric)
-> Gather Merge -> Gather Merge
Workers Planned: 2 Workers Planned: 2
-> Sort -> Sort
Sort Key: pagg_tab_ml_p1.a Sort Key: pagg_tab_ml.a
-> Partial HashAggregate -> Partial HashAggregate
Group Key: pagg_tab_ml_p1.a Group Key: pagg_tab_ml.a
-> Parallel Seq Scan on pagg_tab_ml_p1 -> Parallel Seq Scan on pagg_tab_ml_p1 pagg_tab_ml
-> Finalize GroupAggregate -> Finalize GroupAggregate
Group Key: pagg_tab_ml_p2_s1.a Group Key: pagg_tab_ml_1.a
Filter: (avg(pagg_tab_ml_p2_s1.b) < '3'::numeric) Filter: (avg(pagg_tab_ml_1.b) < '3'::numeric)
-> Gather Merge -> Gather Merge
Workers Planned: 2 Workers Planned: 2
-> Sort -> Sort
Sort Key: pagg_tab_ml_p2_s1.a Sort Key: pagg_tab_ml_1.a
-> Parallel Append -> Parallel Append
-> Partial HashAggregate -> Partial HashAggregate
Group Key: pagg_tab_ml_p2_s1.a Group Key: pagg_tab_ml_1.a
-> Parallel Seq Scan on pagg_tab_ml_p2_s1 -> Parallel Seq Scan on pagg_tab_ml_p2_s1 pagg_tab_ml_1
-> Partial HashAggregate -> Partial HashAggregate
Group Key: pagg_tab_ml_p2_s2.a Group Key: pagg_tab_ml_2.a
-> Parallel Seq Scan on pagg_tab_ml_p2_s2 -> Parallel Seq Scan on pagg_tab_ml_p2_s2 pagg_tab_ml_2
-> Finalize GroupAggregate -> Finalize GroupAggregate
Group Key: pagg_tab_ml_p3_s1.a Group Key: pagg_tab_ml_3.a
Filter: (avg(pagg_tab_ml_p3_s1.b) < '3'::numeric) Filter: (avg(pagg_tab_ml_3.b) < '3'::numeric)
-> Gather Merge -> Gather Merge
Workers Planned: 2 Workers Planned: 2
-> Sort -> Sort
Sort Key: pagg_tab_ml_p3_s1.a Sort Key: pagg_tab_ml_3.a
-> Parallel Append -> Parallel Append
-> Partial HashAggregate -> Partial HashAggregate
Group Key: pagg_tab_ml_p3_s1.a Group Key: pagg_tab_ml_3.a
-> Parallel Seq Scan on pagg_tab_ml_p3_s1 -> Parallel Seq Scan on pagg_tab_ml_p3_s1 pagg_tab_ml_3
-> Partial HashAggregate -> Partial HashAggregate
Group Key: pagg_tab_ml_p3_s2.a Group Key: pagg_tab_ml_4.a
-> Parallel Seq Scan on pagg_tab_ml_p3_s2 -> Parallel Seq Scan on pagg_tab_ml_p3_s2 pagg_tab_ml_4
(41 rows) (41 rows)
SELECT a, sum(b), count(*) FROM pagg_tab_ml GROUP BY a HAVING avg(b) < 3 ORDER BY 1, 2, 3; SELECT a, sum(b), count(*) FROM pagg_tab_ml GROUP BY a HAVING avg(b) < 3 ORDER BY 1, 2, 3;
...@@ -1232,32 +1232,32 @@ SELECT a, sum(b), count(*) FROM pagg_tab_ml GROUP BY a HAVING avg(b) < 3 ORDER B ...@@ -1232,32 +1232,32 @@ SELECT a, sum(b), count(*) FROM pagg_tab_ml GROUP BY a HAVING avg(b) < 3 ORDER B
-- PARTITION KEY -- PARTITION KEY
EXPLAIN (COSTS OFF) EXPLAIN (COSTS OFF)
SELECT b, sum(a), count(*) FROM pagg_tab_ml GROUP BY b ORDER BY 1, 2, 3; SELECT b, sum(a), count(*) FROM pagg_tab_ml GROUP BY b ORDER BY 1, 2, 3;
QUERY PLAN QUERY PLAN
---------------------------------------------------------------------------- ------------------------------------------------------------------------------------------
Sort Sort
Sort Key: pagg_tab_ml_p1.b, (sum(pagg_tab_ml_p1.a)), (count(*)) Sort Key: pagg_tab_ml.b, (sum(pagg_tab_ml.a)), (count(*))
-> Finalize GroupAggregate -> Finalize GroupAggregate
Group Key: pagg_tab_ml_p1.b Group Key: pagg_tab_ml.b
-> Gather Merge -> Gather Merge
Workers Planned: 2 Workers Planned: 2
-> Sort -> Sort
Sort Key: pagg_tab_ml_p1.b Sort Key: pagg_tab_ml.b
-> Parallel Append -> Parallel Append
-> Partial HashAggregate -> Partial HashAggregate
Group Key: pagg_tab_ml_p1.b Group Key: pagg_tab_ml.b
-> Parallel Seq Scan on pagg_tab_ml_p1 -> Parallel Seq Scan on pagg_tab_ml_p1 pagg_tab_ml
-> Partial HashAggregate -> Partial HashAggregate
Group Key: pagg_tab_ml_p2_s1.b Group Key: pagg_tab_ml_1.b
-> Parallel Seq Scan on pagg_tab_ml_p2_s1 -> Parallel Seq Scan on pagg_tab_ml_p2_s1 pagg_tab_ml_1
-> Partial HashAggregate -> Partial HashAggregate
Group Key: pagg_tab_ml_p2_s2.b Group Key: pagg_tab_ml_2.b
-> Parallel Seq Scan on pagg_tab_ml_p2_s2 -> Parallel Seq Scan on pagg_tab_ml_p2_s2 pagg_tab_ml_2
-> Partial HashAggregate -> Partial HashAggregate
Group Key: pagg_tab_ml_p3_s1.b Group Key: pagg_tab_ml_3.b
-> Parallel Seq Scan on pagg_tab_ml_p3_s1 -> Parallel Seq Scan on pagg_tab_ml_p3_s1 pagg_tab_ml_3
-> Partial HashAggregate -> Partial HashAggregate
Group Key: pagg_tab_ml_p3_s2.b Group Key: pagg_tab_ml_4.b
-> Parallel Seq Scan on pagg_tab_ml_p3_s2 -> Parallel Seq Scan on pagg_tab_ml_p3_s2 pagg_tab_ml_4
(24 rows) (24 rows)
SELECT b, sum(a), count(*) FROM pagg_tab_ml GROUP BY b HAVING avg(a) < 15 ORDER BY 1, 2, 3; SELECT b, sum(a), count(*) FROM pagg_tab_ml GROUP BY b HAVING avg(a) < 15 ORDER BY 1, 2, 3;
...@@ -1273,33 +1273,33 @@ SELECT b, sum(a), count(*) FROM pagg_tab_ml GROUP BY b HAVING avg(a) < 15 ORDER ...@@ -1273,33 +1273,33 @@ 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 -- Full aggregation at all levels as GROUP BY clause matches with PARTITION KEY
EXPLAIN (COSTS OFF) 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; 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 Gather Merge
Workers Planned: 2 Workers Planned: 2
-> Sort -> Sort
Sort Key: pagg_tab_ml_p1.a, (sum(pagg_tab_ml_p1.b)), (count(*)) Sort Key: pagg_tab_ml.a, (sum(pagg_tab_ml.b)), (count(*))
-> Parallel Append -> Parallel Append
-> HashAggregate -> HashAggregate
Group Key: pagg_tab_ml_p1.a, pagg_tab_ml_p1.b, pagg_tab_ml_p1.c Group Key: pagg_tab_ml.a, pagg_tab_ml.b, pagg_tab_ml.c
Filter: (avg(pagg_tab_ml_p1.b) > '7'::numeric) Filter: (avg(pagg_tab_ml.b) > '7'::numeric)
-> Seq Scan on pagg_tab_ml_p1 -> Seq Scan on pagg_tab_ml_p1 pagg_tab_ml
-> HashAggregate -> HashAggregate
Group Key: pagg_tab_ml_p2_s1.a, pagg_tab_ml_p2_s1.b, pagg_tab_ml_p2_s1.c Group Key: pagg_tab_ml_1.a, pagg_tab_ml_1.b, pagg_tab_ml_1.c
Filter: (avg(pagg_tab_ml_p2_s1.b) > '7'::numeric) Filter: (avg(pagg_tab_ml_1.b) > '7'::numeric)
-> Seq Scan on pagg_tab_ml_p2_s1 -> Seq Scan on pagg_tab_ml_p2_s1 pagg_tab_ml_1
-> HashAggregate -> HashAggregate
Group Key: pagg_tab_ml_p2_s2.a, pagg_tab_ml_p2_s2.b, pagg_tab_ml_p2_s2.c Group Key: pagg_tab_ml_2.a, pagg_tab_ml_2.b, pagg_tab_ml_2.c
Filter: (avg(pagg_tab_ml_p2_s2.b) > '7'::numeric) Filter: (avg(pagg_tab_ml_2.b) > '7'::numeric)
-> Seq Scan on pagg_tab_ml_p2_s2 -> Seq Scan on pagg_tab_ml_p2_s2 pagg_tab_ml_2
-> HashAggregate -> HashAggregate
Group Key: pagg_tab_ml_p3_s1.a, pagg_tab_ml_p3_s1.b, pagg_tab_ml_p3_s1.c Group Key: pagg_tab_ml_3.a, pagg_tab_ml_3.b, pagg_tab_ml_3.c
Filter: (avg(pagg_tab_ml_p3_s1.b) > '7'::numeric) Filter: (avg(pagg_tab_ml_3.b) > '7'::numeric)
-> Seq Scan on pagg_tab_ml_p3_s1 -> Seq Scan on pagg_tab_ml_p3_s1 pagg_tab_ml_3
-> HashAggregate -> HashAggregate
Group Key: pagg_tab_ml_p3_s2.a, pagg_tab_ml_p3_s2.b, pagg_tab_ml_p3_s2.c Group Key: pagg_tab_ml_4.a, pagg_tab_ml_4.b, pagg_tab_ml_4.c
Filter: (avg(pagg_tab_ml_p3_s2.b) > '7'::numeric) Filter: (avg(pagg_tab_ml_4.b) > '7'::numeric)
-> Seq Scan on pagg_tab_ml_p3_s2 -> Seq Scan on pagg_tab_ml_p3_s2 pagg_tab_ml_4
(25 rows) (25 rows)
SELECT a, sum(b), count(*) FROM pagg_tab_ml GROUP BY a, b, c HAVING avg(b) > 7 ORDER BY 1, 2, 3; SELECT a, sum(b), count(*) FROM pagg_tab_ml GROUP BY a, b, c HAVING avg(b) > 7 ORDER BY 1, 2, 3;
...@@ -1337,27 +1337,27 @@ ANALYZE pagg_tab_para; ...@@ -1337,27 +1337,27 @@ ANALYZE pagg_tab_para;
-- When GROUP BY clause matches; full aggregation is performed for each partition. -- When GROUP BY clause matches; full aggregation is performed for each partition.
EXPLAIN (COSTS OFF) 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; 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
Sort Key: pagg_tab_para_p1.x, (sum(pagg_tab_para_p1.y)), (avg(pagg_tab_para_p1.y)) Sort Key: pagg_tab_para.x, (sum(pagg_tab_para.y)), (avg(pagg_tab_para.y))
-> Finalize GroupAggregate -> Finalize GroupAggregate
Group Key: pagg_tab_para_p1.x Group Key: pagg_tab_para.x
Filter: (avg(pagg_tab_para_p1.y) < '7'::numeric) Filter: (avg(pagg_tab_para.y) < '7'::numeric)
-> Gather Merge -> Gather Merge
Workers Planned: 2 Workers Planned: 2
-> Sort -> Sort
Sort Key: pagg_tab_para_p1.x Sort Key: pagg_tab_para.x
-> Parallel Append -> Parallel Append
-> Partial HashAggregate -> Partial HashAggregate
Group Key: pagg_tab_para_p1.x Group Key: pagg_tab_para.x
-> Parallel Seq Scan on pagg_tab_para_p1 -> Parallel Seq Scan on pagg_tab_para_p1 pagg_tab_para
-> Partial HashAggregate -> Partial HashAggregate
Group Key: pagg_tab_para_p2.x Group Key: pagg_tab_para_1.x
-> Parallel Seq Scan on pagg_tab_para_p2 -> Parallel Seq Scan on pagg_tab_para_p2 pagg_tab_para_1
-> Partial HashAggregate -> Partial HashAggregate
Group Key: pagg_tab_para_p3.x Group Key: pagg_tab_para_2.x
-> Parallel Seq Scan on pagg_tab_para_p3 -> Parallel Seq Scan on pagg_tab_para_p3 pagg_tab_para_2
(19 rows) (19 rows)
SELECT x, sum(y), avg(y), count(*) FROM pagg_tab_para GROUP BY x HAVING avg(y) < 7 ORDER BY 1, 2, 3; SELECT x, sum(y), avg(y), count(*) FROM pagg_tab_para GROUP BY x HAVING avg(y) < 7 ORDER BY 1, 2, 3;
...@@ -1374,27 +1374,27 @@ SELECT x, sum(y), avg(y), count(*) FROM pagg_tab_para GROUP BY x HAVING avg(y) < ...@@ -1374,27 +1374,27 @@ 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. -- When GROUP BY clause does not match; partial aggregation is performed for each partition.
EXPLAIN (COSTS OFF) 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; 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
Sort Key: pagg_tab_para_p1.y, (sum(pagg_tab_para_p1.x)), (avg(pagg_tab_para_p1.x)) Sort Key: pagg_tab_para.y, (sum(pagg_tab_para.x)), (avg(pagg_tab_para.x))
-> Finalize GroupAggregate -> Finalize GroupAggregate
Group Key: pagg_tab_para_p1.y Group Key: pagg_tab_para.y
Filter: (avg(pagg_tab_para_p1.x) < '12'::numeric) Filter: (avg(pagg_tab_para.x) < '12'::numeric)
-> Gather Merge -> Gather Merge
Workers Planned: 2 Workers Planned: 2
-> Sort -> Sort
Sort Key: pagg_tab_para_p1.y Sort Key: pagg_tab_para.y
-> Parallel Append -> Parallel Append
-> Partial HashAggregate -> Partial HashAggregate
Group Key: pagg_tab_para_p1.y Group Key: pagg_tab_para.y
-> Parallel Seq Scan on pagg_tab_para_p1 -> Parallel Seq Scan on pagg_tab_para_p1 pagg_tab_para
-> Partial HashAggregate -> Partial HashAggregate
Group Key: pagg_tab_para_p2.y Group Key: pagg_tab_para_1.y
-> Parallel Seq Scan on pagg_tab_para_p2 -> Parallel Seq Scan on pagg_tab_para_p2 pagg_tab_para_1
-> Partial HashAggregate -> Partial HashAggregate
Group Key: pagg_tab_para_p3.y Group Key: pagg_tab_para_2.y
-> Parallel Seq Scan on pagg_tab_para_p3 -> Parallel Seq Scan on pagg_tab_para_p3 pagg_tab_para_2
(19 rows) (19 rows)
SELECT y, sum(x), avg(x), count(*) FROM pagg_tab_para GROUP BY y HAVING avg(x) < 12 ORDER BY 1, 2, 3; SELECT y, sum(x), avg(x), count(*) FROM pagg_tab_para GROUP BY y HAVING avg(x) < 12 ORDER BY 1, 2, 3;
...@@ -1412,23 +1412,23 @@ ALTER TABLE pagg_tab_para_p3 SET (parallel_workers = 0); ...@@ -1412,23 +1412,23 @@ ALTER TABLE pagg_tab_para_p3 SET (parallel_workers = 0);
ANALYZE pagg_tab_para; ANALYZE pagg_tab_para;
EXPLAIN (COSTS OFF) 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; 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
Sort Key: pagg_tab_para_p1.x, (sum(pagg_tab_para_p1.y)), (avg(pagg_tab_para_p1.y)) Sort Key: pagg_tab_para.x, (sum(pagg_tab_para.y)), (avg(pagg_tab_para.y))
-> Finalize GroupAggregate -> Finalize GroupAggregate
Group Key: pagg_tab_para_p1.x Group Key: pagg_tab_para.x
Filter: (avg(pagg_tab_para_p1.y) < '7'::numeric) Filter: (avg(pagg_tab_para.y) < '7'::numeric)
-> Gather Merge -> Gather Merge
Workers Planned: 2 Workers Planned: 2
-> Sort -> Sort
Sort Key: pagg_tab_para_p1.x Sort Key: pagg_tab_para.x
-> Partial HashAggregate -> Partial HashAggregate
Group Key: pagg_tab_para_p1.x Group Key: pagg_tab_para.x
-> Parallel Append -> Parallel Append
-> Seq Scan on pagg_tab_para_p1 -> Seq Scan on pagg_tab_para_p1 pagg_tab_para
-> Seq Scan on pagg_tab_para_p3 -> Seq Scan on pagg_tab_para_p3 pagg_tab_para_2
-> Parallel Seq Scan on pagg_tab_para_p2 -> Parallel Seq Scan on pagg_tab_para_p2 pagg_tab_para_1
(15 rows) (15 rows)
SELECT x, sum(y), avg(y), count(*) FROM pagg_tab_para GROUP BY x HAVING avg(y) < 7 ORDER BY 1, 2, 3; SELECT x, sum(y), avg(y), count(*) FROM pagg_tab_para GROUP BY x HAVING avg(y) < 7 ORDER BY 1, 2, 3;
...@@ -1446,23 +1446,23 @@ ALTER TABLE pagg_tab_para_p2 SET (parallel_workers = 0); ...@@ -1446,23 +1446,23 @@ ALTER TABLE pagg_tab_para_p2 SET (parallel_workers = 0);
ANALYZE pagg_tab_para; ANALYZE pagg_tab_para;
EXPLAIN (COSTS OFF) 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; 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
Sort Key: pagg_tab_para_p1.x, (sum(pagg_tab_para_p1.y)), (avg(pagg_tab_para_p1.y)) Sort Key: pagg_tab_para.x, (sum(pagg_tab_para.y)), (avg(pagg_tab_para.y))
-> Finalize GroupAggregate -> Finalize GroupAggregate
Group Key: pagg_tab_para_p1.x Group Key: pagg_tab_para.x
Filter: (avg(pagg_tab_para_p1.y) < '7'::numeric) Filter: (avg(pagg_tab_para.y) < '7'::numeric)
-> Gather Merge -> Gather Merge
Workers Planned: 2 Workers Planned: 2
-> Sort -> Sort
Sort Key: pagg_tab_para_p1.x Sort Key: pagg_tab_para.x
-> Partial HashAggregate -> Partial HashAggregate
Group Key: pagg_tab_para_p1.x Group Key: pagg_tab_para.x
-> Parallel Append -> Parallel Append
-> Seq Scan on pagg_tab_para_p1 -> Seq Scan on pagg_tab_para_p1 pagg_tab_para
-> Seq Scan on pagg_tab_para_p2 -> Seq Scan on pagg_tab_para_p2 pagg_tab_para_1
-> Seq Scan on pagg_tab_para_p3 -> Seq Scan on pagg_tab_para_p3 pagg_tab_para_2
(15 rows) (15 rows)
SELECT x, sum(y), avg(y), count(*) FROM pagg_tab_para GROUP BY x HAVING avg(y) < 7 ORDER BY 1, 2, 3; SELECT x, sum(y), avg(y), count(*) FROM pagg_tab_para GROUP BY x HAVING avg(y) < 7 ORDER BY 1, 2, 3;
...@@ -1481,23 +1481,23 @@ RESET min_parallel_table_scan_size; ...@@ -1481,23 +1481,23 @@ RESET min_parallel_table_scan_size;
RESET parallel_setup_cost; RESET parallel_setup_cost;
EXPLAIN (COSTS OFF) 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; 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
Sort Key: pagg_tab_para_p1.x, (sum(pagg_tab_para_p1.y)), (avg(pagg_tab_para_p1.y)) Sort Key: pagg_tab_para.x, (sum(pagg_tab_para.y)), (avg(pagg_tab_para.y))
-> Append -> Append
-> HashAggregate -> HashAggregate
Group Key: pagg_tab_para_p1.x Group Key: pagg_tab_para.x
Filter: (avg(pagg_tab_para_p1.y) < '7'::numeric) Filter: (avg(pagg_tab_para.y) < '7'::numeric)
-> Seq Scan on pagg_tab_para_p1 -> Seq Scan on pagg_tab_para_p1 pagg_tab_para
-> HashAggregate -> HashAggregate
Group Key: pagg_tab_para_p2.x Group Key: pagg_tab_para_1.x
Filter: (avg(pagg_tab_para_p2.y) < '7'::numeric) Filter: (avg(pagg_tab_para_1.y) < '7'::numeric)
-> Seq Scan on pagg_tab_para_p2 -> Seq Scan on pagg_tab_para_p2 pagg_tab_para_1
-> HashAggregate -> HashAggregate
Group Key: pagg_tab_para_p3.x Group Key: pagg_tab_para_2.x
Filter: (avg(pagg_tab_para_p3.y) < '7'::numeric) Filter: (avg(pagg_tab_para_2.y) < '7'::numeric)
-> Seq Scan on pagg_tab_para_p3 -> Seq Scan on pagg_tab_para_p3 pagg_tab_para_2
(15 rows) (15 rows)
SELECT x, sum(y), avg(y), count(*) FROM pagg_tab_para GROUP BY x HAVING avg(y) < 7 ORDER BY 1, 2, 3; SELECT x, sum(y), avg(y), count(*) FROM pagg_tab_para GROUP BY x HAVING avg(y) < 7 ORDER BY 1, 2, 3;
......
src/test/regress/expected/partition_join.out
View file @ 55a1954d
...@@ -145,34 +145,34 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHE ...@@ -145,34 +145,34 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHE
-- full outer join, with placeholder vars -- full outer join, with placeholder vars
EXPLAIN (COSTS OFF) EXPLAIN (COSTS OFF)
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; 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;
QUERY PLAN QUERY PLAN
------------------------------------------------------------------ ----------------------------------------------------------------
Sort Sort
Sort Key: prt1_p1.a, prt2_p1.b Sort Key: prt1.a, prt2.b
-> Append -> Append
-> Hash Full Join -> Hash Full Join
Hash Cond: (prt1_p1.a = prt2_p1.b) Hash Cond: (prt1.a = prt2.b)
Filter: (((50) = prt1_p1.a) OR ((75) = prt2_p1.b)) Filter: (((50) = prt1.a) OR ((75) = prt2.b))
-> Seq Scan on prt1_p1 -> Seq Scan on prt1_p1 prt1
Filter: (b = 0) Filter: (b = 0)
-> Hash -> Hash
-> Seq Scan on prt2_p1 -> Seq Scan on prt2_p1 prt2
Filter: (a = 0) Filter: (a = 0)
-> Hash Full Join -> Hash Full Join
Hash Cond: (prt1_p2.a = prt2_p2.b) Hash Cond: (prt1_1.a = prt2_1.b)
Filter: (((50) = prt1_p2.a) OR ((75) = prt2_p2.b)) Filter: (((50) = prt1_1.a) OR ((75) = prt2_1.b))
-> Seq Scan on prt1_p2 -> Seq Scan on prt1_p2 prt1_1
Filter: (b = 0) Filter: (b = 0)
-> Hash -> Hash
-> Seq Scan on prt2_p2 -> Seq Scan on prt2_p2 prt2_1
Filter: (a = 0) Filter: (a = 0)
-> Hash Full Join -> Hash Full Join
Hash Cond: (prt1_p3.a = prt2_p3.b) Hash Cond: (prt1_2.a = prt2_2.b)
Filter: (((50) = prt1_p3.a) OR ((75) = prt2_p3.b)) Filter: (((50) = prt1_2.a) OR ((75) = prt2_2.b))
-> Seq Scan on prt1_p3 -> Seq Scan on prt1_p3 prt1_2
Filter: (b = 0) Filter: (b = 0)
-> Hash -> Hash
-> Seq Scan on prt2_p3 -> Seq Scan on prt2_p3 prt2_2
Filter: (a = 0) Filter: (a = 0)
(27 rows) (27 rows)
...@@ -211,19 +211,19 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JO ...@@ -211,19 +211,19 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JO
QUERY PLAN QUERY PLAN
----------------------------------------------------------- -----------------------------------------------------------
Sort Sort
Sort Key: prt1_p1.a, prt2_p2.b Sort Key: prt1.a, prt2.b
-> Hash Right Join -> Hash Right Join
Hash Cond: (prt2_p2.b = prt1_p1.a) Hash Cond: (prt2.b = prt1.a)
-> Append -> Append
-> Seq Scan on prt2_p2 -> Seq Scan on prt2_p2 prt2
Filter: (b > 250) Filter: (b > 250)
-> Seq Scan on prt2_p3 -> Seq Scan on prt2_p3 prt2_1
Filter: (b > 250) Filter: (b > 250)
-> Hash -> Hash
-> Append -> Append
-> Seq Scan on prt1_p1 -> Seq Scan on prt1_p1 prt1
Filter: ((a < 450) AND (b = 0)) Filter: ((a < 450) AND (b = 0))
-> Seq Scan on prt1_p2 -> Seq Scan on prt1_p2 prt1_1
Filter: ((a < 450) AND (b = 0)) Filter: ((a < 450) AND (b = 0))
(15 rows) (15 rows)
...@@ -244,23 +244,23 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JO ...@@ -244,23 +244,23 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JO
-- Currently we can't do partitioned join if nullable-side partitions are pruned -- Currently we can't do partitioned join if nullable-side partitions are pruned
EXPLAIN (COSTS OFF) EXPLAIN (COSTS OFF)
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; 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;
QUERY PLAN QUERY PLAN
------------------------------------------------------ ----------------------------------------------------
Sort Sort
Sort Key: prt1_p1.a, prt2_p2.b Sort Key: prt1.a, prt2.b
-> Hash Full Join -> Hash Full Join
Hash Cond: (prt1_p1.a = prt2_p2.b) Hash Cond: (prt1.a = prt2.b)
Filter: ((prt1_p1.b = 0) OR (prt2_p2.a = 0)) Filter: ((prt1.b = 0) OR (prt2.a = 0))
-> Append -> Append
-> Seq Scan on prt1_p1 -> Seq Scan on prt1_p1 prt1
Filter: (a < 450) Filter: (a < 450)
-> Seq Scan on prt1_p2 -> Seq Scan on prt1_p2 prt1_1
Filter: (a < 450) Filter: (a < 450)
-> Hash -> Hash
-> Append -> Append
-> Seq Scan on prt2_p2 -> Seq Scan on prt2_p2 prt2
Filter: (b > 250) Filter: (b > 250)
-> Seq Scan on prt2_p3 -> Seq Scan on prt2_p3 prt2_1
Filter: (b > 250) Filter: (b > 250)
(16 rows) (16 rows)
...@@ -466,48 +466,48 @@ EXPLAIN (COSTS OFF) ...@@ -466,48 +466,48 @@ EXPLAIN (COSTS OFF)
SELECT a, b FROM prt1 FULL JOIN prt2 p2(b,a,c) USING(a,b) SELECT a, b FROM prt1 FULL JOIN prt2 p2(b,a,c) USING(a,b)
WHERE a BETWEEN 490 AND 510 WHERE a BETWEEN 490 AND 510
GROUP BY 1, 2 ORDER BY 1, 2; GROUP BY 1, 2 ORDER BY 1, 2;
QUERY PLAN QUERY PLAN
------------------------------------------------------------------------------------------------------------------- -----------------------------------------------------------------------------------------------------------------
Group Group
Group Key: (COALESCE(prt1_p1.a, p2.a)), (COALESCE(prt1_p1.b, p2.b)) Group Key: (COALESCE(prt1.a, p2.a)), (COALESCE(prt1.b, p2.b))
-> Merge Append -> Merge Append
Sort Key: (COALESCE(prt1_p1.a, p2.a)), (COALESCE(prt1_p1.b, p2.b)) Sort Key: (COALESCE(prt1.a, p2.a)), (COALESCE(prt1.b, p2.b))
-> Group -> Group
Group Key: (COALESCE(prt1_p1.a, p2.a)), (COALESCE(prt1_p1.b, p2.b)) Group Key: (COALESCE(prt1.a, p2.a)), (COALESCE(prt1.b, p2.b))
-> Sort -> Sort
Sort Key: (COALESCE(prt1_p1.a, p2.a)), (COALESCE(prt1_p1.b, p2.b)) Sort Key: (COALESCE(prt1.a, p2.a)), (COALESCE(prt1.b, p2.b))
-> Merge Full Join -> Merge Full Join
Merge Cond: ((prt1_p1.a = p2.a) AND (prt1_p1.b = p2.b)) Merge Cond: ((prt1.a = p2.a) AND (prt1.b = p2.b))
Filter: ((COALESCE(prt1_p1.a, p2.a) >= 490) AND (COALESCE(prt1_p1.a, p2.a) <= 510)) Filter: ((COALESCE(prt1.a, p2.a) >= 490) AND (COALESCE(prt1.a, p2.a) <= 510))
-> Sort -> Sort
Sort Key: prt1_p1.a, prt1_p1.b Sort Key: prt1.a, prt1.b
-> Seq Scan on prt1_p1 -> Seq Scan on prt1_p1 prt1
-> Sort -> Sort
Sort Key: p2.a, p2.b Sort Key: p2.a, p2.b
-> Seq Scan on prt2_p1 p2 -> Seq Scan on prt2_p1 p2
-> Group -> Group
Group Key: (COALESCE(prt1_p2.a, p2_1.a)), (COALESCE(prt1_p2.b, p2_1.b)) Group Key: (COALESCE(prt1_1.a, p2_1.a)), (COALESCE(prt1_1.b, p2_1.b))
-> Sort -> Sort
Sort Key: (COALESCE(prt1_p2.a, p2_1.a)), (COALESCE(prt1_p2.b, p2_1.b)) Sort Key: (COALESCE(prt1_1.a, p2_1.a)), (COALESCE(prt1_1.b, p2_1.b))
-> Merge Full Join -> Merge Full Join
Merge Cond: ((prt1_p2.a = p2_1.a) AND (prt1_p2.b = p2_1.b)) Merge Cond: ((prt1_1.a = p2_1.a) AND (prt1_1.b = p2_1.b))
Filter: ((COALESCE(prt1_p2.a, p2_1.a) >= 490) AND (COALESCE(prt1_p2.a, p2_1.a) <= 510)) Filter: ((COALESCE(prt1_1.a, p2_1.a) >= 490) AND (COALESCE(prt1_1.a, p2_1.a) <= 510))
-> Sort -> Sort
Sort Key: prt1_p2.a, prt1_p2.b Sort Key: prt1_1.a, prt1_1.b
-> Seq Scan on prt1_p2 -> Seq Scan on prt1_p2 prt1_1
-> Sort -> Sort
Sort Key: p2_1.a, p2_1.b Sort Key: p2_1.a, p2_1.b
-> Seq Scan on prt2_p2 p2_1 -> Seq Scan on prt2_p2 p2_1
-> Group -> Group
Group Key: (COALESCE(prt1_p3.a, p2_2.a)), (COALESCE(prt1_p3.b, p2_2.b)) Group Key: (COALESCE(prt1_2.a, p2_2.a)), (COALESCE(prt1_2.b, p2_2.b))
-> Sort -> Sort
Sort Key: (COALESCE(prt1_p3.a, p2_2.a)), (COALESCE(prt1_p3.b, p2_2.b)) Sort Key: (COALESCE(prt1_2.a, p2_2.a)), (COALESCE(prt1_2.b, p2_2.b))
-> Merge Full Join -> Merge Full Join
Merge Cond: ((prt1_p3.a = p2_2.a) AND (prt1_p3.b = p2_2.b)) Merge Cond: ((prt1_2.a = p2_2.a) AND (prt1_2.b = p2_2.b))
Filter: ((COALESCE(prt1_p3.a, p2_2.a) >= 490) AND (COALESCE(prt1_p3.a, p2_2.a) <= 510)) Filter: ((COALESCE(prt1_2.a, p2_2.a) >= 490) AND (COALESCE(prt1_2.a, p2_2.a) <= 510))
-> Sort -> Sort
Sort Key: prt1_p3.a, prt1_p3.b Sort Key: prt1_2.a, prt1_2.b
-> Seq Scan on prt1_p3 -> Seq Scan on prt1_p3 prt1_2
-> Sort -> Sort
Sort Key: p2_2.a, p2_2.b Sort Key: p2_2.a, p2_2.b
-> Seq Scan on prt2_p3 p2_2 -> Seq Scan on prt2_p3 p2_2
...@@ -754,49 +754,49 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ...@@ -754,49 +754,49 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
-- make sure these go to null as expected -- make sure these go to null as expected
EXPLAIN (COSTS OFF) EXPLAIN (COSTS OFF)
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; 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;
QUERY PLAN QUERY PLAN
---------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------
Sort Sort
Sort Key: prt1_p1.a, prt2_p1.b, ((prt1_e_p1.a + prt1_e_p1.b)) Sort Key: prt1.a, prt2.b, ((prt1_e.a + prt1_e.b))
-> Append -> Append
-> Hash Full Join -> Hash Full Join
Hash Cond: (prt1_p1.a = ((prt1_e_p1.a + prt1_e_p1.b) / 2)) Hash Cond: (prt1.a = ((prt1_e.a + prt1_e.b) / 2))
Filter: ((prt1_p1.a = (50)) OR (prt2_p1.b = (75)) OR (((prt1_e_p1.a + prt1_e_p1.b) / 2) = (50))) Filter: ((prt1.a = (50)) OR (prt2.b = (75)) OR (((prt1_e.a + prt1_e.b) / 2) = (50)))
-> Hash Full Join -> Hash Full Join
Hash Cond: (prt1_p1.a = prt2_p1.b) Hash Cond: (prt1.a = prt2.b)
-> Seq Scan on prt1_p1 -> Seq Scan on prt1_p1 prt1
Filter: (b = 0) Filter: (b = 0)
-> Hash -> Hash
-> Seq Scan on prt2_p1 -> Seq Scan on prt2_p1 prt2
Filter: (a = 0) Filter: (a = 0)
-> Hash -> Hash
-> Seq Scan on prt1_e_p1 -> Seq Scan on prt1_e_p1 prt1_e
Filter: (c = 0) Filter: (c = 0)
-> Hash Full Join -> Hash Full Join
Hash Cond: (prt1_p2.a = ((prt1_e_p2.a + prt1_e_p2.b) / 2)) Hash Cond: (prt1_1.a = ((prt1_e_1.a + prt1_e_1.b) / 2))
Filter: ((prt1_p2.a = (50)) OR (prt2_p2.b = (75)) OR (((prt1_e_p2.a + prt1_e_p2.b) / 2) = (50))) Filter: ((prt1_1.a = (50)) OR (prt2_1.b = (75)) OR (((prt1_e_1.a + prt1_e_1.b) / 2) = (50)))
-> Hash Full Join -> Hash Full Join
Hash Cond: (prt1_p2.a = prt2_p2.b) Hash Cond: (prt1_1.a = prt2_1.b)
-> Seq Scan on prt1_p2 -> Seq Scan on prt1_p2 prt1_1
Filter: (b = 0) Filter: (b = 0)
-> Hash -> Hash
-> Seq Scan on prt2_p2 -> Seq Scan on prt2_p2 prt2_1
Filter: (a = 0) Filter: (a = 0)
-> Hash -> Hash
-> Seq Scan on prt1_e_p2 -> Seq Scan on prt1_e_p2 prt1_e_1
Filter: (c = 0) Filter: (c = 0)
-> Hash Full Join -> Hash Full Join
Hash Cond: (prt1_p3.a = ((prt1_e_p3.a + prt1_e_p3.b) / 2)) Hash Cond: (prt1_2.a = ((prt1_e_2.a + prt1_e_2.b) / 2))
Filter: ((prt1_p3.a = (50)) OR (prt2_p3.b = (75)) OR (((prt1_e_p3.a + prt1_e_p3.b) / 2) = (50))) Filter: ((prt1_2.a = (50)) OR (prt2_2.b = (75)) OR (((prt1_e_2.a + prt1_e_2.b) / 2) = (50)))
-> Hash Full Join -> Hash Full Join
Hash Cond: (prt1_p3.a = prt2_p3.b) Hash Cond: (prt1_2.a = prt2_2.b)
-> Seq Scan on prt1_p3 -> Seq Scan on prt1_p3 prt1_2
Filter: (b = 0) Filter: (b = 0)
-> Hash -> Hash
-> Seq Scan on prt2_p3 -> Seq Scan on prt2_p3 prt2_2
Filter: (a = 0) Filter: (a = 0)
-> Hash -> Hash
-> Seq Scan on prt1_e_p3 -> Seq Scan on prt1_e_p3 prt1_e_2
Filter: (c = 0) Filter: (c = 0)
(42 rows) (42 rows)
...@@ -1064,22 +1064,22 @@ SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT * ...@@ -1064,22 +1064,22 @@ SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT *
QUERY PLAN QUERY PLAN
----------------------------------------------------------- -----------------------------------------------------------
Sort Sort
Sort Key: prt1_p1.a, prt2_p2.b Sort Key: prt1.a, prt2.b
-> Merge Left Join -> Merge Left Join
Merge Cond: (prt1_p1.a = prt2_p2.b) Merge Cond: (prt1.a = prt2.b)
-> Sort -> Sort
Sort Key: prt1_p1.a Sort Key: prt1.a
-> Append -> Append
-> Seq Scan on prt1_p1 -> Seq Scan on prt1_p1 prt1
Filter: ((a < 450) AND (b = 0)) Filter: ((a < 450) AND (b = 0))
-> Seq Scan on prt1_p2 -> Seq Scan on prt1_p2 prt1_1
Filter: ((a < 450) AND (b = 0)) Filter: ((a < 450) AND (b = 0))
-> Sort -> Sort
Sort Key: prt2_p2.b Sort Key: prt2.b
-> Append -> Append
-> Seq Scan on prt2_p2 -> Seq Scan on prt2_p2 prt2
Filter: (b > 250) Filter: (b > 250)
-> Seq Scan on prt2_p3 -> Seq Scan on prt2_p3 prt2_1
Filter: (b > 250) Filter: (b > 250)
(18 rows) (18 rows)
...@@ -1150,31 +1150,31 @@ INSERT INTO prt2_m SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i; ...@@ -1150,31 +1150,31 @@ INSERT INTO prt2_m SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
ANALYZE prt2_m; ANALYZE prt2_m;
EXPLAIN (COSTS OFF) EXPLAIN (COSTS OFF)
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; 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;
QUERY PLAN QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------ ------------------------------------------------------------------------------------------------------------------------------
Sort Sort
Sort Key: prt1_m_p1.a, prt2_m_p1.b Sort Key: prt1_m.a, prt2_m.b
-> Append -> Append
-> Hash Full Join -> Hash Full Join
Hash Cond: ((prt1_m_p1.a = ((prt2_m_p1.b + prt2_m_p1.a) / 2)) AND (((prt1_m_p1.a + prt1_m_p1.b) / 2) = prt2_m_p1.b)) Hash Cond: ((prt1_m.a = ((prt2_m.b + prt2_m.a) / 2)) AND (((prt1_m.a + prt1_m.b) / 2) = prt2_m.b))
-> Seq Scan on prt1_m_p1 -> Seq Scan on prt1_m_p1 prt1_m
Filter: (c = 0) Filter: (c = 0)
-> Hash -> Hash
-> Seq Scan on prt2_m_p1 -> Seq Scan on prt2_m_p1 prt2_m
Filter: (c = 0) Filter: (c = 0)
-> Hash Full Join -> Hash Full Join
Hash Cond: ((prt1_m_p2.a = ((prt2_m_p2.b + prt2_m_p2.a) / 2)) AND (((prt1_m_p2.a + prt1_m_p2.b) / 2) = prt2_m_p2.b)) Hash Cond: ((prt1_m_1.a = ((prt2_m_1.b + prt2_m_1.a) / 2)) AND (((prt1_m_1.a + prt1_m_1.b) / 2) = prt2_m_1.b))
-> Seq Scan on prt1_m_p2 -> Seq Scan on prt1_m_p2 prt1_m_1
Filter: (c = 0) Filter: (c = 0)
-> Hash -> Hash
-> Seq Scan on prt2_m_p2 -> Seq Scan on prt2_m_p2 prt2_m_1
Filter: (c = 0) Filter: (c = 0)
-> Hash Full Join -> Hash Full Join
Hash Cond: ((prt1_m_p3.a = ((prt2_m_p3.b + prt2_m_p3.a) / 2)) AND (((prt1_m_p3.a + prt1_m_p3.b) / 2) = prt2_m_p3.b)) Hash Cond: ((prt1_m_2.a = ((prt2_m_2.b + prt2_m_2.a) / 2)) AND (((prt1_m_2.a + prt1_m_2.b) / 2) = prt2_m_2.b))
-> Seq Scan on prt1_m_p3 -> Seq Scan on prt1_m_p3 prt1_m_2
Filter: (c = 0) Filter: (c = 0)
-> Hash -> Hash
-> Seq Scan on prt2_m_p3 -> Seq Scan on prt2_m_p3 prt2_m_2
Filter: (c = 0) Filter: (c = 0)
(24 rows) (24 rows)
...@@ -1659,38 +1659,38 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_l t1 RIGHT JOIN prt2_l t2 ON t1.a = t2.b ...@@ -1659,38 +1659,38 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_l t1 RIGHT JOIN prt2_l t2 ON t1.a = t2.b
-- full join -- full join
EXPLAIN (COSTS OFF) EXPLAIN (COSTS OFF)
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; 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;
QUERY PLAN QUERY PLAN
-------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------
Sort Sort
Sort Key: prt1_l_p1.a, prt2_l_p1.b Sort Key: prt1_l.a, prt2_l.b
-> Append -> Append
-> Hash Full Join -> Hash Full Join
Hash Cond: ((prt1_l_p1.a = prt2_l_p1.b) AND ((prt1_l_p1.c)::text = (prt2_l_p1.c)::text)) Hash Cond: ((prt1_l.a = prt2_l.b) AND ((prt1_l.c)::text = (prt2_l.c)::text))
-> Seq Scan on prt1_l_p1 -> Seq Scan on prt1_l_p1 prt1_l
Filter: (b = 0) Filter: (b = 0)
-> Hash -> Hash
-> Seq Scan on prt2_l_p1 -> Seq Scan on prt2_l_p1 prt2_l
Filter: (a = 0) Filter: (a = 0)
-> Hash Full Join -> Hash Full Join
Hash Cond: ((prt1_l_p2_p1.a = prt2_l_p2_p1.b) AND ((prt1_l_p2_p1.c)::text = (prt2_l_p2_p1.c)::text)) Hash Cond: ((prt1_l_1.a = prt2_l_1.b) AND ((prt1_l_1.c)::text = (prt2_l_1.c)::text))
-> Seq Scan on prt1_l_p2_p1 -> Seq Scan on prt1_l_p2_p1 prt1_l_1
Filter: (b = 0) Filter: (b = 0)
-> Hash -> Hash
-> Seq Scan on prt2_l_p2_p1 -> Seq Scan on prt2_l_p2_p1 prt2_l_1
Filter: (a = 0) Filter: (a = 0)
-> Hash Full Join -> Hash Full Join
Hash Cond: ((prt1_l_p2_p2.a = prt2_l_p2_p2.b) AND ((prt1_l_p2_p2.c)::text = (prt2_l_p2_p2.c)::text)) Hash Cond: ((prt1_l_2.a = prt2_l_2.b) AND ((prt1_l_2.c)::text = (prt2_l_2.c)::text))
-> Seq Scan on prt1_l_p2_p2 -> Seq Scan on prt1_l_p2_p2 prt1_l_2
Filter: (b = 0) Filter: (b = 0)
-> Hash -> Hash
-> Seq Scan on prt2_l_p2_p2 -> Seq Scan on prt2_l_p2_p2 prt2_l_2
Filter: (a = 0) Filter: (a = 0)
-> Hash Full Join -> Hash Full Join
Hash Cond: ((prt1_l_p3_p1.a = prt2_l_p3_p1.b) AND ((prt1_l_p3_p1.c)::text = (prt2_l_p3_p1.c)::text)) Hash Cond: ((prt1_l_3.a = prt2_l_3.b) AND ((prt1_l_3.c)::text = (prt2_l_3.c)::text))
-> Seq Scan on prt1_l_p3_p1 -> Seq Scan on prt1_l_p3_p1 prt1_l_3
Filter: (b = 0) Filter: (b = 0)
-> Hash -> Hash
-> Seq Scan on prt2_l_p3_p1 -> Seq Scan on prt2_l_p3_p1 prt2_l_3
Filter: (a = 0) Filter: (a = 0)
(31 rows) (31 rows)
...@@ -1819,11 +1819,11 @@ WHERE EXISTS ( ...@@ -1819,11 +1819,11 @@ WHERE EXISTS (
QUERY PLAN QUERY PLAN
--------------------------------------------------------------- ---------------------------------------------------------------
Delete on prt1_l Delete on prt1_l
Delete on prt1_l_p1 Delete on prt1_l_p1 prt1_l_1
Delete on prt1_l_p3_p1 Delete on prt1_l_p3_p1 prt1_l_2
Delete on prt1_l_p3_p2 Delete on prt1_l_p3_p2 prt1_l_3
-> Nested Loop Semi Join -> Nested Loop Semi Join
-> Seq Scan on prt1_l_p1 -> Seq Scan on prt1_l_p1 prt1_l_1
Filter: (c IS NULL) Filter: (c IS NULL)
-> Nested Loop -> Nested Loop
-> Seq Scan on int4_tbl -> Seq Scan on int4_tbl
...@@ -1831,7 +1831,7 @@ WHERE EXISTS ( ...@@ -1831,7 +1831,7 @@ WHERE EXISTS (
-> Limit -> Limit
-> Seq Scan on int8_tbl -> Seq Scan on int8_tbl
-> Nested Loop Semi Join -> Nested Loop Semi Join
-> Seq Scan on prt1_l_p3_p1 -> Seq Scan on prt1_l_p3_p1 prt1_l_2
Filter: (c IS NULL) Filter: (c IS NULL)
-> Nested Loop -> Nested Loop
-> Seq Scan on int4_tbl -> Seq Scan on int4_tbl
...@@ -1839,7 +1839,7 @@ WHERE EXISTS ( ...@@ -1839,7 +1839,7 @@ WHERE EXISTS (
-> Limit -> Limit
-> Seq Scan on int8_tbl int8_tbl_1 -> Seq Scan on int8_tbl int8_tbl_1
-> Nested Loop Semi Join -> Nested Loop Semi Join
-> Seq Scan on prt1_l_p3_p2 -> Seq Scan on prt1_l_p3_p2 prt1_l_3
Filter: (c IS NULL) Filter: (c IS NULL)
-> Nested Loop -> Nested Loop
-> Seq Scan on int4_tbl -> Seq Scan on int4_tbl
......
src/test/regress/expected/partition_prune.out
View file @ 55a1954d
This source diff could not be displayed because it is too large. You can view the blob instead.
src/test/regress/expected/rowsecurity.out
View file @ 55a1954d
...@@ -664,9 +664,9 @@ EXPLAIN (COSTS OFF) SELECT * FROM t1; ...@@ -664,9 +664,9 @@ EXPLAIN (COSTS OFF) SELECT * FROM t1;
Append Append
-> Seq Scan on t1 -> Seq Scan on t1
Filter: ((a % 2) = 0) Filter: ((a % 2) = 0)
-> Seq Scan on t2 -> Seq Scan on t2 t1_1
Filter: ((a % 2) = 0) Filter: ((a % 2) = 0)
-> Seq Scan on t3 -> Seq Scan on t3 t1_2
Filter: ((a % 2) = 0) Filter: ((a % 2) = 0)
(7 rows) (7 rows)
...@@ -691,9 +691,9 @@ EXPLAIN (COSTS OFF) SELECT * FROM t1 WHERE f_leak(b); ...@@ -691,9 +691,9 @@ EXPLAIN (COSTS OFF) SELECT * FROM t1 WHERE f_leak(b);
Append Append
-> Seq Scan on t1 -> Seq Scan on t1
Filter: (((a % 2) = 0) AND f_leak(b)) Filter: (((a % 2) = 0) AND f_leak(b))
-> Seq Scan on t2 -> Seq Scan on t2 t1_1
Filter: (((a % 2) = 0) AND f_leak(b)) Filter: (((a % 2) = 0) AND f_leak(b))
-> Seq Scan on t3 -> Seq Scan on t3 t1_2
Filter: (((a % 2) = 0) AND f_leak(b)) Filter: (((a % 2) = 0) AND f_leak(b))
(7 rows) (7 rows)
...@@ -714,9 +714,9 @@ EXPLAIN (COSTS OFF) SELECT *, t1 FROM t1; ...@@ -714,9 +714,9 @@ EXPLAIN (COSTS OFF) SELECT *, t1 FROM t1;
Append Append
-> Seq Scan on t1 -> Seq Scan on t1
Filter: ((a % 2) = 0) Filter: ((a % 2) = 0)
-> Seq Scan on t2 -> Seq Scan on t2 t1_1
Filter: ((a % 2) = 0) Filter: ((a % 2) = 0)
-> Seq Scan on t3 -> Seq Scan on t3 t1_2
Filter: ((a % 2) = 0) Filter: ((a % 2) = 0)
(7 rows) (7 rows)
...@@ -737,9 +737,9 @@ EXPLAIN (COSTS OFF) SELECT *, t1 FROM t1; ...@@ -737,9 +737,9 @@ EXPLAIN (COSTS OFF) SELECT *, t1 FROM t1;
Append Append
-> Seq Scan on t1 -> Seq Scan on t1
Filter: ((a % 2) = 0) Filter: ((a % 2) = 0)
-> Seq Scan on t2 -> Seq Scan on t2 t1_1
Filter: ((a % 2) = 0) Filter: ((a % 2) = 0)
-> Seq Scan on t3 -> Seq Scan on t3 t1_2
Filter: ((a % 2) = 0) Filter: ((a % 2) = 0)
(7 rows) (7 rows)
...@@ -761,9 +761,9 @@ EXPLAIN (COSTS OFF) SELECT * FROM t1 FOR SHARE; ...@@ -761,9 +761,9 @@ EXPLAIN (COSTS OFF) SELECT * FROM t1 FOR SHARE;
-> Append -> Append
-> Seq Scan on t1 -> Seq Scan on t1
Filter: ((a % 2) = 0) Filter: ((a % 2) = 0)
-> Seq Scan on t2 -> Seq Scan on t2 t1_1
Filter: ((a % 2) = 0) Filter: ((a % 2) = 0)
-> Seq Scan on t3 -> Seq Scan on t3 t1_2
Filter: ((a % 2) = 0) Filter: ((a % 2) = 0)
(8 rows) (8 rows)
...@@ -789,9 +789,9 @@ EXPLAIN (COSTS OFF) SELECT * FROM t1 WHERE f_leak(b) FOR SHARE; ...@@ -789,9 +789,9 @@ EXPLAIN (COSTS OFF) SELECT * FROM t1 WHERE f_leak(b) FOR SHARE;
-> Append -> Append
-> Seq Scan on t1 -> Seq Scan on t1
Filter: (((a % 2) = 0) AND f_leak(b)) Filter: (((a % 2) = 0) AND f_leak(b))
-> Seq Scan on t2 -> Seq Scan on t2 t1_1
Filter: (((a % 2) = 0) AND f_leak(b)) Filter: (((a % 2) = 0) AND f_leak(b))
-> Seq Scan on t3 -> Seq Scan on t3 t1_2
Filter: (((a % 2) = 0) AND f_leak(b)) Filter: (((a % 2) = 0) AND f_leak(b))
(8 rows) (8 rows)
...@@ -851,9 +851,9 @@ EXPLAIN (COSTS OFF) SELECT * FROM t1 WHERE f_leak(b); ...@@ -851,9 +851,9 @@ EXPLAIN (COSTS OFF) SELECT * FROM t1 WHERE f_leak(b);
Append Append
-> Seq Scan on t1 -> Seq Scan on t1
Filter: f_leak(b) Filter: f_leak(b)
-> Seq Scan on t2 -> Seq Scan on t2 t1_1
Filter: f_leak(b) Filter: f_leak(b)
-> Seq Scan on t3 -> Seq Scan on t3 t1_2
Filter: f_leak(b) Filter: f_leak(b)
(7 rows) (7 rows)
...@@ -893,9 +893,9 @@ EXPLAIN (COSTS OFF) SELECT * FROM t1 WHERE f_leak(b); ...@@ -893,9 +893,9 @@ EXPLAIN (COSTS OFF) SELECT * FROM t1 WHERE f_leak(b);
Append Append
-> Seq Scan on t1 -> Seq Scan on t1
Filter: f_leak(b) Filter: f_leak(b)
-> Seq Scan on t2 -> Seq Scan on t2 t1_1
Filter: f_leak(b) Filter: f_leak(b)
-> Seq Scan on t3 -> Seq Scan on t3 t1_2
Filter: f_leak(b) Filter: f_leak(b)
(7 rows) (7 rows)
...@@ -985,17 +985,17 @@ NOTICE: f_leak => my first satire ...@@ -985,17 +985,17 @@ NOTICE: f_leak => my first satire
(4 rows) (4 rows)
EXPLAIN (COSTS OFF) SELECT * FROM part_document WHERE f_leak(dtitle); EXPLAIN (COSTS OFF) SELECT * FROM part_document WHERE f_leak(dtitle);
QUERY PLAN QUERY PLAN
----------------------------------------------------- ------------------------------------------------------------
Append Append
InitPlan 1 (returns $0) InitPlan 1 (returns $0)
-> Index Scan using uaccount_pkey on uaccount -> Index Scan using uaccount_pkey on uaccount
Index Cond: (pguser = CURRENT_USER) Index Cond: (pguser = CURRENT_USER)
-> Seq Scan on part_document_fiction -> Seq Scan on part_document_fiction part_document
Filter: ((dlevel <= $0) AND f_leak(dtitle)) Filter: ((dlevel <= $0) AND f_leak(dtitle))
-> Seq Scan on part_document_satire -> Seq Scan on part_document_satire part_document_1
Filter: ((dlevel <= $0) AND f_leak(dtitle)) Filter: ((dlevel <= $0) AND f_leak(dtitle))
-> Seq Scan on part_document_nonfiction -> Seq Scan on part_document_nonfiction part_document_2
Filter: ((dlevel <= $0) AND f_leak(dtitle)) Filter: ((dlevel <= $0) AND f_leak(dtitle))
(10 rows) (10 rows)
...@@ -1027,17 +1027,17 @@ NOTICE: f_leak => awesome technology book ...@@ -1027,17 +1027,17 @@ NOTICE: f_leak => awesome technology book
(10 rows) (10 rows)
EXPLAIN (COSTS OFF) SELECT * FROM part_document WHERE f_leak(dtitle); EXPLAIN (COSTS OFF) SELECT * FROM part_document WHERE f_leak(dtitle);
QUERY PLAN QUERY PLAN
----------------------------------------------------- ------------------------------------------------------------
Append Append
InitPlan 1 (returns $0) InitPlan 1 (returns $0)
-> Index Scan using uaccount_pkey on uaccount -> Index Scan using uaccount_pkey on uaccount
Index Cond: (pguser = CURRENT_USER) Index Cond: (pguser = CURRENT_USER)
-> Seq Scan on part_document_fiction -> Seq Scan on part_document_fiction part_document
Filter: ((dlevel <= $0) AND f_leak(dtitle)) Filter: ((dlevel <= $0) AND f_leak(dtitle))
-> Seq Scan on part_document_satire -> Seq Scan on part_document_satire part_document_1
Filter: ((dlevel <= $0) AND f_leak(dtitle)) Filter: ((dlevel <= $0) AND f_leak(dtitle))
-> Seq Scan on part_document_nonfiction -> Seq Scan on part_document_nonfiction part_document_2
Filter: ((dlevel <= $0) AND f_leak(dtitle)) Filter: ((dlevel <= $0) AND f_leak(dtitle))
(10 rows) (10 rows)
...@@ -1059,7 +1059,7 @@ NOTICE: f_leak => awesome science fiction ...@@ -1059,7 +1059,7 @@ NOTICE: f_leak => awesome science fiction
EXPLAIN (COSTS OFF) SELECT * FROM part_document WHERE f_leak(dtitle); EXPLAIN (COSTS OFF) SELECT * FROM part_document WHERE f_leak(dtitle);
QUERY PLAN QUERY PLAN
-------------------------------------------------------------- --------------------------------------------------------------
Seq Scan on part_document_fiction Seq Scan on part_document_fiction part_document
Filter: ((cid < 55) AND (dlevel <= $0) AND f_leak(dtitle)) Filter: ((cid < 55) AND (dlevel <= $0) AND f_leak(dtitle))
InitPlan 1 (returns $0) InitPlan 1 (returns $0)
-> Index Scan using uaccount_pkey on uaccount -> Index Scan using uaccount_pkey on uaccount
...@@ -1137,7 +1137,7 @@ NOTICE: f_leak => awesome science fiction ...@@ -1137,7 +1137,7 @@ NOTICE: f_leak => awesome science fiction
EXPLAIN (COSTS OFF) SELECT * FROM part_document WHERE f_leak(dtitle); EXPLAIN (COSTS OFF) SELECT * FROM part_document WHERE f_leak(dtitle);
QUERY PLAN QUERY PLAN
-------------------------------------------------------------- --------------------------------------------------------------
Seq Scan on part_document_fiction Seq Scan on part_document_fiction part_document
Filter: ((cid < 55) AND (dlevel <= $0) AND f_leak(dtitle)) Filter: ((cid < 55) AND (dlevel <= $0) AND f_leak(dtitle))
InitPlan 1 (returns $0) InitPlan 1 (returns $0)
-> Index Scan using uaccount_pkey on uaccount -> Index Scan using uaccount_pkey on uaccount
...@@ -1174,17 +1174,17 @@ NOTICE: f_leak => awesome technology book ...@@ -1174,17 +1174,17 @@ NOTICE: f_leak => awesome technology book
(11 rows) (11 rows)
EXPLAIN (COSTS OFF) SELECT * FROM part_document WHERE f_leak(dtitle); EXPLAIN (COSTS OFF) SELECT * FROM part_document WHERE f_leak(dtitle);
QUERY PLAN QUERY PLAN
----------------------------------------------------- ------------------------------------------------------------
Append Append
InitPlan 1 (returns $0) InitPlan 1 (returns $0)
-> Index Scan using uaccount_pkey on uaccount -> Index Scan using uaccount_pkey on uaccount
Index Cond: (pguser = CURRENT_USER) Index Cond: (pguser = CURRENT_USER)
-> Seq Scan on part_document_fiction -> Seq Scan on part_document_fiction part_document
Filter: ((dlevel <= $0) AND f_leak(dtitle)) Filter: ((dlevel <= $0) AND f_leak(dtitle))
-> Seq Scan on part_document_satire -> Seq Scan on part_document_satire part_document_1
Filter: ((dlevel <= $0) AND f_leak(dtitle)) Filter: ((dlevel <= $0) AND f_leak(dtitle))
-> Seq Scan on part_document_nonfiction -> Seq Scan on part_document_nonfiction part_document_2
Filter: ((dlevel <= $0) AND f_leak(dtitle)) Filter: ((dlevel <= $0) AND f_leak(dtitle))
(10 rows) (10 rows)
...@@ -1229,11 +1229,11 @@ EXPLAIN (COSTS OFF) SELECT * FROM part_document WHERE f_leak(dtitle); ...@@ -1229,11 +1229,11 @@ EXPLAIN (COSTS OFF) SELECT * FROM part_document WHERE f_leak(dtitle);
QUERY PLAN QUERY PLAN
--------------------------------------------------------------- ---------------------------------------------------------------
Append Append
-> Seq Scan on part_document_fiction -> Seq Scan on part_document_fiction part_document
Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle))
-> Seq Scan on part_document_satire -> Seq Scan on part_document_satire part_document_1
Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle))
-> Seq Scan on part_document_nonfiction -> Seq Scan on part_document_nonfiction part_document_2
Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle))
(7 rows) (7 rows)
...@@ -1511,9 +1511,9 @@ EXPLAIN (COSTS OFF) EXECUTE p1(2); ...@@ -1511,9 +1511,9 @@ EXPLAIN (COSTS OFF) EXECUTE p1(2);
Append Append
-> Seq Scan on t1 -> Seq Scan on t1
Filter: ((a <= 2) AND ((a % 2) = 0)) Filter: ((a <= 2) AND ((a % 2) = 0))
-> Seq Scan on t2 -> Seq Scan on t2 t1_1
Filter: ((a <= 2) AND ((a % 2) = 0)) Filter: ((a <= 2) AND ((a % 2) = 0))
-> Seq Scan on t3 -> Seq Scan on t3 t1_2
Filter: ((a <= 2) AND ((a % 2) = 0)) Filter: ((a <= 2) AND ((a % 2) = 0))
(7 rows) (7 rows)
...@@ -1553,9 +1553,9 @@ EXPLAIN (COSTS OFF) SELECT * FROM t1 WHERE f_leak(b); ...@@ -1553,9 +1553,9 @@ EXPLAIN (COSTS OFF) SELECT * FROM t1 WHERE f_leak(b);
Append Append
-> Seq Scan on t1 -> Seq Scan on t1
Filter: f_leak(b) Filter: f_leak(b)
-> Seq Scan on t2 -> Seq Scan on t2 t1_1
Filter: f_leak(b) Filter: f_leak(b)
-> Seq Scan on t3 -> Seq Scan on t3 t1_2
Filter: f_leak(b) Filter: f_leak(b)
(7 rows) (7 rows)
...@@ -1572,14 +1572,14 @@ EXECUTE p1(2); ...@@ -1572,14 +1572,14 @@ EXECUTE p1(2);
(6 rows) (6 rows)
EXPLAIN (COSTS OFF) EXECUTE p1(2); EXPLAIN (COSTS OFF) EXECUTE p1(2);
QUERY PLAN QUERY PLAN
-------------------------- ---------------------------
Append Append
-> Seq Scan on t1 -> Seq Scan on t1
Filter: (a <= 2) Filter: (a <= 2)
-> Seq Scan on t2 -> Seq Scan on t2 t1_1
Filter: (a <= 2) Filter: (a <= 2)
-> Seq Scan on t3 -> Seq Scan on t3 t1_2
Filter: (a <= 2) Filter: (a <= 2)
(7 rows) (7 rows)
...@@ -1593,14 +1593,14 @@ EXECUTE p2(2); ...@@ -1593,14 +1593,14 @@ EXECUTE p2(2);
(3 rows) (3 rows)
EXPLAIN (COSTS OFF) EXECUTE p2(2); EXPLAIN (COSTS OFF) EXECUTE p2(2);
QUERY PLAN QUERY PLAN
------------------------- ---------------------------
Append Append
-> Seq Scan on t1 -> Seq Scan on t1
Filter: (a = 2) Filter: (a = 2)
-> Seq Scan on t2 -> Seq Scan on t2 t1_1
Filter: (a = 2) Filter: (a = 2)
-> Seq Scan on t3 -> Seq Scan on t3 t1_2
Filter: (a = 2) Filter: (a = 2)
(7 rows) (7 rows)
...@@ -1621,9 +1621,9 @@ EXPLAIN (COSTS OFF) EXECUTE p2(2); ...@@ -1621,9 +1621,9 @@ EXPLAIN (COSTS OFF) EXECUTE p2(2);
Append Append
-> Seq Scan on t1 -> Seq Scan on t1
Filter: ((a = 2) AND ((a % 2) = 0)) Filter: ((a = 2) AND ((a % 2) = 0))
-> Seq Scan on t2 -> Seq Scan on t2 t1_1
Filter: ((a = 2) AND ((a % 2) = 0)) Filter: ((a = 2) AND ((a % 2) = 0))
-> Seq Scan on t3 -> Seq Scan on t3 t1_2
Filter: ((a = 2) AND ((a % 2) = 0)) Filter: ((a = 2) AND ((a % 2) = 0))
(7 rows) (7 rows)
...@@ -1636,13 +1636,13 @@ EXPLAIN (COSTS OFF) UPDATE t1 SET b = b || b WHERE f_leak(b); ...@@ -1636,13 +1636,13 @@ EXPLAIN (COSTS OFF) UPDATE t1 SET b = b || b WHERE f_leak(b);
----------------------------------------------- -----------------------------------------------
Update on t1 Update on t1
Update on t1 Update on t1
Update on t2 Update on t2 t1_1
Update on t3 Update on t3 t1_2
-> Seq Scan on t1 -> Seq Scan on t1
Filter: (((a % 2) = 0) AND f_leak(b)) Filter: (((a % 2) = 0) AND f_leak(b))
-> Seq Scan on t2 -> Seq Scan on t2 t1_1
Filter: (((a % 2) = 0) AND f_leak(b)) Filter: (((a % 2) = 0) AND f_leak(b))
-> Seq Scan on t3 -> Seq Scan on t3 t1_2
Filter: (((a % 2) = 0) AND f_leak(b)) Filter: (((a % 2) = 0) AND f_leak(b))
(10 rows) (10 rows)
...@@ -1726,20 +1726,20 @@ WHERE t1.a = 3 and t2.a = 3 AND f_leak(t1.b) AND f_leak(t2.b); ...@@ -1726,20 +1726,20 @@ WHERE t1.a = 3 and t2.a = 3 AND f_leak(t1.b) AND f_leak(t2.b);
----------------------------------------------------------------- -----------------------------------------------------------------
Update on t1 Update on t1
Update on t1 Update on t1
Update on t2 t2_1 Update on t2 t1_1
Update on t3 Update on t3 t1_2
-> Nested Loop -> Nested Loop
-> Seq Scan on t1 -> Seq Scan on t1
Filter: ((a = 3) AND ((a % 2) = 0) AND f_leak(b)) Filter: ((a = 3) AND ((a % 2) = 0) AND f_leak(b))
-> Seq Scan on t2 -> Seq Scan on t2
Filter: ((a = 3) AND ((a % 2) = 1) AND f_leak(b)) Filter: ((a = 3) AND ((a % 2) = 1) AND f_leak(b))
-> Nested Loop -> Nested Loop
-> Seq Scan on t2 t2_1 -> Seq Scan on t2 t1_1
Filter: ((a = 3) AND ((a % 2) = 0) AND f_leak(b)) Filter: ((a = 3) AND ((a % 2) = 0) AND f_leak(b))
-> Seq Scan on t2 -> Seq Scan on t2
Filter: ((a = 3) AND ((a % 2) = 1) AND f_leak(b)) Filter: ((a = 3) AND ((a % 2) = 1) AND f_leak(b))
-> Nested Loop -> Nested Loop
-> Seq Scan on t3 -> Seq Scan on t3 t1_2
Filter: ((a = 3) AND ((a % 2) = 0) AND f_leak(b)) Filter: ((a = 3) AND ((a % 2) = 0) AND f_leak(b))
-> Seq Scan on t2 -> Seq Scan on t2
Filter: ((a = 3) AND ((a % 2) = 1) AND f_leak(b)) Filter: ((a = 3) AND ((a % 2) = 1) AND f_leak(b))
...@@ -1758,9 +1758,9 @@ WHERE t1.a = 3 and t2.a = 3 AND f_leak(t1.b) AND f_leak(t2.b); ...@@ -1758,9 +1758,9 @@ WHERE t1.a = 3 and t2.a = 3 AND f_leak(t1.b) AND f_leak(t2.b);
-> Append -> Append
-> Seq Scan on t1 -> Seq Scan on t1
Filter: ((a = 3) AND ((a % 2) = 0) AND f_leak(b)) Filter: ((a = 3) AND ((a % 2) = 0) AND f_leak(b))
-> Seq Scan on t2 t2_1 -> Seq Scan on t2 t1_1
Filter: ((a = 3) AND ((a % 2) = 0) AND f_leak(b)) Filter: ((a = 3) AND ((a % 2) = 0) AND f_leak(b))
-> Seq Scan on t3 -> Seq Scan on t3 t1_2
Filter: ((a = 3) AND ((a % 2) = 0) AND f_leak(b)) Filter: ((a = 3) AND ((a % 2) = 0) AND f_leak(b))
(11 rows) (11 rows)
...@@ -1884,13 +1884,13 @@ EXPLAIN (COSTS OFF) DELETE FROM t1 WHERE f_leak(b); ...@@ -1884,13 +1884,13 @@ EXPLAIN (COSTS OFF) DELETE FROM t1 WHERE f_leak(b);
----------------------------------------------- -----------------------------------------------
Delete on t1 Delete on t1
Delete on t1 Delete on t1
Delete on t2 Delete on t2 t1_1
Delete on t3 Delete on t3 t1_2
-> Seq Scan on t1 -> Seq Scan on t1
Filter: (((a % 2) = 0) AND f_leak(b)) Filter: (((a % 2) = 0) AND f_leak(b))
-> Seq Scan on t2 -> Seq Scan on t2 t1_1
Filter: (((a % 2) = 0) AND f_leak(b)) Filter: (((a % 2) = 0) AND f_leak(b))
-> Seq Scan on t3 -> Seq Scan on t3 t1_2
Filter: (((a % 2) = 0) AND f_leak(b)) Filter: (((a % 2) = 0) AND f_leak(b))
(10 rows) (10 rows)
......
src/test/regress/expected/select_parallel.out
View file @ 55a1954d
...@@ -14,18 +14,18 @@ set max_parallel_workers_per_gather=4; ...@@ -14,18 +14,18 @@ set max_parallel_workers_per_gather=4;
-- Parallel Append with partial-subplans -- Parallel Append with partial-subplans
explain (costs off) explain (costs off)
select round(avg(aa)), sum(aa) from a_star; select round(avg(aa)), sum(aa) from a_star;
QUERY PLAN QUERY PLAN
----------------------------------------------------- --------------------------------------------------------------
Finalize Aggregate Finalize Aggregate
-> Gather -> Gather
Workers Planned: 3 Workers Planned: 3
-> Partial Aggregate -> Partial Aggregate
-> Parallel Append -> Parallel Append
-> Parallel Seq Scan on d_star -> Parallel Seq Scan on d_star a_star_3
-> Parallel Seq Scan on f_star -> Parallel Seq Scan on f_star a_star_5
-> Parallel Seq Scan on e_star -> Parallel Seq Scan on e_star a_star_4
-> Parallel Seq Scan on b_star -> Parallel Seq Scan on b_star a_star_1
-> Parallel Seq Scan on c_star -> Parallel Seq Scan on c_star a_star_2
-> Parallel Seq Scan on a_star -> Parallel Seq Scan on a_star
(11 rows) (11 rows)
...@@ -40,18 +40,18 @@ alter table c_star set (parallel_workers = 0); ...@@ -40,18 +40,18 @@ alter table c_star set (parallel_workers = 0);
alter table d_star set (parallel_workers = 0); alter table d_star set (parallel_workers = 0);
explain (costs off) explain (costs off)
select round(avg(aa)), sum(aa) from a_star; select round(avg(aa)), sum(aa) from a_star;
QUERY PLAN QUERY PLAN
----------------------------------------------------- --------------------------------------------------------------
Finalize Aggregate Finalize Aggregate
-> Gather -> Gather
Workers Planned: 3 Workers Planned: 3
-> Partial Aggregate -> Partial Aggregate
-> Parallel Append -> Parallel Append
-> Seq Scan on d_star -> Seq Scan on d_star a_star_3
-> Seq Scan on c_star -> Seq Scan on c_star a_star_2
-> Parallel Seq Scan on f_star -> Parallel Seq Scan on f_star a_star_5
-> Parallel Seq Scan on e_star -> Parallel Seq Scan on e_star a_star_4
-> Parallel Seq Scan on b_star -> Parallel Seq Scan on b_star a_star_1
-> Parallel Seq Scan on a_star -> Parallel Seq Scan on a_star
(11 rows) (11 rows)
...@@ -68,18 +68,18 @@ alter table e_star set (parallel_workers = 0); ...@@ -68,18 +68,18 @@ alter table e_star set (parallel_workers = 0);
alter table f_star set (parallel_workers = 0); alter table f_star set (parallel_workers = 0);
explain (costs off) explain (costs off)
select round(avg(aa)), sum(aa) from a_star; select round(avg(aa)), sum(aa) from a_star;
QUERY PLAN QUERY PLAN
-------------------------------------------- -----------------------------------------------------
Finalize Aggregate Finalize Aggregate
-> Gather -> Gather
Workers Planned: 3 Workers Planned: 3
-> Partial Aggregate -> Partial Aggregate
-> Parallel Append -> Parallel Append
-> Seq Scan on d_star -> Seq Scan on d_star a_star_3
-> Seq Scan on f_star -> Seq Scan on f_star a_star_5
-> Seq Scan on e_star -> Seq Scan on e_star a_star_4
-> Seq Scan on b_star -> Seq Scan on b_star a_star_1
-> Seq Scan on c_star -> Seq Scan on c_star a_star_2
-> Seq Scan on a_star -> Seq Scan on a_star
(11 rows) (11 rows)
...@@ -99,19 +99,19 @@ alter table f_star reset (parallel_workers); ...@@ -99,19 +99,19 @@ alter table f_star reset (parallel_workers);
set enable_parallel_append to off; set enable_parallel_append to off;
explain (costs off) explain (costs off)
select round(avg(aa)), sum(aa) from a_star; select round(avg(aa)), sum(aa) from a_star;
QUERY PLAN QUERY PLAN
----------------------------------------------------- --------------------------------------------------------------
Finalize Aggregate Finalize Aggregate
-> Gather -> Gather
Workers Planned: 1 Workers Planned: 1
-> Partial Aggregate -> Partial Aggregate
-> Append -> Append
-> Parallel Seq Scan on a_star -> Parallel Seq Scan on a_star
-> Parallel Seq Scan on b_star -> Parallel Seq Scan on b_star a_star_1
-> Parallel Seq Scan on c_star -> Parallel Seq Scan on c_star a_star_2
-> Parallel Seq Scan on d_star -> Parallel Seq Scan on d_star a_star_3
-> Parallel Seq Scan on e_star -> Parallel Seq Scan on e_star a_star_4
-> Parallel Seq Scan on f_star -> Parallel Seq Scan on f_star a_star_5
(11 rows) (11 rows)
select round(avg(aa)), sum(aa) from a_star a4; select round(avg(aa)), sum(aa) from a_star a4;
......
src/test/regress/expected/tablesample.out
View file @ 55a1954d
...@@ -200,11 +200,11 @@ explain (costs off) ...@@ -200,11 +200,11 @@ explain (costs off)
-> Append -> Append
-> Sample Scan on person -> Sample Scan on person
Sampling: bernoulli ('100'::real) Sampling: bernoulli ('100'::real)
-> Sample Scan on emp -> Sample Scan on emp person_1
Sampling: bernoulli ('100'::real) Sampling: bernoulli ('100'::real)
-> Sample Scan on student -> Sample Scan on student person_2
Sampling: bernoulli ('100'::real) Sampling: bernoulli ('100'::real)
-> Sample Scan on stud_emp -> Sample Scan on stud_emp person_3
Sampling: bernoulli ('100'::real) Sampling: bernoulli ('100'::real)
(10 rows) (10 rows)
...@@ -319,12 +319,12 @@ create table parted_sample_1 partition of parted_sample for values in (1); ...@@ -319,12 +319,12 @@ create table parted_sample_1 partition of parted_sample for values in (1);
create table parted_sample_2 partition of parted_sample for values in (2); create table parted_sample_2 partition of parted_sample for values in (2);
explain (costs off) explain (costs off)
select * from parted_sample tablesample bernoulli (100); select * from parted_sample tablesample bernoulli (100);
QUERY PLAN QUERY PLAN
------------------------------------------- ------------------------------------------------------
Append Append
-> Sample Scan on parted_sample_1 -> Sample Scan on parted_sample_1 parted_sample
Sampling: bernoulli ('100'::real) Sampling: bernoulli ('100'::real)
-> Sample Scan on parted_sample_2 -> Sample Scan on parted_sample_2 parted_sample_1
Sampling: bernoulli ('100'::real) Sampling: bernoulli ('100'::real)
(5 rows) (5 rows)
......
src/test/regress/expected/union.out
View file @ 55a1954d
...@@ -751,15 +751,15 @@ explain (costs off) ...@@ -751,15 +751,15 @@ explain (costs off)
UNION ALL UNION ALL
SELECT ab FROM t2) t SELECT ab FROM t2) t
ORDER BY 1 LIMIT 8; ORDER BY 1 LIMIT 8;
QUERY PLAN QUERY PLAN
------------------------------------------------ -----------------------------------------------------
Limit Limit
-> Merge Append -> Merge Append
Sort Key: ((t1.a || t1.b)) Sort Key: ((t1.a || t1.b))
-> Index Scan using t1_ab_idx on t1 -> Index Scan using t1_ab_idx on t1
-> Index Scan using t1c_ab_idx on t1c -> Index Scan using t1c_ab_idx on t1c t1_1
-> Index Scan using t2_pkey on t2 -> Index Scan using t2_pkey on t2
-> Index Scan using t2c_pkey on t2c -> Index Scan using t2c_pkey on t2c t2_1
(7 rows) (7 rows)
SELECT * FROM SELECT * FROM
...@@ -798,8 +798,8 @@ select event_id ...@@ -798,8 +798,8 @@ select event_id
Sort Key: events.event_id Sort Key: events.event_id
-> Index Scan using events_pkey on events -> Index Scan using events_pkey on events
-> Sort -> Sort
Sort Key: events_child.event_id Sort Key: events_1.event_id
-> Seq Scan on events_child -> Seq Scan on events_child events_1
-> Index Scan using other_events_pkey on other_events -> Index Scan using other_events_pkey on other_events
(7 rows) (7 rows)
......
src/test/regress/expected/updatable_views.out
View file @ 55a1954d
...@@ -1548,28 +1548,28 @@ INSERT INTO other_tbl_parent VALUES (7),(200); ...@@ -1548,28 +1548,28 @@ INSERT INTO other_tbl_parent VALUES (7),(200);
INSERT INTO other_tbl_child VALUES (8),(100); INSERT INTO other_tbl_child VALUES (8),(100);
EXPLAIN (costs off) EXPLAIN (costs off)
UPDATE rw_view1 SET a = a + 1000 FROM other_tbl_parent WHERE a = id; UPDATE rw_view1 SET a = a + 1000 FROM other_tbl_parent WHERE a = id;
QUERY PLAN QUERY PLAN
-------------------------------------------------------------- ------------------------------------------------------------------------
Update on base_tbl_parent Update on base_tbl_parent
Update on base_tbl_parent Update on base_tbl_parent
Update on base_tbl_child Update on base_tbl_child base_tbl_parent_1
-> Hash Join -> Hash Join
Hash Cond: (other_tbl_parent.id = base_tbl_parent.a) Hash Cond: (other_tbl_parent.id = base_tbl_parent.a)
-> Append -> Append
-> Seq Scan on other_tbl_parent -> Seq Scan on other_tbl_parent
-> Seq Scan on other_tbl_child -> Seq Scan on other_tbl_child other_tbl_parent_1
-> Hash -> Hash
-> Seq Scan on base_tbl_parent -> Seq Scan on base_tbl_parent
-> Merge Join -> Merge Join
Merge Cond: (base_tbl_child.a = other_tbl_parent.id) Merge Cond: (base_tbl_parent_1.a = other_tbl_parent.id)
-> Sort -> Sort
Sort Key: base_tbl_child.a Sort Key: base_tbl_parent_1.a
-> Seq Scan on base_tbl_child -> Seq Scan on base_tbl_child base_tbl_parent_1
-> Sort -> Sort
Sort Key: other_tbl_parent.id Sort Key: other_tbl_parent.id
-> Append -> Append
-> Seq Scan on other_tbl_parent -> Seq Scan on other_tbl_parent
-> Seq Scan on other_tbl_child -> Seq Scan on other_tbl_child other_tbl_parent_1
(20 rows) (20 rows)
UPDATE rw_view1 SET a = a + 1000 FROM other_tbl_parent WHERE a = id; UPDATE rw_view1 SET a = a + 1000 FROM other_tbl_parent WHERE a = id;
...@@ -2284,37 +2284,37 @@ UPDATE v1 SET a=100 WHERE snoop(a) AND leakproof(a) AND a < 7 AND a != 6; ...@@ -2284,37 +2284,37 @@ UPDATE v1 SET a=100 WHERE snoop(a) AND leakproof(a) AND a < 7 AND a != 6;
--------------------------------------------------------------------------------------------------------------------------- ---------------------------------------------------------------------------------------------------------------------------
Update on public.t1 Update on public.t1
Update on public.t1 Update on public.t1
Update on public.t11 Update on public.t11 t1_1
Update on public.t12 Update on public.t12 t1_2
Update on public.t111 Update on public.t111 t1_3
-> Index Scan using t1_a_idx on public.t1 -> Index Scan using t1_a_idx on public.t1
Output: 100, t1.b, t1.c, t1.ctid Output: 100, t1.b, t1.c, t1.ctid
Index Cond: ((t1.a > 5) AND (t1.a < 7)) Index Cond: ((t1.a > 5) AND (t1.a < 7))
Filter: ((t1.a <> 6) AND (alternatives: SubPlan 1 or hashed SubPlan 2) AND snoop(t1.a) AND leakproof(t1.a)) Filter: ((t1.a <> 6) AND (alternatives: SubPlan 1 or hashed SubPlan 2) AND snoop(t1.a) AND leakproof(t1.a))
SubPlan 1 SubPlan 1
-> Append -> Append
-> Seq Scan on public.t12 t12_1 -> Seq Scan on public.t12
Filter: (t12.a = t1.a)
-> Seq Scan on public.t111 t12_1
Filter: (t12_1.a = t1.a) Filter: (t12_1.a = t1.a)
-> Seq Scan on public.t111 t111_1
Filter: (t111_1.a = t1.a)
SubPlan 2 SubPlan 2
-> Append -> Append
-> Seq Scan on public.t12 t12_2 -> Seq Scan on public.t12 t12_2
Output: t12_2.a Output: t12_2.a
-> Seq Scan on public.t111 t111_2 -> Seq Scan on public.t111 t12_3
Output: t111_2.a Output: t12_3.a
-> Index Scan using t11_a_idx on public.t11 -> Index Scan using t11_a_idx on public.t11 t1_1
Output: 100, t11.b, t11.c, t11.d, t11.ctid Output: 100, t1_1.b, t1_1.c, t1_1.d, t1_1.ctid
Index Cond: ((t11.a > 5) AND (t11.a < 7)) Index Cond: ((t1_1.a > 5) AND (t1_1.a < 7))
Filter: ((t11.a <> 6) AND (alternatives: SubPlan 1 or hashed SubPlan 2) AND snoop(t11.a) AND leakproof(t11.a)) Filter: ((t1_1.a <> 6) AND (alternatives: SubPlan 1 or hashed SubPlan 2) AND snoop(t1_1.a) AND leakproof(t1_1.a))
-> Index Scan using t12_a_idx on public.t12 -> Index Scan using t12_a_idx on public.t12 t1_2
Output: 100, t12.b, t12.c, t12.e, t12.ctid Output: 100, t1_2.b, t1_2.c, t1_2.e, t1_2.ctid
Index Cond: ((t12.a > 5) AND (t12.a < 7)) Index Cond: ((t1_2.a > 5) AND (t1_2.a < 7))
Filter: ((t12.a <> 6) AND (alternatives: SubPlan 1 or hashed SubPlan 2) AND snoop(t12.a) AND leakproof(t12.a)) Filter: ((t1_2.a <> 6) AND (alternatives: SubPlan 1 or hashed SubPlan 2) AND snoop(t1_2.a) AND leakproof(t1_2.a))
-> Index Scan using t111_a_idx on public.t111 -> Index Scan using t111_a_idx on public.t111 t1_3
Output: 100, t111.b, t111.c, t111.d, t111.e, t111.ctid Output: 100, t1_3.b, t1_3.c, t1_3.d, t1_3.e, t1_3.ctid
Index Cond: ((t111.a > 5) AND (t111.a < 7)) Index Cond: ((t1_3.a > 5) AND (t1_3.a < 7))
Filter: ((t111.a <> 6) AND (alternatives: SubPlan 1 or hashed SubPlan 2) AND snoop(t111.a) AND leakproof(t111.a)) Filter: ((t1_3.a <> 6) AND (alternatives: SubPlan 1 or hashed SubPlan 2) AND snoop(t1_3.a) AND leakproof(t1_3.a))
(33 rows) (33 rows)
UPDATE v1 SET a=100 WHERE snoop(a) AND leakproof(a) AND a < 7 AND a != 6; UPDATE v1 SET a=100 WHERE snoop(a) AND leakproof(a) AND a < 7 AND a != 6;
...@@ -2334,37 +2334,37 @@ UPDATE v1 SET a=a+1 WHERE snoop(a) AND leakproof(a) AND a = 8; ...@@ -2334,37 +2334,37 @@ UPDATE v1 SET a=a+1 WHERE snoop(a) AND leakproof(a) AND a = 8;
--------------------------------------------------------------------------------------------------------- ---------------------------------------------------------------------------------------------------------
Update on public.t1 Update on public.t1
Update on public.t1 Update on public.t1
Update on public.t11 Update on public.t11 t1_1
Update on public.t12 Update on public.t12 t1_2
Update on public.t111 Update on public.t111 t1_3
-> Index Scan using t1_a_idx on public.t1 -> Index Scan using t1_a_idx on public.t1
Output: (t1.a + 1), t1.b, t1.c, t1.ctid Output: (t1.a + 1), t1.b, t1.c, t1.ctid
Index Cond: ((t1.a > 5) AND (t1.a = 8)) Index Cond: ((t1.a > 5) AND (t1.a = 8))
Filter: ((alternatives: SubPlan 1 or hashed SubPlan 2) AND snoop(t1.a) AND leakproof(t1.a)) Filter: ((alternatives: SubPlan 1 or hashed SubPlan 2) AND snoop(t1.a) AND leakproof(t1.a))
SubPlan 1 SubPlan 1
-> Append -> Append
-> Seq Scan on public.t12 t12_1 -> Seq Scan on public.t12
Filter: (t12.a = t1.a)
-> Seq Scan on public.t111 t12_1
Filter: (t12_1.a = t1.a) Filter: (t12_1.a = t1.a)
-> Seq Scan on public.t111 t111_1
Filter: (t111_1.a = t1.a)
SubPlan 2 SubPlan 2
-> Append -> Append
-> Seq Scan on public.t12 t12_2 -> Seq Scan on public.t12 t12_2
Output: t12_2.a Output: t12_2.a
-> Seq Scan on public.t111 t111_2 -> Seq Scan on public.t111 t12_3
Output: t111_2.a Output: t12_3.a
-> Index Scan using t11_a_idx on public.t11 -> Index Scan using t11_a_idx on public.t11 t1_1
Output: (t11.a + 1), t11.b, t11.c, t11.d, t11.ctid Output: (t1_1.a + 1), t1_1.b, t1_1.c, t1_1.d, t1_1.ctid
Index Cond: ((t11.a > 5) AND (t11.a = 8)) Index Cond: ((t1_1.a > 5) AND (t1_1.a = 8))
Filter: ((alternatives: SubPlan 1 or hashed SubPlan 2) AND snoop(t11.a) AND leakproof(t11.a)) Filter: ((alternatives: SubPlan 1 or hashed SubPlan 2) AND snoop(t1_1.a) AND leakproof(t1_1.a))
-> Index Scan using t12_a_idx on public.t12 -> Index Scan using t12_a_idx on public.t12 t1_2
Output: (t12.a + 1), t12.b, t12.c, t12.e, t12.ctid Output: (t1_2.a + 1), t1_2.b, t1_2.c, t1_2.e, t1_2.ctid
Index Cond: ((t12.a > 5) AND (t12.a = 8)) Index Cond: ((t1_2.a > 5) AND (t1_2.a = 8))
Filter: ((alternatives: SubPlan 1 or hashed SubPlan 2) AND snoop(t12.a) AND leakproof(t12.a)) Filter: ((alternatives: SubPlan 1 or hashed SubPlan 2) AND snoop(t1_2.a) AND leakproof(t1_2.a))
-> Index Scan using t111_a_idx on public.t111 -> Index Scan using t111_a_idx on public.t111 t1_3
Output: (t111.a + 1), t111.b, t111.c, t111.d, t111.e, t111.ctid Output: (t1_3.a + 1), t1_3.b, t1_3.c, t1_3.d, t1_3.e, t1_3.ctid
Index Cond: ((t111.a > 5) AND (t111.a = 8)) Index Cond: ((t1_3.a > 5) AND (t1_3.a = 8))
Filter: ((alternatives: SubPlan 1 or hashed SubPlan 2) AND snoop(t111.a) AND leakproof(t111.a)) Filter: ((alternatives: SubPlan 1 or hashed SubPlan 2) AND snoop(t1_3.a) AND leakproof(t1_3.a))
(33 rows) (33 rows)
UPDATE v1 SET a=a+1 WHERE snoop(a) AND leakproof(a) AND a = 8; UPDATE v1 SET a=a+1 WHERE snoop(a) AND leakproof(a) AND a = 8;
......
src/test/regress/expected/update.out
View file @ 55a1954d
...@@ -310,29 +310,29 @@ ALTER TABLE part_b_10_b_20 ATTACH PARTITION part_c_1_100 FOR VALUES FROM (1) TO ...@@ -310,29 +310,29 @@ ALTER TABLE part_b_10_b_20 ATTACH PARTITION part_c_1_100 FOR VALUES FROM (1) TO
-- The order of subplans should be in bound order -- The order of subplans should be in bound order
EXPLAIN (costs off) UPDATE range_parted set c = c - 50 WHERE c > 97; EXPLAIN (costs off) UPDATE range_parted set c = c - 50 WHERE c > 97;
QUERY PLAN QUERY PLAN
------------------------------------- -------------------------------------------------
Update on range_parted Update on range_parted
Update on part_a_1_a_10 Update on part_a_1_a_10 range_parted_1
Update on part_a_10_a_20 Update on part_a_10_a_20 range_parted_2
Update on part_b_1_b_10 Update on part_b_1_b_10 range_parted_3
Update on part_c_1_100 Update on part_c_1_100 range_parted_4
Update on part_d_1_15 Update on part_d_1_15 range_parted_5
Update on part_d_15_20 Update on part_d_15_20 range_parted_6
Update on part_b_20_b_30 Update on part_b_20_b_30 range_parted_7
-> Seq Scan on part_a_1_a_10 -> Seq Scan on part_a_1_a_10 range_parted_1
Filter: (c > '97'::numeric) Filter: (c > '97'::numeric)
-> Seq Scan on part_a_10_a_20 -> Seq Scan on part_a_10_a_20 range_parted_2
Filter: (c > '97'::numeric) Filter: (c > '97'::numeric)
-> Seq Scan on part_b_1_b_10 -> Seq Scan on part_b_1_b_10 range_parted_3
Filter: (c > '97'::numeric) Filter: (c > '97'::numeric)
-> Seq Scan on part_c_1_100 -> Seq Scan on part_c_1_100 range_parted_4
Filter: (c > '97'::numeric) Filter: (c > '97'::numeric)
-> Seq Scan on part_d_1_15 -> Seq Scan on part_d_1_15 range_parted_5
Filter: (c > '97'::numeric) Filter: (c > '97'::numeric)
-> Seq Scan on part_d_15_20 -> Seq Scan on part_d_15_20 range_parted_6
Filter: (c > '97'::numeric) Filter: (c > '97'::numeric)
-> Seq Scan on part_b_20_b_30 -> Seq Scan on part_b_20_b_30 range_parted_7
Filter: (c > '97'::numeric) Filter: (c > '97'::numeric)
(22 rows) (22 rows)
......
src/test/regress/expected/with.out
View file @ 55a1954d
...@@ -2185,9 +2185,9 @@ DELETE FROM a USING wcte WHERE aa = q2; ...@@ -2185,9 +2185,9 @@ DELETE FROM a USING wcte WHERE aa = q2;
---------------------------------------------------- ----------------------------------------------------
Delete on public.a Delete on public.a
Delete on public.a Delete on public.a
Delete on public.b Delete on public.b a_1
Delete on public.c Delete on public.c a_2
Delete on public.d Delete on public.d a_3
CTE wcte CTE wcte
-> Insert on public.int8_tbl -> Insert on public.int8_tbl
Output: int8_tbl.q2 Output: int8_tbl.q2
...@@ -2201,24 +2201,24 @@ DELETE FROM a USING wcte WHERE aa = q2; ...@@ -2201,24 +2201,24 @@ DELETE FROM a USING wcte WHERE aa = q2;
-> CTE Scan on wcte -> CTE Scan on wcte
Output: wcte.*, wcte.q2 Output: wcte.*, wcte.q2
-> Nested Loop -> Nested Loop
Output: b.ctid, wcte.* Output: a_1.ctid, wcte.*
Join Filter: (b.aa = wcte.q2) Join Filter: (a_1.aa = wcte.q2)
-> Seq Scan on public.b -> Seq Scan on public.b a_1
Output: b.ctid, b.aa Output: a_1.ctid, a_1.aa
-> CTE Scan on wcte -> CTE Scan on wcte
Output: wcte.*, wcte.q2 Output: wcte.*, wcte.q2
-> Nested Loop -> Nested Loop
Output: c.ctid, wcte.* Output: a_2.ctid, wcte.*
Join Filter: (c.aa = wcte.q2) Join Filter: (a_2.aa = wcte.q2)
-> Seq Scan on public.c -> Seq Scan on public.c a_2
Output: c.ctid, c.aa Output: a_2.ctid, a_2.aa
-> CTE Scan on wcte -> CTE Scan on wcte
Output: wcte.*, wcte.q2 Output: wcte.*, wcte.q2
-> Nested Loop -> Nested Loop
Output: d.ctid, wcte.* Output: a_3.ctid, wcte.*
Join Filter: (d.aa = wcte.q2) Join Filter: (a_3.aa = wcte.q2)
-> Seq Scan on public.d -> Seq Scan on public.d a_3
Output: d.ctid, d.aa Output: a_3.ctid, a_3.aa
-> CTE Scan on wcte -> CTE Scan on wcte
Output: wcte.*, wcte.q2 Output: wcte.*, wcte.q2
(38 rows) (38 rows)
......
src/test/regress/sql/partition_prune.sql
View file @ 55a1954d
...@@ -202,8 +202,13 @@ CREATE TABLE part (a INT, b INT) PARTITION BY LIST (a); ...@@ -202,8 +202,13 @@ CREATE TABLE part (a INT, b INT) PARTITION BY LIST (a);
CREATE TABLE part_p1 PARTITION OF part FOR VALUES IN (-2,-1,0,1,2); CREATE TABLE part_p1 PARTITION OF part FOR VALUES IN (-2,-1,0,1,2);
CREATE TABLE part_p2 PARTITION OF part DEFAULT PARTITION BY RANGE(a); CREATE TABLE part_p2 PARTITION OF part DEFAULT PARTITION BY RANGE(a);
CREATE TABLE part_p2_p1 PARTITION OF part_p2 DEFAULT; CREATE TABLE part_p2_p1 PARTITION OF part_p2 DEFAULT;
CREATE TABLE part_rev (b INT, c INT, a INT);
ALTER TABLE part ATTACH PARTITION part_rev FOR VALUES IN (3); -- fail
ALTER TABLE part_rev DROP COLUMN c;
ALTER TABLE part ATTACH PARTITION part_rev FOR VALUES IN (3); -- now it's ok
INSERT INTO part VALUES (-1,-1), (1,1), (2,NULL), (NULL,-2),(NULL,NULL); INSERT INTO part VALUES (-1,-1), (1,1), (2,NULL), (NULL,-2),(NULL,NULL);
EXPLAIN (COSTS OFF) SELECT tableoid::regclass as part, a, b FROM part WHERE a IS NULL ORDER BY 1, 2, 3; EXPLAIN (COSTS OFF) SELECT tableoid::regclass as part, a, b FROM part WHERE a IS NULL ORDER BY 1, 2, 3;
EXPLAIN (VERBOSE, COSTS OFF) SELECT * FROM part p(x) ORDER BY x;
-- --
-- some more cases -- some more cases
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment