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)); }