[SQL] LINQ에 의해 중첩 된 그룹

LINQ에 의해 중첩 된 그룹

내가 LINQ 쿼리와 함께이 문제를 해결할 수없는입니다.

우리는 테이블 구조를 가지고 그래서 다음과 같이 :    아이디 || || bug_category bug_name || bug_details || bug_priority

나는 bug_category 처음으로 그룹으로합니다. 각 bug_category, 나는 bug__priority에 의해 차례로 그룹을합니다.

그래서 기본적으로 내가 좋아하는 뭔가를 원하는 :

버그의 bug_category = AUDIO : 없음 -> 크리티컬 = 3, 중간 = 2, 낮음 = 7 버그.    bug_category = VIDEO :: 버그 없음 -> 크리티컬 = 5, 보통 = 1, 낮음 = 9 버그.

쿼리 아래의 카테고리와 customer_priority의 모든 고유 조합을 반환합니다 :

(RawDataList가 갖는 데이터를 단순히리스트이고 상기 한 구성)

        var ProceesedData = from d in RawDataList
                      group d by new { d.bug_category, d.bug_priority } into g
                      select new
                      {
                          g.Key.bug_category,
                          g.Key.bug_priority
                      };

쿼리 아래의 해당 범주의 레코드 목록 다음 범주를 반환합니다 :

            var ProceesedData = from d in RawDataList
                      group d by d.bug_category into g
                      select new { g.Key, records = g
                      };

하지만 ProcessedData (리턴 변수) 알 수없는 타입이기 때문에 더 이상 진행 할 수 없습니다입니다. 이것에 대한 어떤 생각?

해결법

1. ==============================

   1.나는 당신이 (이름이 더 관용적로 변경) 할 생각 :

   나는 당신이 (이름이 더 관용적로 변경) 할 생각 :

   var query = from bug in RawListData
               group bug by new { bug.Category, bug.Priority } into grouped
               select new { 
                   Category = grouped.Key.Category,
                   Priority = grouped.Key.Priority,
                   Count = grouped.Count()
               };
   

   그때:

   foreach (var result in query)
   {
       Console.WriteLine("{0} - {1} - {2}",
                         result.Category, result.Priority, result.Count);
   }
   

   또한 (하지만 나중에 참조)

   var query = from bug in RawListData
               group bug by new bug.Category into grouped
               select new { 
                   Category = grouped.Category,
                   Counts = from bug in grouped
                            group bug by grouped.Priority into g2
                            select new { Priority = g2.Key, Count = g2.Count() }
               };
   
   foreach (var result in query)
   {
       Console.WriteLine("{0}: ", result.Category);
       foreach (var subresult in result.Counts)
       {
           Console.WriteLine("  {0}: {1}", subresult.Priority, subresult.Count);
       }
   }
   

   편집 : 코멘트에 언급 한 바와 같이,이 여러 SQL 쿼리가 발생합니다. 비슷한 결과 구조를 얻으려면하지만 더 효율적으로 사용할 수 있습니다 :

   var dbQuery = from bug in RawListData
                 group bug by new { bug.Category, bug.Priority } into grouped
                 select new { 
                     Category = grouped.Key.Category,
                     Priority = grouped.Key.Priority,
                     Count = grouped.Count()
                 };
   
   var query = dbQuery.ToLookup(result => result.Category,
                                result => new { result.Priority, result.Count };
   
   
   foreach (var result in query)
   {
       Console.WriteLine("{0}: ", result.Key);
       foreach (var subresult in result)
       {
           Console.WriteLine("  {0}: {1}", subresult.Priority, subresult.Count);
       }
   }
   

2. ==============================

   2.이 중첩 된 그룹을 달성하는 쉬운 방법입니다. 나는 특정 DB 공급자가 잘 처리 할 달라질 수 있습니다, 또는 잘 수행 알 수 있는지 여부, 메모리 컬렉션에 그것을 테스트했습니다.

   이 중첩 된 그룹을 달성하는 쉬운 방법입니다. 나는 특정 DB 공급자가 잘 처리 할 달라질 수 있습니다, 또는 잘 수행 알 수 있는지 여부, 메모리 컬렉션에 그것을 테스트했습니다.

   당신을 가정하면 두 가지 속성이 있고, 국가와 국가에 의해 그룹 원 :

   var grouped = People
     .GroupBy(l => new { l.State, l.Country})//group by two things
     .GroupBy(l=> l.Key.Country)//this will become the outer grouping
   
   
   foreach(var country in grouped)
   {
     foreach(var state in country)
     {
        foreach(var personInState in state)
        {
          string description = $"Name: {personInState.Name}, State: {state.StateCode}, Country: {country.CountryCode}";
          ...
   
        }
     }
   }
   

3. ==============================

   3.난 당신이 그런 일을 검색하는 생각 :

   난 당신이 그런 일을 검색하는 생각 :

       var processedData =
           rawData.GroupBy(bugs => bugs.bug_category,
               (category, elements) =>
               new
                   {
                       Category = category,
                       Bugs = elements.GroupBy(bugs => bugs.bug_priority,
                                           (priority, realbugs) =>
                                           new
                                               {
                                                   Priority = priority,
                                                   Count = realbugs.Count()
                                               })
                   });
       foreach (var data in processedData)
       {
           Console.WriteLine(data.Category);
   
           foreach (var element in data.Bugs)
               Console.WriteLine("  " + element.Priority + " = " + element.Count);
       }
   

4. ==============================

   4.당신은 이런 식으로 작업을 수행 할 수 있습니다

   당신은 이런 식으로 작업을 수행 할 수 있습니다

    var retList = (from dbc in db.Companies
                              where dbc.IsVerified && dbc.SellsPCBs && !dbc.IsDeleted && !dbc.IsSpam && dbc.IsApproved
                              select new
                              {
                                  name = dbc.CompanyName,
                                  compID = dbc.CompanyID,
                                  state = dbc.State,
                                  city = dbc.City,
                                  businessType = dbc.BusinessType
                              }).GroupBy(k => k.state).ToList();
   
   
               List<dynamic> finalList = new List<dynamic>();
   
               foreach (var item in retList)
               {
                   finalList.Add(item.GroupBy(i => i.city));
               }
   

from https://stackoverflow.com/questions/9578887/nested-group-by-linq by cc-by-sa and MIT license