Comment générer SQL COUNT (*) OVER (PARTITION BY {ColumnName}) dans LINQ-to-SQL?

Question

Est-il possible de générer la requête SQL suivante à l'aide de l'expression de requête LINQ-to-SQL ou des chaînes de méthodes qui sont différées-exécutables?

Structure des données

alt text 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 

Résultat attendu

alt text http://www.freeimagehosting.net/uploads/47a79fea8b.jpg

Answer 1

Essayez ceci:

 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); 

Je n'ai pas testé ci-dessus, mais vous pouvez vérifier mon code d'origine au cas où je suis quelque chose de mal dans le rewrite:

 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() 
           } 
       }; 

Un peu plus structuré que le résultat affiché prévu, mais Je trouve que c'est mieux.

Vous pouvez toujours utiliser SelectMany si vous voulez revenir à déstructuré:

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