postgres_fdw: Consider foreign joining and foreign sorting together.
Commitccd8f97922gave us the ability to request that the remote side sort the data, and, later, commite4106b2528gave us the ability to request that the remote side perform the join for us rather than doing it locally. But we could not do both things at the same time: a remote SQL query that had an ORDER BY clause would never be a join. This commit adds that capability. Ashutosh Bapat, reviewed by me.
This commit is contained in:
Robert Haas
parent
d31f20e2b5
commit
aa09cd242f
|
|
@ -444,6 +444,40 @@ SELECT t1.c1, t2."C 1" FROM ft2 t1 LEFT JOIN "S 1"."T 1" t2 ON (t1.c1 = t2."C 1"
|
|||
110 | 110
|
||||
(10 rows)
|
||||
|
||||
-- A join between local table and foreign join. ORDER BY clause is added to the
|
||||
-- foreign join so that the local table can be joined using merge join strategy.
|
||||
EXPLAIN (COSTS false, VERBOSE)
|
||||
SELECT t1."C 1" FROM "S 1"."T 1" t1 left join ft1 t2 join ft2 t3 on (t2.c1 = t3.c1) on (t3.c1 = t1."C 1") OFFSET 100 LIMIT 10;
|
||||
QUERY PLAN
|
||||
--------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
Limit
|
||||
Output: t1."C 1"
|
||||
-> Merge Right Join
|
||||
Output: t1."C 1"
|
||||
Merge Cond: (t3.c1 = t1."C 1")
|
||||
-> Foreign Scan
|
||||
Output: t3.c1
|
||||
Relations: (public.ft1 t2) INNER JOIN (public.ft2 t3)
|
||||
Remote SQL: SELECT r3."C 1" FROM ("S 1"."T 1" r2 INNER JOIN "S 1"."T 1" r3 ON (TRUE)) WHERE ((r2."C 1" = r3."C 1")) ORDER BY r2."C 1" ASC NULLS LAST
|
||||
-> Index Only Scan using t1_pkey on "S 1"."T 1" t1
|
||||
Output: t1."C 1"
|
||||
(11 rows)
|
||||
|
||||
SELECT t1."C 1" FROM "S 1"."T 1" t1 left join ft1 t2 join ft2 t3 on (t2.c1 = t3.c1) on (t3.c1 = t1."C 1") OFFSET 100 LIMIT 10;
|
||||
C 1
|
||||
-----
|
||||
101
|
||||
102
|
||||
103
|
||||
104
|
||||
105
|
||||
106
|
||||
107
|
||||
108
|
||||
109
|
||||
110
|
||||
(10 rows)
|
||||
|
||||
RESET enable_hashjoin;
|
||||
RESET enable_nestloop;
|
||||
-- ===================================================================
|
||||
|
|
@ -869,18 +903,15 @@ ANALYZE ft5;
|
|||
-- join two tables
|
||||
EXPLAIN (COSTS false, VERBOSE)
|
||||
SELECT t1.c1, t2.c1 FROM ft1 t1 JOIN ft2 t2 ON (t1.c1 = t2.c1) ORDER BY t1.c3, t1.c1 OFFSET 100 LIMIT 10;
|
||||
QUERY PLAN
|
||||
----------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
QUERY PLAN
|
||||
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
Limit
|
||||
Output: t1.c1, t2.c1, t1.c3
|
||||
-> Sort
|
||||
-> Foreign Scan
|
||||
Output: t1.c1, t2.c1, t1.c3
|
||||
Sort Key: t1.c3, t1.c1
|
||||
-> Foreign Scan
|
||||
Output: t1.c1, t2.c1, t1.c3
|
||||
Relations: (public.ft1 t1) INNER JOIN (public.ft2 t2)
|
||||
Remote SQL: SELECT r1."C 1", r1.c3, r2."C 1" FROM ("S 1"."T 1" r1 INNER JOIN "S 1"."T 1" r2 ON (TRUE)) WHERE ((r1."C 1" = r2."C 1"))
|
||||
(9 rows)
|
||||
Relations: (public.ft1 t1) INNER JOIN (public.ft2 t2)
|
||||
Remote SQL: SELECT r1."C 1", r1.c3, r2."C 1" FROM ("S 1"."T 1" r1 INNER JOIN "S 1"."T 1" r2 ON (TRUE)) WHERE ((r1."C 1" = r2."C 1")) ORDER BY r1.c3 ASC NULLS LAST, r1."C 1" ASC NULLS LAST
|
||||
(6 rows)
|
||||
|
||||
SELECT t1.c1, t2.c1 FROM ft1 t1 JOIN ft2 t2 ON (t1.c1 = t2.c1) ORDER BY t1.c3, t1.c1 OFFSET 100 LIMIT 10;
|
||||
c1 | c1
|
||||
|
|
@ -931,18 +962,15 @@ SELECT t1.c1, t2.c2, t3.c3 FROM ft1 t1 JOIN ft2 t2 ON (t1.c1 = t2.c1) JOIN ft4 t
|
|||
-- left outer join
|
||||
EXPLAIN (COSTS false, VERBOSE)
|
||||
SELECT t1.c1, t2.c1 FROM ft4 t1 LEFT JOIN ft5 t2 ON (t1.c1 = t2.c1) ORDER BY t1.c1, t2.c1 OFFSET 10 LIMIT 10;
|
||||
QUERY PLAN
|
||||
---------------------------------------------------------------------------------------------------------------------
|
||||
QUERY PLAN
|
||||
-------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
Limit
|
||||
Output: t1.c1, t2.c1
|
||||
-> Sort
|
||||
-> Foreign Scan
|
||||
Output: t1.c1, t2.c1
|
||||
Sort Key: t1.c1, t2.c1
|
||||
-> Foreign Scan
|
||||
Output: t1.c1, t2.c1
|
||||
Relations: (public.ft4 t1) LEFT JOIN (public.ft5 t2)
|
||||
Remote SQL: SELECT r1.c1, r2.c1 FROM ("S 1"."T 3" r1 LEFT JOIN "S 1"."T 4" r2 ON (((r1.c1 = r2.c1))))
|
||||
(9 rows)
|
||||
Relations: (public.ft4 t1) LEFT JOIN (public.ft5 t2)
|
||||
Remote SQL: SELECT r1.c1, r2.c1 FROM ("S 1"."T 3" r1 LEFT JOIN "S 1"."T 4" r2 ON (((r1.c1 = r2.c1)))) ORDER BY r1.c1 ASC NULLS LAST, r2.c1 ASC NULLS LAST
|
||||
(6 rows)
|
||||
|
||||
SELECT t1.c1, t2.c1 FROM ft4 t1 LEFT JOIN ft5 t2 ON (t1.c1 = t2.c1) ORDER BY t1.c1, t2.c1 OFFSET 10 LIMIT 10;
|
||||
c1 | c1
|
||||
|
|
@ -1007,18 +1035,15 @@ SELECT t1.c1, t1.c2, t2.c1, t2.c2 FROM ft4 t1 LEFT JOIN (SELECT * FROM ft5 WHERE
|
|||
-- right outer join
|
||||
EXPLAIN (COSTS false, VERBOSE)
|
||||
SELECT t1.c1, t2.c1 FROM ft5 t1 RIGHT JOIN ft4 t2 ON (t1.c1 = t2.c1) ORDER BY t2.c1, t1.c1 OFFSET 10 LIMIT 10;
|
||||
QUERY PLAN
|
||||
---------------------------------------------------------------------------------------------------------------------
|
||||
QUERY PLAN
|
||||
-------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
Limit
|
||||
Output: t1.c1, t2.c1
|
||||
-> Sort
|
||||
-> Foreign Scan
|
||||
Output: t1.c1, t2.c1
|
||||
Sort Key: t2.c1, t1.c1
|
||||
-> Foreign Scan
|
||||
Output: t1.c1, t2.c1
|
||||
Relations: (public.ft4 t2) LEFT JOIN (public.ft5 t1)
|
||||
Remote SQL: SELECT r2.c1, r1.c1 FROM ("S 1"."T 3" r2 LEFT JOIN "S 1"."T 4" r1 ON (((r1.c1 = r2.c1))))
|
||||
(9 rows)
|
||||
Relations: (public.ft4 t2) LEFT JOIN (public.ft5 t1)
|
||||
Remote SQL: SELECT r2.c1, r1.c1 FROM ("S 1"."T 3" r2 LEFT JOIN "S 1"."T 4" r1 ON (((r1.c1 = r2.c1)))) ORDER BY r2.c1 ASC NULLS LAST, r1.c1 ASC NULLS LAST
|
||||
(6 rows)
|
||||
|
||||
SELECT t1.c1, t2.c1 FROM ft5 t1 RIGHT JOIN ft4 t2 ON (t1.c1 = t2.c1) ORDER BY t2.c1, t1.c1 OFFSET 10 LIMIT 10;
|
||||
c1 | c1
|
||||
|
|
@ -1038,18 +1063,15 @@ SELECT t1.c1, t2.c1 FROM ft5 t1 RIGHT JOIN ft4 t2 ON (t1.c1 = t2.c1) ORDER BY t2
|
|||
-- full outer join
|
||||
EXPLAIN (COSTS false, VERBOSE)
|
||||
SELECT t1.c1, t2.c1 FROM ft4 t1 FULL JOIN ft5 t2 ON (t1.c1 = t2.c1) ORDER BY t1.c1, t2.c1 OFFSET 45 LIMIT 10;
|
||||
QUERY PLAN
|
||||
---------------------------------------------------------------------------------------------------------------------
|
||||
QUERY PLAN
|
||||
-------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
Limit
|
||||
Output: t1.c1, t2.c1
|
||||
-> Sort
|
||||
-> Foreign Scan
|
||||
Output: t1.c1, t2.c1
|
||||
Sort Key: t1.c1, t2.c1
|
||||
-> Foreign Scan
|
||||
Output: t1.c1, t2.c1
|
||||
Relations: (public.ft4 t1) FULL JOIN (public.ft5 t2)
|
||||
Remote SQL: SELECT r1.c1, r2.c1 FROM ("S 1"."T 3" r1 FULL JOIN "S 1"."T 4" r2 ON (((r1.c1 = r2.c1))))
|
||||
(9 rows)
|
||||
Relations: (public.ft4 t1) FULL JOIN (public.ft5 t2)
|
||||
Remote SQL: SELECT r1.c1, r2.c1 FROM ("S 1"."T 3" r1 FULL JOIN "S 1"."T 4" r2 ON (((r1.c1 = r2.c1)))) ORDER BY r1.c1 ASC NULLS LAST, r2.c1 ASC NULLS LAST
|
||||
(6 rows)
|
||||
|
||||
SELECT t1.c1, t2.c1 FROM ft4 t1 FULL JOIN ft5 t2 ON (t1.c1 = t2.c1) ORDER BY t1.c1, t2.c1 OFFSET 45 LIMIT 10;
|
||||
c1 | c1
|
||||
|
|
@ -1101,35 +1123,32 @@ SELECT t1.c1, t2.c1 FROM ft4 t1 FULL JOIN ft5 t2 ON (t1.c1 = t2.c1) WHERE (t1.c1
|
|||
-- tests whole-row reference for row marks
|
||||
EXPLAIN (COSTS false, VERBOSE)
|
||||
SELECT t1.c1, t2.c1 FROM ft1 t1 JOIN ft2 t2 ON (t1.c1 = t2.c1) ORDER BY t1.c3, t1.c1 OFFSET 100 LIMIT 10 FOR UPDATE OF t1;
|
||||
QUERY PLAN
|
||||
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
QUERY PLAN
|
||||
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
Limit
|
||||
Output: t1.c1, t2.c1, t1.c3, t1.*, t2.*
|
||||
-> LockRows
|
||||
Output: t1.c1, t2.c1, t1.c3, t1.*, t2.*
|
||||
-> Sort
|
||||
-> Foreign Scan
|
||||
Output: t1.c1, t2.c1, t1.c3, t1.*, t2.*
|
||||
Sort Key: t1.c3, t1.c1
|
||||
-> Foreign Scan
|
||||
Output: t1.c1, t2.c1, t1.c3, t1.*, t2.*
|
||||
Relations: (public.ft1 t1) INNER JOIN (public.ft2 t2)
|
||||
Remote SQL: SELECT r1."C 1", r1.c3, ROW(r1."C 1", r1.c2, r1.c3, r1.c4, r1.c5, r1.c6, r1.c7, r1.c8), r2."C 1", ROW(r2."C 1", r2.c2, r2.c3, r2.c4, r2.c5, r2.c6, r2.c7, r2.c8) FROM ("S 1"."T 1" r1 INNER JOIN "S 1"."T 1" r2 ON (TRUE)) WHERE ((r1."C 1" = r2."C 1")) FOR UPDATE OF r1
|
||||
-> Merge Join
|
||||
Output: t1.c1, t1.c3, t1.*, t2.c1, t2.*
|
||||
Merge Cond: (t1.c1 = t2.c1)
|
||||
-> Sort
|
||||
Relations: (public.ft1 t1) INNER JOIN (public.ft2 t2)
|
||||
Remote SQL: SELECT r1."C 1", r1.c3, ROW(r1."C 1", r1.c2, r1.c3, r1.c4, r1.c5, r1.c6, r1.c7, r1.c8), r2."C 1", ROW(r2."C 1", r2.c2, r2.c3, r2.c4, r2.c5, r2.c6, r2.c7, r2.c8) FROM ("S 1"."T 1" r1 INNER JOIN "S 1"."T 1" r2 ON (TRUE)) WHERE ((r1."C 1" = r2."C 1")) ORDER BY r1.c3 ASC NULLS LAST, r1."C 1" ASC NULLS LAST FOR UPDATE OF r1
|
||||
-> Merge Join
|
||||
Output: t1.c1, t1.c3, t1.*, t2.c1, t2.*
|
||||
Merge Cond: (t1.c1 = t2.c1)
|
||||
-> Sort
|
||||
Output: t1.c1, t1.c3, t1.*
|
||||
Sort Key: t1.c1
|
||||
-> Foreign Scan on public.ft1 t1
|
||||
Output: t1.c1, t1.c3, t1.*
|
||||
Sort Key: t1.c1
|
||||
-> Foreign Scan on public.ft1 t1
|
||||
Output: t1.c1, t1.c3, t1.*
|
||||
Remote SQL: SELECT "C 1", c2, c3, c4, c5, c6, c7, c8 FROM "S 1"."T 1" FOR UPDATE
|
||||
-> Sort
|
||||
Remote SQL: SELECT "C 1", c2, c3, c4, c5, c6, c7, c8 FROM "S 1"."T 1" FOR UPDATE
|
||||
-> Sort
|
||||
Output: t2.c1, t2.*
|
||||
Sort Key: t2.c1
|
||||
-> Foreign Scan on public.ft2 t2
|
||||
Output: t2.c1, t2.*
|
||||
Sort Key: t2.c1
|
||||
-> Foreign Scan on public.ft2 t2
|
||||
Output: t2.c1, t2.*
|
||||
Remote SQL: SELECT "C 1", c2, c3, c4, c5, c6, c7, c8 FROM "S 1"."T 1"
|
||||
(26 rows)
|
||||
Remote SQL: SELECT "C 1", c2, c3, c4, c5, c6, c7, c8 FROM "S 1"."T 1"
|
||||
(23 rows)
|
||||
|
||||
SELECT t1.c1, t2.c1 FROM ft1 t1 JOIN ft2 t2 ON (t1.c1 = t2.c1) ORDER BY t1.c3, t1.c1 OFFSET 100 LIMIT 10 FOR UPDATE OF t1;
|
||||
c1 | c1
|
||||
|
|
@ -1148,35 +1167,32 @@ SELECT t1.c1, t2.c1 FROM ft1 t1 JOIN ft2 t2 ON (t1.c1 = t2.c1) ORDER BY t1.c3, t
|
|||
|
||||
EXPLAIN (COSTS false, VERBOSE)
|
||||
SELECT t1.c1, t2.c1 FROM ft1 t1 JOIN ft2 t2 ON (t1.c1 = t2.c1) ORDER BY t1.c3, t1.c1 OFFSET 100 LIMIT 10 FOR UPDATE;
|
||||
QUERY PLAN
|
||||
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
QUERY PLAN
|
||||
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
Limit
|
||||
Output: t1.c1, t2.c1, t1.c3, t1.*, t2.*
|
||||
-> LockRows
|
||||
Output: t1.c1, t2.c1, t1.c3, t1.*, t2.*
|
||||
-> Sort
|
||||
-> Foreign Scan
|
||||
Output: t1.c1, t2.c1, t1.c3, t1.*, t2.*
|
||||
Sort Key: t1.c3, t1.c1
|
||||
-> Foreign Scan
|
||||
Output: t1.c1, t2.c1, t1.c3, t1.*, t2.*
|
||||
Relations: (public.ft1 t1) INNER JOIN (public.ft2 t2)
|
||||
Remote SQL: SELECT r1."C 1", r1.c3, ROW(r1."C 1", r1.c2, r1.c3, r1.c4, r1.c5, r1.c6, r1.c7, r1.c8), r2."C 1", ROW(r2."C 1", r2.c2, r2.c3, r2.c4, r2.c5, r2.c6, r2.c7, r2.c8) FROM ("S 1"."T 1" r1 INNER JOIN "S 1"."T 1" r2 ON (TRUE)) WHERE ((r1."C 1" = r2."C 1")) FOR UPDATE OF r1 FOR UPDATE OF r2
|
||||
-> Merge Join
|
||||
Output: t1.c1, t1.c3, t1.*, t2.c1, t2.*
|
||||
Merge Cond: (t1.c1 = t2.c1)
|
||||
-> Sort
|
||||
Relations: (public.ft1 t1) INNER JOIN (public.ft2 t2)
|
||||
Remote SQL: SELECT r1."C 1", r1.c3, ROW(r1."C 1", r1.c2, r1.c3, r1.c4, r1.c5, r1.c6, r1.c7, r1.c8), r2."C 1", ROW(r2."C 1", r2.c2, r2.c3, r2.c4, r2.c5, r2.c6, r2.c7, r2.c8) FROM ("S 1"."T 1" r1 INNER JOIN "S 1"."T 1" r2 ON (TRUE)) WHERE ((r1."C 1" = r2."C 1")) ORDER BY r1.c3 ASC NULLS LAST, r1."C 1" ASC NULLS LAST FOR UPDATE OF r1 FOR UPDATE OF r2
|
||||
-> Merge Join
|
||||
Output: t1.c1, t1.c3, t1.*, t2.c1, t2.*
|
||||
Merge Cond: (t1.c1 = t2.c1)
|
||||
-> Sort
|
||||
Output: t1.c1, t1.c3, t1.*
|
||||
Sort Key: t1.c1
|
||||
-> Foreign Scan on public.ft1 t1
|
||||
Output: t1.c1, t1.c3, t1.*
|
||||
Sort Key: t1.c1
|
||||
-> Foreign Scan on public.ft1 t1
|
||||
Output: t1.c1, t1.c3, t1.*
|
||||
Remote SQL: SELECT "C 1", c2, c3, c4, c5, c6, c7, c8 FROM "S 1"."T 1" FOR UPDATE
|
||||
-> Sort
|
||||
Remote SQL: SELECT "C 1", c2, c3, c4, c5, c6, c7, c8 FROM "S 1"."T 1" FOR UPDATE
|
||||
-> Sort
|
||||
Output: t2.c1, t2.*
|
||||
Sort Key: t2.c1
|
||||
-> Foreign Scan on public.ft2 t2
|
||||
Output: t2.c1, t2.*
|
||||
Sort Key: t2.c1
|
||||
-> Foreign Scan on public.ft2 t2
|
||||
Output: t2.c1, t2.*
|
||||
Remote SQL: SELECT "C 1", c2, c3, c4, c5, c6, c7, c8 FROM "S 1"."T 1" FOR UPDATE
|
||||
(26 rows)
|
||||
Remote SQL: SELECT "C 1", c2, c3, c4, c5, c6, c7, c8 FROM "S 1"."T 1" FOR UPDATE
|
||||
(23 rows)
|
||||
|
||||
SELECT t1.c1, t2.c1 FROM ft1 t1 JOIN ft2 t2 ON (t1.c1 = t2.c1) ORDER BY t1.c3, t1.c1 OFFSET 100 LIMIT 10 FOR UPDATE;
|
||||
c1 | c1
|
||||
|
|
@ -1196,35 +1212,32 @@ SELECT t1.c1, t2.c1 FROM ft1 t1 JOIN ft2 t2 ON (t1.c1 = t2.c1) ORDER BY t1.c3, t
|
|||
-- join two tables with FOR SHARE clause
|
||||
EXPLAIN (COSTS false, VERBOSE)
|
||||
SELECT t1.c1, t2.c1 FROM ft1 t1 JOIN ft2 t2 ON (t1.c1 = t2.c1) ORDER BY t1.c3, t1.c1 OFFSET 100 LIMIT 10 FOR SHARE OF t1;
|
||||
QUERY PLAN
|
||||
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
QUERY PLAN
|
||||
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
Limit
|
||||
Output: t1.c1, t2.c1, t1.c3, t1.*, t2.*
|
||||
-> LockRows
|
||||
Output: t1.c1, t2.c1, t1.c3, t1.*, t2.*
|
||||
-> Sort
|
||||
-> Foreign Scan
|
||||
Output: t1.c1, t2.c1, t1.c3, t1.*, t2.*
|
||||
Sort Key: t1.c3, t1.c1
|
||||
-> Foreign Scan
|
||||
Output: t1.c1, t2.c1, t1.c3, t1.*, t2.*
|
||||
Relations: (public.ft1 t1) INNER JOIN (public.ft2 t2)
|
||||
Remote SQL: SELECT r1."C 1", r1.c3, ROW(r1."C 1", r1.c2, r1.c3, r1.c4, r1.c5, r1.c6, r1.c7, r1.c8), r2."C 1", ROW(r2."C 1", r2.c2, r2.c3, r2.c4, r2.c5, r2.c6, r2.c7, r2.c8) FROM ("S 1"."T 1" r1 INNER JOIN "S 1"."T 1" r2 ON (TRUE)) WHERE ((r1."C 1" = r2."C 1")) FOR SHARE OF r1
|
||||
-> Merge Join
|
||||
Output: t1.c1, t1.c3, t1.*, t2.c1, t2.*
|
||||
Merge Cond: (t1.c1 = t2.c1)
|
||||
-> Sort
|
||||
Relations: (public.ft1 t1) INNER JOIN (public.ft2 t2)
|
||||
Remote SQL: SELECT r1."C 1", r1.c3, ROW(r1."C 1", r1.c2, r1.c3, r1.c4, r1.c5, r1.c6, r1.c7, r1.c8), r2."C 1", ROW(r2."C 1", r2.c2, r2.c3, r2.c4, r2.c5, r2.c6, r2.c7, r2.c8) FROM ("S 1"."T 1" r1 INNER JOIN "S 1"."T 1" r2 ON (TRUE)) WHERE ((r1."C 1" = r2."C 1")) ORDER BY r1.c3 ASC NULLS LAST, r1."C 1" ASC NULLS LAST FOR SHARE OF r1
|
||||
-> Merge Join
|
||||
Output: t1.c1, t1.c3, t1.*, t2.c1, t2.*
|
||||
Merge Cond: (t1.c1 = t2.c1)
|
||||
-> Sort
|
||||
Output: t1.c1, t1.c3, t1.*
|
||||
Sort Key: t1.c1
|
||||
-> Foreign Scan on public.ft1 t1
|
||||
Output: t1.c1, t1.c3, t1.*
|
||||
Sort Key: t1.c1
|
||||
-> Foreign Scan on public.ft1 t1
|
||||
Output: t1.c1, t1.c3, t1.*
|
||||
Remote SQL: SELECT "C 1", c2, c3, c4, c5, c6, c7, c8 FROM "S 1"."T 1" FOR SHARE
|
||||
-> Sort
|
||||
Remote SQL: SELECT "C 1", c2, c3, c4, c5, c6, c7, c8 FROM "S 1"."T 1" FOR SHARE
|
||||
-> Sort
|
||||
Output: t2.c1, t2.*
|
||||
Sort Key: t2.c1
|
||||
-> Foreign Scan on public.ft2 t2
|
||||
Output: t2.c1, t2.*
|
||||
Sort Key: t2.c1
|
||||
-> Foreign Scan on public.ft2 t2
|
||||
Output: t2.c1, t2.*
|
||||
Remote SQL: SELECT "C 1", c2, c3, c4, c5, c6, c7, c8 FROM "S 1"."T 1"
|
||||
(26 rows)
|
||||
Remote SQL: SELECT "C 1", c2, c3, c4, c5, c6, c7, c8 FROM "S 1"."T 1"
|
||||
(23 rows)
|
||||
|
||||
SELECT t1.c1, t2.c1 FROM ft1 t1 JOIN ft2 t2 ON (t1.c1 = t2.c1) ORDER BY t1.c3, t1.c1 OFFSET 100 LIMIT 10 FOR SHARE OF t1;
|
||||
c1 | c1
|
||||
|
|
@ -1243,35 +1256,32 @@ SELECT t1.c1, t2.c1 FROM ft1 t1 JOIN ft2 t2 ON (t1.c1 = t2.c1) ORDER BY t1.c3, t
|
|||
|
||||
EXPLAIN (COSTS false, VERBOSE)
|
||||
SELECT t1.c1, t2.c1 FROM ft1 t1 JOIN ft2 t2 ON (t1.c1 = t2.c1) ORDER BY t1.c3, t1.c1 OFFSET 100 LIMIT 10 FOR SHARE;
|
||||
QUERY PLAN
|
||||
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
QUERY PLAN
|
||||
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
Limit
|
||||
Output: t1.c1, t2.c1, t1.c3, t1.*, t2.*
|
||||
-> LockRows
|
||||
Output: t1.c1, t2.c1, t1.c3, t1.*, t2.*
|
||||
-> Sort
|
||||
-> Foreign Scan
|
||||
Output: t1.c1, t2.c1, t1.c3, t1.*, t2.*
|
||||
Sort Key: t1.c3, t1.c1
|
||||
-> Foreign Scan
|
||||
Output: t1.c1, t2.c1, t1.c3, t1.*, t2.*
|
||||
Relations: (public.ft1 t1) INNER JOIN (public.ft2 t2)
|
||||
Remote SQL: SELECT r1."C 1", r1.c3, ROW(r1."C 1", r1.c2, r1.c3, r1.c4, r1.c5, r1.c6, r1.c7, r1.c8), r2."C 1", ROW(r2."C 1", r2.c2, r2.c3, r2.c4, r2.c5, r2.c6, r2.c7, r2.c8) FROM ("S 1"."T 1" r1 INNER JOIN "S 1"."T 1" r2 ON (TRUE)) WHERE ((r1."C 1" = r2."C 1")) FOR SHARE OF r1 FOR SHARE OF r2
|
||||
-> Merge Join
|
||||
Output: t1.c1, t1.c3, t1.*, t2.c1, t2.*
|
||||
Merge Cond: (t1.c1 = t2.c1)
|
||||
-> Sort
|
||||
Relations: (public.ft1 t1) INNER JOIN (public.ft2 t2)
|
||||
Remote SQL: SELECT r1."C 1", r1.c3, ROW(r1."C 1", r1.c2, r1.c3, r1.c4, r1.c5, r1.c6, r1.c7, r1.c8), r2."C 1", ROW(r2."C 1", r2.c2, r2.c3, r2.c4, r2.c5, r2.c6, r2.c7, r2.c8) FROM ("S 1"."T 1" r1 INNER JOIN "S 1"."T 1" r2 ON (TRUE)) WHERE ((r1."C 1" = r2."C 1")) ORDER BY r1.c3 ASC NULLS LAST, r1."C 1" ASC NULLS LAST FOR SHARE OF r1 FOR SHARE OF r2
|
||||
-> Merge Join
|
||||
Output: t1.c1, t1.c3, t1.*, t2.c1, t2.*
|
||||
Merge Cond: (t1.c1 = t2.c1)
|
||||
-> Sort
|
||||
Output: t1.c1, t1.c3, t1.*
|
||||
Sort Key: t1.c1
|
||||
-> Foreign Scan on public.ft1 t1
|
||||
Output: t1.c1, t1.c3, t1.*
|
||||
Sort Key: t1.c1
|
||||
-> Foreign Scan on public.ft1 t1
|
||||
Output: t1.c1, t1.c3, t1.*
|
||||
Remote SQL: SELECT "C 1", c2, c3, c4, c5, c6, c7, c8 FROM "S 1"."T 1" FOR SHARE
|
||||
-> Sort
|
||||
Remote SQL: SELECT "C 1", c2, c3, c4, c5, c6, c7, c8 FROM "S 1"."T 1" FOR SHARE
|
||||
-> Sort
|
||||
Output: t2.c1, t2.*
|
||||
Sort Key: t2.c1
|
||||
-> Foreign Scan on public.ft2 t2
|
||||
Output: t2.c1, t2.*
|
||||
Sort Key: t2.c1
|
||||
-> Foreign Scan on public.ft2 t2
|
||||
Output: t2.c1, t2.*
|
||||
Remote SQL: SELECT "C 1", c2, c3, c4, c5, c6, c7, c8 FROM "S 1"."T 1" FOR SHARE
|
||||
(26 rows)
|
||||
Remote SQL: SELECT "C 1", c2, c3, c4, c5, c6, c7, c8 FROM "S 1"."T 1" FOR SHARE
|
||||
(23 rows)
|
||||
|
||||
SELECT t1.c1, t2.c1 FROM ft1 t1 JOIN ft2 t2 ON (t1.c1 = t2.c1) ORDER BY t1.c3, t1.c1 OFFSET 100 LIMIT 10 FOR SHARE;
|
||||
c1 | c1
|
||||
|
|
@ -1325,18 +1335,15 @@ WITH t (c1_1, c1_3, c2_1) AS (SELECT t1.c1, t1.c3, t2.c1 FROM ft1 t1 JOIN ft2 t2
|
|||
-- ctid with whole-row reference
|
||||
EXPLAIN (COSTS false, VERBOSE)
|
||||
SELECT t1.ctid, t1, t2, t1.c1 FROM ft1 t1 JOIN ft2 t2 ON (t1.c1 = t2.c1) ORDER BY t1.c3, t1.c1 OFFSET 100 LIMIT 10;
|
||||
QUERY PLAN
|
||||
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
QUERY PLAN
|
||||
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
Limit
|
||||
Output: t1.ctid, t1.*, t2.*, t1.c1, t1.c3
|
||||
-> Sort
|
||||
-> Foreign Scan
|
||||
Output: t1.ctid, t1.*, t2.*, t1.c1, t1.c3
|
||||
Sort Key: t1.c3, t1.c1
|
||||
-> Foreign Scan
|
||||
Output: t1.ctid, t1.*, t2.*, t1.c1, t1.c3
|
||||
Relations: (public.ft1 t1) INNER JOIN (public.ft2 t2)
|
||||
Remote SQL: SELECT r1.ctid, ROW(r1."C 1", r1.c2, r1.c3, r1.c4, r1.c5, r1.c6, r1.c7, r1.c8), r1."C 1", r1.c3, ROW(r2."C 1", r2.c2, r2.c3, r2.c4, r2.c5, r2.c6, r2.c7, r2.c8) FROM ("S 1"."T 1" r1 INNER JOIN "S 1"."T 1" r2 ON (TRUE)) WHERE ((r1."C 1" = r2."C 1"))
|
||||
(9 rows)
|
||||
Relations: (public.ft1 t1) INNER JOIN (public.ft2 t2)
|
||||
Remote SQL: SELECT r1.ctid, ROW(r1."C 1", r1.c2, r1.c3, r1.c4, r1.c5, r1.c6, r1.c7, r1.c8), r1."C 1", r1.c3, ROW(r2."C 1", r2.c2, r2.c3, r2.c4, r2.c5, r2.c6, r2.c7, r2.c8) FROM ("S 1"."T 1" r1 INNER JOIN "S 1"."T 1" r2 ON (TRUE)) WHERE ((r1."C 1" = r2."C 1")) ORDER BY r1.c3 ASC NULLS LAST, r1."C 1" ASC NULLS LAST
|
||||
(6 rows)
|
||||
|
||||
-- SEMI JOIN, not pushed down
|
||||
EXPLAIN (COSTS false, VERBOSE)
|
||||
|
|
@ -1672,18 +1679,15 @@ GRANT ALL ON ft5 TO view_owner;
|
|||
-- prepare statement with current session user
|
||||
PREPARE join_stmt AS SELECT t1.c1, t2.c1 FROM ft4 t1 LEFT JOIN ft5 t2 ON (t1.c1 = t2.c1) ORDER BY t1.c1, t2.c1 OFFSET 10 LIMIT 10;
|
||||
EXPLAIN (COSTS OFF, VERBOSE) EXECUTE join_stmt;
|
||||
QUERY PLAN
|
||||
---------------------------------------------------------------------------------------------------------------------
|
||||
QUERY PLAN
|
||||
-------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
Limit
|
||||
Output: t1.c1, t2.c1
|
||||
-> Sort
|
||||
-> Foreign Scan
|
||||
Output: t1.c1, t2.c1
|
||||
Sort Key: t1.c1, t2.c1
|
||||
-> Foreign Scan
|
||||
Output: t1.c1, t2.c1
|
||||
Relations: (public.ft4 t1) LEFT JOIN (public.ft5 t2)
|
||||
Remote SQL: SELECT r1.c1, r2.c1 FROM ("S 1"."T 3" r1 LEFT JOIN "S 1"."T 4" r2 ON (((r1.c1 = r2.c1))))
|
||||
(9 rows)
|
||||
Relations: (public.ft4 t1) LEFT JOIN (public.ft5 t2)
|
||||
Remote SQL: SELECT r1.c1, r2.c1 FROM ("S 1"."T 3" r1 LEFT JOIN "S 1"."T 4" r2 ON (((r1.c1 = r2.c1)))) ORDER BY r1.c1 ASC NULLS LAST, r2.c1 ASC NULLS LAST
|
||||
(6 rows)
|
||||
|
||||
EXECUTE join_stmt;
|
||||
c1 | c1
|
||||
|
|
@ -1723,18 +1727,15 @@ CREATE USER MAPPING FOR PUBLIC SERVER loopback;
|
|||
-- joining sides, join pushed down, no result expected.
|
||||
PREPARE join_stmt AS SELECT t1.c1, t2.c1 FROM ft5 t1 JOIN v_ft5 t2 ON (t1.c1 = t2.c1) ORDER BY t1.c1, t2.c1 OFFSET 100 LIMIT 10;
|
||||
EXPLAIN (COSTS false, VERBOSE) EXECUTE join_stmt;
|
||||
QUERY PLAN
|
||||
---------------------------------------------------------------------------------------------------------------------------------
|
||||
QUERY PLAN
|
||||
---------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
Limit
|
||||
Output: t1.c1, ft5.c1
|
||||
-> Sort
|
||||
-> Foreign Scan
|
||||
Output: t1.c1, ft5.c1
|
||||
Sort Key: t1.c1
|
||||
-> Foreign Scan
|
||||
Output: t1.c1, ft5.c1
|
||||
Relations: (public.ft5 t1) INNER JOIN (public.ft5)
|
||||
Remote SQL: SELECT r1.c1, r6.c1 FROM ("S 1"."T 4" r1 INNER JOIN "S 1"."T 4" r6 ON (TRUE)) WHERE ((r1.c1 = r6.c1))
|
||||
(9 rows)
|
||||
Relations: (public.ft5 t1) INNER JOIN (public.ft5)
|
||||
Remote SQL: SELECT r1.c1, r6.c1 FROM ("S 1"."T 4" r1 INNER JOIN "S 1"."T 4" r6 ON (TRUE)) WHERE ((r1.c1 = r6.c1)) ORDER BY r1.c1 ASC NULLS LAST
|
||||
(6 rows)
|
||||
|
||||
EXECUTE join_stmt;
|
||||
c1 | c1
|
||||
|
|
|
|||
|
|
@ -283,9 +283,6 @@ static void postgresGetForeignJoinPaths(PlannerInfo *root,
|
|||
JoinPathExtraData *extra);
|
||||
static bool postgresRecheckForeignScan(ForeignScanState *node,
|
||||
TupleTableSlot *slot);
|
||||
static List *get_useful_pathkeys_for_relation(PlannerInfo *root,
|
||||
RelOptInfo *rel);
|
||||
static List *get_useful_ecs_for_relation(PlannerInfo *root, RelOptInfo *rel);
|
||||
|
||||
/*
|
||||
* Helper functions
|
||||
|
|
@ -331,6 +328,11 @@ static void conversion_error_callback(void *arg);
|
|||
static bool foreign_join_ok(PlannerInfo *root, RelOptInfo *joinrel,
|
||||
JoinType jointype, RelOptInfo *outerrel, RelOptInfo *innerrel,
|
||||
JoinPathExtraData *extra);
|
||||
static List *get_useful_pathkeys_for_relation(PlannerInfo *root,
|
||||
RelOptInfo *rel);
|
||||
static List *get_useful_ecs_for_relation(PlannerInfo *root, RelOptInfo *rel);
|
||||
static void add_paths_with_pathkeys_for_rel(PlannerInfo *root, RelOptInfo *rel,
|
||||
Path *epq_path);
|
||||
|
||||
|
||||
/*
|
||||
|
|
@ -502,6 +504,14 @@ postgresGetForeignRelSize(PlannerInfo *root,
|
|||
|
||||
cost_qual_eval(&fpinfo->local_conds_cost, fpinfo->local_conds, root);
|
||||
|
||||
/*
|
||||
* Set cached relation costs to some negative value, so that we can detect
|
||||
* when they are set to some sensible costs during one (usually the first)
|
||||
* of the calls to estimate_path_cost_size().
|
||||
*/
|
||||
fpinfo->rel_startup_cost = -1;
|
||||
fpinfo->rel_total_cost = -1;
|
||||
|
||||
/*
|
||||
* If the table or the server is configured to use remote estimates,
|
||||
* connect to the foreign server and execute EXPLAIN to estimate the
|
||||
|
|
@ -774,7 +784,6 @@ postgresGetForeignPaths(PlannerInfo *root,
|
|||
ForeignPath *path;
|
||||
List *ppi_list;
|
||||
ListCell *lc;
|
||||
List *useful_pathkeys_list = NIL; /* List of all pathkeys */
|
||||
|
||||
/*
|
||||
* Create simplest ForeignScan path node and add it to baserel. This path
|
||||
|
|
@ -793,30 +802,8 @@ postgresGetForeignPaths(PlannerInfo *root,
|
|||
NIL); /* no fdw_private list */
|
||||
add_path(baserel, (Path *) path);
|
||||
|
||||
useful_pathkeys_list = get_useful_pathkeys_for_relation(root, baserel);
|
||||
|
||||
/* Create one path for each set of pathkeys we found above. */
|
||||
foreach(lc, useful_pathkeys_list)
|
||||
{
|
||||
double rows;
|
||||
int width;
|
||||
Cost startup_cost;
|
||||
Cost total_cost;
|
||||
List *useful_pathkeys = lfirst(lc);
|
||||
|
||||
estimate_path_cost_size(root, baserel, NIL, useful_pathkeys,
|
||||
&rows, &width, &startup_cost, &total_cost);
|
||||
|
||||
add_path(baserel, (Path *)
|
||||
create_foreignscan_path(root, baserel,
|
||||
rows,
|
||||
startup_cost,
|
||||
total_cost,
|
||||
useful_pathkeys,
|
||||
NULL,
|
||||
NULL,
|
||||
NIL));
|
||||
}
|
||||
/* Add paths with pathkeys */
|
||||
add_paths_with_pathkeys_for_rel(root, baserel, NULL);
|
||||
|
||||
/*
|
||||
* If we're not using remote estimates, stop here. We have no way to
|
||||
|
|
@ -2182,7 +2169,18 @@ estimate_path_cost_size(PlannerInfo *root,
|
|||
/* Back into an estimate of the number of retrieved rows. */
|
||||
retrieved_rows = clamp_row_est(rows / fpinfo->local_conds_sel);
|
||||
|
||||
if (foreignrel->reloptkind != RELOPT_JOINREL)
|
||||
/*
|
||||
* We will come here again and again with different set of pathkeys
|
||||
* that caller wants to cost. We don't need to calculate the cost of
|
||||
* bare scan each time. Instead, use the costs if we have cached them
|
||||
* already.
|
||||
*/
|
||||
if (fpinfo->rel_startup_cost > 0 && fpinfo->rel_total_cost > 0)
|
||||
{
|
||||
startup_cost = fpinfo->rel_startup_cost;
|
||||
run_cost = fpinfo->rel_total_cost - fpinfo->rel_startup_cost;
|
||||
}
|
||||
else if (foreignrel->reloptkind != RELOPT_JOINREL)
|
||||
{
|
||||
/* Clamp retrieved rows estimates to at most foreignrel->tuples. */
|
||||
retrieved_rows = Min(retrieved_rows, foreignrel->tuples);
|
||||
|
|
@ -2284,13 +2282,19 @@ estimate_path_cost_size(PlannerInfo *root,
|
|||
}
|
||||
|
||||
/*
|
||||
* Cache the costs prior to adding the costs for transferring data from
|
||||
* the foreign server. These costs are useful for costing the join between
|
||||
* this relation and another foreign relation, when the cost of join can
|
||||
* not be obtained from the foreign server.
|
||||
* Cache the costs for scans without any pathkeys or parameterization
|
||||
* before adding the costs for transferring data from the foreign server.
|
||||
* These costs are useful for costing the join between this relation and
|
||||
* another foreign relation or to calculate the costs of paths with
|
||||
* pathkeys for this relation, when the costs can not be obtained from the
|
||||
* foreign server. This function will be called at least once for every
|
||||
* foreign relation without pathkeys and parameterization.
|
||||
*/
|
||||
fpinfo->rel_startup_cost = startup_cost;
|
||||
fpinfo->rel_total_cost = total_cost;
|
||||
if (pathkeys == NIL && param_join_conds == NIL)
|
||||
{
|
||||
fpinfo->rel_startup_cost = startup_cost;
|
||||
fpinfo->rel_total_cost = total_cost;
|
||||
}
|
||||
|
||||
/*
|
||||
* Add some additional cost factors to account for connection overhead
|
||||
|
|
@ -3458,6 +3462,14 @@ foreign_join_ok(PlannerInfo *root, RelOptInfo *joinrel, JoinType jointype,
|
|||
fpinfo->fdw_startup_cost = fpinfo_o->fdw_startup_cost;
|
||||
fpinfo->fdw_tuple_cost = fpinfo_o->fdw_tuple_cost;
|
||||
|
||||
/*
|
||||
* Set cached relation costs to some negative value, so that we can detect
|
||||
* when they are set to some sensible costs, during one (usually the
|
||||
* first) of the calls to estimate_path_cost_size().
|
||||
*/
|
||||
fpinfo->rel_startup_cost = -1;
|
||||
fpinfo->rel_total_cost = -1;
|
||||
|
||||
/* Mark that this join can be pushed down safely */
|
||||
fpinfo->pushdown_safe = true;
|
||||
|
||||
|
|
@ -3532,6 +3544,39 @@ foreign_join_ok(PlannerInfo *root, RelOptInfo *joinrel, JoinType jointype,
|
|||
return true;
|
||||
}
|
||||
|
||||
static void
|
||||
add_paths_with_pathkeys_for_rel(PlannerInfo *root, RelOptInfo *rel,
|
||||
Path *epq_path)
|
||||
{
|
||||
List *useful_pathkeys_list = NIL; /* List of all pathkeys */
|
||||
ListCell *lc;
|
||||
|
||||
useful_pathkeys_list = get_useful_pathkeys_for_relation(root, rel);
|
||||
|
||||
/* Create one path for each set of pathkeys we found above. */
|
||||
foreach(lc, useful_pathkeys_list)
|
||||
{
|
||||
double rows;
|
||||
int width;
|
||||
Cost startup_cost;
|
||||
Cost total_cost;
|
||||
List *useful_pathkeys = lfirst(lc);
|
||||
|
||||
estimate_path_cost_size(root, rel, NIL, useful_pathkeys,
|
||||
&rows, &width, &startup_cost, &total_cost);
|
||||
|
||||
add_path(rel, (Path *)
|
||||
create_foreignscan_path(root, rel,
|
||||
rows,
|
||||
startup_cost,
|
||||
total_cost,
|
||||
useful_pathkeys,
|
||||
NULL,
|
||||
epq_path,
|
||||
NIL));
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* postgresGetForeignJoinPaths
|
||||
* Add possible ForeignPath to joinrel, if join is safe to push down.
|
||||
|
|
@ -3670,7 +3715,8 @@ postgresGetForeignJoinPaths(PlannerInfo *root,
|
|||
/* Add generated path into joinrel by add_path(). */
|
||||
add_path(joinrel, (Path *) joinpath);
|
||||
|
||||
/* XXX Consider pathkeys for the join relation */
|
||||
/* Consider pathkeys for the join relation */
|
||||
add_paths_with_pathkeys_for_rel(root, joinrel, epq_path);
|
||||
|
||||
/* XXX Consider parameterized paths for the join relation */
|
||||
}
|
||||
|
|
@ -3877,7 +3923,7 @@ find_em_expr_for_rel(EquivalenceClass *ec, RelOptInfo *rel)
|
|||
{
|
||||
EquivalenceMember *em = lfirst(lc_em);
|
||||
|
||||
if (bms_equal(em->em_relids, rel->relids))
|
||||
if (bms_is_subset(em->em_relids, rel->relids))
|
||||
{
|
||||
/*
|
||||
* If there is more than one equivalence member whose Vars are
|
||||
|
|
|
|||
|
|
@ -237,6 +237,11 @@ SELECT t1.c1, t2."C 1" FROM ft2 t1 JOIN "S 1"."T 1" t2 ON (t1.c1 = t2."C 1") OFF
|
|||
EXPLAIN (VERBOSE, COSTS false)
|
||||
SELECT t1.c1, t2."C 1" FROM ft2 t1 LEFT JOIN "S 1"."T 1" t2 ON (t1.c1 = t2."C 1") OFFSET 100 LIMIT 10;
|
||||
SELECT t1.c1, t2."C 1" FROM ft2 t1 LEFT JOIN "S 1"."T 1" t2 ON (t1.c1 = t2."C 1") OFFSET 100 LIMIT 10;
|
||||
-- A join between local table and foreign join. ORDER BY clause is added to the
|
||||
-- foreign join so that the local table can be joined using merge join strategy.
|
||||
EXPLAIN (COSTS false, VERBOSE)
|
||||
SELECT t1."C 1" FROM "S 1"."T 1" t1 left join ft1 t2 join ft2 t3 on (t2.c1 = t3.c1) on (t3.c1 = t1."C 1") OFFSET 100 LIMIT 10;
|
||||
SELECT t1."C 1" FROM "S 1"."T 1" t1 left join ft1 t2 join ft2 t3 on (t2.c1 = t3.c1) on (t3.c1 = t1."C 1") OFFSET 100 LIMIT 10;
|
||||
RESET enable_hashjoin;
|
||||
RESET enable_nestloop;
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue