LINQ의 관계 구분?

Question

관계 부분은 Codd의 프리미티브 관계 연산자 중 하나이며, 모든 부분을 제공하는 공급자로 구어체로 알려져 있습니다. 예를 들어 SQL에 다양한 번역이있었습니다. Celko는 the pilots who can fly all the planes in the hangar의 예를 사용하여 몇 가지 접근법에 대해 설명합니다.

내가 선호하는 것은 "나머지와 함께"(즉, 윌슨도 F-17 전투기를 비행 할 수 있지만 격납고에는 하나도 없기 때문입니다.)

WITH PilotSkills 
    AS 
    (
     SELECT * 
     FROM (
       VALUES ('Celko', 'Piper Cub'), 
        ('Higgins', 'B-52 Bomber'), ('Higgins', 'F-14 Fighter'), 
        ('Higgins', 'Piper Cub'), 
        ('Jones', 'B-52 Bomber'), ('Jones', 'F-14 Fighter'), 
        ('Smith', 'B-1 Bomber'), ('Smith', 'B-52 Bomber'), 
        ('Smith', 'F-14 Fighter'), 
        ('Wilson', 'B-1 Bomber'), ('Wilson', 'B-52 Bomber'), 
        ('Wilson', 'F-14 Fighter'), ('Wilson', 'F-17 Fighter') 
      ) AS T (pilot_name, plane_name) 
    ), 
    Hangar 
    AS 
    (
     SELECT * 
     FROM (
       VALUES ('B-1 Bomber'), 
        ('B-52 Bomber'), 
        ('F-14 Fighter') 
      ) AS T (plane_name) 
    ) 
SELECT DISTINCT pilot_name 
    FROM PilotSkills AS P1 
WHERE NOT EXISTS (
        SELECT plane_name 
        FROM Hangar 
        EXCEPT 
        SELECT plane_name 
        FROM PilotSkills AS P2 
        WHERE P1.pilot_name = P2.pilot_name 
       ); 

가 지금은 객체에 LINQ에서이 작업을 수행 할 필요가 : 제수가 빈 세트 (격납고가 비어 즉 때 모든 조종사가 반환)입니다. 제안 된 직접 번역본은 다음과 같습니다.

var hangar = new [] 
{ 
    new { PlaneName = "B-1 Bomber" }, 
    new { PlaneName = "F-14 Fighter" }, 
    new { PlaneName = "B-52 Bomber" } 
}.AsEnumerable(); 

var pilotSkills = new [] 
{ 
    new { PilotName = "Celko", PlaneName = "Piper Cub" }, 
    new { PilotName = "Higgins", PlaneName = "B-52 Bomber" }, 
    new { PilotName = "Higgins", PlaneName = "F-14 Fighter" }, 
    new { PilotName = "Higgins", PlaneName = "Piper Cub" }, 
    new { PilotName = "Jones", PlaneName = "B-52 Bomber" }, 
    new { PilotName = "Jones", PlaneName = "F-14 Fighter" }, 
    new { PilotName = "Smith", PlaneName = "B-1 Bomber" }, 
    new { PilotName = "Smith", PlaneName = "B-52 Bomber" }, 
    new { PilotName = "Smith", PlaneName = "F-14 Fighter" }, 
    new { PilotName = "Wilson", PlaneName = "B-1 Bomber" }, 
    new { PilotName = "Wilson", PlaneName = "B-52 Bomber" }, 
    new { PilotName = "Wilson", PlaneName = "F-14 Fighter" }, 
    new { PilotName = "Wilson", PlaneName = "F-17 Fighter" } 
}.AsEnumerable(); 

var actual = pilotSkills.Where 
(
    p1 => hangar.Except 
    ( 
     pilotSkills.Where(p2 => p2.PilotName == p1.PilotName) 
        .Select(p2 => new { p2.PlaneName }) 
    ).Any() == false 
).Select(p1 => new { p1.PilotName }).Distinct(); 

var expected = new [] 
{ 
    new { PilotName = "Smith" }, 
    new { PilotName = "Wilson" } 
}; 

Assert.That(actual, Is.EquivalentTo(expected)); 

LINQ is supposedly based on the relational algebra 다음은 직접적인 번역입니다. 그러나 더 나은 '기본'LINQ 접근 방식이 있습니까? @Daniel Hilgarth의 대답에 반영

---

, .NET 땅에있는 데이터로 시작하는 '그룹화'될 가능성이 :

var pilotSkills = new [] 
{ 
    new { PilotName = "Celko", 
      Planes = new [] 
      { new { PlaneName = "Piper Cub" }, } }, 
    new { PilotName = "Higgins", 
      Planes = new [] 
      { new { PlaneName = "B-52 Bomber" }, 
       new { PlaneName = "F-14 Fighter" }, 
       new { PlaneName = "Piper Cub" }, } }, 
    new { PilotName = "Jones", 
      Planes = new [] 
      { new { PlaneName = "B-52 Bomber" }, 
       new { PlaneName = "F-14 Fighter" }, } }, 
    new { PilotName = "Smith", 
      Planes = new [] 
      { new { PlaneName = "B-1 Bomber" }, 
       new { PlaneName = "B-52 Bomber" }, 
       new { PlaneName = "F-14 Fighter" }, } }, 
    new { PilotName = "Wilson", 
      Planes = new [] 
      { new { PlaneName = "B-1 Bomber" }, 
       new { PlaneName = "B-52 Bomber" }, 
       new { PlaneName = "F-14 Fighter" }, 
       new { PlaneName = "F-17 Fighter" }, } }, 
}; 

... 그냥 이름을 투사하는 만들기, 임의 훨씬 더 간단 잠재적 인 솔루션 :

// Easy to understand at a glance: 
var actual1 = pilotSkills.Where(x => hangar.All(y => x.Planes.Contains(y))); 

// Potentially more efficient: 
var actual = pilotSkills.Where(x => !hangar.Except(x.Planes).Any()); 

Answer 1

다음은 동일한 결과를해야 다음

를

이것은 격납고의 모든 비행기를 조종 할 수있는 조종사 당 하나의 그룹을 반환합니다.
그룹의 열쇠는 조종사의 이름이고, 조종사가 날 수있는 모든 비행기, 격납고에없는조차 조종사의 내용입니다.

이제 조종사 만 원하는 경우 .Select(g => new { PilotName = g.Key })을 쿼리 끝에 추가 할 수 있습니다. 그것은 단지 한 번 g을 반복 처리하기 때문에,

pilotSkills.GroupBy(x => x.PilotName, x => new { x.PlaneName }) 
      .Where(g => !hangar.Except(g).Any()); 

이 두 번째 쿼리가 잠재적으로 더 나은;

---

가까운 영업 이익의 원본을 만드는 Except와 함께 위의 방법을 사용 Contains의 첫 번째 쿼리는 N 번 반복하고 격납 장치의 평면 수를 N으로합니다. 가까이 내 원래에 @Daniel Hilgarth의 대답하지만 방법을 사용

는

Answer 2

:

var actual = pilotSkills 
       .GroupBy(x => x.PilotName, x => new { x.PlaneName }) 
       .Where(g => !hangar.Except(g).Any()) 
       .Select(x => new { PilotName = x.Key });