/* * This file is used to test pull down of subplan expressions */ set query_dop = 1; create schema nodegroup_subplan_test; set current_schema = nodegroup_subplan_test; set enable_nodegroup_explain=true; ERROR: unrecognized configuration parameter "enable_nodegroup_explain" set expected_computing_nodegroup='group1'; create node group ng0 with (datanode1, datanode2, datanode3); create node group ng1 with (datanode4, datanode5, datanode6); create node group ng2 with (datanode7, datanode8, datanode9); create node group ng3 with (datanode10, datanode11, datanode12); -- Create Table and Insert Data create table temp(a int, b int, c int, d int)with(autovacuum_enabled = off); create table t_subplan1(a1 int, b1 int, c1 int, d1 int) with (orientation = column,autovacuum_enabled = off) distribute by hash(a1, b1) to group ng0; create table t_subplan2(a2 int, b2 int, c2 int, d2 int) with (orientation = column,autovacuum_enabled = off) distribute by hash(a2, b2) to group ng1; insert into temp select generate_series(1, 100)%98, generate_series(1, 100)%20, generate_series(1, 100)%13, generate_series(1, 100)%6; insert into t_subplan1 select * from temp; delete from temp; insert into temp select generate_series(1, 50)%48, generate_series(1, 50)%28, generate_series(1, 50)%12, generate_series(1, 50)%9; insert into t_subplan2 select * from temp; create table t_subplan5(a1 int, b1 int, c1 int, d1 int) with (orientation = column,autovacuum_enabled = off) distribute by hash(a1, b1) to group ng2; create table t_subplan6(a2 int, b2 int, c2 int, d2 int) with (orientation = column,autovacuum_enabled = off) distribute by hash(a2, b2) to group ng3; insert into t_subplan5 select * from t_subplan1; insert into t_subplan6 select * from t_subplan2; --create row table create table t_subplan7(a1 int, b1 int, c1 int, d1 int) with (orientation = column,autovacuum_enabled = off) distribute by hash(a1, b1) to group ng1; insert into t_subplan7 select * from t_subplan1; -- 1. initplan explain (costs off) select case when (select count(*) from t_subplan2 where a2 between 1 and 20) > 15 then (select avg(b2) from t_subplan2 where a2 between 1 and 20) else (select avg(c2) from t_subplan2 where a2 between 1 and 20) end bucket1 , case when (select count(*) from t_subplan2 where a2 between 1 and 20) > 25 then (select avg(b2) from t_subplan2 where a2 between 1 and 20) else (select avg(c2) from t_subplan2 where a2 between 1 and 20) end bucket2 from t_subplan1 where a1 = 5 or a1 = 6 ; QUERY PLAN ------------------------------------------------------------------------------- Row Adapter -> Vector Streaming (type: GATHER) InitPlan 1 (returns $0) -> Row Adapter -> Vector Aggregate -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) -> Vector Aggregate -> CStore Scan on t_subplan2 Filter: ((a2 >= 1) AND (a2 <= 20)) InitPlan 2 (returns $1) -> Row Adapter -> Vector Aggregate -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) -> Vector Aggregate -> CStore Scan on t_subplan2 Filter: ((a2 >= 1) AND (a2 <= 20)) InitPlan 3 (returns $2) -> Row Adapter -> Vector Aggregate -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) -> Vector Aggregate -> CStore Scan on t_subplan2 Filter: ((a2 >= 1) AND (a2 <= 20)) InitPlan 4 (returns $3) -> Row Adapter -> Vector Aggregate -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) -> Vector Aggregate -> CStore Scan on t_subplan2 Filter: ((a2 >= 1) AND (a2 <= 20)) InitPlan 5 (returns $4) -> Row Adapter -> Vector Aggregate -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) -> Vector Aggregate -> CStore Scan on t_subplan2 Filter: ((a2 >= 1) AND (a2 <= 20)) InitPlan 6 (returns $5) -> Row Adapter -> Vector Aggregate -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) -> Vector Aggregate -> CStore Scan on t_subplan2 Filter: ((a2 >= 1) AND (a2 <= 20)) -> CStore Scan on t_subplan1 Filter: ((a1 = 5) OR (a1 = 6)) (46 rows) explain (costs off) select a1, count(*) cnt from t_subplan1 ,t_subplan2 where a1 = a2 and c2 > (select (avg (d1)) from t_subplan1 t1 where a1 > (select avg(a2) from t_subplan2 t2)) group by a1 order by a1, cnt limit 10; QUERY PLAN ------------------------------------------------------------------------------------------------ Row Adapter -> Vector Limit InitPlan 2 (returns $1) -> Row Adapter -> Vector Aggregate InitPlan 1 (returns $0) -> Row Adapter -> Vector Aggregate -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) -> Vector Aggregate -> CStore Scan on t_subplan2 t2 -> Vector Streaming(type: BROADCAST ng: ng0->GenGroup) -> Vector Aggregate -> CStore Scan on t_subplan1 t1 Filter: ((a1)::numeric > $0) -> Vector Streaming (type: GATHER) Merge Sort Key: t_subplan1.a1, (count(*)) -> Vector Limit -> Vector Sort Sort Key: t_subplan1.a1, (count(*)) -> Vector Sonic Hash Aggregate Group By Key: t_subplan1.a1 -> Vector Streaming(type: REDISTRIBUTE ng: ng0->group1) -> Vector Sonic Hash Join Hash Cond: (t_subplan2.a2 = t_subplan1.a1) -> Vector Streaming(type: BROADCAST ng: ng1->ng0) -> CStore Scan on t_subplan2 Filter: ((c2)::numeric > $1) -> CStore Scan on t_subplan1 (29 rows) explain (costs off) select a1, count(*) cnt from t_subplan1 ,t_subplan2 where a1 = a2 and c2 > (select (avg (d1)) from t_subplan1 t1 where a1 > (select avg(a2) from t_subplan2 t2)) group by a1 order by a1, cnt offset (select avg(d2) from t_subplan2); QUERY PLAN --------------------------------------------------------------------------------------------------------------- Row Adapter -> Vector Limit InitPlan 2 (returns $1) -> Row Adapter -> Vector Aggregate InitPlan 1 (returns $0) -> Row Adapter -> Vector Aggregate -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) -> Vector Aggregate -> CStore Scan on t_subplan2 t2 -> Vector Streaming(type: BROADCAST ng: ng0->GenGroup) -> Vector Aggregate -> CStore Scan on t_subplan1 t1 Filter: ((a1)::numeric > $0) InitPlan 3 (returns $2) -> Row Adapter -> Vector Streaming (type: GATHER) -> Vector Aggregate -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) -> Vector Aggregate -> CStore Scan on t_subplan2 -> Vector Streaming (type: GATHER) Merge Sort Key: t_subplan1.a1, (count(*)) -> Vector Limit -> Vector Sort Sort Key: t_subplan1.a1, (count(*)) -> Vector Sonic Hash Aggregate Group By Key: t_subplan1.a1 -> Vector Streaming(type: REDISTRIBUTE ng: ng0->group1) -> Vector Sonic Hash Join Hash Cond: (nodegroup_subplan_test.t_subplan2.a2 = t_subplan1.a1) -> Vector Streaming(type: BROADCAST ng: ng1->ng0) -> CStore Scan on t_subplan2 Filter: ((c2)::numeric > $1) -> CStore Scan on t_subplan1 (36 rows) -- 2. subplan explain (costs off) with t as (select d1 ,d2 ,sum(c1+c2) as total from t_subplan1 ,t_subplan2 where a1 = a2 group by d1 ,d2) select total from t ctr1 where ctr1.total > (select avg(total)*1.2 from t ctr2 where ctr1.d2 = ctr2.d2) order by 1 limit 10; QUERY PLAN -------------------------------------------------------------------------------------------------------------------------------------------------------- Row Adapter -> Vector Limit -> Vector Streaming (type: GATHER) Merge Sort Key: ctr1.total -> Vector Limit -> Vector Sort Sort Key: ctr1.total -> Vector Sonic Hash Join Hash Cond: (ctr2.d2 = ctr1.d2) Join Filter: ((ctr1.total)::numeric > ((avg(ctr2.total) * 1.2))) -> Vector Hash Aggregate Group By Key: ctr2.d2 -> Vector Subquery Scan on ctr2 -> Vector Sonic Hash Aggregate Group By Key: nodegroup_subplan_test.t_subplan1.d1, nodegroup_subplan_test.t_subplan2.d2 -> Vector Streaming(type: REDISTRIBUTE ng: ng0->group1) -> Vector Sonic Hash Join Hash Cond: (nodegroup_subplan_test.t_subplan1.a1 = nodegroup_subplan_test.t_subplan2.a2) -> Vector Streaming(type: REDISTRIBUTE) -> CStore Scan on t_subplan1 -> Vector Streaming(type: REDISTRIBUTE ng: ng1->ng0) -> CStore Scan on t_subplan2 -> Vector Subquery Scan on ctr1 -> Vector Sonic Hash Aggregate Group By Key: nodegroup_subplan_test.t_subplan1.d1, nodegroup_subplan_test.t_subplan2.d2 -> Vector Streaming(type: REDISTRIBUTE ng: ng0->group1) -> Vector Sonic Hash Join Hash Cond: (nodegroup_subplan_test.t_subplan1.a1 = nodegroup_subplan_test.t_subplan2.a2) -> Vector Streaming(type: REDISTRIBUTE) -> CStore Scan on t_subplan1 -> Vector Streaming(type: REDISTRIBUTE ng: ng1->ng0) -> CStore Scan on t_subplan2 (32 rows) explain (costs off) with t as (select d1 ,d2 ,sum(c1+c2) as total from t_subplan1 ,t_subplan2 where a1 = a2 group by d1 ,d2) select total from t ctr1 where ctr1.total > (select avg(total)*1.2 from t ctr2 where ctr1.d2 = ctr2.d2 and ctr1.d2+ctr2.d2 < (select avg(total)*3 from t ctr3 where ctr2.d2=ctr3.d2)) order by 1 limit 10; QUERY PLAN ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Row Adapter -> Vector Limit -> Vector Streaming (type: GATHER) Merge Sort Key: ctr1.total -> Vector Limit -> Vector Sort Sort Key: ctr1.total -> Vector Subquery Scan on ctr1 Filter: ((ctr1.total)::numeric > (SubPlan 1)) -> Vector Sonic Hash Aggregate Group By Key: nodegroup_subplan_test.t_subplan1.d1, nodegroup_subplan_test.t_subplan2.d2 -> Vector Streaming(type: REDISTRIBUTE ng: ng0->group1) -> Vector Sonic Hash Join Hash Cond: (nodegroup_subplan_test.t_subplan1.a1 = nodegroup_subplan_test.t_subplan2.a2) -> Vector Streaming(type: REDISTRIBUTE) -> CStore Scan on t_subplan1 -> Vector Streaming(type: REDISTRIBUTE ng: ng1->ng0) -> CStore Scan on t_subplan2 SubPlan 1 -> Row Adapter -> Vector Aggregate -> Vector Nest Loop Join Filter: (((ctr1.d2 + ctr2.d2))::numeric < ((avg(ctr3.total) * 3::numeric))) -> Vector Result Filter: (ctr2.d2 = ctr1.d2) -> Vector Materialize -> Vector Streaming(type: BROADCAST ng: group1->GenGroup) -> Vector Subquery Scan on ctr2 -> Vector Sonic Hash Aggregate Group By Key: nodegroup_subplan_test.t_subplan1.d1, nodegroup_subplan_test.t_subplan2.d2 -> Vector Streaming(type: REDISTRIBUTE ng: ng0->group1) -> Vector Sonic Hash Join Hash Cond: (nodegroup_subplan_test.t_subplan1.a1 = nodegroup_subplan_test.t_subplan2.a2) -> Vector Streaming(type: REDISTRIBUTE) -> CStore Scan on t_subplan1 -> Vector Streaming(type: REDISTRIBUTE ng: ng1->ng0) -> CStore Scan on t_subplan2 -> Vector Result Filter: (ctr3.d2 = ctr1.d2) -> Vector Materialize -> Vector Streaming(type: BROADCAST ng: group1->GenGroup) -> Vector Hash Aggregate Group By Key: ctr3.d2 -> Vector Subquery Scan on ctr3 -> Vector Sonic Hash Aggregate Group By Key: nodegroup_subplan_test.t_subplan1.d1, nodegroup_subplan_test.t_subplan2.d2 -> Vector Streaming(type: REDISTRIBUTE ng: ng0->group1) -> Vector Sonic Hash Join Hash Cond: (nodegroup_subplan_test.t_subplan1.a1 = nodegroup_subplan_test.t_subplan2.a2) -> Vector Streaming(type: REDISTRIBUTE) -> CStore Scan on t_subplan1 -> Vector Streaming(type: REDISTRIBUTE ng: ng1->ng0) -> CStore Scan on t_subplan2 (53 rows) explain (costs off) with t as (select d1 ,d2 ,sum(c1+c2) as total from t_subplan1 ,t_subplan2 where a1 = a2 group by d1 ,d2) select total from t ctr1 where ctr1.total > (select avg(total)*1.2 from t ctr2 where ctr1.d2 = ctr2.d2 and ctr1.d2+ctr2.d2 < (select avg(total)*3 from t ctr3 where ctr2.d2=ctr3.d2 and ctr1.d1 = ctr3.d1)) order by 1 limit 10; QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ Row Adapter -> Vector Limit -> Vector Streaming (type: GATHER) Merge Sort Key: ctr1.total -> Vector Limit -> Vector Sort Sort Key: ctr1.total -> Vector Subquery Scan on ctr1 Filter: ((ctr1.total)::numeric > (SubPlan 2)) -> Vector Sonic Hash Aggregate Group By Key: nodegroup_subplan_test.t_subplan1.d1, nodegroup_subplan_test.t_subplan2.d2 -> Vector Streaming(type: REDISTRIBUTE ng: ng0->group1) -> Vector Sonic Hash Join Hash Cond: (nodegroup_subplan_test.t_subplan1.a1 = nodegroup_subplan_test.t_subplan2.a2) -> Vector Streaming(type: REDISTRIBUTE) -> CStore Scan on t_subplan1 -> Vector Streaming(type: REDISTRIBUTE ng: ng1->ng0) -> CStore Scan on t_subplan2 SubPlan 2 -> Row Adapter -> Vector Aggregate -> Vector Result Filter: ((ctr1.d2 = ctr2.d2) AND (((ctr1.d2 + ctr2.d2))::numeric < (SubPlan 1))) -> Vector Materialize -> Vector Streaming(type: BROADCAST ng: group1->GenGroup) -> Vector Subquery Scan on ctr2 -> Vector Sonic Hash Aggregate Group By Key: nodegroup_subplan_test.t_subplan1.d1, nodegroup_subplan_test.t_subplan2.d2 -> Vector Streaming(type: REDISTRIBUTE ng: ng0->group1) -> Vector Sonic Hash Join Hash Cond: (nodegroup_subplan_test.t_subplan1.a1 = nodegroup_subplan_test.t_subplan2.a2) -> Vector Streaming(type: REDISTRIBUTE) -> CStore Scan on t_subplan1 -> Vector Streaming(type: REDISTRIBUTE ng: ng1->ng0) -> CStore Scan on t_subplan2 SubPlan 1 -> Row Adapter -> Vector Aggregate -> Vector Result Filter: ((ctr2.d2 = ctr3.d2) AND (ctr1.d1 = ctr3.d1)) -> Vector Materialize -> Vector Streaming(type: BROADCAST ng: group1->GenGroup) -> Vector Subquery Scan on ctr3 -> Vector Sonic Hash Aggregate Group By Key: nodegroup_subplan_test.t_subplan1.d1, nodegroup_subplan_test.t_subplan2.d2 -> Vector Streaming(type: REDISTRIBUTE ng: ng0->group1) -> Vector Sonic Hash Join Hash Cond: (nodegroup_subplan_test.t_subplan1.a1 = nodegroup_subplan_test.t_subplan2.a2) -> Vector Streaming(type: REDISTRIBUTE) -> CStore Scan on t_subplan1 -> Vector Streaming(type: REDISTRIBUTE ng: ng1->ng0) -> CStore Scan on t_subplan2 (52 rows) explain (costs off) select * from t_subplan1 t1 where exists (select * from t_subplan2 t2 where t1.a1=t2.a2) and (exists (select * from t_subplan2 t2 where t1.b1+20=t2.b2) or exists (select * from t_subplan2 t2 where t1.c1 = t2.c2)) order by 1,2,3,4; QUERY PLAN ------------------------------------------------------------------------------------------------------------ Row Adapter -> Vector Streaming (type: GATHER) Merge Sort Key: t1.a1, t1.b1, t1.c1, t1.d1 -> Vector Sort Sort Key: t1.a1, t1.b1, t1.c1, t1.d1 -> Vector Sonic Hash Join Hash Cond: (t1.a1 = t2.a2) -> Vector Streaming(type: REDISTRIBUTE ng: group1->ng1) -> Vector Hash Left Join Hash Cond: (t1.c1 = t2.c2) Filter: ((t2.b2 IS NOT NULL) OR (t2.c2 IS NOT NULL)) -> Vector Streaming(type: REDISTRIBUTE) -> Vector Hash Left Join Hash Cond: (((t1.b1 + 20)) = t2.b2) -> Vector Streaming(type: REDISTRIBUTE ng: ng0->group1) -> CStore Scan on t_subplan1 t1 -> Vector Sonic Hash Aggregate Group By Key: t2.b2 -> Vector Streaming(type: REDISTRIBUTE ng: ng1->group1) -> CStore Scan on t_subplan2 t2 -> Vector Sonic Hash Aggregate Group By Key: t2.c2 -> Vector Streaming(type: REDISTRIBUTE ng: ng1->group1) -> CStore Scan on t_subplan2 t2 -> Vector Sonic Hash Aggregate Group By Key: t2.a2 -> Vector Streaming(type: REDISTRIBUTE) -> CStore Scan on t_subplan2 t2 (28 rows) ; -- 3. initplan & subplan explain (costs off) select a1, count(*) cnt from t_subplan1 ,t_subplan2 where a1 = a2 and c2 > (select avg (d1) from t_subplan1 where a1+b1<200 ) and b1 > 1.2 * (select avg(b2) from t_subplan2 t2 where t2.c2=t_subplan1.c1) group by a1 order by a1, cnt limit 10; QUERY PLAN ----------------------------------------------------------------------------------------------------------------------------------- Row Adapter -> Vector Limit InitPlan 1 (returns $0) -> Row Adapter -> Vector Aggregate -> Vector Streaming(type: BROADCAST ng: ng0->GenGroup) -> Vector Aggregate -> CStore Scan on t_subplan1 Filter: ((a1 + b1) < 200) -> Vector Streaming (type: GATHER) Merge Sort Key: nodegroup_subplan_test.t_subplan1.a1, (count(*)) -> Vector Limit -> Vector Sort Sort Key: nodegroup_subplan_test.t_subplan1.a1, (count(*)) -> Vector Sonic Hash Aggregate Group By Key: nodegroup_subplan_test.t_subplan1.a1 -> Vector Streaming(type: REDISTRIBUTE) -> Vector Sonic Hash Join Hash Cond: (nodegroup_subplan_test.t_subplan1.c1 = t2.c2) Join Filter: ((nodegroup_subplan_test.t_subplan1.b1)::numeric > (1.2 * (avg(t2.b2)))) -> Vector Streaming(type: REDISTRIBUTE ng: ng0->group1) -> Vector Sonic Hash Join Hash Cond: (t_subplan2.a2 = nodegroup_subplan_test.t_subplan1.a1) -> Vector Streaming(type: BROADCAST ng: ng1->ng0) -> CStore Scan on t_subplan2 Filter: ((c2)::numeric > $0) -> CStore Scan on t_subplan1 -> Vector Sonic Hash Aggregate Group By Key: t2.c2 -> Vector Streaming(type: REDISTRIBUTE ng: ng1->group1) -> CStore Scan on t_subplan2 t2 (31 rows) explain (costs off) select a1, count(*) cnt from t_subplan1 ,t_subplan2 where a1 = a2 and c2 > (select avg (d1) from t_subplan1 where a1+b1<200 ) and b1 > 1.2 * (select avg(b2) from t_subplan2 t2 where t2.c2=t_subplan1.c1 and t_subplan1.d1 < (select max(d2) from t_subplan2)) group by a1 order by a1, cnt limit 10; QUERY PLAN -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Row Adapter -> Vector Limit InitPlan 1 (returns $0) -> Row Adapter -> Vector Aggregate -> Vector Streaming(type: BROADCAST ng: ng0->GenGroup) -> Vector Aggregate -> CStore Scan on t_subplan1 Filter: ((a1 + b1) < 200) -> Vector Streaming (type: GATHER) Merge Sort Key: nodegroup_subplan_test.t_subplan1.a1, (count(*)) -> Vector Limit -> Vector Sort Sort Key: nodegroup_subplan_test.t_subplan1.a1, (count(*)) -> Vector Sort Aggregate Group By Key: nodegroup_subplan_test.t_subplan1.a1 -> Vector Merge Join Merge Cond: (nodegroup_subplan_test.t_subplan1.a1 = nodegroup_subplan_test.t_subplan2.a2) -> Vector Sort Sort Key: nodegroup_subplan_test.t_subplan1.a1 -> Vector Streaming(type: REDISTRIBUTE ng: ng0->group1) -> CStore Scan on t_subplan1 Filter: ((b1)::numeric > (1.2 * (SubPlan 3))) SubPlan 3 -> Row Adapter -> Vector Aggregate InitPlan 2 (returns $1) -> Row Adapter -> Vector Aggregate -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) -> Vector Aggregate -> CStore Scan on t_subplan2 (min-max optimization) -> Vector Result Filter: ((nodegroup_subplan_test.t_subplan1.d1 < $1) AND (t2.c2 = nodegroup_subplan_test.t_subplan1.c1)) -> Vector Materialize -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) -> CStore Scan on t_subplan2 t2 -> Vector Sort Sort Key: nodegroup_subplan_test.t_subplan2.a2 -> Vector Streaming(type: REDISTRIBUTE ng: ng1->group1) -> CStore Scan on t_subplan2 Filter: ((c2)::numeric > $0) (42 rows) explain (costs off) select a1, count(*) cnt from t_subplan1 ,t_subplan2 where a1 = a2 and c2 > (select avg (d1) from t_subplan1 where a1+b1<200 ) and b1 > 1.2 * (select avg(b2) from t_subplan2 t2 where t2.c2=t_subplan1.c1 and t2.d2 > (select min(d1) from t_subplan1)) group by a1 order by a1, cnt limit 10; QUERY PLAN ---------------------------------------------------------------------------------------------------------------------------------------------------- Row Adapter -> Vector Limit InitPlan 1 (returns $0) -> Row Adapter -> Vector Aggregate -> Vector Streaming(type: BROADCAST ng: ng0->GenGroup) -> Vector Aggregate -> CStore Scan on t_subplan1 Filter: ((a1 + b1) < 200) -> Vector Streaming (type: GATHER) Merge Sort Key: nodegroup_subplan_test.t_subplan1.a1, (count(*)) -> Vector Limit -> Vector Sort Sort Key: nodegroup_subplan_test.t_subplan1.a1, (count(*)) -> Vector Sonic Hash Aggregate Group By Key: nodegroup_subplan_test.t_subplan1.a1 -> Vector Streaming(type: REDISTRIBUTE ng: ng1->group1) -> Vector Sonic Hash Join Hash Cond: (nodegroup_subplan_test.t_subplan1.a1 = t_subplan2.a2) -> Vector Streaming(type: BROADCAST ng: ng0->ng1) -> Vector Sonic Hash Join Hash Cond: (nodegroup_subplan_test.t_subplan1.c1 = t2.c2) Join Filter: ((nodegroup_subplan_test.t_subplan1.b1)::numeric > (1.2 * (avg(t2.b2)))) -> CStore Scan on t_subplan1 -> Vector Streaming(type: BROADCAST ng: group1->ng0) -> Vector Sonic Hash Aggregate Group By Key: t2.c2 InitPlan 2 (returns $1) -> Row Adapter -> Vector Aggregate -> Vector Streaming(type: BROADCAST ng: ng0->GenGroup) -> Vector Aggregate -> CStore Scan on t_subplan1 (min-max optimization) -> Vector Streaming(type: REDISTRIBUTE ng: ng1->group1) -> CStore Scan on t_subplan2 t2 Filter: (d2 > $1) -> CStore Scan on t_subplan2 Filter: ((c2)::numeric > $0) (38 rows) explain (costs off) select a1, count(*) cnt from t_subplan1 ,t_subplan2 where a1 = a2 and c2 > (select (avg (d1)) from t_subplan1 t1 where a1 > (select avg(a2) from t_subplan2 t2 where t1.d1=t2.d2)) group by a1 order by a1, cnt limit 10; QUERY PLAN -------------------------------------------------------------------------------------------------------- Row Adapter -> Vector Limit InitPlan 1 (returns $0) -> Row Adapter -> Vector Aggregate -> Vector Streaming(type: BROADCAST ng: group1->GenGroup) -> Vector Aggregate -> Vector Sonic Hash Join Hash Cond: (t1.d1 = t2.d2) Join Filter: ((t1.a1)::numeric > (avg(t2.a2))) -> Vector Streaming(type: REDISTRIBUTE ng: ng0->group1) -> CStore Scan on t_subplan1 t1 -> Vector Sonic Hash Aggregate Group By Key: t2.d2 -> Vector Streaming(type: REDISTRIBUTE ng: ng1->group1) -> CStore Scan on t_subplan2 t2 -> Vector Streaming (type: GATHER) Merge Sort Key: t_subplan1.a1, (count(*)) -> Vector Limit -> Vector Sort Sort Key: t_subplan1.a1, (count(*)) -> Vector Sonic Hash Aggregate Group By Key: t_subplan1.a1 -> Vector Streaming(type: REDISTRIBUTE ng: ng0->group1) -> Vector Sonic Hash Join Hash Cond: (t_subplan2.a2 = t_subplan1.a1) -> Vector Streaming(type: BROADCAST ng: ng1->ng0) -> CStore Scan on t_subplan2 Filter: ((c2)::numeric > $0) -> CStore Scan on t_subplan1 (30 rows) -- Set up some simple test tables CREATE TABLE INT4_TBL(f1 int4) with (orientation=column) to group ng2; INSERT INTO INT4_TBL(f1) VALUES (' 0 '); INSERT INTO INT4_TBL(f1) VALUES ('123456 '); INSERT INTO INT4_TBL(f1) VALUES (' -123456'); INSERT INTO INT4_TBL(f1) VALUES ('2147483647'); INSERT INTO INT4_TBL(f1) VALUES ('-2147483647'); INSERT INTO INT4_TBL(f1) VALUES (NULL); CREATE TABLE tenk1 ( unique1 int4, unique2 int4, two int4, four int4, ten int4, twenty int4, hundred int4, thousand int4, twothousand int4, fivethous int4, tenthous int4, odd int4, even int4, stringu1 varchar(64), stringu2 varchar(64), string4 varchar(64) ) WITH (orientation=column) to group ng1; COPY tenk1 FROM '@libdir@/data/tenk.data'; CREATE TABLE SUBSELECT_TBL ( f1 integer, f2 integer, f3 float ) with (orientation=column) distribute by hash(f1, f2, f3) to group ng3; INSERT INTO SUBSELECT_TBL VALUES (1, 2, 3); INSERT INTO SUBSELECT_TBL VALUES (2, 3, 4); INSERT INTO SUBSELECT_TBL VALUES (3, 4, 5); INSERT INTO SUBSELECT_TBL VALUES (1, 1, 1); INSERT INTO SUBSELECT_TBL VALUES (2, 2, 2); INSERT INTO SUBSELECT_TBL VALUES (3, 3, 3); INSERT INTO SUBSELECT_TBL VALUES (6, 7, 8); INSERT INTO SUBSELECT_TBL VALUES (8, 9, NULL); SELECT '' AS eight, * FROM SUBSELECT_TBL ORDER BY f1, f2, f3; eight | f1 | f2 | f3 -------+----+----+---- | 1 | 1 | 1 | 1 | 2 | 3 | 2 | 2 | 2 | 2 | 3 | 4 | 3 | 3 | 3 | 3 | 4 | 5 | 6 | 7 | 8 | 8 | 9 | (8 rows) -- Uncorrelated subselects SELECT '' AS two, f1 AS "Constant Select" FROM SUBSELECT_TBL WHERE f1 IN (SELECT 1) ORDER BY 2; two | Constant Select -----+----------------- | 1 | 1 (2 rows) explain (costs off) SELECT '' AS two, f1 AS "Constant Select" FROM SUBSELECT_TBL WHERE f1 IN (SELECT 1) ORDER BY 2; QUERY PLAN --------------------------------------------------------------------------------- Row Adapter -> Vector Streaming (type: GATHER) Merge Sort Key: subselect_tbl.f1 -> Vector Sort Sort Key: subselect_tbl.f1 -> Vector Nest Loop Semi Join Join Filter: (subselect_tbl.f1 = (1)) -> CStore Scan on subselect_tbl -> Vector Materialize -> Vector Streaming(type: BROADCAST ng: group1->ng3) -> Vector Adapter -> Result (12 rows) explain (costs off) SELECT '' AS six, f1 AS "Uncorrelated Field" FROM SUBSELECT_TBL WHERE f1 IN (SELECT f2 FROM SUBSELECT_TBL) ORDER BY 2; QUERY PLAN -------------------------------------------------------------------------------------------------------------------- Row Adapter -> Vector Streaming (type: GATHER) Merge Sort Key: nodegroup_subplan_test.subselect_tbl.f1 -> Vector Sort Sort Key: nodegroup_subplan_test.subselect_tbl.f1 -> Vector Sonic Hash Join Hash Cond: (nodegroup_subplan_test.subselect_tbl.f1 = nodegroup_subplan_test.subselect_tbl.f2) -> Vector Streaming(type: REDISTRIBUTE) -> CStore Scan on subselect_tbl -> Vector Sonic Hash Aggregate Group By Key: nodegroup_subplan_test.subselect_tbl.f2 -> Vector Streaming(type: REDISTRIBUTE) -> CStore Scan on subselect_tbl (13 rows) explain (costs off) SELECT '' AS six, f1 AS "Uncorrelated Field" FROM SUBSELECT_TBL WHERE f1 IN (SELECT f2 FROM SUBSELECT_TBL WHERE f2 IN (SELECT f1 FROM SUBSELECT_TBL)) ORDER BY 2; QUERY PLAN -------------------------------------------------------------------------------------------------------------------------- Row Adapter -> Vector Streaming (type: GATHER) Merge Sort Key: nodegroup_subplan_test.subselect_tbl.f1 -> Vector Sort Sort Key: nodegroup_subplan_test.subselect_tbl.f1 -> Vector Hash Semi Join Hash Cond: (nodegroup_subplan_test.subselect_tbl.f1 = nodegroup_subplan_test.subselect_tbl.f2) -> Vector Streaming(type: REDISTRIBUTE) -> CStore Scan on subselect_tbl -> Vector Sonic Hash Join Hash Cond: (nodegroup_subplan_test.subselect_tbl.f2 = nodegroup_subplan_test.subselect_tbl.f1) -> Vector Streaming(type: REDISTRIBUTE) -> CStore Scan on subselect_tbl -> Vector Sonic Hash Aggregate Group By Key: nodegroup_subplan_test.subselect_tbl.f1 -> Vector Streaming(type: REDISTRIBUTE) -> CStore Scan on subselect_tbl (17 rows) explain (costs off) SELECT '' AS three, f1, f2 FROM SUBSELECT_TBL WHERE (f1, f2) NOT IN (SELECT f2, CAST(f3 AS int4) FROM SUBSELECT_TBL WHERE f3 IS NOT NULL) ORDER BY f1, f2; QUERY PLAN -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Row Adapter -> Vector Streaming (type: GATHER) Merge Sort Key: nodegroup_subplan_test.subselect_tbl.f1, nodegroup_subplan_test.subselect_tbl.f2 -> Vector Sort Sort Key: nodegroup_subplan_test.subselect_tbl.f1, nodegroup_subplan_test.subselect_tbl.f2 -> Vector Nest Loop Anti Join Join Filter: (((nodegroup_subplan_test.subselect_tbl.f1 = nodegroup_subplan_test.subselect_tbl.f2) OR (nodegroup_subplan_test.subselect_tbl.f1 IS NULL) OR (nodegroup_subplan_test.subselect_tbl.f2 IS NULL)) AND ((nodegroup_subplan_test.subselect_tbl.f2 = (nodegroup_subplan_test.subselect_tbl.f3)::integer) OR (nodegroup_subplan_test.subselect_tbl.f2 IS NULL) OR ((nodegroup_subplan_test.subselect_tbl.f3)::integer IS NULL))) -> Vector Streaming(type: REDISTRIBUTE ng: ng3->group1) -> CStore Scan on subselect_tbl -> Vector Materialize -> Vector Streaming(type: BROADCAST ng: ng3->group1) -> CStore Scan on subselect_tbl Filter: (f3 IS NOT NULL) (13 rows) -- Correlated subselects explain (costs off) SELECT '' AS six, f1 AS "Correlated Field", f2 AS "Second Field" FROM SUBSELECT_TBL upper WHERE f1 IN (SELECT f2 FROM SUBSELECT_TBL WHERE f1 = upper.f1) ORDER BY f1, f2; QUERY PLAN ------------------------------------------------------------------------------------------------- Row Adapter -> Vector Streaming (type: GATHER) Merge Sort Key: upper.f1, upper.f2 -> Vector Sort Sort Key: upper.f1, upper.f2 -> CStore Scan on subselect_tbl upper Filter: (SubPlan 1) SubPlan 1 -> Row Adapter -> Vector Result Filter: (subselect_tbl.f1 = upper.f1) -> Vector Materialize -> Vector Streaming(type: BROADCAST ng: ng3->GenGroup) -> CStore Scan on subselect_tbl (14 rows) explain (costs off) SELECT '' AS six, f1 AS "Correlated Field", f3 AS "Second Field" FROM SUBSELECT_TBL upper WHERE f1 IN (SELECT f2 FROM SUBSELECT_TBL WHERE CAST(upper.f2 AS float) = f3) ORDER BY 2, 3; QUERY PLAN ------------------------------------------------------------------------------------------------- Row Adapter -> Vector Streaming (type: GATHER) Merge Sort Key: upper.f1, upper.f3 -> Vector Sort Sort Key: upper.f1, upper.f3 -> CStore Scan on subselect_tbl upper Filter: (SubPlan 1) SubPlan 1 -> Row Adapter -> Vector Result Filter: ((upper.f2)::double precision = subselect_tbl.f3) -> Vector Materialize -> Vector Streaming(type: BROADCAST ng: ng3->GenGroup) -> CStore Scan on subselect_tbl (14 rows) explain (costs off) SELECT '' AS six, f1 AS "Correlated Field", f3 AS "Second Field" FROM SUBSELECT_TBL upper WHERE f3 IN (SELECT upper.f1 + f2 FROM SUBSELECT_TBL WHERE f2 = CAST(f3 AS integer)) ORDER BY 2, 3; QUERY PLAN ------------------------------------------------------------------------------------------------- Row Adapter -> Vector Streaming (type: GATHER) Merge Sort Key: upper.f1, upper.f3 -> Vector Sort Sort Key: upper.f1, upper.f3 -> CStore Scan on subselect_tbl upper Filter: (SubPlan 1) SubPlan 1 -> Row Adapter -> Vector Result -> Vector Materialize -> Vector Streaming(type: BROADCAST ng: ng3->GenGroup) -> CStore Scan on subselect_tbl Filter: (f2 = (f3)::integer) (14 rows) explain (costs off) SELECT '' AS five, f1 AS "Correlated Field" FROM SUBSELECT_TBL WHERE (f1, f2) IN (SELECT f2, CAST(f3 AS int4) FROM SUBSELECT_TBL WHERE f3 IS NOT NULL) ORDER BY 2; QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Row Adapter -> Vector Streaming (type: GATHER) Merge Sort Key: nodegroup_subplan_test.subselect_tbl.f1 -> Vector Sort Sort Key: nodegroup_subplan_test.subselect_tbl.f1 -> Vector Hash Semi Join Hash Cond: ((nodegroup_subplan_test.subselect_tbl.f1 = nodegroup_subplan_test.subselect_tbl.f2) AND (nodegroup_subplan_test.subselect_tbl.f2 = (nodegroup_subplan_test.subselect_tbl.f3)::integer)) -> Vector Streaming(type: REDISTRIBUTE) -> CStore Scan on subselect_tbl -> Vector Streaming(type: REDISTRIBUTE) -> CStore Scan on subselect_tbl Filter: (f3 IS NOT NULL) (12 rows) -- -- Use some existing tables in the regression test -- explain (costs off) SELECT '' AS eight, ss.f1 AS "Correlated Field", ss.f3 AS "Second Field" FROM SUBSELECT_TBL ss WHERE f1 NOT IN (SELECT f1+1 FROM INT4_TBL WHERE f1 != ss.f1 AND f1 < 2147483647) ORDER BY 2, 3; QUERY PLAN ------------------------------------------------------------------------------------------------- Row Adapter -> Vector Streaming (type: GATHER) Merge Sort Key: ss.f1, ss.f3 -> Vector Sort Sort Key: ss.f1, ss.f3 -> CStore Scan on subselect_tbl ss Filter: (NOT (SubPlan 1)) SubPlan 1 -> Row Adapter -> Vector Result Filter: (int4_tbl.f1 <> ss.f1) -> Vector Materialize -> Vector Streaming(type: BROADCAST ng: ng2->GenGroup) -> CStore Scan on int4_tbl Filter: (f1 < 2147483647) (15 rows) explain (costs off) select f1, float8(count(*)) / (select count(*) from int4_tbl) from int4_tbl group by f1 order by f1; QUERY PLAN ------------------------------------------------------------------------------- Row Adapter -> Vector Streaming (type: GATHER) Merge Sort Key: nodegroup_subplan_test.int4_tbl.f1 InitPlan 1 (returns $0) -> Row Adapter -> Vector Aggregate -> Vector Streaming(type: BROADCAST ng: ng2->GenGroup) -> Vector Aggregate -> CStore Scan on int4_tbl -> Vector Sort Aggregate Group By Key: nodegroup_subplan_test.int4_tbl.f1 -> Vector Sort Sort Key: nodegroup_subplan_test.int4_tbl.f1 -> CStore Scan on int4_tbl (14 rows) -- -- Test cases to catch unpleasant interactions between IN-join processing -- and subquery pullup. -- -- delelte this sentence, because the output is related with number of nodes --select count(*) from -- (select 1 from tenk1 a -- where unique1 IN (select hundred from tenk1 b)) ss; explain (costs off) select count(distinct ss.ten) from (select ten from tenk1 a where unique1 IN (select hundred from tenk1 b)) ss; QUERY PLAN -------------------------------------------------------------------------- Row Adapter -> Vector Aggregate -> Vector Streaming (type: GATHER) -> Vector Aggregate -> Vector Streaming(type: REDISTRIBUTE) -> Vector Hash Right Semi Join Hash Cond: (b.hundred = a.unique1) -> Vector Streaming(type: REDISTRIBUTE) -> CStore Scan on tenk1 b -> CStore Scan on tenk1 a (10 rows) explain (costs off) select count(*) from (select 1 from tenk1 a where unique1 IN (select distinct hundred from tenk1 b)) ss; QUERY PLAN ------------------------------------------------------------------------------------------------ Row Adapter -> Vector Aggregate -> Vector Streaming (type: GATHER) -> Vector Aggregate -> Vector Sonic Hash Join Hash Cond: (a.unique1 = b.hundred) -> CStore Scan on tenk1 a -> Vector Streaming(type: REDISTRIBUTE ng: group1->ng1) -> Vector Sonic Hash Aggregate Group By Key: b.hundred -> Vector Streaming(type: REDISTRIBUTE ng: ng1->group1) -> CStore Scan on tenk1 b (12 rows) explain (costs off) select count(distinct ss.ten) from (select ten from tenk1 a where unique1 IN (select distinct hundred from tenk1 b)) ss; QUERY PLAN ------------------------------------------------------------------------------------------------------ Row Adapter -> Vector Aggregate -> Vector Streaming (type: GATHER) -> Vector Aggregate -> Vector Streaming(type: REDISTRIBUTE) -> Vector Sonic Hash Join Hash Cond: (a.unique1 = b.hundred) -> CStore Scan on tenk1 a -> Vector Streaming(type: REDISTRIBUTE ng: group1->ng1) -> Vector Sonic Hash Aggregate Group By Key: b.hundred -> Vector Streaming(type: REDISTRIBUTE ng: ng1->group1) -> CStore Scan on tenk1 b (13 rows) -- -- Test cases to check for overenthusiastic optimization of -- "IN (SELECT DISTINCT ...)" and related cases. Per example from -- Luca Pireddu and Michael Fuhr. -- -- Enforce use of COMMIT instead of 2PC for temporary objects -- CREATE TEMP TABLE subselect_foo (id integer); CREATE TABLE subselect_foo (id integer) with (orientation = column) to group ng1; -- CREATE TEMP TABLE bar (id1 integer, id2 integer); CREATE TABLE subselect_bar (id1 integer, id2 integer) with (orientation = column) to group ng2; INSERT INTO subselect_foo VALUES (1); INSERT INTO subselect_bar VALUES (1, 1); INSERT INTO subselect_bar VALUES (2, 2); INSERT INTO subselect_bar VALUES (3, 1); -- These cases require an extra level of distinct-ing above subquery s explain (costs off) SELECT * FROM subselect_foo WHERE id IN (SELECT id2 FROM (SELECT DISTINCT id1, id2 FROM subselect_bar) AS s); QUERY PLAN ------------------------------------------------------------------------------------------ Row Adapter -> Vector Streaming (type: GATHER) -> Vector Sonic Hash Join Hash Cond: (subselect_foo.id = s.id2) -> CStore Scan on subselect_foo -> Vector Sonic Hash Aggregate Group By Key: s.id2 -> Vector Streaming(type: REDISTRIBUTE ng: ng2->ng1) -> Vector Subquery Scan on s -> Vector Sonic Hash Aggregate Group By Key: subselect_bar.id1, subselect_bar.id2 -> CStore Scan on subselect_bar (12 rows) explain (costs off) SELECT * FROM subselect_foo WHERE id IN (SELECT id2 FROM (SELECT id1,id2 FROM subselect_bar GROUP BY id1,id2) AS s); QUERY PLAN ------------------------------------------------------------------------------------------ Row Adapter -> Vector Streaming (type: GATHER) -> Vector Sonic Hash Join Hash Cond: (subselect_foo.id = s.id2) -> CStore Scan on subselect_foo -> Vector Sonic Hash Aggregate Group By Key: s.id2 -> Vector Streaming(type: REDISTRIBUTE ng: ng2->ng1) -> Vector Subquery Scan on s -> Vector Sonic Hash Aggregate Group By Key: subselect_bar.id1, subselect_bar.id2 -> CStore Scan on subselect_bar (12 rows) explain (costs off) SELECT * FROM subselect_foo WHERE id IN (SELECT id2 FROM (SELECT id1, id2 FROM subselect_bar UNION SELECT id1, id2 FROM subselect_bar) AS s); QUERY PLAN ---------------------------------------------------------------------------------------------------------------------------------------- Row Adapter -> Vector Streaming (type: GATHER) -> Vector Sonic Hash Join Hash Cond: (subselect_foo.id = s.id2) -> CStore Scan on subselect_foo -> Vector Sonic Hash Aggregate Group By Key: s.id2 -> Vector Streaming(type: REDISTRIBUTE ng: ng2->ng1) -> Vector Subquery Scan on s -> Vector Sonic Hash Aggregate Group By Key: nodegroup_subplan_test.subselect_bar.id1, nodegroup_subplan_test.subselect_bar.id2 -> Vector Append -> CStore Scan on subselect_bar -> CStore Scan on subselect_bar (14 rows) -- These cases do not explain (costs off) SELECT * FROM subselect_foo WHERE id IN (SELECT id2 FROM (SELECT DISTINCT ON (id2) id1, id2 FROM subselect_bar) AS s); QUERY PLAN -------------------------------------------------------------------------- Hash Join Hash Cond: (subselect_bar.id2 = subselect_foo.id) -> Unique -> Sort Sort Key: subselect_bar.id2 -> Data Node Scan on subselect_bar "_REMOTE_TABLE_QUERY_" -> Hash -> Data Node Scan on subselect_foo "_REMOTE_TABLE_QUERY_" (8 rows) explain (costs off) SELECT * FROM subselect_foo WHERE id IN (SELECT id2 FROM (SELECT id2 FROM subselect_bar GROUP BY id2) AS s); QUERY PLAN ------------------------------------------------------------------------------------ Row Adapter -> Vector Streaming (type: GATHER) -> Vector Sonic Hash Join Hash Cond: (subselect_foo.id = subselect_bar.id2) -> CStore Scan on subselect_foo -> Vector Streaming(type: REDISTRIBUTE ng: group1->ng1) -> Vector Sonic Hash Aggregate Group By Key: subselect_bar.id2 -> Vector Streaming(type: REDISTRIBUTE ng: ng2->group1) -> CStore Scan on subselect_bar (10 rows) explain (costs off) SELECT * FROM subselect_foo WHERE id IN (SELECT id2 FROM (SELECT id2 FROM subselect_bar UNION SELECT id2 FROM subselect_bar) AS s); QUERY PLAN ---------------------------------------------------------------------------------------- Row Adapter -> Vector Streaming (type: GATHER) -> Vector Sonic Hash Join Hash Cond: (subselect_foo.id = nodegroup_subplan_test.subselect_bar.id2) -> Vector Streaming(type: REDISTRIBUTE ng: ng1->ng2) -> CStore Scan on subselect_foo -> Vector Sonic Hash Aggregate Group By Key: nodegroup_subplan_test.subselect_bar.id2 -> Vector Append -> Vector Streaming(type: REDISTRIBUTE) -> CStore Scan on subselect_bar -> Vector Streaming(type: REDISTRIBUTE) -> CStore Scan on subselect_bar (13 rows) -- -- Test case to catch problems with multiply nested sub-SELECTs not getting -- recalculated properly. Per bug report from Didier Moens. -- CREATE TABLE orderstest ( approver_ref integer, po_ref integer, ordercanceled boolean ) with (orientation = column,autovacuum_enabled = off) to group ng3; INSERT INTO orderstest VALUES (1, 1, false); INSERT INTO orderstest VALUES (66, 5, false); INSERT INTO orderstest VALUES (66, 6, false); INSERT INTO orderstest VALUES (66, 7, false); INSERT INTO orderstest VALUES (66, 1, true); INSERT INTO orderstest VALUES (66, 8, false); INSERT INTO orderstest VALUES (66, 1, false); INSERT INTO orderstest VALUES (77, 1, false); INSERT INTO orderstest VALUES (1, 1, false); INSERT INTO orderstest VALUES (66, 1, false); INSERT INTO orderstest VALUES (1, 1, false); CREATE VIEW orders_view AS SELECT *, (SELECT CASE WHEN ord.approver_ref=1 THEN '---' ELSE 'Approved' END) AS "Approved", (SELECT CASE WHEN ord.ordercanceled THEN 'Canceled' ELSE (SELECT CASE WHEN ord.po_ref=1 THEN (SELECT CASE WHEN ord.approver_ref=1 THEN '---' ELSE 'Approved' END) ELSE 'PO' END) END) AS "Status", (CASE WHEN ord.ordercanceled THEN 'Canceled' ELSE (CASE WHEN ord.po_ref=1 THEN (CASE WHEN ord.approver_ref=1 THEN '---' ELSE 'Approved' END) ELSE 'PO' END) END) AS "Status_OK" FROM orderstest ord; explain (costs off) SELECT * FROM orders_view ORDER BY approver_ref, po_ref, ordercanceled; QUERY PLAN ------------------------------------------------------------------------- Row Adapter -> Vector Streaming (type: GATHER) Merge Sort Key: ord.approver_ref, ord.po_ref, ord.ordercanceled -> Vector Sort Sort Key: ord.approver_ref, ord.po_ref, ord.ordercanceled -> CStore Scan on orderstest ord SubPlan 1 -> Result SubPlan 4 -> Result InitPlan 3 (returns $4) -> Result InitPlan 2 (returns $2) -> Result (14 rows) SELECT * FROM orders_view ORDER BY approver_ref, po_ref, ordercanceled; approver_ref | po_ref | ordercanceled | Approved | Status | Status_OK --------------+--------+---------------+----------+----------+----------- 1 | 1 | f | --- | --- | --- 1 | 1 | f | --- | --- | --- 1 | 1 | f | --- | --- | --- 66 | 1 | f | Approved | Approved | Approved 66 | 1 | f | Approved | Approved | Approved 66 | 1 | t | Approved | Canceled | Canceled 66 | 5 | f | Approved | PO | PO 66 | 6 | f | Approved | PO | PO 66 | 7 | f | Approved | PO | PO 66 | 8 | f | Approved | PO | PO 77 | 1 | f | Approved | Approved | Approved (11 rows) DROP TABLE orderstest cascade; NOTICE: drop cascades to view orders_view explain (costs off) select f1, ss1 as relabel from (select *, (select sum(f1) from int4_tbl b where f1 >= a.f1) as ss1 from int4_tbl a) ss ORDER BY f1, relabel; QUERY PLAN ------------------------------------------------------------------------------------------------------- Row Adapter -> Vector Streaming (type: GATHER) Merge Sort Key: a.f1, ((SubPlan 1)) -> Vector Sort Sort Key: a.f1, ((SubPlan 1)) -> CStore Scan on int4_tbl a SubPlan 1 -> Row Adapter -> Vector Aggregate -> Vector Result Filter: (b.f1 >= a.f1) -> Vector Materialize -> Vector Streaming(type: BROADCAST ng: ng2->GenGroup) -> CStore Scan on int4_tbl b (14 rows) -- -- Test cases involving PARAM_EXEC parameters and min/max index optimizations. -- Per bug report from David Sanchez i Gregori. -- explain (costs off) select * from ( select max(unique1) from tenk1 as a where exists (select 1 from tenk1 as b where b.thousand = a.unique2) ) ss; QUERY PLAN -------------------------------------------------------------------------------- Row Adapter -> Vector Streaming (type: GATHER) -> Vector Aggregate -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) -> Vector Aggregate -> Vector Sonic Hash Join Hash Cond: (a.unique2 = b.thousand) -> Vector Streaming(type: REDISTRIBUTE) -> CStore Scan on tenk1 a -> Vector Sonic Hash Aggregate Group By Key: b.thousand -> Vector Streaming(type: REDISTRIBUTE) -> CStore Scan on tenk1 b (13 rows) explain (costs off) select * from ( select min(unique1) from tenk1 as a where not exists (select 1 from tenk1 as b where b.unique2 = 10000) ) ss; QUERY PLAN ------------------------------------------------------------------------------- Row Adapter -> Vector Streaming (type: GATHER) -> Vector Aggregate InitPlan 1 (returns $0) -> Row Adapter -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) -> CStore Scan on tenk1 b Filter: (unique2 = 10000) -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) -> Vector Aggregate -> Vector Result One-Time Filter: (NOT $0) -> CStore Scan on tenk1 a (13 rows) -- -- Test case for bug #4290: bogus calculation of subplan param sets -- create table ta (id int, val int) with (orientation=column) to group ng1; insert into ta values(1,1); insert into ta values(2,2); create table tb (id int, aval int) with (orientation=column) to group ng2; insert into tb values(1,1); insert into tb values(2,1); insert into tb values(3,2); insert into tb values(4,2); create table tc (id int, aid int) with (orientation=column) to group ng3; insert into tc values(1,1); insert into tc values(2,2); explain (costs off) select ( select min(tb.id) from tb where tb.aval = (select ta.val from ta where ta.id = tc.aid) ) as min_tb_id from tc ORDER BY min_tb_id; QUERY PLAN --------------------------------------------------------------------------------------------------------------- Row Adapter -> Vector Streaming (type: GATHER) Merge Sort Key: ((SubPlan 2)) -> Vector Sort Sort Key: ((SubPlan 2)) -> CStore Scan on tc SubPlan 2 -> Row Adapter -> Vector Aggregate InitPlan 1 (returns $1) -> Row Adapter -> Vector Result Filter: (ta.id = tc.aid) -> Vector Materialize -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) -> CStore Scan on ta -> Vector Result Filter: (tb.aval = $1) -> Vector Materialize -> Vector Streaming(type: BROADCAST ng: ng2->GenGroup) -> CStore Scan on tb (21 rows) -- -- Test case for 8.3 "failed to locate grouping columns" bug -- -- create temp table t1 (f1 numeric(14,0), f2 varchar(30)); create table subselect_t1 (f1 numeric(14,0), f2 varchar(30)) with (orientation=column) to group ng0; explain (costs off) select * from (select distinct f1, f2, (select f2 from subselect_t1 x where x.f1 = up.f1) as fs from subselect_t1 up) ss group by f1,f2,fs; QUERY PLAN ------------------------------------------------------------------------------------------------------------- Row Adapter -> Vector Streaming (type: GATHER) -> Vector Sonic Hash Aggregate Group By Key: up.f1, up.f2, ((SubPlan 1)) -> Vector Hash Aggregate Group By Key: up.f1, up.f2, ((SubPlan 1)) -> Vector Streaming(type: REDISTRIBUTE ng: ng0->group1) -> CStore Scan on subselect_t1 up SubPlan 1 -> Row Adapter -> Vector Result Filter: (x.f1 = up.f1) -> Vector Materialize -> Vector Streaming(type: BROADCAST ng: ng0->GenGroup) -> CStore Scan on subselect_t1 x (15 rows) -- -- Check that whole-row Vars reading the result of a subselect don't include -- any junk columns therein -- explain (costs off) select q from (select max(f1) from int4_tbl group by f1 order by f1) q; QUERY PLAN -------------------------------------------------------- Subquery Scan on q -> Sort Sort Key: int4_tbl.f1 -> Data Node Scan on "__REMOTE_GROUP_QUERY__" (4 rows) explain (costs off) with q as (select max(f1) from int4_tbl group by f1 order by f1) select q from q; QUERY PLAN ---------------------------------------------------------- CTE Scan on q CTE q -> Sort Sort Key: int4_tbl.f1 -> Data Node Scan on "__REMOTE_GROUP_QUERY__" (5 rows) -- -- Test case for sublinks pushed down into subselects via join alias expansion -- explain (costs off) select (select sq1) as qq1 from (select exists(select 1 from int4_tbl where f1 = f1) as sq1, 42 as dummy from int4_tbl) sq0 join int4_tbl i4 on dummy = i4.f1; QUERY PLAN --------------------------------------------------------------------------------- Row Adapter -> Vector Streaming (type: GATHER) InitPlan 2 (returns $1) -> Result InitPlan 1 (returns $0) -> Row Adapter -> Vector Streaming(type: BROADCAST ng: ng2->GenGroup) -> CStore Scan on int4_tbl Filter: (f1 IS NOT NULL) -> Vector Nest Loop -> Vector Streaming(type: BROADCAST) -> CStore Scan on int4_tbl i4 Filter: (42 = f1) -> CStore Scan on int4_tbl (14 rows) select (select sq1) as qq1 from (select exists(select 1 from int4_tbl where f1 = f1) as sq1, 42 as dummy from int4_tbl) sq0 join int4_tbl i4 on dummy = i4.f1; qq1 ----- (0 rows) -- -- Test case for cross-type partial matching in hashed subplan (bug #7597) -- -- create temp table outer_7597 (f1 int4, f2 int4); create table outer_7597 (f1 int4, f2 int4) with (orientation=column) to group ng0; insert into outer_7597 values (0, 0); insert into outer_7597 values (1, 0); insert into outer_7597 values (0, null); insert into outer_7597 values (1, null); -- create temp table inner_7597(c1 int8, c2 int8); create table inner_7597(c1 int8, c2 int8) with (orientation=column) to group ng1; insert into inner_7597 values(0, null); explain (costs off) select * from outer_7597 where (f1, f2) not in (select * from inner_7597); QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ Row Adapter -> Vector Streaming (type: GATHER) -> Vector Nest Loop Anti Join Join Filter: (((outer_7597.f1 = inner_7597.c1) OR (outer_7597.f1 IS NULL) OR (inner_7597.c1 IS NULL)) AND ((outer_7597.f2 = inner_7597.c2) OR (outer_7597.f2 IS NULL) OR (inner_7597.c2 IS NULL))) -> Vector Streaming(type: REDISTRIBUTE ng: ng0->group1) -> CStore Scan on outer_7597 -> Vector Materialize -> Vector Streaming(type: BROADCAST ng: ng1->group1) -> CStore Scan on inner_7597 (9 rows) -- -- Test case for planner bug with nested EXISTS handling -- explain (costs off) select a.thousand from tenk1 a, tenk1 b where a.thousand = b.thousand and exists ( select 1 from tenk1 c where b.hundred = c.hundred and not exists ( select 1 from tenk1 d where a.thousand = d.thousand ) ); QUERY PLAN -------------------------------------------------------------------------------- Row Adapter -> Vector Streaming (type: GATHER) -> Vector Sonic Hash Join Hash Cond: (b.hundred = c.hundred) -> Vector Streaming(type: REDISTRIBUTE) -> Vector Sonic Hash Join Hash Cond: (a.thousand = b.thousand) -> Vector Streaming(type: BROADCAST) -> Vector Hash Anti Join Hash Cond: (a.thousand = d.thousand) -> Vector Streaming(type: REDISTRIBUTE) -> CStore Scan on tenk1 a -> Vector Streaming(type: REDISTRIBUTE) -> CStore Scan on tenk1 d -> CStore Scan on tenk1 b -> Vector Sonic Hash Aggregate Group By Key: c.hundred -> Vector Streaming(type: REDISTRIBUTE) -> CStore Scan on tenk1 c (19 rows) -- other sdv failed case create table t_subplan3(a3 int, b3 int) with (orientation=column) distribute by replication to group ng3 partition by range(a3) (partition p1 values less than (25), partition p2 values less than (maxvalue)); insert into t_subplan3 values(1, 20); insert into t_subplan3 values(27, 27); explain (costs off) select * from t_subplan3 where b3=(select max(b2) from t_subplan2); QUERY PLAN ---------------------------------------------------------------------------------------- Row Adapter -> Vector Streaming (type: GATHER) InitPlan 1 (returns $0) -> Row Adapter -> Vector Aggregate -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) -> Vector Aggregate -> CStore Scan on t_subplan2 (min-max optimization) -> Vector Partition Iterator Iterations: 2 -> Partitioned CStore Scan on t_subplan3 Filter: (b3 = $0) Selected Partitions: 1..2 (13 rows) explain (costs off) select count(*) from t_subplan3 t1 group by a3,b3 having not exists (select sum(t2.b3), t2.a3, t2.b3, rank() over (partition by t1.b3 order by t2.a3) from t_subplan3 t2 group by 2,3 order by 1,2,3,4); QUERY PLAN --------------------------------------------------------------------------------------------------------------------- Row Adapter -> Vector Streaming (type: GATHER) -> Vector Hash Aggregate Group By Key: t1.a3, t1.b3 Filter: (NOT (SubPlan 1)) -> Vector Partition Iterator Iterations: 2 -> Partitioned CStore Scan on t_subplan3 t1 Selected Partitions: 1..2 SubPlan 1 -> Row Adapter -> Vector Sort Sort Key: (sum(t2.b3)), t2.a3, t2.b3, (rank() OVER (ORDER BY t2.a3 USING = NULLS LAST)) -> Vector WindowAgg -> Vector Sort Sort Key: t2.a3 -> Vector Hash Aggregate Group By Key: t2.a3, t2.b3 -> Vector Materialize -> Vector Streaming(type: BROADCAST ng: ng3->GenGroup) -> Vector Partition Iterator Iterations: 2 -> Partitioned CStore Scan on t_subplan3 t2 Selected Partitions: 1..2 (24 rows) explain (costs off, verbose on) select c1, d1 from t_subplan1 where exists(select b3 from t_subplan3 where a3>=2) group by c1, d1 order by c1+1 desc, 2 desc limit 5; WARNING: Statistics in some tables or columns(nodegroup_subplan_test.t_subplan3.a3, nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan1.c1, nodegroup_subplan_test.t_subplan1.d1) are not collected. HINT: Do analyze for them in order to generate optimized plan. QUERY PLAN -------------------------------------------------------------------------------------------------- Row Adapter Output: t_subplan1.c1, t_subplan1.d1, ((t_subplan1.c1 + 1)) -> Vector Limit Output: t_subplan1.c1, t_subplan1.d1, ((t_subplan1.c1 + 1)) InitPlan 1 (returns $1) -> Row Adapter Output: ('Dummy') -> Vector Streaming(type: BROADCAST ng: ng3->GenGroup) Output: ('Dummy') -> Vector Partition Iterator Output: 'Dummy' Iterations: 2 -> Partitioned CStore Scan on nodegroup_subplan_test.t_subplan3 Output: 'Dummy' Filter: (t_subplan3.a3 >= 2) Selected Partitions: 1..2 -> Vector Streaming (type: GATHER) Output: t_subplan1.c1, t_subplan1.d1, ((t_subplan1.c1 + 1)) Merge Sort Key: ((t_subplan1.c1 + 1)) DESC, t_subplan1.d1 DESC -> Vector Limit Output: t_subplan1.c1, t_subplan1.d1, ((t_subplan1.c1 + 1)) -> Vector Sort Output: t_subplan1.c1, t_subplan1.d1, ((t_subplan1.c1 + 1)) Sort Key: ((t_subplan1.c1 + 1)) DESC, t_subplan1.d1 DESC -> Vector Sonic Hash Aggregate Output: t_subplan1.c1, t_subplan1.d1, (t_subplan1.c1 + 1) Group By Key: t_subplan1.c1, t_subplan1.d1 -> Vector Streaming(type: REDISTRIBUTE ng: ng0->group1) Output: t_subplan1.c1, t_subplan1.d1 Distribute Key: t_subplan1.c1, t_subplan1.d1 -> Vector Result Output: t_subplan1.c1, t_subplan1.d1 One-Time Filter: $1 -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: t_subplan1.c1, t_subplan1.d1 Distribute Key: t_subplan1.a1, t_subplan1.b1 (36 rows) explain (costs off, verbose on) select * from t_subplan2 where exists (select d1 from t_subplan1 where d1<8 and exists (select b1 from t_subplan1 where c1<20 and exists (select * from t_subplan1 where d1<9 and d1 >1 order by d1 limit 7) order by c1,b1 limit 10)) and exists( select max(a1),count(b1),c2 from t_subplan1 group by c2 having c2>2 or c2 is null) order by a2, b2, c2, d2 limit 10; WARNING: Statistics in some tables or columns(nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan1.d1, nodegroup_subplan_test.t_subplan1.c1, nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2) are not collected. HINT: Do analyze for them in order to generate optimized plan. QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ Row Adapter Output: t_subplan2.a2, t_subplan2.b2, t_subplan2.c2, t_subplan2.d2 -> Vector Limit Output: t_subplan2.a2, t_subplan2.b2, t_subplan2.c2, t_subplan2.d2 InitPlan 3 (returns $2) -> Row Adapter Output: ('Dummy') -> Vector Streaming(type: BROADCAST ng: ng0->GenGroup) Output: ('Dummy') -> Vector Result Output: ('Dummy') One-Time Filter: $1 InitPlan 2 (returns $1) -> Row Adapter Output: nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan1.c1 -> Vector Streaming(type: BROADCAST ng: ng0->GenGroup) Output: nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan1.c1 -> Vector Limit Output: nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan1.c1 InitPlan 1 (returns $0) -> Row Adapter Output: nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan1.c1, nodegroup_subplan_test.t_subplan1.d1 -> Vector Streaming(type: BROADCAST ng: ng0->GenGroup) Output: nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan1.c1, nodegroup_subplan_test.t_subplan1.d1 -> Vector Limit Output: nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan1.c1, nodegroup_subplan_test.t_subplan1.d1 -> Vector Streaming(type: BROADCAST) Output: nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan1.c1, nodegroup_subplan_test.t_subplan1.d1 Merge Sort Key: nodegroup_subplan_test.t_subplan1.d1 -> Vector Limit Output: nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan1.c1, nodegroup_subplan_test.t_subplan1.d1 -> Vector Sort Output: nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan1.c1, nodegroup_subplan_test.t_subplan1.d1 Sort Key: nodegroup_subplan_test.t_subplan1.d1 -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan1.c1, nodegroup_subplan_test.t_subplan1.d1 Distribute Key: nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1 Filter: ((nodegroup_subplan_test.t_subplan1.d1 < 9) AND (nodegroup_subplan_test.t_subplan1.d1 > 1)) -> Vector Sort Output: nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan1.c1 Sort Key: nodegroup_subplan_test.t_subplan1.c1, nodegroup_subplan_test.t_subplan1.b1 -> Vector Streaming(type: BROADCAST) Output: nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan1.c1 -> Vector Limit Output: nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan1.c1 -> Vector Sort Output: nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan1.c1 Sort Key: nodegroup_subplan_test.t_subplan1.c1, nodegroup_subplan_test.t_subplan1.b1 -> Vector Result Output: nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan1.c1 One-Time Filter: $0 -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan1.c1 Distribute Key: nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1 Filter: (nodegroup_subplan_test.t_subplan1.c1 < 20) -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: 'Dummy' Distribute Key: nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1 Filter: (nodegroup_subplan_test.t_subplan1.d1 < 8) -> Vector Streaming (type: GATHER) Output: t_subplan2.a2, t_subplan2.b2, t_subplan2.c2, t_subplan2.d2 Merge Sort Key: t_subplan2.a2, t_subplan2.b2, t_subplan2.c2, t_subplan2.d2 -> Vector Limit Output: t_subplan2.a2, t_subplan2.b2, t_subplan2.c2, t_subplan2.d2 -> Vector Sort Output: t_subplan2.a2, t_subplan2.b2, t_subplan2.c2, t_subplan2.d2 Sort Key: t_subplan2.a2, t_subplan2.b2, t_subplan2.c2, t_subplan2.d2 -> Vector Result Output: t_subplan2.a2, t_subplan2.b2, t_subplan2.c2, t_subplan2.d2 One-Time Filter: $2 -> CStore Scan on nodegroup_subplan_test.t_subplan2 Output: t_subplan2.a2, t_subplan2.b2, t_subplan2.c2, t_subplan2.d2 Distribute Key: t_subplan2.a2, t_subplan2.b2 Filter: (SubPlan 4) SubPlan 4 -> Row Adapter Output: (max(nodegroup_subplan_test.t_subplan1.a1)), (count(nodegroup_subplan_test.t_subplan1.b1)), ($3) -> Vector Sort Aggregate Output: max(nodegroup_subplan_test.t_subplan1.a1), count(nodegroup_subplan_test.t_subplan1.b1), (t_subplan2.c2) Group By Key: t_subplan2.c2 -> Vector Result Output: t_subplan2.c2, nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1 Filter: ((t_subplan2.c2 > 2) OR (t_subplan2.c2 IS NULL)) -> Vector Materialize Output: nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1 -> Vector Streaming(type: BROADCAST ng: ng0->GenGroup) Output: nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1 -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1 Distribute Key: nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1 (90 rows) explain (costs off, verbose on) select * from t_subplan2 where exists( select max(a1),count(b1),c2 from t_subplan1 group by rollup(c2,c2) having c2>2 and c2 is not null) order by a2,b2,c2,d2 limit 10; WARNING: Statistics in some tables or columns(nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2) are not collected. HINT: Do analyze for them in order to generate optimized plan. QUERY PLAN ---------------------------------------------------------------------------------------------------------------------- Row Adapter Output: t_subplan2.a2, t_subplan2.b2, t_subplan2.c2, t_subplan2.d2 -> Vector Limit Output: t_subplan2.a2, t_subplan2.b2, t_subplan2.c2, t_subplan2.d2 -> Vector Streaming (type: GATHER) Output: t_subplan2.a2, t_subplan2.b2, t_subplan2.c2, t_subplan2.d2 Merge Sort Key: t_subplan2.a2, t_subplan2.b2, t_subplan2.c2, t_subplan2.d2 -> Vector Limit Output: t_subplan2.a2, t_subplan2.b2, t_subplan2.c2, t_subplan2.d2 -> Vector Sort Output: t_subplan2.a2, t_subplan2.b2, t_subplan2.c2, t_subplan2.d2 Sort Key: t_subplan2.a2, t_subplan2.b2, t_subplan2.c2, t_subplan2.d2 -> CStore Scan on nodegroup_subplan_test.t_subplan2 Output: t_subplan2.a2, t_subplan2.b2, t_subplan2.c2, t_subplan2.d2 Distribute Key: t_subplan2.a2, t_subplan2.b2 Filter: (SubPlan 1) SubPlan 1 -> Row Adapter Output: (max(t_subplan1.a1)), (count(t_subplan1.b1)), ($0) -> Vector Sort Aggregate Output: max(t_subplan1.a1), count(t_subplan1.b1), (t_subplan2.c2) Group By Key: t_subplan2.c2 Group By Key: t_subplan2.c2 Group By Key: () Filter: (((t_subplan2.c2) > 2) AND ((t_subplan2.c2) IS NOT NULL)) -> Vector Result Output: t_subplan2.c2, t_subplan1.a1, t_subplan1.b1 -> Vector Materialize Output: t_subplan1.a1, t_subplan1.b1 -> Vector Streaming(type: BROADCAST ng: ng0->GenGroup) Output: t_subplan1.a1, t_subplan1.b1 -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: t_subplan1.a1, t_subplan1.b1 Distribute Key: t_subplan1.a1, t_subplan1.b1 (34 rows) -- test any, all, rowcompare, array sublink explain (costs off, verbose on) select * from t_subplan1 where a1 in (select count(c2) from t_subplan2) or d1=0 order by 1,2,3,4; WARNING: Statistics in some tables or columns(nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2, nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan1.d1) are not collected. HINT: Do analyze for them in order to generate optimized plan. QUERY PLAN ---------------------------------------------------------------------------------------------------------- Row Adapter Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> Vector Streaming (type: GATHER) Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 Merge Sort Key: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> Vector Sort Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 Sort Key: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 Distribute Key: t_subplan1.a1, t_subplan1.b1 Filter: ((hashed SubPlan 1) OR (t_subplan1.d1 = 0)) SubPlan 1 -> Row Adapter Output: (count((count(t_subplan2.c2)))) -> Vector Materialize Output: (count((count(t_subplan2.c2)))) -> Vector Aggregate Output: count((count(t_subplan2.c2))) -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) Output: (count(t_subplan2.c2)) -> Vector Aggregate Output: count(t_subplan2.c2) -> CStore Scan on nodegroup_subplan_test.t_subplan2 Output: t_subplan2.c2 Distribute Key: t_subplan2.a2, t_subplan2.b2 (26 rows) explain (costs off, verbose on) select * from t_subplan1 where a1 in (select count(c2) from t_subplan2 where c1>d2 minus all select d1 from t_subplan2) or d1=0 order by 1,2,3,4; WARNING: Statistics in some tables or columns(nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2, nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan1.d1) are not collected. HINT: Do analyze for them in order to generate optimized plan. QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ Row Adapter Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> Vector Streaming (type: GATHER) Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 Merge Sort Key: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> Vector Sort Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 Sort Key: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 Distribute Key: t_subplan1.a1, t_subplan1.b1 Filter: ((SubPlan 1) OR (t_subplan1.d1 = 0)) SubPlan 1 -> Row Adapter Output: "*SELECT* 1".count, (0) -> Vector HashSetOp Except All Output: "*SELECT* 1".count, (0) -> Vector Append -> Vector Subquery Scan on "*SELECT* 1" Output: "*SELECT* 1".count, 0 -> Vector Aggregate Output: count(nodegroup_subplan_test.t_subplan2.c2) -> Vector Result Output: nodegroup_subplan_test.t_subplan2.c2, nodegroup_subplan_test.t_subplan2.d2 Filter: (t_subplan1.c1 > nodegroup_subplan_test.t_subplan2.d2) -> Vector Materialize Output: nodegroup_subplan_test.t_subplan2.c2, nodegroup_subplan_test.t_subplan2.d2 -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) Output: nodegroup_subplan_test.t_subplan2.c2, nodegroup_subplan_test.t_subplan2.d2 -> CStore Scan on nodegroup_subplan_test.t_subplan2 Output: nodegroup_subplan_test.t_subplan2.c2, nodegroup_subplan_test.t_subplan2.d2 Distribute Key: nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2 -> Vector Subquery Scan on "*SELECT* 2" Output: "*SELECT* 2".d1, 1 -> Vector Result Output: t_subplan1.d1 -> Vector Materialize Output: ('Dummy') -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) Output: ('Dummy') -> CStore Scan on nodegroup_subplan_test.t_subplan2 Output: 'Dummy' Distribute Key: nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2 (43 rows) explain (costs off, verbose on) select * from t_subplan1 where a1 in (select count(c2)::int from t_subplan2 where c1>d2 union all select d1 from t_subplan2) or d1=0 order by 1,2,3,4 limit 5; WARNING: Statistics in some tables or columns(nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2, nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan1.d1) are not collected. HINT: Do analyze for them in order to generate optimized plan. QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ Row Adapter Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> Vector Limit Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> Vector Streaming (type: GATHER) Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 Merge Sort Key: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> Vector Limit Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> Vector Sort Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 Sort Key: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 Distribute Key: t_subplan1.a1, t_subplan1.b1 Filter: ((SubPlan 1) OR (t_subplan1.d1 = 0)) SubPlan 1 -> Row Adapter Output: ((count(nodegroup_subplan_test.t_subplan2.c2))::integer) -> Vector Append -> Vector Aggregate Output: (count(nodegroup_subplan_test.t_subplan2.c2))::integer -> Vector Result Output: nodegroup_subplan_test.t_subplan2.c2, nodegroup_subplan_test.t_subplan2.d2 Filter: (t_subplan1.c1 > nodegroup_subplan_test.t_subplan2.d2) -> Vector Materialize Output: nodegroup_subplan_test.t_subplan2.c2, nodegroup_subplan_test.t_subplan2.d2 -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) Output: nodegroup_subplan_test.t_subplan2.c2, nodegroup_subplan_test.t_subplan2.d2 -> CStore Scan on nodegroup_subplan_test.t_subplan2 Output: nodegroup_subplan_test.t_subplan2.c2, nodegroup_subplan_test.t_subplan2.d2 Distribute Key: nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2 -> Vector Result Output: t_subplan1.d1 -> Vector Materialize Output: ('Dummy') -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) Output: ('Dummy') -> CStore Scan on nodegroup_subplan_test.t_subplan2 Output: 'Dummy' Distribute Key: nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2 (41 rows) explain (costs off, verbose on) select b1, count(*) from t_subplan1 where c1 = all (select b2 from t_subplan2 where b2>4) or d1 != all (select c2 from t_subplan2 where c2>10) group by b1 order by 1, 2 limit 5; WARNING: Statistics in some tables or columns(nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2, nodegroup_subplan_test.t_subplan2.c2, nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1) are not collected. HINT: Do analyze for them in order to generate optimized plan. QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------------------------------ Row Adapter Output: t_subplan1.b1, (count(*)) -> Vector Limit Output: t_subplan1.b1, (count(*)) -> Vector Streaming (type: GATHER) Output: t_subplan1.b1, (count(*)) Merge Sort Key: t_subplan1.b1, (count(*)) -> Vector Limit Output: t_subplan1.b1, (count(*)) -> Vector Sort Output: t_subplan1.b1, (count(*)) Sort Key: t_subplan1.b1, (count(*)) -> Vector Sonic Hash Aggregate Output: t_subplan1.b1, count(*) Group By Key: t_subplan1.b1 -> Vector Streaming(type: REDISTRIBUTE ng: ng0->group1) Output: t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 Distribute Key: t_subplan1.b1 -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 Distribute Key: t_subplan1.a1, t_subplan1.b1 Filter: ((SubPlan 1) OR (SubPlan 2)) SubPlan 1 -> Row Adapter Output: nodegroup_subplan_test.t_subplan2.b2 -> Vector Materialize Output: nodegroup_subplan_test.t_subplan2.b2 -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) Output: nodegroup_subplan_test.t_subplan2.b2 -> CStore Scan on nodegroup_subplan_test.t_subplan2 Output: nodegroup_subplan_test.t_subplan2.b2 Distribute Key: nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2 Filter: (nodegroup_subplan_test.t_subplan2.b2 > 4) SubPlan 2 -> Row Adapter Output: nodegroup_subplan_test.t_subplan2.c2 -> Vector Materialize Output: nodegroup_subplan_test.t_subplan2.c2 -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) Output: nodegroup_subplan_test.t_subplan2.c2 -> CStore Scan on nodegroup_subplan_test.t_subplan2 Output: nodegroup_subplan_test.t_subplan2.c2 Distribute Key: nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2 Filter: (nodegroup_subplan_test.t_subplan2.c2 > 10) (44 rows) explain (costs off, verbose on) select b1, count(*) from t_subplan1 where c1 = any (select b2 from t_subplan2 where b2>4) or d1 != any (select c2 from t_subplan2 where c2>10) group by b1 order by 1, 2 limit 5; WARNING: Statistics in some tables or columns(nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2, nodegroup_subplan_test.t_subplan2.c2, nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan1.c1, nodegroup_subplan_test.t_subplan1.d1) are not collected. HINT: Do analyze for them in order to generate optimized plan. QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------------------------------ Row Adapter Output: t_subplan1.b1, (count(*)) -> Vector Limit Output: t_subplan1.b1, (count(*)) -> Vector Streaming (type: GATHER) Output: t_subplan1.b1, (count(*)) Merge Sort Key: t_subplan1.b1, (count(*)) -> Vector Limit Output: t_subplan1.b1, (count(*)) -> Vector Sort Output: t_subplan1.b1, (count(*)) Sort Key: t_subplan1.b1, (count(*)) -> Vector Sonic Hash Aggregate Output: t_subplan1.b1, count(*) Group By Key: t_subplan1.b1 -> Vector Streaming(type: REDISTRIBUTE) Output: t_subplan1.b1 Distribute Key: t_subplan1.b1 -> Vector Hash Left Join Output: t_subplan1.b1 Hash Cond: (t_subplan1.c1 = nodegroup_subplan_test.t_subplan2.b2) Filter: ((nodegroup_subplan_test.t_subplan2.b2 IS NOT NULL) OR (SubPlan 1)) -> Vector Streaming(type: REDISTRIBUTE ng: ng0->group1) Output: t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 Distribute Key: t_subplan1.c1 -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 Distribute Key: t_subplan1.a1, t_subplan1.b1 -> Vector Sonic Hash Aggregate Output: nodegroup_subplan_test.t_subplan2.b2 Group By Key: nodegroup_subplan_test.t_subplan2.b2 -> Vector Streaming(type: REDISTRIBUTE ng: ng1->group1) Output: nodegroup_subplan_test.t_subplan2.b2 Distribute Key: nodegroup_subplan_test.t_subplan2.b2 -> CStore Scan on nodegroup_subplan_test.t_subplan2 Output: nodegroup_subplan_test.t_subplan2.b2 Distribute Key: nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2 Filter: (nodegroup_subplan_test.t_subplan2.b2 > 4) SubPlan 1 -> Row Adapter Output: nodegroup_subplan_test.t_subplan2.c2 -> Vector Materialize Output: nodegroup_subplan_test.t_subplan2.c2 -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) Output: nodegroup_subplan_test.t_subplan2.c2 -> CStore Scan on nodegroup_subplan_test.t_subplan2 Output: nodegroup_subplan_test.t_subplan2.c2 Distribute Key: nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2 Filter: (nodegroup_subplan_test.t_subplan2.c2 > 10) (49 rows) explain (costs off, verbose on) select * from t_subplan1 where (10,15)<=(select b1, min(b2) from t_subplan2 group by b1) order by a1, b1, c1, d1; WARNING: Statistics in some tables or columns(nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2, nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1) are not collected. HINT: Do analyze for them in order to generate optimized plan. QUERY PLAN ---------------------------------------------------------------------------------------------------------- Row Adapter Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> Vector Streaming (type: GATHER) Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 Merge Sort Key: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> Vector Sort Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 Sort Key: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 Distribute Key: t_subplan1.a1, t_subplan1.b1 Filter: (SubPlan 1) SubPlan 1 -> Row Adapter Output: ($0), (min(t_subplan2.b2)) -> Vector Sort Aggregate Output: (t_subplan1.b1), min(t_subplan2.b2) Group By Key: t_subplan1.b1 -> Vector Result Output: t_subplan1.b1, t_subplan2.b2 -> Vector Materialize Output: t_subplan2.b2 -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) Output: t_subplan2.b2 -> CStore Scan on nodegroup_subplan_test.t_subplan2 Output: t_subplan2.b2 Distribute Key: t_subplan2.a2, t_subplan2.b2 (27 rows) explain (costs off, verbose on) select * from t_subplan1 where (b1,c1) < (select a2, b2 from t_subplan2 where b2=4 and a2=4) order by a1, b1, c1, d1; WARNING: Statistics in some tables or columns(nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2, nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1) are not collected. HINT: Do analyze for them in order to generate optimized plan. QUERY PLAN ---------------------------------------------------------------------------------------- Row Adapter Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> Vector Streaming (type: GATHER) Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 Merge Sort Key: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 InitPlan 1 (returns $0,$1) -> Row Adapter Output: t_subplan2.a2, t_subplan2.b2 -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) Output: t_subplan2.a2, t_subplan2.b2 -> CStore Scan on nodegroup_subplan_test.t_subplan2 Output: t_subplan2.a2, t_subplan2.b2 Distribute Key: t_subplan2.a2, t_subplan2.b2 Filter: ((t_subplan2.b2 = 4) AND (t_subplan2.a2 = 4)) -> Vector Sort Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 Sort Key: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 Distribute Key: t_subplan1.a1, t_subplan1.b1 Filter: (ROW(t_subplan1.b1, t_subplan1.c1) < ROW($0, $1)) (21 rows) explain (costs off, verbose on) select * from t_subplan1 where array(select max(b2) from t_subplan2 group by b1)=array(select min(b2) from t_subplan2 group by b1); WARNING: Statistics in some tables or columns(nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2, nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1) are not collected. HINT: Do analyze for them in order to generate optimized plan. QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------------ Row Adapter Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> Vector Streaming (type: GATHER) Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 Distribute Key: t_subplan1.a1, t_subplan1.b1 Filter: ((SubPlan 1) = (SubPlan 2)) SubPlan 1 -> Row Adapter Output: (max(nodegroup_subplan_test.t_subplan2.b2)), ($0) -> Vector Sort Aggregate Output: max(nodegroup_subplan_test.t_subplan2.b2), (t_subplan1.b1) Group By Key: t_subplan1.b1 -> Vector Result Output: t_subplan1.b1, nodegroup_subplan_test.t_subplan2.b2 -> Vector Materialize Output: nodegroup_subplan_test.t_subplan2.b2 -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) Output: nodegroup_subplan_test.t_subplan2.b2 -> CStore Scan on nodegroup_subplan_test.t_subplan2 Output: nodegroup_subplan_test.t_subplan2.b2 Distribute Key: nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2 SubPlan 2 -> Row Adapter Output: (min(nodegroup_subplan_test.t_subplan2.b2)), ($1) -> Vector Sort Aggregate Output: min(nodegroup_subplan_test.t_subplan2.b2), (t_subplan1.b1) Group By Key: t_subplan1.b1 -> Vector Result Output: t_subplan1.b1, nodegroup_subplan_test.t_subplan2.b2 -> Vector Materialize Output: nodegroup_subplan_test.t_subplan2.b2 -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) Output: nodegroup_subplan_test.t_subplan2.b2 -> CStore Scan on nodegroup_subplan_test.t_subplan2 Output: nodegroup_subplan_test.t_subplan2.b2 Distribute Key: nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2 (38 rows) explain (costs off, verbose on) select array(select max(b2) from t_subplan2 group by b1) from t_subplan1 order by a1, b1, c1, d1; WARNING: Statistics in some tables or columns(nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2, nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1) are not collected. HINT: Do analyze for them in order to generate optimized plan. QUERY PLAN ---------------------------------------------------------------------------------------------------------- Row Adapter Output: ((SubPlan 1)), t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> Vector Streaming (type: GATHER) Output: ((SubPlan 1)), t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 Merge Sort Key: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> Vector Sort Output: ((SubPlan 1)), t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 Sort Key: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: (SubPlan 1), t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 Distribute Key: t_subplan1.a1, t_subplan1.b1 SubPlan 1 -> Row Adapter Output: (max(t_subplan2.b2)), ($0) -> Vector Sort Aggregate Output: max(t_subplan2.b2), (t_subplan1.b1) Group By Key: t_subplan1.b1 -> Vector Result Output: t_subplan1.b1, t_subplan2.b2 -> Vector Materialize Output: t_subplan2.b2 -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) Output: t_subplan2.b2 -> CStore Scan on nodegroup_subplan_test.t_subplan2 Output: t_subplan2.b2 Distribute Key: t_subplan2.a2, t_subplan2.b2 (26 rows) explain (costs off, verbose on) select array(select a1 from t_subplan1 where t_subplan1.b1=t_subplan2.b2 order by 1) from t_subplan2 order by a2, b2, c2, d2; WARNING: Statistics in some tables or columns(nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2) are not collected. HINT: Do analyze for them in order to generate optimized plan. QUERY PLAN ---------------------------------------------------------------------------------------------------------- Row Adapter Output: ((SubPlan 1)), t_subplan2.a2, t_subplan2.b2, t_subplan2.c2, t_subplan2.d2 -> Vector Streaming (type: GATHER) Output: ((SubPlan 1)), t_subplan2.a2, t_subplan2.b2, t_subplan2.c2, t_subplan2.d2 Merge Sort Key: t_subplan2.a2, t_subplan2.b2, t_subplan2.c2, t_subplan2.d2 -> Vector Sort Output: ((SubPlan 1)), t_subplan2.a2, t_subplan2.b2, t_subplan2.c2, t_subplan2.d2 Sort Key: t_subplan2.a2, t_subplan2.b2, t_subplan2.c2, t_subplan2.d2 -> CStore Scan on nodegroup_subplan_test.t_subplan2 Output: (SubPlan 1), t_subplan2.a2, t_subplan2.b2, t_subplan2.c2, t_subplan2.d2 Distribute Key: t_subplan2.a2, t_subplan2.b2 SubPlan 1 -> Row Adapter Output: t_subplan1.a1 -> Vector Sort Output: t_subplan1.a1 Sort Key: t_subplan1.a1 -> Vector Result Output: t_subplan1.a1 Filter: (t_subplan1.b1 = t_subplan2.b2) -> Vector Materialize Output: t_subplan1.a1, t_subplan1.b1 -> Vector Streaming(type: BROADCAST ng: ng0->GenGroup) Output: t_subplan1.a1, t_subplan1.b1 -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: t_subplan1.a1, t_subplan1.b1 Distribute Key: t_subplan1.a1, t_subplan1.b1 (27 rows) -- test cte sublink explain (costs off, verbose on) select (with cte(foo) as (select a1) select foo from cte) from t_subplan1 order by 1 limit 3; WARNING: Statistics in some tables or columns(nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1) are not collected. HINT: Do analyze for them in order to generate optimized plan. QUERY PLAN -------------------------------------------------------------------------------- Row Adapter Output: ((SubPlan 1)) -> Vector Limit Output: ((SubPlan 1)) -> Vector Streaming (type: GATHER) Output: ((SubPlan 1)) Merge Sort Key: ((SubPlan 1)) -> Vector Limit Output: ((SubPlan 1)) -> Vector Sort Output: ((SubPlan 1)) Sort Key: ((SubPlan 1)) -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: (SubPlan 1) Distribute Key: t_subplan1.a1, t_subplan1.b1 SubPlan 1 -> Result Output: t_subplan1.a1 (18 rows) select (with cte(foo) as (select a1) select foo from cte) from t_subplan1 order by 1 limit 3; foo ----- 0 1 1 (3 rows) explain (costs off, verbose on) select (with cte(foo) as (select a1 from dual) select foo from cte) from t_subplan1 order by 1 limit 3; WARNING: Statistics in some tables or columns(nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1) are not collected. HINT: Do analyze for them in order to generate optimized plan. QUERY PLAN -------------------------------------------------------------------------------- Row Adapter Output: ((SubPlan 1)) -> Vector Limit Output: ((SubPlan 1)) -> Vector Streaming (type: GATHER) Output: ((SubPlan 1)) Merge Sort Key: ((SubPlan 1)) -> Vector Limit Output: ((SubPlan 1)) -> Vector Sort Output: ((SubPlan 1)) Sort Key: ((SubPlan 1)) -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: (SubPlan 1) Distribute Key: t_subplan1.a1, t_subplan1.b1 SubPlan 1 -> Subquery Scan on dual Output: t_subplan1.a1 -> Result Output: 'X'::text (20 rows) select (with cte(foo) as (select a1 from dual) select foo from cte) from t_subplan1 order by 1 limit 3; foo ----- 0 1 1 (3 rows) explain (costs off, verbose on) select (with cte(foo) as (values(b1)) values((select foo from cte))) from t_subplan1 order by 1 limit 3; WARNING: Statistics in some tables or columns(nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1) are not collected. HINT: Do analyze for them in order to generate optimized plan. QUERY PLAN -------------------------------------------------------------------------------- Row Adapter Output: ((SubPlan 2)) -> Vector Limit Output: ((SubPlan 2)) -> Vector Streaming (type: GATHER) Output: ((SubPlan 2)) Merge Sort Key: ((SubPlan 2)) -> Vector Limit Output: ((SubPlan 2)) -> Vector Sort Output: ((SubPlan 2)) Sort Key: ((SubPlan 2)) -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: (SubPlan 2) Distribute Key: t_subplan1.a1, t_subplan1.b1 SubPlan 2 -> Values Scan on "*VALUES*" Output: "*VALUES*".column1 InitPlan 1 (returns $1) -> Values Scan on "*VALUES*" Output: "*VALUES*".column1 (21 rows) explain (costs off, verbose on) select (with cte(foo) as (select avg(a1) from t_subplan1) select foo from cte) from t_subplan1 order by 1 limit 3; WARNING: Statistics in some tables or columns(nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1) are not collected. HINT: Do analyze for them in order to generate optimized plan. QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------ Row Adapter Output: ($0) -> Vector Limit Output: ($0) InitPlan 1 (returns $0) -> Row Adapter Output: (pg_catalog.avg((avg(nodegroup_subplan_test.t_subplan1.a1)))) -> Vector Aggregate Output: pg_catalog.avg((avg(nodegroup_subplan_test.t_subplan1.a1))) -> Vector Streaming(type: BROADCAST ng: ng0->GenGroup) Output: (avg(nodegroup_subplan_test.t_subplan1.a1)) -> Vector Aggregate Output: avg(nodegroup_subplan_test.t_subplan1.a1) -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: nodegroup_subplan_test.t_subplan1.a1 Distribute Key: nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1 -> Vector Streaming (type: GATHER) Output: ($0) -> Vector Limit Output: ($0) -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: $0 Distribute Key: nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1 (23 rows) explain (costs off, verbose on) select (with cte(foo) as (select t_subplan1.b1 from t_subplan2 limit 1) select foo from cte) from t_subplan1 order by 1 limit 3; WARNING: Statistics in some tables or columns(nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2, nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1) are not collected. HINT: Do analyze for them in order to generate optimized plan. QUERY PLAN ---------------------------------------------------------------------------------------------------------------------------- Row Adapter Output: ((SubPlan 1)) -> Vector Limit Output: ((SubPlan 1)) -> Vector Streaming (type: GATHER) Output: ((SubPlan 1)) Merge Sort Key: ((SubPlan 1)) -> Vector Limit Output: ((SubPlan 1)) -> Vector Sort Output: ((SubPlan 1)) Sort Key: ((SubPlan 1)) -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: (SubPlan 1) Distribute Key: t_subplan1.a1, t_subplan1.b1 SubPlan 1 -> Row Adapter Output: ($0) -> Vector Limit Output: (t_subplan1.b1) -> Vector Sort Output: (t_subplan1.b1) Sort Key: (t_subplan1.b1) -> Vector Result Output: t_subplan1.b1 -> Vector Materialize Output: ('Dummy') -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) Output: ('Dummy') -> CStore Scan on nodegroup_subplan_test.t_subplan2 Output: 'Dummy' Distribute Key: t_subplan2.a2, t_subplan2.b2 (32 rows) explain (costs off, verbose on) select (with cte(foo) as (select t_subplan1.b1 from t_subplan2 limit 1) select foo+t_subplan1.c1 from cte) from t_subplan1 order by 1 limit 3; WARNING: Statistics in some tables or columns(nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2, nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1) are not collected. HINT: Do analyze for them in order to generate optimized plan. QUERY PLAN ---------------------------------------------------------------------------------------------------------------------------------- Row Adapter Output: ((SubPlan 1)) -> Vector Limit Output: ((SubPlan 1)) -> Vector Streaming (type: GATHER) Output: ((SubPlan 1)) Merge Sort Key: ((SubPlan 1)) -> Vector Limit Output: ((SubPlan 1)) -> Vector Sort Output: ((SubPlan 1)) Sort Key: ((SubPlan 1)) -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: (SubPlan 1) Distribute Key: t_subplan1.a1, t_subplan1.b1 SubPlan 1 -> Row Adapter Output: ((cte.foo + $0)) -> Vector Subquery Scan on cte Output: (cte.foo + t_subplan1.c1) -> Vector Limit Output: (t_subplan1.b1) -> Vector Sort Output: (t_subplan1.b1) Sort Key: (t_subplan1.b1) -> Vector Result Output: t_subplan1.b1 -> Vector Materialize Output: ('Dummy') -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) Output: ('Dummy') -> CStore Scan on nodegroup_subplan_test.t_subplan2 Output: 'Dummy' Distribute Key: t_subplan2.a2, t_subplan2.b2 (34 rows) explain (costs off, verbose on) select (with cte(foo) as (select t_subplan1.b1 from t_subplan2 limit 1) values((select foo from cte))) from t_subplan1 order by 1 limit 3; WARNING: Statistics in some tables or columns(nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2, nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1) are not collected. HINT: Do analyze for them in order to generate optimized plan. QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------ Row Adapter Output: ((SubPlan 2)) -> Vector Limit Output: ((SubPlan 2)) -> Vector Streaming (type: GATHER) Output: ((SubPlan 2)) Merge Sort Key: ((SubPlan 2)) -> Vector Limit Output: ((SubPlan 2)) -> Vector Sort Output: ((SubPlan 2)) Sort Key: ((SubPlan 2)) -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: (SubPlan 2) Distribute Key: t_subplan1.a1, t_subplan1.b1 SubPlan 2 -> Values Scan on "*VALUES*" Output: "*VALUES*".column1 InitPlan 1 (returns $1) -> Row Adapter Output: (t_subplan1.b1) -> Vector Limit Output: (t_subplan1.b1) -> Vector Sort Output: (t_subplan1.b1) Sort Key: (t_subplan1.b1) -> Vector Result Output: t_subplan1.b1 -> Vector Materialize Output: ('Dummy') -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) Output: ('Dummy') -> CStore Scan on nodegroup_subplan_test.t_subplan2 Output: 'Dummy' Distribute Key: t_subplan2.a2, t_subplan2.b2 (35 rows) explain (costs off, verbose on) select (with cte(foo) as (values(b1)) select foo from cte) from t_subplan1 order by 1 limit 3; WARNING: Statistics in some tables or columns(nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1) are not collected. HINT: Do analyze for them in order to generate optimized plan. QUERY PLAN -------------------------------------------------------------------------------- Row Adapter Output: ((SubPlan 1)) -> Vector Limit Output: ((SubPlan 1)) -> Vector Streaming (type: GATHER) Output: ((SubPlan 1)) Merge Sort Key: ((SubPlan 1)) -> Vector Limit Output: ((SubPlan 1)) -> Vector Sort Output: ((SubPlan 1)) Sort Key: ((SubPlan 1)) -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: (SubPlan 1) Distribute Key: t_subplan1.a1, t_subplan1.b1 SubPlan 1 -> Values Scan on "*VALUES*" Output: "*VALUES*".column1 (18 rows) explain (costs off, verbose on) select (select b1 from (values((select b1 from t_subplan2 limit 1), (select a1 from t_subplan2 limit 1))) as t(c,d)) from t_subplan1 order by 1 limit 3; WARNING: Statistics in some tables or columns(nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2, nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1) are not collected. HINT: Do analyze for them in order to generate optimized plan. QUERY PLAN -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Row Adapter Output: ((SubPlan 3)) -> Vector Limit Output: ((SubPlan 3)) -> Vector Streaming (type: GATHER) Output: ((SubPlan 3)) Merge Sort Key: ((SubPlan 3)) -> Vector Limit Output: ((SubPlan 3)) -> Vector Sort Output: ((SubPlan 3)) Sort Key: ((SubPlan 3)) -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: (SubPlan 3) Distribute Key: t_subplan1.a1, t_subplan1.b1 SubPlan 3 -> Values Scan on "*VALUES*" Output: t_subplan1.b1 InitPlan 1 (returns $1) -> Row Adapter Output: (t_subplan1.b1) -> Vector Limit Output: (t_subplan1.b1) -> Vector Sort Output: (t_subplan1.b1) Sort Key: (t_subplan1.b1) -> Vector Result Output: t_subplan1.b1 -> Vector Materialize Output: ('Dummy') -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) Output: ('Dummy') -> CStore Scan on nodegroup_subplan_test.t_subplan2 Output: 'Dummy' Distribute Key: nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2 InitPlan 2 (returns $3) -> Row Adapter Output: (t_subplan1.a1) -> Vector Limit Output: (t_subplan1.a1) -> Vector Sort Output: (t_subplan1.a1) Sort Key: (t_subplan1.a1) -> Vector Result Output: t_subplan1.a1 -> Vector Materialize Output: ('Dummy') -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) Output: ('Dummy') -> CStore Scan on nodegroup_subplan_test.t_subplan2 Output: 'Dummy' Distribute Key: nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2 (52 rows) -- test cte sublink applied in different subquery level explain (costs off, verbose on) select * from t_subplan1 where c1 = (with tmp as (select d2 from t_subplan2 where b2=a1) select count(*) from (select 'abc', count(d2) from tmp)) order by 1,2,3,4; WARNING: Statistics in some tables or columns(nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2, nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan1.c1) are not collected. HINT: Do analyze for them in order to generate optimized plan. QUERY PLAN ---------------------------------------------------------------------------------------------------------------- Row Adapter Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> Vector Streaming (type: GATHER) Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 Merge Sort Key: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> Vector Sort Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 Sort Key: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 Distribute Key: t_subplan1.a1, t_subplan1.b1 Filter: (t_subplan1.c1 = (SubPlan 1)) SubPlan 1 -> Row Adapter Output: (count(*)) -> Vector Aggregate Output: count(*) -> Vector Aggregate Output: 'abc'::text, count(t_subplan2.d2) -> Vector Result Output: t_subplan2.d2, t_subplan2.b2 Filter: (t_subplan2.b2 = t_subplan1.a1) -> Vector Materialize Output: t_subplan2.d2, t_subplan2.b2 -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) Output: t_subplan2.d2, t_subplan2.b2 -> CStore Scan on nodegroup_subplan_test.t_subplan2 Output: t_subplan2.d2, t_subplan2.b2 Distribute Key: t_subplan2.a2, t_subplan2.b2 (29 rows) explain (costs off, verbose on) select * from t_subplan1 where a1 = (with tmp as (select d2 from t_subplan2 where b2=a1) select count(*) from (select 'abc', d2 from tmp)) order by 1,2,3,4; WARNING: Statistics in some tables or columns(nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2, nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1) are not collected. HINT: Do analyze for them in order to generate optimized plan. QUERY PLAN ---------------------------------------------------------------------------------------------------------- Row Adapter Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> Vector Streaming (type: GATHER) Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 Merge Sort Key: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> Vector Sort Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 Sort Key: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 Distribute Key: t_subplan1.a1, t_subplan1.b1 Filter: (t_subplan1.a1 = (SubPlan 1)) SubPlan 1 -> Row Adapter Output: (count(*)) -> Vector Aggregate Output: count(*) -> Vector Result Output: t_subplan2.b2 Filter: (t_subplan2.b2 = t_subplan1.a1) -> Vector Materialize Output: t_subplan2.b2 -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) Output: t_subplan2.b2 -> CStore Scan on nodegroup_subplan_test.t_subplan2 Output: t_subplan2.b2 Distribute Key: t_subplan2.a2, t_subplan2.b2 (27 rows) explain (costs off, verbose on) select * from t_subplan1 where c1 = (with tmp as (select d2 from t_subplan2 where b2=a1) select count(*) from (select 'abc', count(d2) from tmp tmp1 where d2>(select count(*) from tmp tmp2 where tmp2.d2=tmp1.d2))) order by 1,2,3,4; WARNING: Statistics in some tables or columns(nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2, nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan1.c1) are not collected. HINT: Do analyze for them in order to generate optimized plan. QUERY PLAN ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Row Adapter Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> Vector Streaming (type: GATHER) Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 Merge Sort Key: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> Vector Sort Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 Sort Key: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 Distribute Key: t_subplan1.a1, t_subplan1.b1 Filter: (t_subplan1.c1 = (SubPlan 2)) SubPlan 2 -> Row Adapter Output: (count(*)) -> Vector Aggregate Output: count(*) -> Vector Aggregate Output: 'abc'::text, count(nodegroup_subplan_test.t_subplan2.d2) -> Vector Result Output: nodegroup_subplan_test.t_subplan2.d2, nodegroup_subplan_test.t_subplan2.b2 Filter: ((nodegroup_subplan_test.t_subplan2.b2 = t_subplan1.a1) AND (nodegroup_subplan_test.t_subplan2.d2 > (SubPlan 1))) -> Vector Materialize Output: nodegroup_subplan_test.t_subplan2.d2, nodegroup_subplan_test.t_subplan2.b2 -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) Output: nodegroup_subplan_test.t_subplan2.d2, nodegroup_subplan_test.t_subplan2.b2 -> CStore Scan on nodegroup_subplan_test.t_subplan2 Output: nodegroup_subplan_test.t_subplan2.d2, nodegroup_subplan_test.t_subplan2.b2 Distribute Key: nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2 SubPlan 1 -> Row Adapter Output: (count(*)) -> Vector Aggregate Output: count(*) -> Vector Result Output: nodegroup_subplan_test.t_subplan2.b2, nodegroup_subplan_test.t_subplan2.d2 Filter: ((nodegroup_subplan_test.t_subplan2.b2 = t_subplan1.a1) AND (nodegroup_subplan_test.t_subplan2.d2 = nodegroup_subplan_test.t_subplan2.d2)) -> Vector Materialize Output: nodegroup_subplan_test.t_subplan2.b2, nodegroup_subplan_test.t_subplan2.d2 -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) Output: nodegroup_subplan_test.t_subplan2.b2, nodegroup_subplan_test.t_subplan2.d2 -> CStore Scan on nodegroup_subplan_test.t_subplan2 Output: nodegroup_subplan_test.t_subplan2.b2, nodegroup_subplan_test.t_subplan2.d2 Distribute Key: nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2 (44 rows) explain (costs off, verbose on) select * from t_subplan1 where c1 = (with tmp as (select d2 from t_subplan2 where b2=a1) select count(*) from (select 'abc', d2 from tmp tmp1 where d2>(select count(*) from tmp tmp2 where tmp2.d2=tmp1.d2))) order by 1,2,3,4; WARNING: Statistics in some tables or columns(nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2, nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan1.c1) are not collected. HINT: Do analyze for them in order to generate optimized plan. QUERY PLAN ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Row Adapter Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> Vector Streaming (type: GATHER) Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 Merge Sort Key: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> Vector Sort Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 Sort Key: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 Distribute Key: t_subplan1.a1, t_subplan1.b1 Filter: (t_subplan1.c1 = (SubPlan 2)) SubPlan 2 -> Row Adapter Output: (count(*)) -> Vector Aggregate Output: count(*) -> Vector Result Output: nodegroup_subplan_test.t_subplan2.b2, nodegroup_subplan_test.t_subplan2.d2 Filter: ((nodegroup_subplan_test.t_subplan2.b2 = t_subplan1.a1) AND (nodegroup_subplan_test.t_subplan2.d2 > (SubPlan 1))) -> Vector Materialize Output: nodegroup_subplan_test.t_subplan2.b2, nodegroup_subplan_test.t_subplan2.d2 -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) Output: nodegroup_subplan_test.t_subplan2.b2, nodegroup_subplan_test.t_subplan2.d2 -> CStore Scan on nodegroup_subplan_test.t_subplan2 Output: nodegroup_subplan_test.t_subplan2.b2, nodegroup_subplan_test.t_subplan2.d2 Distribute Key: nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2 SubPlan 1 -> Row Adapter Output: (count(*)) -> Vector Aggregate Output: count(*) -> Vector Result Output: nodegroup_subplan_test.t_subplan2.b2, nodegroup_subplan_test.t_subplan2.d2 Filter: ((nodegroup_subplan_test.t_subplan2.b2 = t_subplan1.a1) AND (nodegroup_subplan_test.t_subplan2.d2 = nodegroup_subplan_test.t_subplan2.d2)) -> Vector Materialize Output: nodegroup_subplan_test.t_subplan2.b2, nodegroup_subplan_test.t_subplan2.d2 -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) Output: nodegroup_subplan_test.t_subplan2.b2, nodegroup_subplan_test.t_subplan2.d2 -> CStore Scan on nodegroup_subplan_test.t_subplan2 Output: nodegroup_subplan_test.t_subplan2.b2, nodegroup_subplan_test.t_subplan2.d2 Distribute Key: nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2 (42 rows) explain (costs off, verbose on) select * from t_subplan1 left join (select a2, b2, (select b1 from t_subplan1 limit 1) c2 from t_subplan2) on b2=b1 and a1 not in (null) inner join t_subplan1 t3 on t3.a1=t_subplan1.c1 where t3.a1=0 order by 1,2,3,4 limit 5; WARNING: Statistics in some tables or columns(nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan1.c1, nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2) are not collected. HINT: Do analyze for them in order to generate optimized plan. QUERY PLAN ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Row Adapter Output: nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan1.c1, nodegroup_subplan_test.t_subplan1.d1, t_subplan2.a2, t_subplan2.b2, ($0), t3.a1, t3.b1, t3.c1, t3.d1 -> Vector Limit Output: nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan1.c1, nodegroup_subplan_test.t_subplan1.d1, t_subplan2.a2, t_subplan2.b2, ($0), t3.a1, t3.b1, t3.c1, t3.d1 InitPlan 1 (returns $0) -> Row Adapter Output: nodegroup_subplan_test.t_subplan1.b1 -> Vector Streaming(type: BROADCAST ng: ng0->GenGroup) Output: nodegroup_subplan_test.t_subplan1.b1 -> Vector Limit Output: nodegroup_subplan_test.t_subplan1.b1 -> Vector Streaming(type: BROADCAST) Output: nodegroup_subplan_test.t_subplan1.b1 -> Vector Limit Output: nodegroup_subplan_test.t_subplan1.b1 -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: nodegroup_subplan_test.t_subplan1.b1 Distribute Key: nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1 -> Vector Streaming (type: GATHER) Output: nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan1.c1, nodegroup_subplan_test.t_subplan1.d1, t_subplan2.a2, t_subplan2.b2, ($0), t3.a1, t3.b1, t3.c1, t3.d1 Merge Sort Key: nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan1.d1 -> Vector Limit Output: nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan1.c1, nodegroup_subplan_test.t_subplan1.d1, t_subplan2.a2, t_subplan2.b2, ($0), t3.a1, t3.b1, t3.c1, t3.d1 -> Vector Sort Output: nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan1.c1, nodegroup_subplan_test.t_subplan1.d1, t_subplan2.a2, t_subplan2.b2, ($0), t3.a1, t3.b1, t3.c1, t3.d1 Sort Key: nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan1.d1 -> Vector Nest Loop Output: nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan1.c1, nodegroup_subplan_test.t_subplan1.d1, t_subplan2.a2, t_subplan2.b2, ($0), t3.a1, t3.b1, t3.c1, t3.d1 -> Vector Streaming(type: BROADCAST) Output: t3.a1, t3.b1, t3.c1, t3.d1 -> CStore Scan on nodegroup_subplan_test.t_subplan1 t3 Output: t3.a1, t3.b1, t3.c1, t3.d1 Distribute Key: t3.a1, t3.b1 Filter: (t3.a1 = 0) -> Vector Materialize Output: nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan1.c1, nodegroup_subplan_test.t_subplan1.d1, t_subplan2.a2, t_subplan2.b2, ($0) -> Vector Streaming(type: REDISTRIBUTE ng: group1->ng0) Output: nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan1.c1, nodegroup_subplan_test.t_subplan1.d1, t_subplan2.a2, t_subplan2.b2, ($0) Distribute Key: nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1 -> Vector Nest Loop Left Join Output: nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan1.c1, nodegroup_subplan_test.t_subplan1.d1, t_subplan2.a2, t_subplan2.b2, ($0) Join Filter: false -> Vector Streaming(type: REDISTRIBUTE ng: ng0->group1) Output: nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan1.c1, nodegroup_subplan_test.t_subplan1.d1 Distribute Key: nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1 -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan1.c1, nodegroup_subplan_test.t_subplan1.d1 Distribute Key: nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1 Filter: (nodegroup_subplan_test.t_subplan1.c1 = 0) -> Vector Adapter Output: t_subplan2.a2, t_subplan2.b2, ($0) -> Result Output: t_subplan2.a2, t_subplan2.b2, $0 One-Time Filter: false (54 rows) explain (costs off, verbose on) select count(*) from t_subplan2 group by a2,b2 order by (a2,b2) > some(select min(a1), length(trim(b2)) from t_subplan1), 1; WARNING: Statistics in some tables or columns(nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2) are not collected. HINT: Do analyze for them in order to generate optimized plan. QUERY PLAN ---------------------------------------------------------------------------------------------------- Row Adapter Output: (count(*)), ((SubPlan 1)), t_subplan2.a2, t_subplan2.b2 -> Vector Streaming (type: GATHER) Output: (count(*)), ((SubPlan 1)), t_subplan2.a2, t_subplan2.b2 Merge Sort Key: ((SubPlan 1)), (count(*)) -> Vector Sort Output: (count(*)), ((SubPlan 1)), t_subplan2.a2, t_subplan2.b2 Sort Key: ((SubPlan 1)), (count(*)) -> Vector Hash Aggregate Output: count(*), (SubPlan 1), t_subplan2.a2, t_subplan2.b2 Group By Key: t_subplan2.a2, t_subplan2.b2 -> Vector Streaming(type: REDISTRIBUTE ng: ng1->group1) Output: t_subplan2.a2, t_subplan2.b2 Distribute Key: t_subplan2.a2, t_subplan2.b2 -> CStore Scan on nodegroup_subplan_test.t_subplan2 Output: t_subplan2.a2, t_subplan2.b2 Distribute Key: t_subplan2.a2, t_subplan2.b2 SubPlan 1 -> Row Adapter Output: (min(t_subplan1.a1)), (length(btrim(($0)::text))) -> Vector Aggregate Output: min(t_subplan1.a1), length(btrim((t_subplan2.b2)::text)) -> Vector Materialize Output: t_subplan1.a1 -> Vector Streaming(type: BROADCAST ng: ng0->GenGroup) Output: t_subplan1.a1 -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: t_subplan1.a1 Distribute Key: t_subplan1.a1, t_subplan1.b1 (29 rows) -- update explain (costs off, verbose on) update t_subplan2 set d2 = t1.b from (select max(a1) b from t_subplan1 group by c1 not in (select a1*0-1 from t_subplan1)) t1; WARNING: Statistics in some tables or columns(nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2, nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan1.c1) are not collected. HINT: Do analyze for them in order to generate optimized plan. QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ Row Adapter -> Vector Streaming (type: GATHER) -> Vector Update on nodegroup_subplan_test.t_subplan2 -> Vector Nest Loop Output: t_subplan2.a2, t_subplan2.b2, t_subplan2.c2, t1.b, t_subplan2.ctid, t_subplan2.tableoid, t_subplan2.xc_node_id, t1.b -> CStore Scan on nodegroup_subplan_test.t_subplan2 Output: t_subplan2.a2, t_subplan2.b2, t_subplan2.c2, t_subplan2.ctid, t_subplan2.tableoid, t_subplan2.xc_node_id Distribute Key: t_subplan2.a2, t_subplan2.b2 -> Vector Materialize Output: t1.b -> Vector Streaming(type: BROADCAST ng: group1->ng1) Output: t1.b -> Vector Subquery Scan on t1 Output: t1.b -> Vector Hash Aggregate Output: max(nodegroup_subplan_test.t_subplan1.a1), ((NOT (hashed SubPlan 1))) Group By Key: ((NOT (hashed SubPlan 1))) -> Vector Streaming(type: REDISTRIBUTE ng: ng0->group1) Output: ((NOT (hashed SubPlan 1))), nodegroup_subplan_test.t_subplan1.a1 Distribute Key: ((NOT (hashed SubPlan 1))) -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: (NOT (hashed SubPlan 1)), nodegroup_subplan_test.t_subplan1.a1 Distribute Key: nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1 SubPlan 1 -> Row Adapter Output: (((nodegroup_subplan_test.t_subplan1.a1 * 0) - 1)) -> Vector Materialize Output: (((nodegroup_subplan_test.t_subplan1.a1 * 0) - 1)) -> Vector Streaming(type: BROADCAST ng: ng0->GenGroup) Output: (((nodegroup_subplan_test.t_subplan1.a1 * 0) - 1)) -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: ((nodegroup_subplan_test.t_subplan1.a1 * 0) - 1) Distribute Key: nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1 (33 rows) explain (costs off, verbose on) select count(*) from t_subplan1 group by a1 having(avg(b1) = some (select b2 from t_subplan2)) order by 1 limit 5; WARNING: Statistics in some tables or columns(nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2, nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1) are not collected. HINT: Do analyze for them in order to generate optimized plan. QUERY PLAN ---------------------------------------------------------------------------------------------------------- Row Adapter Output: (count(*)), t_subplan1.a1 -> Vector Limit Output: (count(*)), t_subplan1.a1 -> Vector Streaming (type: GATHER) Output: (count(*)), t_subplan1.a1 Merge Sort Key: (count(*)) -> Vector Limit Output: (count(*)), t_subplan1.a1 -> Vector Sort Output: (count(*)), t_subplan1.a1 Sort Key: (count(*)) -> Vector Sonic Hash Aggregate Output: count(*), t_subplan1.a1 Group By Key: t_subplan1.a1 Filter: (hashed SubPlan 1) -> Vector Streaming(type: REDISTRIBUTE ng: ng0->group1) Output: t_subplan1.a1, t_subplan1.b1 Distribute Key: t_subplan1.a1 -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: t_subplan1.a1, t_subplan1.b1 Distribute Key: t_subplan1.a1, t_subplan1.b1 SubPlan 1 -> Row Adapter Output: t_subplan2.b2 -> Vector Materialize Output: t_subplan2.b2 -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) Output: t_subplan2.b2 -> CStore Scan on nodegroup_subplan_test.t_subplan2 Output: t_subplan2.b2 Distribute Key: t_subplan2.a2, t_subplan2.b2 (32 rows) explain (costs off, verbose on) select max(a1), b1 = some (select b2 from t_subplan2) from t_subplan1 group by b1 order by 1,2 limit 5; WARNING: Statistics in some tables or columns(nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2, nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1) are not collected. HINT: Do analyze for them in order to generate optimized plan. QUERY PLAN ---------------------------------------------------------------------------------------------------------- Row Adapter Output: (max(t_subplan1.a1)), ((hashed SubPlan 1)), t_subplan1.b1 -> Vector Limit Output: (max(t_subplan1.a1)), ((hashed SubPlan 1)), t_subplan1.b1 -> Vector Streaming (type: GATHER) Output: (max(t_subplan1.a1)), ((hashed SubPlan 1)), t_subplan1.b1 Merge Sort Key: (max(t_subplan1.a1)), ((hashed SubPlan 1)) -> Vector Limit Output: (max(t_subplan1.a1)), ((hashed SubPlan 1)), t_subplan1.b1 -> Vector Sort Output: (max(t_subplan1.a1)), ((hashed SubPlan 1)), t_subplan1.b1 Sort Key: (max(t_subplan1.a1)), ((hashed SubPlan 1)) -> Vector Hash Aggregate Output: max(t_subplan1.a1), (hashed SubPlan 1), t_subplan1.b1 Group By Key: t_subplan1.b1 -> Vector Streaming(type: REDISTRIBUTE ng: ng0->group1) Output: t_subplan1.b1, t_subplan1.a1 Distribute Key: t_subplan1.b1 -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: t_subplan1.b1, t_subplan1.a1 Distribute Key: t_subplan1.a1, t_subplan1.b1 SubPlan 1 -> Row Adapter Output: t_subplan2.b2 -> Vector Materialize Output: t_subplan2.b2 -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) Output: t_subplan2.b2 -> CStore Scan on nodegroup_subplan_test.t_subplan2 Output: t_subplan2.b2 Distribute Key: t_subplan2.a2, t_subplan2.b2 (31 rows) explain (costs off, verbose on) select max(a1), min(b1) = some (select b2 from t_subplan2) from t_subplan1 group by b1 order by 1,2 limit 5; WARNING: Statistics in some tables or columns(nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2, nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1) are not collected. HINT: Do analyze for them in order to generate optimized plan. QUERY PLAN ---------------------------------------------------------------------------------------------------------- Row Adapter Output: (max(t_subplan1.a1)), ((hashed SubPlan 1)), t_subplan1.b1 -> Vector Limit Output: (max(t_subplan1.a1)), ((hashed SubPlan 1)), t_subplan1.b1 -> Vector Streaming (type: GATHER) Output: (max(t_subplan1.a1)), ((hashed SubPlan 1)), t_subplan1.b1 Merge Sort Key: (max(t_subplan1.a1)), ((hashed SubPlan 1)) -> Vector Limit Output: (max(t_subplan1.a1)), ((hashed SubPlan 1)), t_subplan1.b1 -> Vector Sort Output: (max(t_subplan1.a1)), ((hashed SubPlan 1)), t_subplan1.b1 Sort Key: (max(t_subplan1.a1)), ((hashed SubPlan 1)) -> Vector Hash Aggregate Output: max(t_subplan1.a1), (hashed SubPlan 1), t_subplan1.b1 Group By Key: t_subplan1.b1 -> Vector Streaming(type: REDISTRIBUTE ng: ng0->group1) Output: t_subplan1.b1, t_subplan1.a1 Distribute Key: t_subplan1.b1 -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: t_subplan1.b1, t_subplan1.a1 Distribute Key: t_subplan1.a1, t_subplan1.b1 SubPlan 1 -> Row Adapter Output: t_subplan2.b2 -> Vector Materialize Output: t_subplan2.b2 -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) Output: t_subplan2.b2 -> CStore Scan on nodegroup_subplan_test.t_subplan2 Output: t_subplan2.b2 Distribute Key: t_subplan2.a2, t_subplan2.b2 (31 rows) explain (costs off, verbose on) select a1, b1 from t_subplan1 group by a1, b1 having(grouping(b1)) = some (select b2 from t_subplan2) order by 1,2 limit 5; WARNING: Statistics in some tables or columns(nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2, nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1) are not collected. HINT: Do analyze for them in order to generate optimized plan. QUERY PLAN ---------------------------------------------------------------------------------------------------- Row Adapter Output: t_subplan1.a1, t_subplan1.b1 -> Vector Limit Output: t_subplan1.a1, t_subplan1.b1 -> Vector Streaming (type: GATHER) Output: t_subplan1.a1, t_subplan1.b1 Merge Sort Key: t_subplan1.a1, t_subplan1.b1 -> Vector Limit Output: t_subplan1.a1, t_subplan1.b1 -> Vector Sort Aggregate Output: t_subplan1.a1, t_subplan1.b1 Group By Key: t_subplan1.a1, t_subplan1.b1 Filter: (hashed SubPlan 1) -> Vector Sort Output: t_subplan1.a1, t_subplan1.b1 Sort Key: t_subplan1.a1, t_subplan1.b1 -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: t_subplan1.a1, t_subplan1.b1 Distribute Key: t_subplan1.a1, t_subplan1.b1 SubPlan 1 -> Row Adapter Output: t_subplan2.b2 -> Vector Materialize Output: t_subplan2.b2 -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) Output: t_subplan2.b2 -> CStore Scan on nodegroup_subplan_test.t_subplan2 Output: t_subplan2.b2 Distribute Key: t_subplan2.a2, t_subplan2.b2 (29 rows) explain (costs off, verbose on) select a1, rank() over(partition by a1) = some (select a2 from t_subplan2) from t_subplan1 order by 1,2 limit 5; WARNING: Statistics in some tables or columns(nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2, nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1) are not collected. HINT: Do analyze for them in order to generate optimized plan. QUERY PLAN ---------------------------------------------------------------------------------------------------------- Row Adapter Output: t_subplan1.a1, ((hashed SubPlan 1)) -> Vector Limit Output: t_subplan1.a1, ((hashed SubPlan 1)) -> Vector Streaming (type: GATHER) Output: t_subplan1.a1, ((hashed SubPlan 1)) Merge Sort Key: t_subplan1.a1, ((hashed SubPlan 1)) -> Vector Limit Output: t_subplan1.a1, ((hashed SubPlan 1)) -> Vector Sort Output: t_subplan1.a1, ((hashed SubPlan 1)) Sort Key: t_subplan1.a1, ((hashed SubPlan 1)) -> Vector WindowAgg Output: t_subplan1.a1, (hashed SubPlan 1) -> Vector Sort Output: t_subplan1.a1 Sort Key: t_subplan1.a1 -> Vector Streaming(type: REDISTRIBUTE) Output: t_subplan1.a1 Distribute Key: t_subplan1.a1 -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: t_subplan1.a1 Distribute Key: t_subplan1.a1, t_subplan1.b1 SubPlan 1 -> Row Adapter Output: t_subplan2.a2 -> Vector Materialize Output: t_subplan2.a2 -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) Output: t_subplan2.a2 -> CStore Scan on nodegroup_subplan_test.t_subplan2 Output: t_subplan2.a2 Distribute Key: t_subplan2.a2, t_subplan2.b2 (33 rows) explain (costs off, verbose on) select * from t_subplan7 t1 where a1 in (select t1.a1 - 1 from t_subplan1); WARNING: Statistics in some tables or columns(nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1, nodegroup_subplan_test.t_subplan7.a1, nodegroup_subplan_test.t_subplan7.b1) are not collected. HINT: Do analyze for them in order to generate optimized plan. QUERY PLAN ---------------------------------------------------------------------------------------------- Row Adapter Output: t1.a1, t1.b1, t1.c1, t1.d1 -> Vector Streaming (type: GATHER) Output: t1.a1, t1.b1, t1.c1, t1.d1 -> CStore Scan on nodegroup_subplan_test.t_subplan7 t1 Output: t1.a1, t1.b1, t1.c1, t1.d1 Distribute Key: t1.a1, t1.b1 Filter: (SubPlan 1) SubPlan 1 -> Row Adapter Output: (($0 - 1)) -> Vector Result Output: (t1.a1 - 1) -> Vector Materialize Output: ('Dummy') -> Vector Streaming(type: BROADCAST ng: ng0->GenGroup) Output: ('Dummy') -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: 'Dummy' Distribute Key: t_subplan1.a1, t_subplan1.b1 (20 rows) set work_mem = '1MB'; set enable_nestloop = off; set enable_hashjoin = off; explain (costs off, verbose on) select * from t_subplan1 where c1 > any(select c2 from t_subplan2 join t_subplan3 on a3 = a2 where b2 < b1) order by 1,2,3,4 limit 10; WARNING: Statistics in some tables or columns(nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2, nodegroup_subplan_test.t_subplan3.a3, nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1) are not collected. HINT: Do analyze for them in order to generate optimized plan. QUERY PLAN ---------------------------------------------------------------------------------------------------------------------------------------- Row Adapter Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> Vector Limit Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> Vector Streaming (type: GATHER) Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 Merge Sort Key: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> Vector Limit Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> Vector Sort Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 Sort Key: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 Distribute Key: t_subplan1.a1, t_subplan1.b1 Filter: (SubPlan 1) SubPlan 1 -> Row Adapter Output: t_subplan2.c2 -> Vector Merge Join Output: t_subplan2.c2 Merge Cond: (t_subplan2.a2 = t_subplan3.a3) -> Vector Sort Output: t_subplan2.c2, t_subplan2.a2, t_subplan2.b2 Sort Key: t_subplan2.a2 -> Vector Result Output: t_subplan2.c2, t_subplan2.a2, t_subplan2.b2 Filter: (t_subplan2.b2 < t_subplan1.b1) -> Vector Materialize Output: t_subplan2.c2, t_subplan2.a2, t_subplan2.b2 -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) Output: t_subplan2.c2, t_subplan2.a2, t_subplan2.b2 -> CStore Scan on nodegroup_subplan_test.t_subplan2 Output: t_subplan2.c2, t_subplan2.a2, t_subplan2.b2 Distribute Key: t_subplan2.a2, t_subplan2.b2 -> Vector Sort Output: t_subplan3.a3 Sort Key: t_subplan3.a3 -> Vector Materialize Output: t_subplan3.a3 -> Vector Streaming(type: BROADCAST ng: ng3->GenGroup) Output: t_subplan3.a3 -> Vector Partition Iterator Output: t_subplan3.a3 Iterations: 2 -> Partitioned CStore Scan on nodegroup_subplan_test.t_subplan3 Output: t_subplan3.a3 Selected Partitions: 1..2 (48 rows) set enable_mergejoin=off; set enable_hashjoin = on; explain (costs off, verbose on) select * from t_subplan1 where c1 > any(select c2 from t_subplan2 join t_subplan3 on a3 = a2 where b2 < b1) order by 1,2,3,4 limit 10; WARNING: Statistics in some tables or columns(nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2, nodegroup_subplan_test.t_subplan3.a3, nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1) are not collected. HINT: Do analyze for them in order to generate optimized plan. QUERY PLAN ---------------------------------------------------------------------------------------------------------------------------------- Row Adapter Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> Vector Limit Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> Vector Streaming (type: GATHER) Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 Merge Sort Key: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> Vector Limit Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> Vector Sort Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 Sort Key: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: t_subplan1.a1, t_subplan1.b1, t_subplan1.c1, t_subplan1.d1 Distribute Key: t_subplan1.a1, t_subplan1.b1 Filter: (SubPlan 1) SubPlan 1 -> Row Adapter Output: t_subplan2.c2 -> Vector Sonic Hash Join Output: t_subplan2.c2 Hash Cond: (t_subplan3.a3 = t_subplan2.a2) -> Vector Materialize Output: t_subplan3.a3 -> Vector Streaming(type: BROADCAST ng: ng3->GenGroup) Output: t_subplan3.a3 -> Vector Partition Iterator Output: t_subplan3.a3 Iterations: 2 -> Partitioned CStore Scan on nodegroup_subplan_test.t_subplan3 Output: t_subplan3.a3 Selected Partitions: 1..2 -> Vector Result Output: t_subplan2.c2, t_subplan2.a2, t_subplan2.b2 Filter: (t_subplan2.b2 < t_subplan1.b1) -> Vector Materialize Output: t_subplan2.c2, t_subplan2.a2, t_subplan2.b2 -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) Output: t_subplan2.c2, t_subplan2.a2, t_subplan2.b2 -> CStore Scan on nodegroup_subplan_test.t_subplan2 Output: t_subplan2.c2, t_subplan2.a2, t_subplan2.b2 Distribute Key: t_subplan2.a2, t_subplan2.b2 (42 rows) ---add llt case CREATE TABLE t_subplan08 ( col_num numeric(5, 0) ,col_int int ,col_timestamptz timestamptz ,col_varchar varchar ,col_char char(2) ,col_interval interval ,col_timetz timetz ,col_tinterval tinterval ) with(orientation=column) to group ng0; COPY t_subplan08(col_num, col_int, col_timestamptz, col_varchar, col_char, col_interval, col_timetz, col_tinterval) FROM stdin; CREATE TABLE t_subplan09 ( col_num numeric(5, 0) ,col_int int ,col_timestamptz timestamptz ,col_varchar varchar ,col_char char(2) ,col_interval interval ,col_timetz timetz ,col_tinterval tinterval ) with(orientation=column) to group ng2; insert into t_subplan09 select * from t_subplan08; insert into t_subplan09 values (NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL); CREATE TABLE t_subplan10 ( col_num numeric(5, 0) ,col_int int ,col_timestamptz timestamptz ,col_varchar varchar ,col_char char(2) ,col_interval interval ,col_timetz timetz ,col_tinterval tinterval ) with(orientation=column) to group ng3; insert into t_subplan08 values (1,4,'2014-01-09 19:35:37','2014-11-09 19:35:37','j','8 day 13:34:56','1988-2-6 01:00:30+8', NULL); explain (costs off, verbose on) select count(*) from t_subplan08 group by col_interval having(min(col_interval) = any(select col_interval from t_subplan09)); WARNING: Statistics in some tables or columns(nodegroup_subplan_test.t_subplan09.col_num, nodegroup_subplan_test.t_subplan08.col_num, nodegroup_subplan_test.t_subplan08.col_interval) are not collected. HINT: Do analyze for them in order to generate optimized plan. QUERY PLAN ----------------------------------------------------------------------------------------- Row Adapter Output: (count(*)), t_subplan08.col_interval -> Vector Streaming (type: GATHER) Output: (count(*)), t_subplan08.col_interval -> Vector Hash Aggregate Output: count(*), t_subplan08.col_interval Group By Key: t_subplan08.col_interval Filter: (hashed SubPlan 1) -> Vector Streaming(type: REDISTRIBUTE ng: ng0->group1) Output: t_subplan08.col_interval Distribute Key: t_subplan08.col_interval -> CStore Scan on nodegroup_subplan_test.t_subplan08 Output: t_subplan08.col_interval Distribute Key: t_subplan08.col_num SubPlan 1 -> Row Adapter Output: t_subplan09.col_interval -> Vector Materialize Output: t_subplan09.col_interval -> Vector Streaming(type: BROADCAST ng: ng2->GenGroup) Output: t_subplan09.col_interval -> CStore Scan on nodegroup_subplan_test.t_subplan09 Output: t_subplan09.col_interval Distribute Key: t_subplan09.col_num (24 rows) explain (costs off, verbose on) select count(*) from t_subplan08 group by col_interval having(min(col_interval) = any(select col_interval from t_subplan10)); WARNING: Statistics in some tables or columns(nodegroup_subplan_test.t_subplan10.col_num, nodegroup_subplan_test.t_subplan08.col_num, nodegroup_subplan_test.t_subplan08.col_interval) are not collected. HINT: Do analyze for them in order to generate optimized plan. QUERY PLAN ----------------------------------------------------------------------------------------- Row Adapter Output: (count(*)), t_subplan08.col_interval -> Vector Streaming (type: GATHER) Output: (count(*)), t_subplan08.col_interval -> Vector Hash Aggregate Output: count(*), t_subplan08.col_interval Group By Key: t_subplan08.col_interval Filter: (hashed SubPlan 1) -> Vector Streaming(type: REDISTRIBUTE ng: ng0->group1) Output: t_subplan08.col_interval Distribute Key: t_subplan08.col_interval -> CStore Scan on nodegroup_subplan_test.t_subplan08 Output: t_subplan08.col_interval Distribute Key: t_subplan08.col_num SubPlan 1 -> Row Adapter Output: t_subplan10.col_interval -> Vector Materialize Output: t_subplan10.col_interval -> Vector Streaming(type: BROADCAST ng: ng3->GenGroup) Output: t_subplan10.col_interval -> CStore Scan on nodegroup_subplan_test.t_subplan10 Output: t_subplan10.col_interval Distribute Key: t_subplan10.col_num (24 rows) explain (costs off, verbose on) select count(*) from t_subplan08 group by col_timetz having(min(col_timetz) = any(select col_timetz from t_subplan09)) order by 1; WARNING: Statistics in some tables or columns(nodegroup_subplan_test.t_subplan09.col_num, nodegroup_subplan_test.t_subplan08.col_num, nodegroup_subplan_test.t_subplan08.col_timetz) are not collected. HINT: Do analyze for them in order to generate optimized plan. QUERY PLAN ----------------------------------------------------------------------------------------------- Row Adapter Output: (count(*)), t_subplan08.col_timetz -> Vector Streaming (type: GATHER) Output: (count(*)), t_subplan08.col_timetz Merge Sort Key: (count(*)) -> Vector Sort Output: (count(*)), t_subplan08.col_timetz Sort Key: (count(*)) -> Vector Hash Aggregate Output: count(*), t_subplan08.col_timetz Group By Key: t_subplan08.col_timetz Filter: (hashed SubPlan 1) -> Vector Streaming(type: REDISTRIBUTE ng: ng0->group1) Output: t_subplan08.col_timetz Distribute Key: t_subplan08.col_timetz -> CStore Scan on nodegroup_subplan_test.t_subplan08 Output: t_subplan08.col_timetz Distribute Key: t_subplan08.col_num SubPlan 1 -> Row Adapter Output: t_subplan09.col_timetz -> Vector Materialize Output: t_subplan09.col_timetz -> Vector Streaming(type: BROADCAST ng: ng2->GenGroup) Output: t_subplan09.col_timetz -> CStore Scan on nodegroup_subplan_test.t_subplan09 Output: t_subplan09.col_timetz Distribute Key: t_subplan09.col_num (28 rows) explain (costs off, verbose on) select count(*) from t_subplan08 group by col_char having(min(col_char) = any(select col_char from t_subplan09)) order by 1; WARNING: Statistics in some tables or columns(nodegroup_subplan_test.t_subplan09.col_num, nodegroup_subplan_test.t_subplan08.col_num, nodegroup_subplan_test.t_subplan08.col_char) are not collected. HINT: Do analyze for them in order to generate optimized plan. QUERY PLAN ----------------------------------------------------------------------------------------------- Row Adapter Output: (count(*)), t_subplan08.col_char -> Vector Streaming (type: GATHER) Output: (count(*)), t_subplan08.col_char Merge Sort Key: (count(*)) -> Vector Sort Output: (count(*)), t_subplan08.col_char Sort Key: (count(*)) -> Vector Hash Aggregate Output: count(*), t_subplan08.col_char Group By Key: t_subplan08.col_char Filter: (hashed SubPlan 1) -> Vector Streaming(type: REDISTRIBUTE ng: ng0->group1) Output: t_subplan08.col_char Distribute Key: t_subplan08.col_char -> CStore Scan on nodegroup_subplan_test.t_subplan08 Output: t_subplan08.col_char Distribute Key: t_subplan08.col_num SubPlan 1 -> Row Adapter Output: t_subplan09.col_char -> Vector Materialize Output: t_subplan09.col_char -> Vector Streaming(type: BROADCAST ng: ng2->GenGroup) Output: t_subplan09.col_char -> CStore Scan on nodegroup_subplan_test.t_subplan09 Output: t_subplan09.col_char Distribute Key: t_subplan09.col_num (28 rows) explain (costs off, verbose on) select b1, count(*) from t_subplan1 where c1 = all (select b2 from t_subplan2 where b2 != c1) group by b1 order by 1, 2 limit 5; WARNING: Statistics in some tables or columns(nodegroup_subplan_test.t_subplan2.a2, nodegroup_subplan_test.t_subplan2.b2, nodegroup_subplan_test.t_subplan1.a1, nodegroup_subplan_test.t_subplan1.b1) are not collected. HINT: Do analyze for them in order to generate optimized plan. QUERY PLAN ---------------------------------------------------------------------------------------------------------------------------- Row Adapter Output: t_subplan1.b1, (count(*)) -> Vector Limit Output: t_subplan1.b1, (count(*)) -> Vector Streaming (type: GATHER) Output: t_subplan1.b1, (count(*)) Merge Sort Key: t_subplan1.b1, (count(*)) -> Vector Limit Output: t_subplan1.b1, (count(*)) -> Vector Sort Output: t_subplan1.b1, (count(*)) Sort Key: t_subplan1.b1, (count(*)) -> Vector Sonic Hash Aggregate Output: t_subplan1.b1, count(*) Group By Key: t_subplan1.b1 -> Vector Streaming(type: REDISTRIBUTE ng: ng0->group1) Output: t_subplan1.b1, t_subplan1.c1 Distribute Key: t_subplan1.b1 -> CStore Scan on nodegroup_subplan_test.t_subplan1 Output: t_subplan1.b1, t_subplan1.c1 Distribute Key: t_subplan1.a1, t_subplan1.b1 Filter: (SubPlan 1) SubPlan 1 -> Row Adapter Output: t_subplan2.b2 -> Vector Result Output: t_subplan2.b2 Filter: (t_subplan2.b2 <> t_subplan1.c1) -> Vector Materialize Output: t_subplan2.b2 -> Vector Streaming(type: BROADCAST ng: ng1->GenGroup) Output: t_subplan2.b2 -> CStore Scan on nodegroup_subplan_test.t_subplan2 Output: t_subplan2.b2 Distribute Key: t_subplan2.a2, t_subplan2.b2 (35 rows) reset current_schema; drop schema nodegroup_subplan_test cascade; NOTICE: drop cascades to 21 other objects DETAIL: drop cascades to table nodegroup_subplan_test.temp drop cascades to table nodegroup_subplan_test.t_subplan1 drop cascades to table nodegroup_subplan_test.t_subplan2 drop cascades to table nodegroup_subplan_test.t_subplan5 drop cascades to table nodegroup_subplan_test.t_subplan6 drop cascades to table nodegroup_subplan_test.t_subplan7 drop cascades to table nodegroup_subplan_test.int4_tbl drop cascades to table nodegroup_subplan_test.tenk1 drop cascades to table nodegroup_subplan_test.subselect_tbl drop cascades to table nodegroup_subplan_test.subselect_foo drop cascades to table nodegroup_subplan_test.subselect_bar drop cascades to table nodegroup_subplan_test.ta drop cascades to table nodegroup_subplan_test.tb drop cascades to table nodegroup_subplan_test.tc drop cascades to table nodegroup_subplan_test.subselect_t1 drop cascades to table nodegroup_subplan_test.outer_7597 drop cascades to table nodegroup_subplan_test.inner_7597 drop cascades to table nodegroup_subplan_test.t_subplan3 drop cascades to table nodegroup_subplan_test.t_subplan08 drop cascades to table nodegroup_subplan_test.t_subplan09 drop cascades to table nodegroup_subplan_test.t_subplan10 drop node group ng0; drop node group ng1; drop node group ng2; drop node group ng3; reset query_dop;