LINQ to SQL unirsi genera SQL che unisce il IS NULL

Question

Io non sono bravo a espressione LINQ, oggi io sono in esecuzione in un problema strano come il seguito di interno join,

var orders = (from q in dao.CurrentDBContext.New_OrderForm 
       join d in dao.CurrentDBContext.New_OrderGoodsDetail on q.billNum equals d.billNum 
       select new 
      {  
       q.billNum, 
       q.orderSource, 
       q.sourceOddNum  
       d.PPT  
      } 

Mentre ho tracciato il LINQ affermazione, mi sono confuso di quella Entity Framework convertirà la dichiarazione LINQ to SQL lo statment sotto

SELECT 
[Extent1].[billNum] AS [billNum], 
[Extent1].[orderSource] AS [orderSource], 
[Extent1].[sourceOddNum] AS [sourceOddNum], 
[Extent2].[PPT] AS [PPT] 
FROM [dbo].[New_OrderForm] AS [Extent1] 
INNER JOIN [dbo].[New_OrderGoodsDetail] AS [Extent2] 
      ON ([Extent1].[billNum] = [Extent2].[billNum]) OR 
       (([Extent1].[billNum] IS NULL) AND ([Extent2].[billNum] IS NULL)) 

sapete perché il segmento di SQL di seguito ha allegato automaticamente?

OR (([Extent1]. [BillNum] IS NULL) E ([Extent2]. [BillNum] IS NULL) "

non mi aspetto che quanto sopra aggiungerà automaticamente, dal momento che ha fatto .? rallentare le prestazioni di SQL Eventuali suggerimenti

Answer 1

Ecco cosa si può fare nel caso in cui non è possibile modificare le colonne billNum essere non annullabile.

In primo luogo, impostare l'opzione di cui parla @Giorgi

class CurrentDBContext 
{ 
    public CurrentDBContext() 
    { 
     Configuration.UseDatabaseNullSemantics = true; 
     // ... 
    } 
} 

quindi modificare la query LINQ to non utilizzarejoin, ma semplice where come questo

var orders = (from q in dao.CurrentDBContext.New_OrderForm 
       from d in dao.CurrentDBContext.New_OrderGoodsDetail 
       where q.billNum == d.billNum 
       select ... 

Il risultato sarà l'esatto Query SQL come quella che hai mostrato (conJOIN!) Senza la parte OR.

Answer 2

sulla scia @ risposta di Giorgi, la bandiera UseDatabaseNullSemantics non funziona con la parola chiave equals -. solo il == operando Così, al fine di ovviare a questo e garantire il join sul billNum non è parte della clausola OR questo approccio dovrebbe funzionare (in combinazione con il flag UseDatabaseNullSemantics):

var orders = (from q in dao.CurrentDBContext.New_OrderForm 
      from d in dao.CurrentDBContext.New_OrderGoodsDetail 
      where q.billNum == d.billNum 
      select new 
     {  
      q.billNum, 
      q.orderSource, 
      q.sourceOddNum  
      d.PPT  
     } 

Questo genererà la JOIN senza il OR.

Answer 3

Sembra che Linq traduca q.billNum equals d.billNum sia tale che include anche una corrispondenza valida nel caso in cui sia q.billNum che d.billNum siano NULL (in SQL NULL non è mai uguale a NULL, quindi l'OR nella query) .

Rendere entrambi i campi non annullabili sarebbe la soluzione migliore, a condizione che entrambi i campi non possano mai essere NULL.

In caso contrario, è possibile anche provare ad aggiungere una clausola where nella dichiarazione Linq per specificare che sia q.billNum che d.billNum non possono essere NULL. Con un po 'di fortuna, Linq riconoscerà che i valori nullable non sono possibili.

Nota: se si sta lavorando con Oracle, è necessario verificare le stringhe vuote e NULL (la stringa vuota è equivalente a NULL). Le stringhe vuote dovrebbero essere valide come valore valido in SQL Server.

Poiché quanto sopra non ha aiutato, è possibile provare a scrivere la query da soli. Se non sto sbagliare sarebbe qualcosa lungo le seguenti linee (supponendo var è un List<Order> nel codice di esempio - i risultati della query devono corrispondere alla classe che si sta utilizzando):

StringBuilder query = new StringBuilder(); 
query.AppendLine("SELECT [Extent1].[billNum] AS [billNum],"); 
query.AppendLine("  [Extent1].[orderSource] AS [orderSource],"); 
query.AppendLine("  [Extent1].[sourceOddNum] AS [sourceOddNum],"); 
query.AppendLine("  [Extent2].[PPT] AS [PPT]"); 
query.AppendLine("FROM [dbo].[New_OrderForm] AS [Extent1]"); 
query.AppendLine("INNER JOIN [dbo].[New_OrderGoodsDetail] AS [Extent2] ON [Extent1].[billNum] = [Extent2].[billNum]"); 

List<Order> orders = DbContext.Database.SqlQuery<Order>(query.ToString()).ToList(); 

ho usato simili soluzioni alternative per aggirare i problemi di prestazioni in passato.

Answer 4

Se si utilizza EF6 provare a impostare

context.Configuration.UseDatabaseNullSemantics = true; 

e non genererà controlli NULL per le colonne.

According to documentation

Ad esempio (operando1 == operando2) viene tradotto come: (operando1 = operando2) se UseDatabaseNullSemantics è vero, rispettivamente (((operando1 = operando2) AND (NOT (operand1 è nullo o operand2 IS NULL))) OR ((operando 1 È NULL) E (operando 2 È NULL))) se UseDatabaseNullSemantics è falso.