J'ai une héritée de Heckuva à déterminer comment traduire une simple jointure extérieure SQL gauche avec deux conditions où la clause dans une requête de Linq-to-entités. Il n'y a que deux tables. J'ai besoin de valeurs pour toutes les lignes de TABLE1, quelles que soient les matchs dans le tableau2, mais la clause où la clause utilise des champs du tableau2. Dans SQL, les deux paramètres seraient Table2Wherecolumn1 et Table2Wherecolumn2, et la requête (qui fonctionne) ressemble à ceci: J'ai essayé d'utiliser groupe de groupe code> avec code> avec Defaulfempty () Code>, ainsi qu'une jointure implicite (sans le mot de jointure code> code> ne reçoit que des lignes pour des éléments qui ont des valeurs dans le tableau2. Je suis sûr que cela ne vous aidera pas, mais voici un exemple de Linq que j'essayais que cela ne fonctionne pas: P> Public Shared Function GetProfilePreferencesForCedent(ByVal dc As EntityContext, _
ByVal where1 As Int32, _
ByVal where2 As Int32) _
As IQueryable(Of ProjectedEntity)
Return From t1 In dc.Table1
Group Join t2 In dc.Table2 _
On t1.Table1Id Equals t2.Table1Id _
Into t2g1 = Group _
From t2gx In t2g1.DefaultIfEmpty(Nothing)
Where (t2gx.Table2Where1 = where1 Or t2gx.Table2Where1 = Nothing) _
And (t2gx.Table2Where2 = where2 Or t2gx.Table2Where2 = Nothing)
Order By t1.SortOrder
Select New ProjectedEntity With {
.Table1Id = t1.Table1Id, _
.FieldDescription = t1.FieldDescription, _
.FieldValue = If(t2gx Is Nothing, String.Empty, t2gx.FieldValue) _
}
End Function
3 Réponses :
Passez à ces questions et dites-moi s'ils travaillent pour vous. Je n'ai pas mis en place les données à tester, mais elles devraient aller bien.
Veuillez excuser mon mélange de c # & vb.net. J'avais l'habitude d'être un développeur VB.NET, mais au cours des deux dernières années, j'ai surtout travaillé dans C #, alors je me sens maintenant plus à l'aise là-bas. P>
Voici les classes que j'ai créées pour Tableau1 Code> & Table2 CODE>: P> Dim query = _
From t1 In Table1 _
Group Join t2 In Table2 On t1.Table1Id Equals t2.Table1Id Into _Table2 = Group _
From _t2 In _Table2.DefaultIfEmpty() _
Where If(_t2 Is Nothing, True, _t2.Table2WhereColumn1 = someId AndAlso _
_t2.Table2WhereColumn2 = someOtherId) _
Order By t1.OrderByColumn _
Select New With { _
.Table1Id = t1.Table1Id, _
.FieldDescription = t1.FieldDescription, _
.FieldValue = If(_t2 Is Nothing, "", _t2.FieldValue) _
}
Exceptionnel! Fonctionne comme un charme. Je ne suis pas sûr de comprendre comment fonctionne la clause de la clause, mais cela fonctionne.
Personnellement s'il existe des conditions pour le côté droit d'une jointure gauche, je préfère généralement les mettre dans les critères de jointure
dans ce cas, le SQL ressemblerait à: P>
var query =
from t1 in Table1
join t2 in Table2 on new{a = t1.Table1Id, b = someId, c = someotherId}
equals new {a = t2.Table1Id b = t2.Table2WhereColumn1, c = Table2WhereColumn2}
into _Table2
from _t2 in _Table2.DefaultIfEmpty()
orderby t1.OrderByColumn
select new
{
t1.Table1Id,
t1.FieldDescription,
FieldValue = _t2 == null ? "" : _t2.FieldValue,
};
+1 Ceci est la façon dont j'aime générer une table droite Linq où les conditions d'une joigniste extérieure gauche, car je pense que cela se lit plus similaire à la syntaxe SQL, je suis habitué à.
Vraiment belle syntaxe. Je dois d'accord sur la sensation plus sql.
Comment pouvez-vous faire ce qui précède mais avec un ou des conditions dans la jointure?
Je ne prendrai pas de crédit pour cette réponse, mais c'est magnifique: Linq à SQL - GAUD OUTER rejoindre avec plusieurs conditions de jointure
essentiellement, utilisez la méthode de l'extension où la clause sur la sous-requête, mais vous devez l'utiliser avant defaulifempty () : < / p>
Simple et élégant, parfait.