LINQ Left Join with Grouping and Convert this TSQL

Question

Следующий TSQL представляет собой пример того, как я могу решить эту проблему с SQL. Цель состоит в том, чтобы вернуть 1 строку на OID из левой таблицы, где количество записей в левой таблице равно количеству совпадающих строк в правой таблице.

SELECT cs.OID, Count(cs.OID) AS CarCount, Sum(RS.Check) AS RoadCount 
    FROM Cars AS cs 
LEFT JOIN Roads AS RS 
    ON CS.oid = RS.OID 
    AND cs.RID = RS.RID 
    GROUP BY cs.OID 
    HAVING Count(cs.OID) = Sum(RS.Check) 

Использование настройки объекта ниже, есть эквивалент LINQ запрос, который может быть построен, или это не возможно? Обратите внимание на значение по умолчанию, указанное для проверки в объявлении класса Road. В приведенном ниже примере установки результат должен быть равен нулю. Добавление еще одного дорожного пути с соответствующими значениями приведет к возврату только одного. По крайней мере, это то, что идеально.

Проблема, с которой я столкнулся, заключается в том, что, похоже, этот тип TSQL-кода слишком сложный для LINQ. Я не нашел очевидного или неочевидного решения для достижения аналогичного поведения. Таким образом, я считаю, возможно, решение состоит в том, чтобы перестать пытаться копировать SQL и делать что-то другое. Не имея опыта LINQ, я не знаю, с чего начать.

public class Roads : List<Road>{} 
public class Road 
{ 
    public int RID; 
    public int OID; 
    public int check = 1; 
} 
public class Cars : List<Car> { } 
public class Car 
{ 
    public int RID; 
    public int OID; 
} 

private void CheckCheck() 
{ 
    Roads rs = new Roads(); 
    Cars cs = new Cars(); 

    Car c = new Car(); 
    c.OID = 1; 
    c.RID = 1; 
    cs.Add(c); 
    c = new Car(); 
    c.OID = 1; 
    c.RID = 2; 
    cs.Add(c); 
    c = new Car(); 
    c.OID = 1; 
    c.RID = 3; 
    cs.Add(c); 

    Road r = new Road(); 
    r.OID = 1; 
    r.RID = 1; 
    rs.Add(r); 
    r = new Road(); 
    r.OID = 1; 
    r.RID = 2; 
    rs.Add(r); 

    // Results should be : 
    // OID where Count of OID from C = Count of OID from R 
} 

Answer 1

• Ваше HAVING положение будет отфильтровывать любые автомобили, которые не соответствуют дороги. Это делает левое соединение во внутреннем соединении.
• У вас есть COUNT(cs.OID), который говорит, что он подсчитывает автомобили, но это не так. Вы могли бы иметь в виду COUNT(DISTINCT cs.OID)

Вот дословный перевод:

from c in Cars 
join r in Roads on new {c.OID, c.RID} equals new {r.OID, r.RID} 
group new {Car = c, Road = r} by c.OID into g 
let carCount = g.Count() //did you mean g.Select(x => x.Car.OID).Distinct().Count() 
let roadCount = g.Sum(x => x.Road.Check) 
where carCount = roadCount 
select new {OID = g.Key, CarCount = carCount, RoadCount = roadCount} 

---

Цель состоит в том, чтобы вернуть 1 строку на OID из левой таблицы, где граф записей в левая таблица равна количеству совпадающих строк в правой таблице.

Исходя из этого описания, я бы написать:

var carLookup = Cars.ToLookup(c => c.OID); 
var roadLookup = Roads.ToLookup(r => r.OID); 

from x in carLookup 
let carCount = x.Count() 
let roadCount = roadLookup[x.Key].Count() 
where carCount = roadCount 
select new {OID = g.Key, CarCount = carCount, RoadCount = roadCount} 

Answer 2

Я не уверен, я полностью понимаю, что желаемые результаты, но вот мой выстрел на него. Поле check не обязательно необходимо для LINQ, поскольку оно не служит никакой цели, кроме как для подсчета.

Я неправильно понял важность соединения и что сделало предложение HAVING для запроса. Теперь он возвращается к исходной версии TSQL, но с измененным вычислением RoadCount. Я верю, что это то, о чем вы просили.

var results = from Car in cs 
       join road in rs 
        on new { Car.OID, Car.RID } equals new { road.OID, road.RID } 
        into Roads 
       group roads by Car.OID into cars 
       let CarCount = cars.Count() 
       let RoadCount = cars.Sum(roads => roads.Count()) 
       where CarCount == RoadCount 
       select new 
       { 
        OID = cars.Key, 
        CarCount, 
        RoadCount 
       };