Npgsql中的重复联接具有相同的导航属性

Question

This question already exists here , but for Entity Framework to TSQL

When using the same navigation property multiple times on a select, Npgsql query results in multiple joins, one for every use of the navigation property. This result in an awful performance hit (tested)

I've read that this is a problem with EF 4, but this problem also occurs on EF 6.

I think that this is an issue with the Npgsql LINQ to SQL translator

This is the code that Npgsql generate for the same navigation property used mutliple times, obviously, only one join is needed (copied from the other questions because is exactly the same case)

LEFT OUTER JOIN [dbo].[Versions] AS [Extent4] ON [Extent1].[IDVersionReported] = [Extent4].[ID]
LEFT OUTER JOIN [dbo].[Versions] AS [Extent5] ON [Extent1].[IDVersionReported] = [Extent5].[ID]
LEFT OUTER JOIN [dbo].[Versions] AS [Extent6] ON [Extent1].[IDVersionReported] = [Extent6].[ID]
LEFT OUTER JOIN [dbo].[Versions] AS [Extent7] ON [Extent1].[IDVersionReported] = [Extent7].[ID]

Is it posible to tune PostgreSql to optimize repeated joins?

If not, which option is the best for solving this problem?

• Wait until Npgsql gets fixed
• Download Npgsql code and find the way to fix it
• Intercept generated SQL before reaching the database, parse it, and remove duplicated joins. (Read here )
• Do not use navigation properties, use LINQ joins instead

Answer 1

Indeed, this is a problem of Entity Framework, but I found a workaround, hope that this helps someone.

This was the original where part of the LINQ query:

 from cr in Creditos
 where cr.validado == 1 &&
 cr.fecharegistro >= Desde &&
 cr.fecharegistro <= Hasta &&
 !ProductosExcluidos.Contains(cr.idproducto.Value) &&
 cr.amortizaciones.Sum(am => am.importecapital - am.pagoscap - am.capcancel) > 1

 //All references to the navigation property cr.numcliente
 //results on a separated LEFT OUTTER JOIN between this the 'creditos' and 'clientes' tables
 select new ArchivoCliente
 {
    RFC = cr.numcliente.rfc,
    Nombres = cr.numcliente.nombres,
    ApellidoPaterno = cr.numcliente.apellidopaterno,
    ApellidoMaterno = cr.numcliente.apellidomaterno,
 }

Note the last condition of the where, that condition does a sum of all child entities of cr , if we take out that last condition, all the duplicated LEFT OUTTER JOIN are replaced by one single JOIN , for some reason, Entity Framework doesn't like subqueries or aggregates on the where part of the query

If instead we replace the original query with this other equivalent query only a single LEFT OUTTER JOIN is generated.

 (from cr in Creditos
 where cr.validado == 1 &&
 cr.fecharegistro >= Desde &&
 cr.fecharegistro <= Hasta &&
 !ProductosExcluidos.Contains(cr.idproducto.Value) &&
 //Excluded aggregate function condition from the first where
 //the value is now on the select and used for posterior filtering

 select new ArchivoCliente
 {
    RFC = cr.numcliente.rfc,
    Nombres = cr.numcliente.nombres,
    ApellidoPaterno = cr.numcliente.apellidopaterno,
    ApellidoMaterno = cr.numcliente.apellidomaterno,
    SumaAmort = cr.amortizaciones.Sum(am => am.importecapital - am.pagoscap - am.capcancel)
 }).Where (x => x.SumaAmort > 1);

Now instead of directly filtering on the first where statement, the aggregate result is stored as part of the projection, and then, a second where is applied to the resulting query.

This results in a much faster query, with only the necessary joins on the translated SQL statement.