如何在LINQ-to-SQL中生成SQL COUNT（*）OVER（PARTITION BY {ColumnName}）？

Question

是否可以使用LINQ-to-SQL查詢表達式或延遲執行的方法鏈來生成以下SQL查詢？

數據結構

替代文字http://www.freeimagehosting.net/uploads/e062a48837.jpg

   Select Distinct ClassRoomTitle, 
                Count(*) Over(Partition By ClassRoomNo) As [No Sessions Per Room], 
                TeacherName, 
                Count(*) Over(Partition By ClassRoomNo, TeacherName) As [No Sessions Per Teacher] From ClassRoom

預期結果

替代文字http://www.freeimagehosting.net/uploads/47a79fea8b.jpg

Answer 1

嘗試這個：

        var vGroup = from p in ClassRoom
                     group p by new { p.ClassRoomNo, p.TeacherName }
                         into g
                         from i in g
                         select new
                         {
                             i.ClassRoomNo,
                             i.TeacherName,
                             i.ClassRoomTitle,
                             NoSessionsPerTeacher = g.Count()
                         };

        var pGroup = from p in vGroup
                     group p by new { p.ClassRoomNo }
                         into g
                         from i in g
                         select new
                         {
                             i.ClassRoomTitle,
                             NoSessionsPerRoom = g.Count(),
                             i.TeacherName,
                             i.NoSessionsPerTeacher
                         };

        var result = pGroup.OrderBy(p => p.ClassRoomNo).ThenBy(p => p.TeacherName);

我沒有測試上面的內容，但是您可以檢查我的原始代碼，以防萬一我在改寫中出錯了：

        var vGroup = from p in Products
                     group p by new { p.ProductId, p.VariantId }
                         into g
                         from i in g
                         select new
                         {
                             i.ProductId,
                             i.VariantId,
                             VariantCount = g.Count()
                         };

        var pGroup = from p in vGroup
                     group p by new { p.ProductId }
                         into g
                         from i in g
                         select new
                         {
                             i.ProductId,
                             ProductCount = g.Count(),
                             i.VariantId,
                             i.VariantCount
                         };

        var result = pGroup.OrderBy(p => p.ProductId).ThenBy(p => p.VariantId);

Answer 2

var classRooms = from c in context.ClassRooms
                 group c by new {c.ClassRoomNo} into room
                 select new {
                    Title = room.First().ClassRoomTitle,
                    NoSessions = room.Count(),
                    Teachers = from cr in room
                               group cr by new {cr.TeacherName} into t
                               select new {
                                   Teacher = t.Key,
                                   NoSessions = t.Count()
                               }
                 };

比發布的預期結果更加結構化，但是我發現它會更好。

如果要返回非結構化，則始終可以使用SelectMany：

var unstructured = classRooms
   .SelectMany(c=> c.Teachers.Select( t=> new {
      Title = c.Title,
      SessionsPerRoom = c.NoSessions,
      Teacher = t.Teacher,
      SessionsPerTeacher = t.NoSessions
   });