external
/
citus
mirror of https://github.com/citusdata/citus.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add explain_filter calls to window function tests for better query plan visibility

pull/8344/head
Mehmet Yilmaz 2025-11-17 11:15:49 +00:00
parent 643282df8c
commit a5c68ed720
12 changed files with 236 additions and 164 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/test/regress/expected/mixed_relkind_tests.out
View File

@ -633,11 +633,13 @@ $Q$);
(4 rows) (4 rows)
-- pull to coordinator WINDOW -- pull to coordinator WINDOW
select public.explain_filter('
SELECT public.coordinator_plan($Q$ SELECT public.coordinator_plan($Q$
EXPLAIN (COSTS OFF) EXPLAIN (COSTS OFF)
SELECT a, COUNT(*) OVER (PARTITION BY a+1) FROM partitioned_distributed_table ORDER BY 1,2; SELECT a, COUNT(*) OVER (PARTITION BY a+1) FROM partitioned_distributed_table ORDER BY 1,2;
$Q$); $Q$)
coordinator_plan ');
explain_filter
--------------------------------------------------------------------- ---------------------------------------------------------------------
Sort Sort
Sort Key: remote_scan.a, (count(*) OVER (?)) Sort Key: remote_scan.a, (count(*) OVER (?))
@ -645,7 +647,7 @@ $Q$);
-> Sort -> Sort
Sort Key: remote_scan.worker_column_2 Sort Key: remote_scan.worker_column_2
-> Custom Scan (Citus Adaptive) -> Custom Scan (Citus Adaptive)
Task Count: 4 Task Count: N
(7 rows) (7 rows)
-- FOR UPDATE -- FOR UPDATE

60
src/test/regress/expected/multi_explain.out
View File

