Restricting deeply-nested child records returned using LINQ - linq

Question

Given this object structure, how do I bring back a WorkItem, it's report(s), row(s) and student(s), but only the row whose Student's name is 'Bob' (I want to omit the rows containing 'Alice' and 'Claire').
WorkItem
----Report1 (held in WorkItem.Reports collection)
--------ReportRow1 (held in Report.ReportRows collection)
------------Student.Name = 'Alice'
--------ReportRow2 (held in Report.ReportRows collection)
------------Student.Name = 'Bob'
--------ReportRow3 (held in Report.ReportRows collection)
------------Student.Name = 'Claire'
(sorry about the formatting)
I thought something like this would work, but it still brings back all 3 rows
WorkItem found = (from workItem in session.Query<WorkItem>()
from report in workItem.Reports
from row in report.ReportRows
where workItem.Id == 1 && row.Student.Name == "Bob"
select workItem)
.SingleOrDefault<WorkItem>();
Update
I also tried this, thinking it would only bring back the results when I actually try to use them (which it does) but looking at the logs, it still does a select for each student (I was hoping the 'where' clause in the final foreach loop would bring back just the one I was interested in.
var query = from workItem in session.Query<WorkItem>()
where workItem.Id == 1
select workItem;
WorkItem found = query.SingleOrDefault<WorkItem>();
foreach (var report in found.Reports)
{
foreach (var row in report.ReportRows.Where(x => x.Student.Name == "Bob"))
{
Console.WriteLine("--" + row.Student.Name);
}
}
This is my current best stab at it based on help from Ocelot20:
var result = (from workItem in session.Query<WorkItem>()
.FetchMany(x => x.Reports)
.ThenFetchMany(y => y.ReportRows.Where(z => z.Student.Name == "Bob"))
where workItem.Id == 1
select workItem);
The only thing that doesn't work is the Where clause for the student name. If I remove that, I get a result back (albeit with too many rows). If I can get the where clause right I think it will be bringing back what I want

Answer 1

From what I can see here, you are only selecting a WorkItem. You are doing joins that limit the WorkItems that are returned, but you are still only selecting a WorkItem and not telling it to select specific Reports, ReportRows, etc. So essentially your query is saying: "Give me only WorkItems with an Id of 1 that can be joined with students named Bob". Note the lack of: "Then select that WorkItem with only the appropriate ReportRows.
My guess is that you're doing something like this:
WorkItem found = (from workItem in session.Query<WorkItem>()
from report in workItem.Reports
from row in report.ReportRows
where workItem.Id == 1 && row.Student.Name == "Bob"
select workItem).SingleOrDefault<WorkItem>();
// Doing something to select `ReportRows` without filtering them:
var someSelection = found.Reports.First().ReportRows;
Depending on how you have lazy loading set up, ReportRows will not even be queried until you call it on the someSelection line. At this point, it knows nothing about what you want to filter on. You have a couple of options here. First, you can just filter the items in the second query once you have already loaded the WorkItem like so:
// Filter on the second query:
var someSelection = found.Reports.First().ReportRows
.Where(rr => rr.Student.Name == "Bob");
Or you could just change up your query to explicitly select the work item and related rows: select new { workItem, reportRows = // select specific rows with a where clause here. }.
Lastly, there's the nhibernate ability to specify what related entities should be preloaded into your selected entity. I know entity framework lets you add Where clauses on the related entities, but I haven't used nhibernate to know whether or not you can do something like this:
var customers = session.Query<Customer>()
.FetchMany(c => c.Orders.Where(o => o.Amount == 100);
If this works, this could be applied to your query to tell nhibernate to load the WorkItem with related rows where the Student name is "Bob".