internal static LinqLambdaExpression CreateLambda(QueryExpression source, IEnumerable <KeyValuePair <QueryProperty, QueryConstantExpression> > keys)
{
ExceptionUtilities.CheckArgumentNotNull(source, "source");
ExceptionUtilities.CheckCollectionNotEmpty(keys, "keys");
QueryType parameterType;
if (source.ExpressionType.IsUnresolved)
{
parameterType = QueryType.Unresolved;
}
else
{
var queryCollectionType = source.ExpressionType as QueryCollectionType;
ExceptionUtilities.CheckObjectNotNull(queryCollectionType, "Source expression type was not a collection. Type was: {0}", source.ExpressionType);
parameterType = queryCollectionType.ElementType;
}
var parameter = LinqBuilder.Parameter(ParameterName, parameterType);
// specifically using the overload of .Property which takes a type because it may have already been resolved and we don't want to throw that away
var predicate = keys.Select(k => parameter.Property(k.Key.Name, k.Key.PropertyType).EqualTo(k.Value)).ToList();
QueryExpression body = predicate[0];
if (predicate.Count > 1)
{
for (int i = 1; i < predicate.Count; i++)
{
body = CommonQueryBuilder.And(body, predicate[i]);
}
}
return(LinqBuilder.Lambda(body, parameter));
}
/// <summary>
/// Resolves types for the specified expression.
/// </summary>
/// <param name="expression">The expression to resolve types for.</param>
/// <returns>Expression with resolved types.</returns>
public QueryExpression Visit(LinqLambdaExpression expression)
{
var parameters = expression.Parameters.Select(this.ResolveTypes).Cast <LinqParameterExpression>().ToArray();
var body = this.ResolveTypes(expression.Body);
var type = new LinqLambdaType(body.ExpressionType, parameters.Select(p => p.ExpressionType), this.EvaluationStrategy);
return(LinqBuilder.Lambda(body, parameters.ToArray(), type));
}
/// <summary>
/// Replaces the given expression.
/// </summary>
/// <param name="expression">The root node of the expression tree being visited.</param>
/// <returns>Replaced expression.</returns>
public virtual QueryExpression Visit(LinqLambdaExpression expression)
{
var parameters = expression.Parameters.Select(this.ReplaceExpression).Cast <LinqParameterExpression>().ToArray();
QueryExpression body = this.ReplaceExpression(expression.Body);
if (HasChanged(expression.Body, body) || HasChanged(expression.Parameters, parameters))
{
return(LinqBuilder.Lambda(body, parameters, expression.ExpressionType));
}
return(expression);
}
/// <summary>
/// Replaces the given expression.
/// </summary>
/// <param name="expression">The root node of the expression tree being visited.</param>
/// <returns>
/// Replaced expression.
/// </returns>
public override QueryExpression Visit(LinqSelectExpression expression)
{
// in a select, only properties will be sent
this.propertyExpressions.Clear();
expression.Lambda.Accept(this);
if (this.propertyExpressions.Count == 0)
{
return(expression.Source);
}
var newExpression = LinqBuilder.New(this.propertyExpressions.Select(p => this.IdentifierGenerator.GenerateIdentifier("temp")), this.propertyExpressions);
var lambda = LinqBuilder.Lambda(newExpression, expression.Lambda.Parameters.ToArray());
return(expression.Source.Select(lambda));
}
