private QueryValue VisitSingleExpression(LinqQueryMethodWithLambdaExpression expression, bool isOrDefault)
{
var source = this.EvaluateCollection(expression.Source);
QueryCollectionValue collection = source;
if (expression.Lambda != null)
{
collection = source.Where(v => this.EvaluateLambda <QueryScalarValue>(expression.Lambda, v));
}
if (collection.Elements.Count == 0)
{
if (isOrDefault)
{
return(collection.Type.ElementType.NullValue);
}
else
{
var expectedException = new ExpectedExceptions(new ExpectedExceptionTypeMessageVerifier <InvalidOperationException>(null, "Sequence contains no elements"));
return(source.Type.ElementType.CreateErrorValue(expectedException));
}
}
else if (collection.Elements.Count == 1)
{
return(collection.Elements[0]);
}
else
{
var expectedException = new ExpectedExceptions(new ExpectedExceptionTypeMessageVerifier <InvalidOperationException>(null, "Sequence contains more than one element"));
return(collection.Type.ElementType.CreateErrorValue(expectedException));
}
}
private QueryValue VisitFirstExpression(LinqQueryMethodWithLambdaExpression expression, bool isOrDefault)
{
var source = this.EvaluateCollection(expression.Source);
IEnumerable <QueryValue> elements = source.Elements;
if (expression.Lambda != null)
{
// Note: cannot directly use souce.Where(...) since underlying store semantics might change order!
elements = source.Elements.Where(v =>
{
QueryScalarValue predicate = this.EvaluateLambda <QueryScalarValue>(expression.Lambda, v);
return(!predicate.IsNull && (bool)predicate.Value);
}).ToArray();
}
if (elements.Count() == 0)
{
if (isOrDefault)
{
return(source.Type.ElementType.NullValue);
}
else
{
var expectedException = new ExpectedExceptions(new ExpectedExceptionTypeMessageVerifier <InvalidOperationException>(null, "Sequence contains no elements"));
return(source.Type.ElementType.CreateErrorValue(expectedException));
}
}
else
{
return(elements.First());
}
}
private QueryExpression VisitQueryMethodWithLambdaExpression(
LinqQueryMethodWithLambdaExpression expression,
Func <QueryExpression, LinqLambdaExpression, QueryType, QueryExpression> linqBuilderCall)
{
QueryExpression source = this.ReplaceExpression(expression.Source);
if (expression.Lambda != null)
{
var lambda = (LinqLambdaExpression)this.ReplaceExpression(expression.Lambda);
if (HasChanged(expression.Source, source) || HasChanged(expression.Lambda, lambda))
{
return(linqBuilderCall(source, lambda, expression.ExpressionType));
}
return(expression);
}
if (this.HasChanged(expression.Source, source))
{
return(linqBuilderCall(source, null, expression.ExpressionType));
}
return(expression);
}
private CodeExpression VisitQueryMethodWithLambdaExpression(LinqQueryMethodWithLambdaExpression expression, string methodName)
{
CodeExpression source = this.GenerateCode(expression.Source);
if (expression.Lambda == null)
{
return(source.Call(methodName));
}
else
{
var lambda = this.GenerateCode(expression.Lambda) as CodeLambdaExpression;
return(source.Call(methodName, lambda));
}
}
private string VisitAnyOrAll(LinqQueryMethodWithLambdaExpression expression, string operatorName)
{
ExceptionUtilities.CheckArgumentNotNull(expression, "expression");
string source = this.Convert(expression.Source);
if (expression.Lambda == null)
{
return(string.Format(CultureInfo.InvariantCulture, "{0}/{1}()", source, operatorName));
}
string lambda = this.Convert(expression.Lambda);
return(string.Format(CultureInfo.InvariantCulture, "{0}/{1}({2})", source, operatorName, lambda));
}
private QueryValue EvaluateQueryMethodWithLambdaExpression <TResult>(
LinqQueryMethodWithLambdaExpression expression,
Func <QueryCollectionValue, QueryValue> nolambdaEvaluator,
Func <QueryCollectionValue, Func <QueryValue, TResult>, QueryValue> lambdaEvaluator)
where TResult : QueryValue
{
var source = this.EvaluateCollection(expression.Source);
LinqLambdaExpression lambda = expression.Lambda;
if (lambda == null)
{
ExceptionUtilities.Assert(nolambdaEvaluator != null, "noLambdaEvaluator must not be null.");
return(nolambdaEvaluator(source));
}
else
{
return(lambdaEvaluator(source, v => this.EvaluateLambda <TResult>(lambda, v)));
}
}
