Postgres left joining 3 tables with a condition - postgresql

Question

I have a query like this:
SELECT x.id
FROM x
LEFT JOIN (
SELECT a.id FROM a
WHERE [condition1] [condition2]
) AS A USING (id)
LEFT JOIN (
SELECT b.id FROM b
WHERE [condition1] [condition3]
) AS B USING (id)
LEFT JOIN (
SELECT c.id FROM c
WHERE [condition1] [condition4]
) AS C USING (id)
WHERE [condition1]
As you can see the [condition1] is common for subqueries and the outer query.
When [in general] might it be worth to remove [condition1] from subqueries (as the result is same) for performance reasons? Please don't give answers like "run it and see". There are lots of data and its changing so we need good worst case behaviour.
I have tried to do some tests but they are far from being conclusive. Will Postgres figure out that the condition applied to subqueries as well and propagate it?
Examples for condition1:
WHERE a.id NOT IN (SELECT id FROM {ft_geom_in}) (this is slow, I know, this is just for example)
WHERE a.id > x

Answer 1

It is difficult to give a clear general answer, since much depends on the actual data model (especially indexes) and queries (conditions).
However, in many cases it makes sense to place condition1 in joined subqueries.
This applies particularly when condition2 excludes much less rows than condition1.
In such cases, the filter on condition1 may significantly reduce the number of checks of condition2.
On the other hand, it seems unlikely that the presence of condition1 in subqueries could substantially slow down the query.
Simple tests do not give general answers, but might serve as an illustration.
create table x (id integer, something text);
create table a (id integer, something text);
insert into x select i, i::text from generate_series (1, 1000000) i;
insert into a select i, i::text from generate_series (1, 1000000) i;
Query A: condition2 excludes few rows.
A1: with condition1
explain analyse
select x.id
from x
left join (
select id from a
where id < 500000 and length(something) > 1
) as a using (id)
where id < 500000;
Average execution time: ~620.000 ms
A2: without condition1
explain analyse
select x.id
from x
left join (
select id from a
where length(something) > 1
) as a using (id)
where id < 500000;
Average execution time: ~810.000 ms
Query B: condition2 excludes many rows.
B1: with condition1
explain analyse
select x.id
from x
left join (
select id from a
where id < 500000 and length(something) = 1
) as a using (id)
where id < 500000;
Average execution time: ~220.000 ms
B2: without condition1
explain analyse
select x.id
from x
left join (
select id from a
where length(something) = 1
) as a using (id)
where id < 500000;
Average execution time: ~230.000 ms
Note, that the queries do not need to have subqueries. Queries with simple left joins and conditions in a common where clause should be a little bit faster. For example, this is the equivalent of query B1:
explain analyse
select x.id
from x
left join a using(id)
where x.id < 500000
and a.id < 500000
and length(a.something) = 1
Average execution time: ~210.000 ms