//Add all IncludeDirectives to Context, and remove 'our' LoadRelated MCE. public override Expression Translate(MethodCallExpression mce, Expression translatedFirstArg, IEnumerable<Expression> otherArgs, QueryAnalysisContext context) { var includes = ((ConstantExpression)((ConstantExpression)mce.Arguments[1]).Value).Value as IncludeDirective[]; if (includes != null) { foreach (var include in includes) AddInclude(context.QueryableType.NonPrimitiveEnumerableItemType, include.GetSelector().Body as MemberExpression, (include is IIncludeInCollectionDirective) ? (include as IIncludeInCollectionDirective).GetFieldSelector() : null); } //Remove the MCE by returning the first arg instead. return translatedFirstArg; }
public override Expression Translate(MethodCallExpression mce, Expression translatedSource1, IEnumerable <Expression> otherArgs, QueryAnalysisContext context) { bool isQueryable = DefinedOnQueryable(mce); var translation = QueryTranslationVisitor.TranslateLambda(otherArgs.First(), new[] { context.QueryableType.NonPrimitiveEnumerableItemType }, context, isQueryable); var newArgs = new Expression[] { translatedSource1, translation.TranslatedExpression }; var translatedMethod = mce.Method.GetGenericMethodDefinition().MakeGenericMethod(context.QueryableType.NonPrimitiveEnumerableItemType.TranslatedType); return(Expression.Call(mce.Object, translatedMethod, newArgs)); }
public override Expression Translate(MethodCallExpression mce, Expression translatedFirstArg, IEnumerable <Expression> otherArgs, QueryAnalysisContext context) { //entityContext.CreateQuery<TSource>. We should turn this into tableContext.GetTable<TranslatedSource> var genericArg = mce.Method.GetGenericArguments().First(); var translatedGenericArg = context.TypeTranslationUtil.GetTranslatedType(genericArg); context.QueryableType = RuntimeTypes.CreateEnumerable(new SimpleType(genericArg, translatedGenericArg)); //We cannot use the same mce.Method like we usually do, since the method itself should change (not just generic args) // EntityContext.CreateQuery should be converted to LinqContext.GetTable. return(context.TypeTranslationUtil.GetTranslatedGenericMethodCall(translatedFirstArg, mce.Method, new Type[] { translatedGenericArg }, new Expression[] { })); }
public override bool ModifyTranslatedResult(MethodCallExpression mce, QueryAnalysisContext context) { return(context.IsOuterExpression); }
protected ExpressionTranslationResult TranslateLambdaToIEnumerableFormat(Expression lambdaArg, SimpleType[] parameterTypes, QueryAnalysisContext context, bool isQueryable) { var lambda = QueryTranslationVisitor.GetLambda(lambdaArg, isQueryable); var translation = QueryTranslationVisitor.TranslateLambda(lambda, parameterTypes, context); //select many requires enumerable return type in collection selector lambda delegate. //hence we need convert to IEnumerable<> var translatedLambda = translation.TranslatedExpression as LambdaExpression; var translatedLambdaArg = QueryTranslationVisitor.FormatLambda(GetTranslatedLambda (translatedLambda.Type, translatedLambda.Body, translatedLambda.Parameters), isQueryable); return(new ExpressionTranslationResult(translatedLambdaArg, translation.QueryableType)); }
public override Expression Translate(MethodCallExpression mce, Expression translatedSource, IEnumerable <Expression> otherArgs, QueryAnalysisContext context) { bool isQueryable = DefinedOnQueryable(mce); //Expression<Func<TSource, int, IEnumerable<TResult>> var selectorTranslation = TranslateLambdaToIEnumerableFormat(otherArgs.First(), new[] { context.QueryableType.NonPrimitiveEnumerableItemType, new SimpleType(typeof(int)) }, context, isQueryable); var newArgs = new Expression[] { translatedSource, selectorTranslation.TranslatedExpression }; //SelectMany<TSource, TResult> var translatedMethod = mce.Method.GetGenericMethodDefinition().MakeGenericMethod( context.QueryableType.NonPrimitiveEnumerableItemType.TranslatedType, selectorTranslation.QueryableType.NonPrimitiveEnumerableItemType.TranslatedType); context.QueryableType = RuntimeTypes.CreateEnumerable(selectorTranslation.QueryableType.NonPrimitiveEnumerableItemType); return(Expression.Call(mce.Object, translatedMethod, newArgs) as Expression); }
public abstract Expression Translate(MethodCallExpression mce, Expression translatedFirstArg, IEnumerable <Expression> otherArgs, QueryAnalysisContext context);
public override bool ModifyTranslatedResult(MethodCallExpression mce, QueryAnalysisContext context) { return context.IsOuterExpression; }
public override Expression Translate(MethodCallExpression mce, Expression translatedSource1, IEnumerable <Expression> otherArgs, QueryAnalysisContext context) { var result = base.Translate(mce, translatedSource1, otherArgs, context); context.QueryableType = context.QueryableType.NonPrimitiveEnumerableItemType; return(result); }
public override Expression Translate(MethodCallExpression mce, Expression translatedOuter, IEnumerable <Expression> otherArgs, QueryAnalysisContext context) { bool isQueryable = DefinedOnQueryable(mce); var _otherArgs = otherArgs.ToArray(); //IEnumerable<TInner> var innerTranslation = QueryTranslationVisitor.VisitWithNewVisitor(_otherArgs[0], context, false); //Func<TOuter, TKey> var outerKeySelectorTranslation = QueryTranslationVisitor.TranslateLambda(_otherArgs[1], new[] { context.QueryableType.NonPrimitiveEnumerableItemType }, context, isQueryable); //Func<TInner, TKey> var innerKeySelectorTranslation = QueryTranslationVisitor.TranslateLambda(_otherArgs[2], new[] { innerTranslation.QueryableType.NonPrimitiveEnumerableItemType }, context, isQueryable); //Func<TOuter, TInner, TResult> var resultSelectorTranslation = QueryTranslationVisitor.TranslateLambda(_otherArgs[3], new[] { context.QueryableType.NonPrimitiveEnumerableItemType, innerTranslation.QueryableType.NonPrimitiveEnumerableItemType }, context, isQueryable); var newArgs = new Expression[] { translatedOuter, innerTranslation.TranslatedExpression, outerKeySelectorTranslation.TranslatedExpression, innerKeySelectorTranslation.TranslatedExpression, resultSelectorTranslation.TranslatedExpression }; //Join<TOuter, TInner, TKey, TResult> var translatedMethod = mce.Method.GetGenericMethodDefinition().MakeGenericMethod( context.QueryableType.NonPrimitiveEnumerableItemType.TranslatedType, innerTranslation.QueryableType.NonPrimitiveEnumerableItemType.TranslatedType, outerKeySelectorTranslation.QueryableType.TranslatedType, resultSelectorTranslation.QueryableType.TranslatedType); context.QueryableType = RuntimeTypes.CreateEnumerable(resultSelectorTranslation.QueryableType); return(Expression.Call(mce.Object, translatedMethod, newArgs)); }
public override Expression Translate(MethodCallExpression mce, Expression translatedSource1, IEnumerable<Expression> otherArgs, QueryAnalysisContext context) { var result = base.Translate(mce, translatedSource1, otherArgs, context); context.QueryableType = new SimpleType(mce.Type, result.Type); return result; }
public override bool ModifyTranslatedSource(MethodCallExpression mce, QueryAnalysisContext context) { //The first arg should be modified, since Concat does not allow the shape to change later. return(true); }
public override Expression Translate(MethodCallExpression mce, Expression translatedSource, IEnumerable <Expression> otherArgs, QueryAnalysisContext context) { var _otherArgs = otherArgs.ToArray(); bool isQueryable = DefinedOnQueryable(mce); //Func<TSource, TKey> var keySelectorTranslation = QueryTranslationVisitor.TranslateLambda(_otherArgs[0], new[] { context.QueryableType.NonPrimitiveEnumerableItemType }, context, isQueryable); //Func<TKey, IEnumerable<TSource>, TResult> var resultSelectorTranslation = QueryTranslationVisitor.TranslateLambda(_otherArgs[1], new[] { keySelectorTranslation.QueryableType, context.QueryableType }, context, isQueryable); var newArgs = new Expression[] { translatedSource, keySelectorTranslation.TranslatedExpression, resultSelectorTranslation.TranslatedExpression }; //GroupBy2<TSource, TKey, TResult> var translatedMethod = mce.Method.GetGenericMethodDefinition().MakeGenericMethod( context.QueryableType.NonPrimitiveEnumerableItemType.TranslatedType, keySelectorTranslation.QueryableType.TranslatedType, resultSelectorTranslation.QueryableType.TranslatedType); //IQueryable<TResult> context.QueryableType = RuntimeTypes.CreateEnumerable(resultSelectorTranslation.QueryableType); return(Expression.Call(mce.Object, translatedMethod, newArgs)); }
public override Expression Translate(MethodCallExpression mce, Expression translatedSource, IEnumerable <Expression> otherArgs, QueryAnalysisContext context) { bool isQueryable = DefinedOnQueryable(mce); //Func<TSource, TKey> var keySelectorTranslation = QueryTranslationVisitor.TranslateLambda(otherArgs.First(), new[] { context.QueryableType.NonPrimitiveEnumerableItemType }, context, isQueryable); var newArgs = new Expression[] { translatedSource, keySelectorTranslation.TranslatedExpression }; //GroupBy<TSource, TKey> var translatedMethod = mce.Method.GetGenericMethodDefinition().MakeGenericMethod( context.QueryableType.NonPrimitiveEnumerableItemType.TranslatedType, keySelectorTranslation.QueryableType.TranslatedType); //IQueryable<IGrouping<TKey, TSource>> var groupingType = RuntimeTypes.CreateGrouping(keySelectorTranslation.QueryableType, context.QueryableType.NonPrimitiveEnumerableItemType); var queryableType = RuntimeTypes.CreateEnumerable(groupingType); context.QueryableType = queryableType; return(Expression.Call(mce.Object, translatedMethod, newArgs)); }
public abstract Expression Translate(MethodCallExpression mce, Expression translatedFirstArg, IEnumerable<Expression> otherArgs, QueryAnalysisContext context);
public override bool ModifyTranslatedSource(MethodCallExpression mce, QueryAnalysisContext context) { return false; }
public abstract bool ModifyTranslatedResult(MethodCallExpression mce, QueryAnalysisContext context);
public override Expression Translate(MethodCallExpression mce, Expression translatedSource1, IEnumerable <Expression> otherArgs, QueryAnalysisContext context) { var result = base.Translate(mce, translatedSource1, otherArgs, context); context.QueryableType = new SimpleType(mce.Type, result.Type); return(result); }
//Add all IncludeDirectives to Context, and remove 'our' LoadRelated MCE. public override Expression Translate(MethodCallExpression mce, Expression translatedFirstArg, IEnumerable <Expression> otherArgs, QueryAnalysisContext context) { var includes = ((ConstantExpression)((ConstantExpression)mce.Arguments[1]).Value).Value as IncludeDirective[]; if (includes != null) { foreach (var include in includes) { AddInclude(context.QueryableType.NonPrimitiveEnumerableItemType, include.GetSelector().Body as MemberExpression, (include is IIncludeInCollectionDirective) ? (include as IIncludeInCollectionDirective).GetFieldSelector() : null); } } //Remove the MCE by returning the first arg instead. return(translatedFirstArg); }
public abstract bool ModifyTranslatedResult(MethodCallExpression mce, QueryAnalysisContext context);
public override Expression Translate(MethodCallExpression mce, Expression translatedSource1, IEnumerable <Expression> otherArgs, QueryAnalysisContext context) { var translatedSource2 = QueryTranslationVisitor.VisitWithNewVisitor(otherArgs.Single(), context, context.ModifyProjection).TranslatedExpression; if (translatedSource1.Type != translatedSource2.Type) { throw new Exception("Queries joined with a Union must be similar."); } var newArgs = new Expression[] { translatedSource1, translatedSource2 }; var translatedMethod = mce.Method.GetGenericMethodDefinition().MakeGenericMethod(context.QueryableType.NonPrimitiveEnumerableItemType.TranslatedType); return(Expression.Call(mce.Object, translatedMethod, newArgs)); }
public override Expression Translate(MethodCallExpression mce, Expression translatedSource, IEnumerable <Expression> otherArgs, QueryAnalysisContext context) { var _otherArgs = otherArgs.ToArray(); bool isQueryable = DefinedOnQueryable(mce); //Func<TSource, int, IEnumerable<TCollection>> var collectionSelectorTranslation = TranslateLambdaToIEnumerableFormat(_otherArgs[0], new[] { context.QueryableType.NonPrimitiveEnumerableItemType, //TSource new SimpleType(typeof(int)) }, //int context, isQueryable); //Func<TSource, TCollection, TResult> var resultSelectorTranslation = QueryTranslationVisitor.TranslateLambda(_otherArgs[1], new[] { context.QueryableType.NonPrimitiveEnumerableItemType, //TSource collectionSelectorTranslation.QueryableType.NonPrimitiveEnumerableItemType }, //TCollection context, isQueryable); var newArgs = new Expression[] { translatedSource, collectionSelectorTranslation.TranslatedExpression }; //SelectMany<TSource, TCollection, TResult> var translatedMethod = mce.Method.GetGenericMethodDefinition().MakeGenericMethod( context.QueryableType.NonPrimitiveEnumerableItemType.TranslatedType, collectionSelectorTranslation.QueryableType.NonPrimitiveEnumerableItemType.TranslatedType, resultSelectorTranslation.QueryableType.TranslatedType); //IEnumerable<TResult> context.QueryableType = RuntimeTypes.CreateEnumerable(resultSelectorTranslation.QueryableType); return(Expression.Call(mce.Object, translatedMethod, newArgs) as Expression); }
public override Expression Translate(MethodCallExpression mce, Expression translatedSource1, IEnumerable <System.Linq.Expressions.Expression> otherArgs, QueryAnalysisContext context) { var translatedSource2 = QueryTranslationVisitor.VisitWithNewVisitor(otherArgs.Single(), context, false).TranslatedExpression; if (translatedSource1.Type != translatedSource2.Type) { throw new Exception("Intersecting queries must be of the same shape."); } var newArgs = new Expression[] { translatedSource1, translatedSource2 }; var translatedMethod = mce.Method.GetGenericMethodDefinition().MakeGenericMethod(context.QueryableType.NonPrimitiveEnumerableItemType.TranslatedType); return(Expression.Call(mce.Object, translatedMethod, newArgs)); }
public override bool ModifyTranslatedSource(MethodCallExpression mce, QueryAnalysisContext context) { return(false); }
public override Expression Translate(MethodCallExpression mce, Expression translatedSource1, IEnumerable <Expression> otherArgs, QueryAnalysisContext context) { var translatedMethod = mce.Method.GetGenericMethodDefinition().MakeGenericMethod(context.QueryableType.NonPrimitiveEnumerableItemType.TranslatedType); return(Expression.Call(mce.Object, translatedMethod, translatedSource1)); }
public override Expression Translate(MethodCallExpression mce, Expression translatedSource, IEnumerable <Expression> otherArgs, QueryAnalysisContext context) { bool isQueryable = DefinedOnQueryable(mce); //Func<TSource, IEnumerable<TResult>> var selectorTranslation = TranslateLambdaToIEnumerableFormat(otherArgs.First(), new[] { context.QueryableType.NonPrimitiveEnumerableItemType }, context, isQueryable); //Handling Many-to-Many Case.. Converting to SelectMany3 case if (selectorTranslation.QueryableType.NonPrimitiveEnumerableItemType is ManyToManyMapType) { var mapType = selectorTranslation.QueryableType.NonPrimitiveEnumerableItemType as ManyToManyMapType; var sourceTypeParam = context.QueryableType.NonPrimitiveEnumerableItemType.GetParameter("p"); var mapParam = mapType.GetParameter("map"); var mappedItemSelector = Expression.Lambda(mapType.GetTranslatedParameterOrMember(mapParam), sourceTypeParam, mapParam); var newArgs2 = new Expression[] { translatedSource, selectorTranslation.TranslatedExpression, isQueryable ? Expression.Quote(mappedItemSelector) as Expression : mappedItemSelector }; Func <IQueryable <object>, Expression <Func <object, IEnumerable <object> > >, Expression <Func <object, object, object> >, IQueryable <object> > f1 = Queryable.SelectMany; Func <IEnumerable <object>, Func <object, IEnumerable <object> >, Func <object, object, object>, IEnumerable <object> > f2 = Enumerable.SelectMany; var newSelectManyMethod = (isQueryable ? f1.Method : f2.Method).GetGenericMethodDefinition() .MakeGenericMethod(context.QueryableType.NonPrimitiveEnumerableItemType.TranslatedType, selectorTranslation.QueryableType.NonPrimitiveEnumerableItemType.TranslatedType, mappedItemSelector.Body.Type); context.QueryableType = RuntimeTypes.CreateEnumerable(new SimpleType(mapType.MappedItemType, mappedItemSelector.Body.Type)); return(Expression.Call(mce.Object, newSelectManyMethod, newArgs2)); } var newArgs = new Expression[] { translatedSource, selectorTranslation.TranslatedExpression }; //SelectMany<TSource, TResult> var translatedMethod = mce.Method.GetGenericMethodDefinition().MakeGenericMethod( context.QueryableType.NonPrimitiveEnumerableItemType.TranslatedType, selectorTranslation.QueryableType.NonPrimitiveEnumerableItemType.TranslatedType); //IQueryable<TResult> context.QueryableType = RuntimeTypes.CreateEnumerable(selectorTranslation.QueryableType.NonPrimitiveEnumerableItemType); return(Expression.Call(mce.Object, translatedMethod, newArgs) as Expression); }
public override Expression Translate(MethodCallExpression mce, Expression translatedSource1, IEnumerable <Expression> otherArgs, QueryAnalysisContext context) { if (context.QueryableType.NonPrimitiveEnumerableItemType is ProjectedType) { throw new NotSupportedException("Contains cannot be called after projection."); } var translatedSource2 = QueryTranslationVisitor.VisitWithNewVisitor(otherArgs.Single(), context, false).TranslatedExpression; var newArgs = new Expression[] { translatedSource1, translatedSource2 }; //If NonPrimitiveEnumerableItemType is not null (case 1), this means we have to change the method's generic args. //Otherwise, re-use the same (case 2). //The second case occurs when we have a List<int> (for example), which has NonPrimitiveEnumerableItemType = null. var translatedMethod = context.QueryableType.NonPrimitiveEnumerableItemType != null? mce.Method.GetGenericMethodDefinition().MakeGenericMethod(context.QueryableType.NonPrimitiveEnumerableItemType.TranslatedType) : mce.Method; context.QueryableType = new SimpleType(typeof(bool), typeof(bool)); return(Expression.Call(mce.Object, translatedMethod, newArgs)); }