private LambdaExpression Parameterize(Expression query, out object[] arguments)
{
IQueryProvider provider = this.FindProvider(query);
if (provider == null)
{
throw new ArgumentException("Cannot deduce query provider from query");
}
var ep = provider as IEntityProvider;
Func <Expression, bool> fn = ep != null ? (Func <Expression, bool>)ep.CanBeEvaluatedLocally : null;
List <ParameterExpression> parameters = new List <ParameterExpression>();
List <object> values = new List <object>();
var body = PartialEvaluator.Eval(query, fn, c =>
{
bool isQueryRoot = c.Value is IQueryable;
if (!isQueryRoot && ep != null && !ep.CanBeParameter(c))
{
return(c);
}
var p = Expression.Parameter(c.Type, "p" + parameters.Count);
parameters.Add(p);
values.Add(c.Value);
// if query root then parameterize but don't replace in the tree
if (isQueryRoot)
{
return(c);
}
return(p);
});
if (body.Type != typeof(object))
{
body = Expression.Convert(body, typeof(object));
}
arguments = values.ToArray();
if (arguments.Length < 5)
{
return(Expression.Lambda(body, parameters.ToArray()));
}
else
{
arguments = new object[] { arguments };
return(ExplicitToObjectArray.Rewrite(body, parameters));
}
}
private LambdaExpression Parameterize(Expression query, out object[] arguments)
{
IQueryProvider provider = this.FindProvider(query);
if (provider == null)
{
throw new ArgumentException(Res.ArgumentQuery);
}
var ep = provider as IDbContext;
// turn all relatively constant expression into actual constants
Func <Expression, bool> fnCanBeEvaluated = e => ep != null?ExpressionHelper.CanBeEvaluatedLocally(e) : true;
var body = PartialEvaluator.Eval(query, fnCanBeEvaluated);
// convert all constants into parameters
List <ParameterExpression> parameters;
List <object> values;
body = Parameterizer.Parameterize(body, out parameters, out values);
// make sure the body will return a value typed as 'object'.
if (body.Type != typeof(object))
{
body = Expression.Convert(body, typeof(object));
}
// make a lambda expression with these parameters
arguments = values.ToArray();
if (arguments.Length < 5)
{
return(Expression.Lambda(body, parameters.ToArray()));
}
else
{
// too many parameters, use an object array instead.
arguments = new object[] { arguments };
return(ExplicitToObjectArray.Rewrite(body, parameters));
}
}
private LambdaExpression Parameterize(Expression query, out object[] arguments)
{
IQueryProvider provider = this.FindProvider(query);
if (provider == null)
{
throw new ArgumentException("Cannot deduce query provider from query");
}
IEntityProvider ep = provider as IEntityProvider;
Func <Expression, bool> fnCanBeEvaluated = (ep != null) ? new Func <Expression, bool>(ep.CanBeEvaluatedLocally) : null;
List <ParameterExpression> parameters = new List <ParameterExpression>();
List <object> values = new List <object>();
Expression expression = PartialEvaluator.Eval(query, fnCanBeEvaluated, delegate(ConstantExpression c) {
bool flag = c.Value is IQueryable;
if (!((flag || (ep == null)) || ep.CanBeParameter(c)))
{
return(c);
}
ParameterExpression item = Expression.Parameter(c.Type, "p" + parameters.Count);
parameters.Add(item);
values.Add(c.Value);
if (flag)
{
return(c);
}
return(item);
});
if (expression.Type != typeof(object))
{
expression = Expression.Convert(expression, typeof(object));
}
arguments = values.ToArray();
if (arguments.Length < 5)
{
return(Expression.Lambda(expression, parameters.ToArray()));
}
arguments = new object[] { arguments };
return(ExplicitToObjectArray.Rewrite(expression, parameters));
}
internal static LambdaExpression Rewrite(Expression body, IList <ParameterExpression> parameters)
{
var visitor = new ExplicitToObjectArray(parameters);
return(Expression.Lambda(visitor.Visit(body), visitor.array));
}
