LlblGen ignores second part of OR
Joined: 18-May-2012
The predicate for the First() query can become false:
First(pec => pec.DateIn < actualWeek && (pec.DateOut == null || pec.DateOut > actualWeek))
The '&&' after pec.DateIn < actualWeek only results in true if pec.DateIn < actualWeek and pec.DateOut is null. The '|| pec.DateOut > actualWeek)' is always false, if pec.DateIn < actualWeek is true (a date can't be both smaller and larger than actualWeek 
)
Nevertheless, the missing expression is a bit odd. It might be due to a compiler optimization (i.e. the predicate is missing from the expression tree as it doesn't have an influence over the result) so I'll check that first. It's not removed when I run the First() query separately:
var q = metaData.Order.First(o => o.OrderDate < actualWeek && (o.ShippedDate == null || o.ShippedDate > actualWeek));
results in:
SELECT TOP 1 [LPA_L1].[CustomerID] AS [CustomerId],
[LPA_L1].[EmployeeID] AS [EmployeeId],
[LPA_L1].[Freight],
[LPA_L1].[OrderDate],
[LPA_L1].[OrderID] AS [OrderId],
[LPA_L1].[RequiredDate],
[LPA_L1].[ShipAddress],
[LPA_L1].[ShipCity],
[LPA_L1].[ShipCountry],
[LPA_L1].[ShipName],
[LPA_L1].[ShippedDate],
[LPA_L1].[ShipPostalCode],
[LPA_L1].[ShipRegion],
[LPA_L1].[ShipVia]
FROM [Northwind].[dbo].[Orders] [LPA_L1]
WHERE (((([LPA_L1].[OrderDate] < '1914-09-15T00:00:00' /* @p1 */)
AND (([LPA_L1].[ShippedDate] IS NULL)
OR ([LPA_L1].[ShippedDate] > '1914-09-15T00:00:00' /* @p2 */)))))
Which did result in a NULL as result, which was a bit surprising till I saw the predicate can't be true if var actualWeek = new DateTime(1914, 9, 15).
Digging deeper 
(edit) Full expression tree of working repro query:
value(SD.LLBLGen.Pro.LinqSupportClasses.DataSource2`1[NW26.Adapter.EntityClasses.CustomerEntity])
.Where(c => ((c.Country == "UK")
AndAlso ((c.Region == null)
OrElse (c.Region == "Isle of Wight"))))
.Select(c => new <>f__AnonymousType84`2(
Customer = c,
Order = c.Orders.FirstOrDefault(o =>
((o.OrderDate < Convert(value(LinqTester.AdapterTests.DynamicListFetches+<>c__DisplayClass0).actualWeek))
AndAlso
((o.ShippedDate == Convert(null))
OrElse
(o.ShippedDate > Convert(value(LinqTester.AdapterTests.DynamicListFetches+<>c__DisplayClass0).actualWeek)))))))
So we can rule out the compiler doing tricks, we have a bug somewhere.
Joined: 18-May-2012
Good to see, you're working on it. We have a workaround, rewriting the query in dot/fluent syntax and placing an .AsEnumerable() in between.
var poolEmps = _metaData.PoolEmployee.Where(pe => pe.PoolId == poolId && (pe.MaxDateOut == null || pe.MaxDateOut > actualDate)) .AsEnumerable() .Select(pe => new PoolEmpExt { PoolEmployee = pe, PoolEmployeeContract = pe.PoolEmployeeContracts.FirstOrDefault(pec => pec.DateIn < actualDate && (pec.DateOut > actualDate || pec.DateOut == null)), }).ToList();
So we can continue but we will wait for the fix because I would like to remove AsEnumerable()
Happy hunting 
Also do realize what I said about the predicate, that the orred expression is unnecessary
Digging...
Found it. And because it's so utterly silly, I'm going to post it here so you all have a good laugh about it
/// <summary>
/// Removes the passed in predicates from the filter to clean.
/// </summary>
/// <param name="predicatesToRemove">The predicates to remove.</param>
/// <param name="filterToClean">The filter to clean.</param>
/// <returns></returns>
public static IPredicateExpression RemovePredicatesFromFilter(List<IPredicate> predicatesToRemove, IPredicateExpression filterToClean)
{
if(filterToClean.IsEmpty())
{
return filterToClean;
}
IPredicateExpression toReturn = new PredicateExpression();
PredicateExpressionOperator lastSeenOperator = PredicateExpressionOperator.And;
foreach(IPredicateExpressionElement element in filterToClean)
{
switch(element.Type)
{
case PredicateExpressionElementType.Empty:
continue;
case PredicateExpressionElementType.Operator:
lastSeenOperator = (PredicateExpressionOperator)element.Contents;
break;
case PredicateExpressionElementType.Predicate:
IPredicate elementToAdd;
IPredicateExpression elementAsExpression = element.Contents as IPredicateExpression;
if(elementAsExpression == null)
{
// IPredicate
if(predicatesToRemove.Contains((IPredicate)element.Contents))
{
// skip, as it's one to remove
continue;
}
// keep this element
elementToAdd = (IPredicate)element.Contents;
}
else
{
var negateBeforeCleanup = elementAsExpression.Negate;
elementAsExpression = RemovePredicatesFromFilter(predicatesToRemove, elementAsExpression);
if(elementAsExpression.IsEmpty())
{
continue;
}
elementToAdd = elementAsExpression;
// negate could have been set on the expression, so we've to set it on the new expression instance we got back.
elementToAdd.Negate = negateBeforeCleanup;
}
if(lastSeenOperator == PredicateExpressionOperator.And)
{
toReturn.AddWithAnd(elementToAdd);
}
break;
}
}
return toReturn;
}
If you spot it, it's so silly.... hint: PredicateExpressionOperator is an enum which also can be... 'Or'
Joined: 18-May-2012
Indeed I laughed, but with respect.
BTW the second part of the OR isn't alway true. That's because DateIn and DateOut are totally different, start day of a contract and end date of a contract.
So if an employee has a contract from 1-1-2014 to 31-12-2014 and actualWeek is this monday 15-9-2014, the second part of the OR is true.
These employees didn't have a contract while being active employees and crashed my code. And that started my search for my errors, I admit I also make bugs 
, or data problems.
Thanks for the fix, I have tested it and it works.
Yeah, my bad, the second predicate isn't like I thought it was Glad it's solved.