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