@ -3118,46 +3118,50 @@ CREATE TABLE distributed_table_1(a int, b int);
SELECT create_distributed_table('distributed_table_1','a'); SELECT create_distributed_table('distributed_table_1','a');
INSERT INTO distributed_table_1 values (1,1); INSERT INTO distributed_table_1 values (1,1);
EXPLAIN :default_analyze_flags SELECT row_number() OVER() AS r FROM distributed_table_1; select public.explain_filter('
WindowAgg (actual rows=1 loops=1) EXPLAIN (ANALYZE on, COSTS off, TIMING off, SUMMARY off, BUFFERS off) SELECT row_number() OVER() AS r FROM distributed_table_1
-> Custom Scan (Citus Adaptive) (actual rows=1 loops=1) ');
Task Count: 2 WindowAgg (actual rows=N loops=N)
Tasks Shown: One of 2 -> Custom Scan (Citus Adaptive) (actual rows=N loops=N)
Task Count: N
Tasks Shown: One of N
-> Task -> Task
Node: host=localhost port=xxxxx dbname=regression Node: host=localhost port=N dbname=regression
-> Seq Scan on distributed_table_1_570032 distributed_table_1 (actual rows=1 loops=1) -> Seq Scan on distributed_table_1_570032 distributed_table_1 (actual rows=N loops=N)
CREATE TABLE distributed_table_2(a int, b int); CREATE TABLE distributed_table_2(a int, b int);
SELECT create_distributed_table('distributed_table_2','a'); SELECT create_distributed_table('distributed_table_2','a');
INSERT INTO distributed_table_2 VALUES (1,1); INSERT INTO distributed_table_2 VALUES (1,1);
EXPLAIN :default_analyze_flags select public.explain_filter('
EXPLAIN (ANALYZE on, COSTS off, TIMING off, SUMMARY off, BUFFERS off)
WITH r AS (SELECT row_number() OVER () AS r FROM distributed_table_1) WITH r AS (SELECT row_number() OVER () AS r FROM distributed_table_1)
SELECT * FROM distributed_table_2 SELECT * FROM distributed_table_2
JOIN r ON (r = distributed_table_2.b) JOIN r ON (r = distributed_table_2.b)
LIMIT 3; LIMIT 3
Limit (actual rows=1 loops=1) ');
-> Custom Scan (Citus Adaptive) (actual rows=1 loops=1) Limit (actual rows=N loops=N)
-> Custom Scan (Citus Adaptive) (actual rows=N loops=N)
-> Distributed Subplan XXX_1 -> Distributed Subplan XXX_1
Intermediate Data Size: 14 bytes Intermediate Data Size: N bytes
Result destination: Send to 2 nodes Result destination: Send to N nodes
-> WindowAgg (actual rows=1 loops=1) -> WindowAgg (actual rows=N loops=N)
-> Custom Scan (Citus Adaptive) (actual rows=1 loops=1) -> Custom Scan (Citus Adaptive) (actual rows=N loops=N)
Task Count: 2 Task Count: N
Tasks Shown: One of 2 Tasks Shown: One of N
-> Task -> Task
Node: host=localhost port=xxxxx dbname=regression Node: host=localhost port=N dbname=regression
-> Seq Scan on distributed_table_1_570032 distributed_table_1 (actual rows=1 loops=1) -> Seq Scan on distributed_table_1_570032 distributed_table_1 (actual rows=N loops=N)
Task Count: 2 Task Count: N
Tuple data received from nodes: 16 bytes Tuple data received from nodes: N bytes
Tasks Shown: One of 2 Tasks Shown: One of N
-> Task -> Task
Tuple data received from node: 16 bytes Tuple data received from node: N bytes
Node: host=localhost port=xxxxx dbname=regression Node: host=localhost port=N dbname=regression
-> Limit (actual rows=1 loops=1) -> Limit (actual rows=N loops=N)
-> Nested Loop (actual rows=1 loops=1) -> Nested Loop (actual rows=N loops=N)
Join Filter: (distributed_table_2.b = intermediate_result.r) Join Filter: (distributed_table_2.b = intermediate_result.r)
-> Function Scan on read_intermediate_result intermediate_result (actual rows=1 loops=1) -> Function Scan on read_intermediate_result intermediate_result (actual rows=N loops=N)
-> Seq Scan on distributed_table_2_570034 distributed_table_2 (actual rows=1 loops=1) -> Seq Scan on distributed_table_2_570034 distributed_table_2 (actual rows=N loops=N)
EXPLAIN :default_analyze_flags SELECT FROM (SELECT * FROM reference_table) subquery; EXPLAIN :default_analyze_flags SELECT FROM (SELECT * FROM reference_table) subquery;
Custom Scan (Citus Adaptive) (actual rows=1 loops=1) Custom Scan (Citus Adaptive) (actual rows=1 loops=1)
Task Count: 1 Task Count: 1

60
src/test/regress/expected/multi_explain_0.out
View File

@ -3107,46 +3107,50 @@ CREATE TABLE distributed_table_1(a int, b int);
SELECT create_distributed_table('distributed_table_1','a'); SELECT create_distributed_table('distributed_table_1','a');
INSERT INTO distributed_table_1 values (1,1); INSERT INTO distributed_table_1 values (1,1);
EXPLAIN :default_analyze_flags SELECT row_number() OVER() AS r FROM distributed_table_1; select public.explain_filter('
WindowAgg (actual rows=1 loops=1) EXPLAIN (ANALYZE on, COSTS off, TIMING off, SUMMARY off, BUFFERS off) SELECT row_number() OVER() AS r FROM distributed_table_1
-> Custom Scan (Citus Adaptive) (actual rows=1 loops=1) ');
Task Count: 2 WindowAgg (actual rows=N loops=N)
Tasks Shown: One of 2 -> Custom Scan (Citus Adaptive) (actual rows=N loops=N)
Task Count: N
Tasks Shown: One of N
-> Task -> Task
Node: host=localhost port=xxxxx dbname=regression Node: host=localhost port=N dbname=regression
-> Seq Scan on distributed_table_1_570032 distributed_table_1 (actual rows=1 loops=1) -> Seq Scan on distributed_table_1_570032 distributed_table_1 (actual rows=N loops=N)
CREATE TABLE distributed_table_2(a int, b int); CREATE TABLE distributed_table_2(a int, b int);
SELECT create_distributed_table('distributed_table_2','a'); SELECT create_distributed_table('distributed_table_2','a');
INSERT INTO distributed_table_2 VALUES (1,1); INSERT INTO distributed_table_2 VALUES (1,1);
EXPLAIN :default_analyze_flags select public.explain_filter('
EXPLAIN (ANALYZE on, COSTS off, TIMING off, SUMMARY off, BUFFERS off)
WITH r AS (SELECT row_number() OVER () AS r FROM distributed_table_1) WITH r AS (SELECT row_number() OVER () AS r FROM distributed_table_1)
SELECT * FROM distributed_table_2 SELECT * FROM distributed_table_2
JOIN r ON (r = distributed_table_2.b) JOIN r ON (r = distributed_table_2.b)
LIMIT 3; LIMIT 3
Limit (actual rows=1 loops=1) ');
-> Custom Scan (Citus Adaptive) (actual rows=1 loops=1) Limit (actual rows=N loops=N)
-> Custom Scan (Citus Adaptive) (actual rows=N loops=N)
-> Distributed Subplan XXX_1 -> Distributed Subplan XXX_1
Intermediate Data Size: 14 bytes Intermediate Data Size: N bytes
Result destination: Send to 2 nodes Result destination: Send to N nodes
-> WindowAgg (actual rows=1 loops=1) -> WindowAgg (actual rows=N loops=N)
-> Custom Scan (Citus Adaptive) (actual rows=1 loops=1) -> Custom Scan (Citus Adaptive) (actual rows=N loops=N)
Task Count: 2 Task Count: N
Tasks Shown: One of 2 Tasks Shown: One of N
-> Task -> Task
Node: host=localhost port=xxxxx dbname=regression Node: host=localhost port=N dbname=regression
-> Seq Scan on distributed_table_1_570032 distributed_table_1 (actual rows=1 loops=1) -> Seq Scan on distributed_table_1_570032 distributed_table_1 (actual rows=N loops=N)
Task Count: 2 Task Count: N
Tuple data received from nodes: 16 bytes Tuple data received from nodes: N bytes
Tasks Shown: One of 2 Tasks Shown: One of N
-> Task -> Task
Tuple data received from node: 16 bytes Tuple data received from node: N bytes
Node: host=localhost port=xxxxx dbname=regression Node: host=localhost port=N dbname=regression
-> Limit (actual rows=1 loops=1) -> Limit (actual rows=N loops=N)
-> Nested Loop (actual rows=1 loops=1) -> Nested Loop (actual rows=N loops=N)
Join Filter: (distributed_table_2.b = intermediate_result.r) Join Filter: (distributed_table_2.b = intermediate_result.r)
-> Function Scan on read_intermediate_result intermediate_result (actual rows=1 loops=1) -> Function Scan on read_intermediate_result intermediate_result (actual rows=N loops=N)
-> Seq Scan on distributed_table_2_570034 distributed_table_2 (actual rows=1 loops=1) -> Seq Scan on distributed_table_2_570034 distributed_table_2 (actual rows=N loops=N)
EXPLAIN :default_analyze_flags SELECT FROM (SELECT * FROM reference_table) subquery; EXPLAIN :default_analyze_flags SELECT FROM (SELECT * FROM reference_table) subquery;
Custom Scan (Citus Adaptive) (actual rows=1 loops=1) Custom Scan (Citus Adaptive) (actual rows=1 loops=1)
Task Count: 1 Task Count: 1

52
src/test/regress/expected/multi_outer_join_columns.out
View File

@ -55,10 +55,12 @@ FROM t1 LEFT OUTER JOIN t2 ON t1.id = t2.account_id;
1 | 1 |
(3 rows) (3 rows)
select public.explain_filter('
EXPLAIN (VERBOSE, COSTS OFF, TIMING OFF) EXPLAIN (VERBOSE, COSTS OFF, TIMING OFF)
SELECT t1.id, MAX(t2.a2) OVER (PARTITION BY t2.id) SELECT t1.id, MAX(t2.a2) OVER (PARTITION BY t2.id)
FROM t1 LEFT OUTER JOIN t2 ON t1.id = t2.account_id; FROM t1 LEFT OUTER JOIN t2 ON t1.id = t2.account_id
QUERY PLAN ');
explain_filter
--------------------------------------------------------------------- ---------------------------------------------------------------------
WindowAgg WindowAgg
Output: remote_scan.id, max(remote_scan.max) OVER (?), remote_scan.worker_column_3 Output: remote_scan.id, max(remote_scan.max) OVER (?), remote_scan.worker_column_3
@ -67,11 +69,11 @@ FROM t1 LEFT OUTER JOIN t2 ON t1.id = t2.account_id;
Sort Key: remote_scan.worker_column_3 Sort Key: remote_scan.worker_column_3
-> Custom Scan (Citus Adaptive) -> Custom Scan (Citus Adaptive)
Output: remote_scan.worker_column_3, remote_scan.id, remote_scan.max Output: remote_scan.worker_column_3, remote_scan.id, remote_scan.max
Task Count: 4 Task Count: N
Tasks Shown: One of 4 Tasks Shown: One of N
-> Task -> Task
Query: SELECT worker_column_1 AS id, worker_column_2 AS max, worker_column_3 FROM (SELECT t1.id AS worker_column_1, t2.a2 AS worker_column_2, t2.id AS worker_column_3 FROM (outer_join_columns_testing.t1_30070000 t1 LEFT JOIN outer_join_columns_testing.t2_30070004 t2 ON ((t1.id OPERATOR(pg_catalog.=) t2.account_id)))) worker_subquery Query: SELECT worker_column_1 AS id, worker_column_2 AS max, worker_column_3 FROM (SELECT t1.id AS worker_column_1, t2.a2 AS worker_column_2, t2.id AS worker_column_3 FROM (outer_join_columns_testing.t1_30070000 t1 LEFT JOIN outer_join_columns_testing.t2_30070004 t2 ON ((t1.id OPERATOR(pg_catalog.=) t2.account_id)))) worker_subquery
Node: host=localhost port=xxxxx dbname=regression Node: host=localhost port=N dbname=regression
-> Hash Right Join -> Hash Right Join
Output: t1.id, t2.a2, t2.id Output: t1.id, t2.a2, t2.id
Inner Unique: true Inner Unique: true
@ -93,10 +95,12 @@ FROM t2 RIGHT OUTER JOIN t1 ON t1.id = t2.account_id;
1 | 1 |
(3 rows) (3 rows)
select public.explain_filter('
EXPLAIN (VERBOSE, COSTS OFF, TIMING OFF) EXPLAIN (VERBOSE, COSTS OFF, TIMING OFF)
SELECT t1.id, MAX(t2.a2) OVER (PARTITION BY t2.id) SELECT t1.id, MAX(t2.a2) OVER (PARTITION BY t2.id)
FROM t2 RIGHT OUTER JOIN t1 ON t1.id = t2.account_id; FROM t2 RIGHT OUTER JOIN t1 ON t1.id = t2.account_id
QUERY PLAN ');
explain_filter
--------------------------------------------------------------------- ---------------------------------------------------------------------
WindowAgg WindowAgg
Output: remote_scan.id, max(remote_scan.max) OVER (?), remote_scan.worker_column_3 Output: remote_scan.id, max(remote_scan.max) OVER (?), remote_scan.worker_column_3
@ -105,11 +109,11 @@ FROM t2 RIGHT OUTER JOIN t1 ON t1.id = t2.account_id;
Sort Key: remote_scan.worker_column_3 Sort Key: remote_scan.worker_column_3
-> Custom Scan (Citus Adaptive) -> Custom Scan (Citus Adaptive)
Output: remote_scan.worker_column_3, remote_scan.id, remote_scan.max Output: remote_scan.worker_column_3, remote_scan.id, remote_scan.max
Task Count: 4 Task Count: N
Tasks Shown: One of 4 Tasks Shown: One of N
-> Task -> Task
Query: SELECT worker_column_1 AS id, worker_column_2 AS max, worker_column_3 FROM (SELECT t1.id AS worker_column_1, t2.a2 AS worker_column_2, t2.id AS worker_column_3 FROM (outer_join_columns_testing.t2_30070004 t2 RIGHT JOIN outer_join_columns_testing.t1_30070000 t1 ON ((t1.id OPERATOR(pg_catalog.=) t2.account_id)))) worker_subquery Query: SELECT worker_column_1 AS id, worker_column_2 AS max, worker_column_3 FROM (SELECT t1.id AS worker_column_1, t2.a2 AS worker_column_2, t2.id AS worker_column_3 FROM (outer_join_columns_testing.t2_30070004 t2 RIGHT JOIN outer_join_columns_testing.t1_30070000 t1 ON ((t1.id OPERATOR(pg_catalog.=) t2.account_id)))) worker_subquery
Node: host=localhost port=xxxxx dbname=regression Node: host=localhost port=N dbname=regression
-> Hash Right Join -> Hash Right Join
Output: t1.id, t2.a2, t2.id Output: t1.id, t2.a2, t2.id
Inner Unique: true Inner Unique: true
@ -131,10 +135,12 @@ FROM t1 LEFT OUTER JOIN t2 ON t1.id = t2.account_id;
2 | 20 2 | 20
(3 rows) (3 rows)
select public.explain_filter('
EXPLAIN (VERBOSE, COSTS OFF, TIMING OFF) EXPLAIN (VERBOSE, COSTS OFF, TIMING OFF)
SELECT DISTINCT t1.id, MAX(t2.a2) OVER (PARTITION BY t2.id) SELECT DISTINCT t1.id, MAX(t2.a2) OVER (PARTITION BY t2.id)
FROM t1 LEFT OUTER JOIN t2 ON t1.id = t2.account_id; FROM t1 LEFT OUTER JOIN t2 ON t1.id = t2.account_id
QUERY PLAN ');
explain_filter
--------------------------------------------------------------------- ---------------------------------------------------------------------
HashAggregate HashAggregate
Output: remote_scan.id, (max(remote_scan.max) OVER (?)), remote_scan.worker_column_3 Output: remote_scan.id, (max(remote_scan.max) OVER (?)), remote_scan.worker_column_3
@ -146,11 +152,11 @@ FROM t1 LEFT OUTER JOIN t2 ON t1.id = t2.account_id;
Sort Key: remote_scan.worker_column_3 Sort Key: remote_scan.worker_column_3
-> Custom Scan (Citus Adaptive) -> Custom Scan (Citus Adaptive)
Output: remote_scan.worker_column_3, remote_scan.id, remote_scan.max Output: remote_scan.worker_column_3, remote_scan.id, remote_scan.max
Task Count: 4 Task Count: N
Tasks Shown: One of 4 Tasks Shown: One of N
-> Task -> Task
Query: SELECT worker_column_1 AS id, worker_column_2 AS max, worker_column_3 FROM (SELECT t1.id AS worker_column_1, t2.a2 AS worker_column_2, t2.id AS worker_column_3 FROM (outer_join_columns_testing.t1_30070000 t1 LEFT JOIN outer_join_columns_testing.t2_30070004 t2 ON ((t1.id OPERATOR(pg_catalog.=) t2.account_id)))) worker_subquery Query: SELECT worker_column_1 AS id, worker_column_2 AS max, worker_column_3 FROM (SELECT t1.id AS worker_column_1, t2.a2 AS worker_column_2, t2.id AS worker_column_3 FROM (outer_join_columns_testing.t1_30070000 t1 LEFT JOIN outer_join_columns_testing.t2_30070004 t2 ON ((t1.id OPERATOR(pg_catalog.=) t2.account_id)))) worker_subquery
Node: host=localhost port=xxxxx dbname=regression Node: host=localhost port=N dbname=regression
-> Hash Right Join -> Hash Right Join
Output: t1.id, t2.a2, t2.id Output: t1.id, t2.a2, t2.id
Inner Unique: true Inner Unique: true
@ -302,27 +308,29 @@ HAVING COUNT(DISTINCT a2) > 1;
1 1
(1 row) (1 row)
select public.explain_filter('
EXPLAIN (VERBOSE, COSTS OFF, TIMING OFF) EXPLAIN (VERBOSE, COSTS OFF, TIMING OFF)
SELECT 1 SELECT 1
FROM t1 LEFT OUTER JOIN t2 ON t1.id = t2.account_id FROM t1 LEFT OUTER JOIN t2 ON t1.id = t2.account_id
HAVING COUNT(DISTINCT a2) > 1; HAVING COUNT(DISTINCT a2) > 1;
QUERY PLAN ');
explain_filter
--------------------------------------------------------------------- ---------------------------------------------------------------------
Aggregate Aggregate
Output: remote_scan."?column?" Output: remote_scan."?column?"
Filter: (count(DISTINCT remote_scan.worker_column_2) > 1) Filter: (count(DISTINCT remote_scan.worker_column_2) > N)
-> Sort -> Sort
Output: remote_scan."?column?", remote_scan.worker_column_2 Output: remote_scan."?column?", remote_scan.worker_column_2
Sort Key: remote_scan.worker_column_2 Sort Key: remote_scan.worker_column_2
-> Custom Scan (Citus Adaptive) -> Custom Scan (Citus Adaptive)
Output: remote_scan."?column?", remote_scan.worker_column_2 Output: remote_scan."?column?", remote_scan.worker_column_2
Task Count: 4 Task Count: N
Tasks Shown: One of 4 Tasks Shown: One of N
-> Task -> Task
Query: SELECT 1, worker_column_1 AS worker_column_2 FROM (SELECT t2.a2 AS worker_column_1 FROM (outer_join_columns_testing.t1_30070000 t1 LEFT JOIN outer_join_columns_testing.t2_30070004 t2 ON ((t1.id OPERATOR(pg_catalog.=) t2.account_id)))) worker_subquery GROUP BY worker_column_1 Query: SELECT N, worker_column_1 AS worker_column_2 FROM (SELECT t2.a2 AS worker_column_1 FROM (outer_join_columns_testing.t1_30070000 t1 LEFT JOIN outer_join_columns_testing.t2_30070004 t2 ON ((t1.id OPERATOR(pg_catalog.=) t2.account_id)))) worker_subquery GROUP BY worker_column_1
Node: host=localhost port=xxxxx dbname=regression Node: host=localhost port=N dbname=regression
-> HashAggregate -> HashAggregate
Output: 1, t2.a2 Output: N, t2.a2
Group Key: t2.a2 Group Key: t2.a2
-> Hash Right Join -> Hash Right Join
Output: t2.a2 Output: t2.a2

52
src/test/regress/expected/multi_outer_join_columns_1.out
View File

@ -55,10 +55,12 @@ FROM t1 LEFT OUTER JOIN t2 ON t1.id = t2.account_id;
1 | 1 |
(3 rows) (3 rows)
select public.explain_filter('
EXPLAIN (VERBOSE, COSTS OFF, TIMING OFF) EXPLAIN (VERBOSE, COSTS OFF, TIMING OFF)
SELECT t1.id, MAX(t2.a2) OVER (PARTITION BY t2.id) SELECT t1.id, MAX(t2.a2) OVER (PARTITION BY t2.id)
FROM t1 LEFT OUTER JOIN t2 ON t1.id = t2.account_id; FROM t1 LEFT OUTER JOIN t2 ON t1.id = t2.account_id
QUERY PLAN ');
explain_filter
--------------------------------------------------------------------- ---------------------------------------------------------------------
WindowAgg WindowAgg
Output: remote_scan.id, max(remote_scan.max) OVER (?), remote_scan.worker_column_3 Output: remote_scan.id, max(remote_scan.max) OVER (?), remote_scan.worker_column_3
@ -67,11 +69,11 @@ FROM t1 LEFT OUTER JOIN t2 ON t1.id = t2.account_id;
Sort Key: remote_scan.worker_column_3 Sort Key: remote_scan.worker_column_3
-> Custom Scan (Citus Adaptive) -> Custom Scan (Citus Adaptive)
Output: remote_scan.worker_column_3, remote_scan.id, remote_scan.max Output: remote_scan.worker_column_3, remote_scan.id, remote_scan.max
Task Count: 4 Task Count: N
Tasks Shown: One of 4 Tasks Shown: One of N
-> Task -> Task
Query: SELECT worker_column_1 AS id, worker_column_2 AS max, worker_column_3 FROM (SELECT t1.id AS worker_column_1, t2.a2 AS worker_column_2, t2.id AS worker_column_3 FROM (outer_join_columns_testing.t1_30070000 t1 LEFT JOIN outer_join_columns_testing.t2_30070004 t2 ON ((t1.id OPERATOR(pg_catalog.=) t2.account_id)))) worker_subquery Query: SELECT worker_column_1 AS id, worker_column_2 AS max, worker_column_3 FROM (SELECT t1.id AS worker_column_1, t2.a2 AS worker_column_2, t2.id AS worker_column_3 FROM (outer_join_columns_testing.t1_30070000 t1 LEFT JOIN outer_join_columns_testing.t2_30070004 t2 ON ((t1.id OPERATOR(pg_catalog.=) t2.account_id)))) worker_subquery
Node: host=localhost port=xxxxx dbname=regression Node: host=localhost port=N dbname=regression
-> Hash Right Join -> Hash Right Join
Output: t1.id, t2.a2, t2.id Output: t1.id, t2.a2, t2.id
Inner Unique: true Inner Unique: true
@ -93,10 +95,12 @@ FROM t2 RIGHT OUTER JOIN t1 ON t1.id = t2.account_id;
1 | 1 |
(3 rows) (3 rows)
select public.explain_filter('
EXPLAIN (VERBOSE, COSTS OFF, TIMING OFF) EXPLAIN (VERBOSE, COSTS OFF, TIMING OFF)
SELECT t1.id, MAX(t2.a2) OVER (PARTITION BY t2.id) SELECT t1.id, MAX(t2.a2) OVER (PARTITION BY t2.id)
FROM t2 RIGHT OUTER JOIN t1 ON t1.id = t2.account_id; FROM t2 RIGHT OUTER JOIN t1 ON t1.id = t2.account_id
QUERY PLAN ');
explain_filter
--------------------------------------------------------------------- ---------------------------------------------------------------------
WindowAgg WindowAgg
Output: remote_scan.id, max(remote_scan.max) OVER (?), remote_scan.worker_column_3 Output: remote_scan.id, max(remote_scan.max) OVER (?), remote_scan.worker_column_3
@ -105,11 +109,11 @@ FROM t2 RIGHT OUTER JOIN t1 ON t1.id = t2.account_id;
Sort Key: remote_scan.worker_column_3 Sort Key: remote_scan.worker_column_3
-> Custom Scan (Citus Adaptive) -> Custom Scan (Citus Adaptive)
Output: remote_scan.worker_column_3, remote_scan.id, remote_scan.max Output: remote_scan.worker_column_3, remote_scan.id, remote_scan.max
Task Count: 4 Task Count: N
Tasks Shown: One of 4 Tasks Shown: One of N
-> Task -> Task
Query: SELECT worker_column_1 AS id, worker_column_2 AS max, worker_column_3 FROM (SELECT t1.id AS worker_column_1, t2.a2 AS worker_column_2, t2.id AS worker_column_3 FROM (outer_join_columns_testing.t2_30070004 t2 RIGHT JOIN outer_join_columns_testing.t1_30070000 t1 ON ((t1.id OPERATOR(pg_catalog.=) t2.account_id)))) worker_subquery Query: SELECT worker_column_1 AS id, worker_column_2 AS max, worker_column_3 FROM (SELECT t1.id AS worker_column_1, t2.a2 AS worker_column_2, t2.id AS worker_column_3 FROM (outer_join_columns_testing.t2_30070004 t2 RIGHT JOIN outer_join_columns_testing.t1_30070000 t1 ON ((t1.id OPERATOR(pg_catalog.=) t2.account_id)))) worker_subquery
Node: host=localhost port=xxxxx dbname=regression Node: host=localhost port=N dbname=regression
-> Hash Right Join -> Hash Right Join
Output: t1.id, t2.a2, t2.id Output: t1.id, t2.a2, t2.id
Inner Unique: true Inner Unique: true
@ -131,10 +135,12 @@ FROM t1 LEFT OUTER JOIN t2 ON t1.id = t2.account_id;
2 | 20 2 | 20
(3 rows) (3 rows)
select public.explain_filter('
EXPLAIN (VERBOSE, COSTS OFF, TIMING OFF) EXPLAIN (VERBOSE, COSTS OFF, TIMING OFF)
SELECT DISTINCT t1.id, MAX(t2.a2) OVER (PARTITION BY t2.id) SELECT DISTINCT t1.id, MAX(t2.a2) OVER (PARTITION BY t2.id)
FROM t1 LEFT OUTER JOIN t2 ON t1.id = t2.account_id; FROM t1 LEFT OUTER JOIN t2 ON t1.id = t2.account_id
QUERY PLAN ');
explain_filter
--------------------------------------------------------------------- ---------------------------------------------------------------------
HashAggregate HashAggregate
Output: remote_scan.id, (max(remote_scan.max) OVER (?)), remote_scan.worker_column_3 Output: remote_scan.id, (max(remote_scan.max) OVER (?)), remote_scan.worker_column_3
@ -146,11 +152,11 @@ FROM t1 LEFT OUTER JOIN t2 ON t1.id = t2.account_id;
Sort Key: remote_scan.worker_column_3 Sort Key: remote_scan.worker_column_3
-> Custom Scan (Citus Adaptive) -> Custom Scan (Citus Adaptive)
Output: remote_scan.worker_column_3, remote_scan.id, remote_scan.max Output: remote_scan.worker_column_3, remote_scan.id, remote_scan.max
Task Count: 4 Task Count: N
Tasks Shown: One of 4 Tasks Shown: One of N
-> Task -> Task
Query: SELECT worker_column_1 AS id, worker_column_2 AS max, worker_column_3 FROM (SELECT t1.id AS worker_column_1, t2.a2 AS worker_column_2, t2.id AS worker_column_3 FROM (outer_join_columns_testing.t1_30070000 t1 LEFT JOIN outer_join_columns_testing.t2_30070004 t2 ON ((t1.id OPERATOR(pg_catalog.=) t2.account_id)))) worker_subquery Query: SELECT worker_column_1 AS id, worker_column_2 AS max, worker_column_3 FROM (SELECT t1.id AS worker_column_1, t2.a2 AS worker_column_2, t2.id AS worker_column_3 FROM (outer_join_columns_testing.t1_30070000 t1 LEFT JOIN outer_join_columns_testing.t2_30070004 t2 ON ((t1.id OPERATOR(pg_catalog.=) t2.account_id)))) worker_subquery
Node: host=localhost port=xxxxx dbname=regression Node: host=localhost port=N dbname=regression
-> Hash Right Join -> Hash Right Join
Output: t1.id, t2.a2, t2.id Output: t1.id, t2.a2, t2.id
Inner Unique: true Inner Unique: true
@ -299,24 +305,26 @@ HAVING COUNT(DISTINCT a2) > 1;
1 1
(1 row) (1 row)
select public.explain_filter('
EXPLAIN (VERBOSE, COSTS OFF, TIMING OFF) EXPLAIN (VERBOSE, COSTS OFF, TIMING OFF)
SELECT 1 SELECT 1
FROM t1 LEFT OUTER JOIN t2 ON t1.id = t2.account_id FROM t1 LEFT OUTER JOIN t2 ON t1.id = t2.account_id
HAVING COUNT(DISTINCT a2) > 1; HAVING COUNT(DISTINCT a2) > 1;
QUERY PLAN ');
explain_filter
--------------------------------------------------------------------- ---------------------------------------------------------------------
Aggregate Aggregate
Output: remote_scan."?column?" Output: remote_scan."?column?"
Filter: (count(DISTINCT remote_scan.worker_column_2) > 1) Filter: (count(DISTINCT remote_scan.worker_column_2) > N)
-> Custom Scan (Citus Adaptive) -> Custom Scan (Citus Adaptive)
Output: remote_scan."?column?", remote_scan.worker_column_2 Output: remote_scan."?column?", remote_scan.worker_column_2
Task Count: 4 Task Count: N
Tasks Shown: One of 4 Tasks Shown: One of N
-> Task -> Task
Query: SELECT 1, worker_column_1 AS worker_column_2 FROM (SELECT t2.a2 AS worker_column_1 FROM (outer_join_columns_testing.t1_30070000 t1 LEFT JOIN outer_join_columns_testing.t2_30070004 t2 ON ((t1.id OPERATOR(pg_catalog.=) t2.account_id)))) worker_subquery GROUP BY worker_column_1 Query: SELECT N, worker_column_1 AS worker_column_2 FROM (SELECT t2.a2 AS worker_column_1 FROM (outer_join_columns_testing.t1_30070000 t1 LEFT JOIN outer_join_columns_testing.t2_30070004 t2 ON ((t1.id OPERATOR(pg_catalog.=) t2.account_id)))) worker_subquery GROUP BY worker_column_1
Node: host=localhost port=xxxxx dbname=regression Node: host=localhost port=N dbname=regression
-> HashAggregate -> HashAggregate
Output: 1, t2.a2 Output: N, t2.a2
Group Key: t2.a2 Group Key: t2.a2
-> Hash Right Join -> Hash Right Join
Output: t2.a2 Output: t2.a2

12
src/test/regress/expected/multi_subquery_window_functions.out
View File

@ -675,6 +675,7 @@ LIMIT
2 | 1 2 | 1
(5 rows) (5 rows)
select public.explain_filter('
EXPLAIN (COSTS FALSE) EXPLAIN (COSTS FALSE)
SELECT * SELECT *
FROM ( FROM (
@ -708,17 +709,18 @@ EXPLAIN (COSTS FALSE)
GROUP BY GROUP BY
user_id)) AS ftop user_id)) AS ftop
ORDER BY 2 DESC, 1 DESC ORDER BY 2 DESC, 1 DESC
LIMIT 5; LIMIT 5
QUERY PLAN ');
explain_filter
--------------------------------------------------------------------- ---------------------------------------------------------------------
Limit Limit
-> Sort -> Sort
Sort Key: remote_scan.sum DESC, remote_scan.user_id DESC Sort Key: remote_scan.sum DESC, remote_scan.user_id DESC
-> Custom Scan (Citus Adaptive) -> Custom Scan (Citus Adaptive)
Task Count: 4 Task Count: N
Tasks Shown: One of 4 Tasks Shown: One of N
-> Task -> Task
Node: host=localhost port=xxxxx dbname=regression Node: host=localhost port=N dbname=regression
-> Limit -> Limit
-> Sort -> Sort
Sort Key: (sum((sum(users_table.value_2) OVER (?)))) DESC, users_table.user_id DESC Sort Key: (sum((sum(users_table.value_2) OVER (?)))) DESC, users_table.user_id DESC

96
src/test/regress/expected/window_functions.out
View File

@ -1292,6 +1292,7 @@ ORDER BY user_id, avg(value_1) DESC;
6 | 1.00000000000000000000 | 5 6 | 1.00000000000000000000 | 5
(32 rows) (32 rows)
select public.explain_filter('
EXPLAIN (COSTS FALSE) EXPLAIN (COSTS FALSE)
SELECT SELECT
user_id, user_id,
@ -1300,19 +1301,20 @@ SELECT
FROM FROM
users_table users_table
GROUP BY user_id, value_2 GROUP BY user_id, value_2
ORDER BY user_id, avg(value_1) DESC; ORDER BY user_id, avg(value_1) DESC
QUERY PLAN ');
explain_filter
--------------------------------------------------------------------- ---------------------------------------------------------------------
Sort Sort
Sort Key: remote_scan.user_id, remote_scan.avg DESC Sort Key: remote_scan.user_id, remote_scan.avg DESC
-> Custom Scan (Citus Adaptive) -> Custom Scan (Citus Adaptive)
Task Count: 4 Task Count: N
Tasks Shown: One of 4 Tasks Shown: One of N
-> Task -> Task
Node: host=localhost port=xxxxx dbname=regression Node: host=localhost port=N dbname=regression
-> WindowAgg -> WindowAgg
-> Sort -> Sort
Sort Key: users_table.user_id, (('1'::numeric / ('1'::numeric + avg(users_table.value_1)))) Sort Key: users_table.user_id, (('N'::numeric / ('N'::numeric + avg(users_table.value_1))))
-> HashAggregate -> HashAggregate
Group Key: users_table.user_id, users_table.value_2 Group Key: users_table.user_id, users_table.value_2
-> Seq Scan on users_table_1400256 users_table -> Seq Scan on users_table_1400256 users_table
@ -1364,6 +1366,7 @@ ORDER BY user_id, avg(value_1) DESC;
(32 rows) (32 rows)
-- limit is not pushed down to worker !! -- limit is not pushed down to worker !!
select public.explain_filter('
EXPLAIN (COSTS FALSE) EXPLAIN (COSTS FALSE)
SELECT SELECT
user_id, user_id,
@ -1373,28 +1376,30 @@ FROM
users_table users_table
GROUP BY user_id, value_2 GROUP BY user_id, value_2
ORDER BY user_id, avg(value_1) DESC ORDER BY user_id, avg(value_1) DESC
LIMIT 5; LIMIT 5
QUERY PLAN ');
explain_filter
--------------------------------------------------------------------- ---------------------------------------------------------------------
Limit Limit
-> Sort -> Sort
Sort Key: remote_scan.user_id, remote_scan.avg DESC Sort Key: remote_scan.user_id, remote_scan.avg DESC
-> Custom Scan (Citus Adaptive) -> Custom Scan (Citus Adaptive)
Task Count: 4 Task Count: N
Tasks Shown: One of 4 Tasks Shown: One of N
-> Task -> Task
Node: host=localhost port=xxxxx dbname=regression Node: host=localhost port=N dbname=regression
-> Limit -> Limit
-> Sort -> Sort
Sort Key: users_table.user_id, (avg(users_table.value_1)) DESC Sort Key: users_table.user_id, (avg(users_table.value_1)) DESC
-> WindowAgg -> WindowAgg
-> Sort -> Sort
Sort Key: users_table.user_id, (('1'::numeric / ('1'::numeric + avg(users_table.value_1)))) Sort Key: users_table.user_id, (('N'::numeric / ('N'::numeric + avg(users_table.value_1))))
-> HashAggregate -> HashAggregate
Group Key: users_table.user_id, users_table.value_2 Group Key: users_table.user_id, users_table.value_2
-> Seq Scan on users_table_1400256 users_table -> Seq Scan on users_table_1400256 users_table
(17 rows) (17 rows)
select public.explain_filter('
EXPLAIN (COSTS FALSE) EXPLAIN (COSTS FALSE)
SELECT SELECT
user_id, user_id,
@ -1404,28 +1409,30 @@ FROM
users_table users_table
GROUP BY user_id, value_2 GROUP BY user_id, value_2
ORDER BY user_id, avg(value_1) DESC ORDER BY user_id, avg(value_1) DESC
LIMIT 5; LIMIT 5
QUERY PLAN ');
explain_filter
--------------------------------------------------------------------- ---------------------------------------------------------------------
Limit Limit
-> Sort -> Sort
Sort Key: remote_scan.user_id, remote_scan.avg DESC Sort Key: remote_scan.user_id, remote_scan.avg DESC
-> Custom Scan (Citus Adaptive) -> Custom Scan (Citus Adaptive)
Task Count: 4 Task Count: N
Tasks Shown: One of 4 Tasks Shown: One of N
-> Task -> Task
Node: host=localhost port=xxxxx dbname=regression Node: host=localhost port=N dbname=regression
-> Limit -> Limit
-> Sort -> Sort
Sort Key: users_table.user_id, (avg(users_table.value_1)) DESC Sort Key: users_table.user_id, (avg(users_table.value_1)) DESC
-> WindowAgg -> WindowAgg
-> Sort -> Sort
Sort Key: users_table.user_id, (('1'::numeric / ('1'::numeric + avg(users_table.value_1)))) Sort Key: users_table.user_id, (('N'::numeric / ('N'::numeric + avg(users_table.value_1))))
-> HashAggregate -> HashAggregate
Group Key: users_table.user_id, users_table.value_2 Group Key: users_table.user_id, users_table.value_2
-> Seq Scan on users_table_1400256 users_table -> Seq Scan on users_table_1400256 users_table
(17 rows) (17 rows)
select public.explain_filter('
EXPLAIN (COSTS FALSE) EXPLAIN (COSTS FALSE)
SELECT SELECT
user_id, user_id,
@ -1435,28 +1442,30 @@ FROM
users_table users_table
GROUP BY user_id, value_2 GROUP BY user_id, value_2
ORDER BY user_id, avg(value_1) DESC ORDER BY user_id, avg(value_1) DESC
LIMIT 5; LIMIT 5
QUERY PLAN ');
explain_filter
--------------------------------------------------------------------- ---------------------------------------------------------------------
Limit Limit
-> Sort -> Sort
Sort Key: remote_scan.user_id, remote_scan.avg DESC Sort Key: remote_scan.user_id, remote_scan.avg DESC
-> Custom Scan (Citus Adaptive) -> Custom Scan (Citus Adaptive)
Task Count: 4 Task Count: N
Tasks Shown: One of 4 Tasks Shown: One of N
-> Task -> Task
Node: host=localhost port=xxxxx dbname=regression Node: host=localhost port=N dbname=regression
-> Limit -> Limit
-> Sort -> Sort
Sort Key: users_table.user_id, (avg(users_table.value_1)) DESC Sort Key: users_table.user_id, (avg(users_table.value_1)) DESC
-> WindowAgg -> WindowAgg
-> Sort -> Sort
Sort Key: users_table.user_id, ((1 / (1 + sum(users_table.value_2)))) Sort Key: users_table.user_id, ((N / (N + sum(users_table.value_2))))
-> HashAggregate -> HashAggregate
Group Key: users_table.user_id, users_table.value_2 Group Key: users_table.user_id, users_table.value_2
-> Seq Scan on users_table_1400256 users_table -> Seq Scan on users_table_1400256 users_table
(17 rows) (17 rows)
select public.explain_filter('
EXPLAIN (COSTS FALSE) EXPLAIN (COSTS FALSE)
SELECT SELECT
user_id, user_id,
@ -1466,17 +1475,18 @@ FROM
users_table users_table
GROUP BY user_id, value_2 GROUP BY user_id, value_2
ORDER BY user_id, avg(value_1) DESC ORDER BY user_id, avg(value_1) DESC
LIMIT 5; LIMIT 5
QUERY PLAN ');
explain_filter
--------------------------------------------------------------------- ---------------------------------------------------------------------
Limit Limit
-> Sort -> Sort
Sort Key: remote_scan.user_id, remote_scan.avg DESC Sort Key: remote_scan.user_id, remote_scan.avg DESC
-> Custom Scan (Citus Adaptive) -> Custom Scan (Citus Adaptive)
Task Count: 4 Task Count: N
Tasks Shown: One of 4 Tasks Shown: One of N
-> Task -> Task
Node: host=localhost port=xxxxx dbname=regression Node: host=localhost port=N dbname=regression
-> Limit -> Limit
-> Sort -> Sort
Sort Key: users_table.user_id, (avg(users_table.value_1)) DESC Sort Key: users_table.user_id, (avg(users_table.value_1)) DESC
@ -1489,23 +1499,25 @@ LIMIT 5;
(17 rows) (17 rows)
-- Grouping can be pushed down with aggregates even when window function can't -- Grouping can be pushed down with aggregates even when window function can't
select public.explain_filter('
EXPLAIN (COSTS FALSE) EXPLAIN (COSTS FALSE)
SELECT user_id, count(value_1), stddev(value_1), count(user_id) OVER (PARTITION BY random()) SELECT user_id, count(value_1), stddev(value_1), count(user_id) OVER (PARTITION BY random())
FROM users_table GROUP BY user_id HAVING avg(value_1) > 2 LIMIT 1; FROM users_table GROUP BY user_id HAVING avg(value_1) > 2 LIMIT 1
QUERY PLAN ');
explain_filter
--------------------------------------------------------------------- ---------------------------------------------------------------------
Limit Limit
-> WindowAgg -> WindowAgg
-> Sort -> Sort
Sort Key: remote_scan.worker_column_5 Sort Key: remote_scan.worker_column_5
-> Custom Scan (Citus Adaptive) -> Custom Scan (Citus Adaptive)
Task Count: 4 Task Count: N
Tasks Shown: One of 4 Tasks Shown: One of N
-> Task -> Task
Node: host=localhost port=xxxxx dbname=regression Node: host=localhost port=N dbname=regression
-> HashAggregate -> HashAggregate
Group Key: user_id Group Key: user_id
Filter: (avg(value_1) > '2'::numeric) Filter: (avg(value_1) > 'N'::numeric)
-> Seq Scan on users_table_1400256 users_table -> Seq Scan on users_table_1400256 users_table
(13 rows) (13 rows)
@ -1534,6 +1546,7 @@ SELECT create_distributed_table('daily_uniques', 'user_id');
(1 row) (1 row)
select public.explain_filter('
EXPLAIN (COSTS FALSE) SELECT EXPLAIN (COSTS FALSE) SELECT
user_id, user_id,
sum(value_2) AS commits, sum(value_2) AS commits,
@ -1547,17 +1560,18 @@ GROUP BY user_id
HAVING HAVING
sum(value_2) > 0 sum(value_2) > 0
ORDER BY commits DESC ORDER BY commits DESC
LIMIT 10; LIMIT 10
QUERY PLAN ');
explain_filter
--------------------------------------------------------------------- ---------------------------------------------------------------------
Limit Limit
-> Sort -> Sort
Sort Key: remote_scan.commits DESC Sort Key: remote_scan.commits DESC
-> Custom Scan (Citus Adaptive) -> Custom Scan (Citus Adaptive)
Task Count: 4 Task Count: N
Tasks Shown: One of 4 Tasks Shown: One of N
-> Task -> Task
Node: host=localhost port=xxxxx dbname=regression Node: host=localhost port=N dbname=regression
-> Limit -> Limit
-> Sort -> Sort
Sort Key: (sum(daily_uniques.value_2)) DESC Sort Key: (sum(daily_uniques.value_2)) DESC
@ -1566,7 +1580,7 @@ LIMIT 10;
Sort Key: daily_uniques.user_id, (sum(daily_uniques.value_2)) DESC Sort Key: daily_uniques.user_id, (sum(daily_uniques.value_2)) DESC
-> HashAggregate -> HashAggregate
Group Key: daily_uniques.user_id Group Key: daily_uniques.user_id
Filter: (sum(daily_uniques.value_2) > '0'::double precision) Filter: (sum(daily_uniques.value_2) > 'N'::double precision)
-> Seq Scan on daily_uniques_xxxxxxx daily_uniques -> Seq Scan on daily_uniques_xxxxxxx daily_uniques
(18 rows) (18 rows)

4
src/test/regress/sql/mixed_relkind_tests.sql
View File

@ -232,10 +232,12 @@ SELECT a, COUNT(*) OVER (PARTITION BY a) FROM partitioned_distributed_table ORDE
$Q$); $Q$);
-- pull to coordinator WINDOW -- pull to coordinator WINDOW
select public.explain_filter('
SELECT public.coordinator_plan($Q$ SELECT public.coordinator_plan($Q$
EXPLAIN (COSTS OFF) EXPLAIN (COSTS OFF)
SELECT a, COUNT(*) OVER (PARTITION BY a+1) FROM partitioned_distributed_table ORDER BY 1,2; SELECT a, COUNT(*) OVER (PARTITION BY a+1) FROM partitioned_distributed_table ORDER BY 1,2;
$Q$); $Q$)
');
-- FOR UPDATE -- FOR UPDATE
SELECT * FROM partitioned_distributed_table WHERE a = 1 ORDER BY 1,2 FOR UPDATE; SELECT * FROM partitioned_distributed_table WHERE a = 1 ORDER BY 1,2 FOR UPDATE;

10
src/test/regress/sql/multi_explain.sql
View File

@ -1137,17 +1137,21 @@ CREATE TABLE distributed_table_1(a int, b int);
SELECT create_distributed_table('distributed_table_1','a'); SELECT create_distributed_table('distributed_table_1','a');
INSERT INTO distributed_table_1 values (1,1); INSERT INTO distributed_table_1 values (1,1);
EXPLAIN :default_analyze_flags SELECT row_number() OVER() AS r FROM distributed_table_1; select public.explain_filter('
EXPLAIN (ANALYZE on, COSTS off, TIMING off, SUMMARY off, BUFFERS off) SELECT row_number() OVER() AS r FROM distributed_table_1
');
CREATE TABLE distributed_table_2(a int, b int); CREATE TABLE distributed_table_2(a int, b int);
SELECT create_distributed_table('distributed_table_2','a'); SELECT create_distributed_table('distributed_table_2','a');
INSERT INTO distributed_table_2 VALUES (1,1); INSERT INTO distributed_table_2 VALUES (1,1);
EXPLAIN :default_analyze_flags select public.explain_filter('
EXPLAIN (ANALYZE on, COSTS off, TIMING off, SUMMARY off, BUFFERS off)
WITH r AS (SELECT row_number() OVER () AS r FROM distributed_table_1) WITH r AS (SELECT row_number() OVER () AS r FROM distributed_table_1)
SELECT * FROM distributed_table_2 SELECT * FROM distributed_table_2
JOIN r ON (r = distributed_table_2.b) JOIN r ON (r = distributed_table_2.b)
LIMIT 3; LIMIT 3
');
EXPLAIN :default_analyze_flags SELECT FROM (SELECT * FROM reference_table) subquery; EXPLAIN :default_analyze_flags SELECT FROM (SELECT * FROM reference_table) subquery;

14
src/test/regress/sql/multi_outer_join_columns.sql
View File

@ -32,21 +32,27 @@ SELECT create_distributed_table('t2', 'account_id');
-- produces a non-empty varnullingrels set in PG 16 (and higher) -- produces a non-empty varnullingrels set in PG 16 (and higher)
SELECT t1.id, MAX(t2.a2) OVER (PARTITION BY t2.id) SELECT t1.id, MAX(t2.a2) OVER (PARTITION BY t2.id)
FROM t1 LEFT OUTER JOIN t2 ON t1.id = t2.account_id; FROM t1 LEFT OUTER JOIN t2 ON t1.id = t2.account_id;
select public.explain_filter('
EXPLAIN (VERBOSE, COSTS OFF, TIMING OFF) EXPLAIN (VERBOSE, COSTS OFF, TIMING OFF)
SELECT t1.id, MAX(t2.a2) OVER (PARTITION BY t2.id) SELECT t1.id, MAX(t2.a2) OVER (PARTITION BY t2.id)
FROM t1 LEFT OUTER JOIN t2 ON t1.id = t2.account_id; FROM t1 LEFT OUTER JOIN t2 ON t1.id = t2.account_id
');
SELECT t1.id, MAX(t2.a2) OVER (PARTITION BY t2.id) SELECT t1.id, MAX(t2.a2) OVER (PARTITION BY t2.id)
FROM t2 RIGHT OUTER JOIN t1 ON t1.id = t2.account_id; FROM t2 RIGHT OUTER JOIN t1 ON t1.id = t2.account_id;
select public.explain_filter('
EXPLAIN (VERBOSE, COSTS OFF, TIMING OFF) EXPLAIN (VERBOSE, COSTS OFF, TIMING OFF)
SELECT t1.id, MAX(t2.a2) OVER (PARTITION BY t2.id) SELECT t1.id, MAX(t2.a2) OVER (PARTITION BY t2.id)
FROM t2 RIGHT OUTER JOIN t1 ON t1.id = t2.account_id; FROM t2 RIGHT OUTER JOIN t1 ON t1.id = t2.account_id
');
SELECT DISTINCT t1.id, MAX(t2.a2) OVER (PARTITION BY t2.id) SELECT DISTINCT t1.id, MAX(t2.a2) OVER (PARTITION BY t2.id)
FROM t1 LEFT OUTER JOIN t2 ON t1.id = t2.account_id; FROM t1 LEFT OUTER JOIN t2 ON t1.id = t2.account_id;
select public.explain_filter('
EXPLAIN (VERBOSE, COSTS OFF, TIMING OFF) EXPLAIN (VERBOSE, COSTS OFF, TIMING OFF)
SELECT DISTINCT t1.id, MAX(t2.a2) OVER (PARTITION BY t2.id) SELECT DISTINCT t1.id, MAX(t2.a2) OVER (PARTITION BY t2.id)
FROM t1 LEFT OUTER JOIN t2 ON t1.id = t2.account_id; FROM t1 LEFT OUTER JOIN t2 ON t1.id = t2.account_id
');
CREATE SEQUENCE test_seq START 101; CREATE SEQUENCE test_seq START 101;
CREATE OR REPLACE FUNCTION TEST_F(int) returns INT language sql stable as $$ select $1 + 42; $$ ; CREATE OR REPLACE FUNCTION TEST_F(int) returns INT language sql stable as $$ select $1 + 42; $$ ;
@ -86,10 +92,12 @@ FROM t1 LEFT OUTER JOIN t2 ON t1.id = t2.account_id;
SELECT 1 SELECT 1
FROM t1 LEFT OUTER JOIN t2 ON t1.id = t2.account_id FROM t1 LEFT OUTER JOIN t2 ON t1.id = t2.account_id
HAVING COUNT(DISTINCT a2) > 1; HAVING COUNT(DISTINCT a2) > 1;
select public.explain_filter('
EXPLAIN (VERBOSE, COSTS OFF, TIMING OFF) EXPLAIN (VERBOSE, COSTS OFF, TIMING OFF)
SELECT 1 SELECT 1
FROM t1 LEFT OUTER JOIN t2 ON t1.id = t2.account_id FROM t1 LEFT OUTER JOIN t2 ON t1.id = t2.account_id
HAVING COUNT(DISTINCT a2) > 1; HAVING COUNT(DISTINCT a2) > 1;
');
-- Check right outer join -- Check right outer join
SELECT COUNT(DISTINCT a2) SELECT COUNT(DISTINCT a2)

4
src/test/regress/sql/multi_subquery_window_functions.sql
View File

@ -441,6 +441,7 @@ ORDER BY
LIMIT LIMIT
5; 5;
select public.explain_filter('
EXPLAIN (COSTS FALSE) EXPLAIN (COSTS FALSE)
SELECT * SELECT *
FROM ( FROM (
@ -474,7 +475,8 @@ EXPLAIN (COSTS FALSE)
GROUP BY GROUP BY
user_id)) AS ftop user_id)) AS ftop
ORDER BY 2 DESC, 1 DESC ORDER BY 2 DESC, 1 DESC
LIMIT 5; LIMIT 5
');
-- test with window functions which aren't pushed down -- test with window functions which aren't pushed down
SELECT SELECT

28
src/test/regress/sql/window_functions.sql
View File

@ -508,6 +508,7 @@ FROM
GROUP BY user_id, value_2 GROUP BY user_id, value_2
ORDER BY user_id, avg(value_1) DESC; ORDER BY user_id, avg(value_1) DESC;
select public.explain_filter('
EXPLAIN (COSTS FALSE) EXPLAIN (COSTS FALSE)
SELECT SELECT
user_id, user_id,
@ -516,7 +517,8 @@ SELECT
FROM FROM
users_table users_table
GROUP BY user_id, value_2 GROUP BY user_id, value_2
ORDER BY user_id, avg(value_1) DESC; ORDER BY user_id, avg(value_1) DESC
');
-- order by in the window function is same as avg(value_1) DESC -- order by in the window function is same as avg(value_1) DESC
SELECT SELECT
@ -529,6 +531,7 @@ GROUP BY user_id, value_2
ORDER BY user_id, avg(value_1) DESC; ORDER BY user_id, avg(value_1) DESC;
-- limit is not pushed down to worker !! -- limit is not pushed down to worker !!
select public.explain_filter('
EXPLAIN (COSTS FALSE) EXPLAIN (COSTS FALSE)
SELECT SELECT
user_id, user_id,
@ -538,8 +541,10 @@ FROM
users_table users_table
GROUP BY user_id, value_2 GROUP BY user_id, value_2
ORDER BY user_id, avg(value_1) DESC ORDER BY user_id, avg(value_1) DESC
LIMIT 5; LIMIT 5
');
select public.explain_filter('
EXPLAIN (COSTS FALSE) EXPLAIN (COSTS FALSE)
SELECT SELECT
user_id, user_id,
@ -549,8 +554,10 @@ FROM
users_table users_table
GROUP BY user_id, value_2 GROUP BY user_id, value_2
ORDER BY user_id, avg(value_1) DESC ORDER BY user_id, avg(value_1) DESC
LIMIT 5; LIMIT 5
');
select public.explain_filter('
EXPLAIN (COSTS FALSE) EXPLAIN (COSTS FALSE)
SELECT SELECT
user_id, user_id,
@ -560,8 +567,10 @@ FROM
users_table users_table
GROUP BY user_id, value_2 GROUP BY user_id, value_2
ORDER BY user_id, avg(value_1) DESC ORDER BY user_id, avg(value_1) DESC
LIMIT 5; LIMIT 5
');
select public.explain_filter('
EXPLAIN (COSTS FALSE) EXPLAIN (COSTS FALSE)
SELECT SELECT
user_id, user_id,
@ -571,12 +580,15 @@ FROM
users_table users_table
GROUP BY user_id, value_2 GROUP BY user_id, value_2
ORDER BY user_id, avg(value_1) DESC ORDER BY user_id, avg(value_1) DESC
LIMIT 5; LIMIT 5
');
-- Grouping can be pushed down with aggregates even when window function can't -- Grouping can be pushed down with aggregates even when window function can't
select public.explain_filter('
EXPLAIN (COSTS FALSE) EXPLAIN (COSTS FALSE)
SELECT user_id, count(value_1), stddev(value_1), count(user_id) OVER (PARTITION BY random()) SELECT user_id, count(value_1), stddev(value_1), count(user_id) OVER (PARTITION BY random())
FROM users_table GROUP BY user_id HAVING avg(value_1) > 2 LIMIT 1; FROM users_table GROUP BY user_id HAVING avg(value_1) > 2 LIMIT 1
');
-- Window function with inlined CTE -- Window function with inlined CTE
WITH cte as ( WITH cte as (
@ -594,6 +606,7 @@ ORDER BY 1;
CREATE TABLE daily_uniques (value_2 float, user_id bigint); CREATE TABLE daily_uniques (value_2 float, user_id bigint);
SELECT create_distributed_table('daily_uniques', 'user_id'); SELECT create_distributed_table('daily_uniques', 'user_id');
select public.explain_filter('
EXPLAIN (COSTS FALSE) SELECT EXPLAIN (COSTS FALSE) SELECT
user_id, user_id,
sum(value_2) AS commits, sum(value_2) AS commits,
@ -607,7 +620,8 @@ GROUP BY user_id
HAVING HAVING
sum(value_2) > 0 sum(value_2) > 0
ORDER BY commits DESC ORDER BY commits DESC
LIMIT 10; LIMIT 10
');
DROP TABLE daily_uniques; DROP TABLE daily_uniques;