Es gibt noch einen weiteren gravierenden Vorteil:

Code:
select x.f1, x.f2
       ,c.*
   from x
 cross Join lateral (Select 
                      Count(*) Count1
                     From x 
                    where a.F1 = x.F1   
                   ) c
Wie man hier sieht, bezieht sich die Where-Klausel auf den vorgelagerten From.

Bei dem inneren Group-By-Join kann man sich nicht auf den äußeren From beziehen.
Man kann den Bezug nur in der on-Klausel herstellen.

Code:
select x.f1, x.f2
       ,c.*
   from x
 left Join (Select f1, Count(*) Count1
             From x 
            group by f1
           ) a on a.F1 = x.F1

Benötigt man nun noch eine zusätzliche Where-Klausel, steht man vor Index-Probleme:

Code:
select x.f1, x.f2
       ,a.Count1
   from x
 left Join (Select f1, Count(*) Count1
             From x 
            where status = 1
            group by f1
           ) a on a.F1 = x.F1
Die Where-Klausel kann sich nicht auf die Gruppenfelder beziehen, da sie sonst für andere Gruppen zu einschränkend wird.
Man benötigt nun 2 Indizes, 1 x für den Status, 1 x für den Group By F1. Wobei noch nicht mal sicher ist, dass auch beide genommen werden.

Ganz anders bei left join lateral (ggf. left, wenn NULL erwartbar ist):

Code:
select x.f1, x.f2
       ,c.*
   from x
 left Join lateral (Select Count(*) Count1
                     From x 
                     where x.status = 1
                       and a.F1 = x.F1
                   ) a on 1=1
Hier kann ein Index über F1+Status direkt verwendet werden ohne über 2 Indizies mit Bitmaps zu kombinieren.
Der "on 1=1" wird da dann sogar wegoptimiert, da kein Tablezugriff erforderlich ist.
Bei komplexere Where-Klauseln ist das dann schon mal sehr hilfreich, performante SQL's zu stricken.
Gravierend vor allem, wenn unterschiedliche Tabellen erforderlich sind.

Bespiel Kursfindung:
Code:
select x.f1, x.f2, x.W1
       ,c.*
   from x
 left Join lateral 
      (Select Kurs, x.w1 * kurs as w1Betrag
        From Kurstabelle k
      where k.waehrung = x.waehrung 
         and k.datum >= x.Datum
        order by k.waehrung, k.datum
         limit 1
     ) c
Wer kennt nicht die CTE-Konstrukte, mit denen man sich via min(datum) group by Key und anschließendem inner join auf das ermittelte Datum auf die Zeile zu kommen.

Vieles ist mit lateral join möglich, wo man sich früher die Gedanken verdrehen musste oder es gar nicht funktioniert hat.