使用许多子查询重构LINQ to SQL / Entities查询

Question

I have the following LINQ to Entities query which has many subqueries to get some aggregate data:

var systems = from s in db.Systems
              orderby s.Name
              select new SystemSummary
              {
                  Id = s.Id,
                  Code = s.Code,
                  Name = s.Name,
                  LastException = (
                      from a in s.Applications
                      from e in a.Summaries
                      select e.CreationDate
                  ).Max(),
                  TodaysExceptions = (
                      from a in s.Applications
                      from e in a.Summaries
                      where e.CreationDate >= today && e.CreationDate < tomorrow
                      select e
                  ).Count(),
                  /* SNIP - 10-15 more subqueries */                              
              };

I shortened up the query to only include 2 of the subqueries, but there could be around 10-15 more of them. Is there a way that I can refactor the query to clean up the code? I'm not looking for a performance increase. I want to just clean up the code by maybe putting the subqueries into separate methods while still making sure that it is a single call to the database. Is this possible?

Answer 1

I just can offer minimize its length by something like this (by using let keyword in your original query):

var subQuery =    from a in s.Applications
                  from e in a.Summaries
                  select e;

Also you can have some refactors like:

subQuery.Count(e=>e.CreationDate >= today && e.CreationDate < tomorrow);

subQuery.max(e=>e.CreationDate);

In fact use dot notation and move your query to related function instead of extra where clause.

and use subQuery in your query:

          from s in db.Systems
          orderby s.Name
          let subQuery =    from a in s.Applications
                  from e in a.Summaries
                  select e
          select new SystemSummary
          {
              Id = s.Id,
              Code = s.Code,
              Name = s.Name,
              LastException = subQuery.max(e=>e.CreationDate),
              TodaysExceptions = subQuery.Count(e=>e.CreationDate >= today 
                                          && e.CreationDate < tomorrow),
              /* SNIP - 10-15 more subqueries */                              
          };

This is still single call to db.

Answer 2

There really is no problem in seperating your query into multiple methods. There are some conditions though.

Make sure that your query is IEumerable. This is by default.

IEnumerable ensures that the query is stored in the variable, but not executed. The compiler optimizes your queries at run time.

Quick and dirty exemple:

private MyContext context = new MyContext()
private IEnumerable<User> getUser(Guid userID)
{
    return context.User.Where(c => c.ID == userID);  
}

private void evaluateUser()
{
    bool isUserActive getUser().Any(c => c.IsActive)
}

You can see that the query is in two methods. There is still only one call to the DB because an IEnumerable stores the query and not the result. The query is executed only when needed.

Answer 3

You may want to consider using the let keyword to create "variables" local to the query (this ultimately ends up being your subqueries). For example:

var systems = from s in db.Systems
              orderby s.Name
              let lastException = (from a in s.Applications from e in a.Summaries select e.CreationDate).Max()
              ...

Another option you could do is possibly create a subquery from the various associations right off the bat, and work with those elements.

var systems = from s in db.Systems
              orderby s.Name
              from summaries in 
                  (from ta in s.Applications
                   from te in ta.Summaries
                   ...
                   select { APPS = ta, SUMMS = te ,/*anything else you want*/ })
              let lastExpire = (from summaries select SUMMS.CreationDate).Max()

Hell, you could even just leave the let out in the second example and just use the summaries entities in your final selects. You might have to play around with it a bit to make sure you don't get any duplication of values, but at least this way you can just do a straight select against your summaries instead of rewriting your subqueries each time.