public void Skip()
{
var query = (from s in ExpressionHelper.CreateQueryable <Cook>()
select s.ID).Skip(1);
var queryModel = QueryParser.GetParsedQuery(query.Expression);
Assert.That(queryModel.GetOutputDataInfo().DataType, Is.SameAs(typeof(IQueryable <int>)));
var mainFromClause = queryModel.MainFromClause;
Assert.That(queryModel.ResultOperators.Count, Is.EqualTo(1));
Assert.That(queryModel.ResultOperators[0], Is.InstanceOf(typeof(SkipResultOperator)));
var skipResultOperator = (SkipResultOperator)queryModel.ResultOperators[0];
CheckResolvedExpression <int, int> (skipResultOperator.Count, mainFromClause, i => 1);
}
public void VBIsNothing()
{
var parameterExpression = Expression.Parameter(typeof(Cook), "c");
var vbIsNothingExpression = Expression.Call(typeof(Information).GetMethod("IsNothing"), parameterExpression);
var query = QuerySource
.Where(Expression.Lambda <Func <Cook, bool> > (vbIsNothingExpression, parameterExpression))
.Select(c => c.Name);
var queryModel = QueryParser.GetParsedQuery(query.Expression);
var whereClause = (WhereClause)queryModel.BodyClauses[0];
var expectedExpression = Expression.Equal(new QuerySourceReferenceExpression(queryModel.MainFromClause), Expression.Constant(null));
ExpressionTreeComparer.CheckAreEqualTrees(expectedExpression, whereClause.Predicate);
}
public void KeyValuePair_And_TupleCtors_GetMemberInfo()
{
var query = from c in QuerySource
select new
{
KVP = new KeyValuePair <string, int>(c.Name, 0),
DE = new DictionaryEntry(c.Name, 0),
Tuple = new Tuple <string, int> (c.Name, 0)
};
var queryModel = QueryParser.GetParsedQuery(query.Expression);
var selector = (NewExpression)queryModel.SelectClause.Selector;
Assert.That(selector.Arguments.Count, Is.EqualTo(3));
Assert.That(selector.Members, Is.Not.Null);
Assert.That(selector.Members.Count, Is.EqualTo(3));
CheckMemberInNewExpression(selector.Type, "KVP", selector.Members[0]);
CheckMemberInNewExpression(selector.Type, "DE", selector.Members[1]);
CheckMemberInNewExpression(selector.Type, "Tuple", selector.Members[2]);
var kvpArgument = (NewExpression)selector.Arguments[0];
Assert.That(kvpArgument.Arguments.Count, Is.EqualTo(2));
Assert.That(kvpArgument.Members, Is.Not.Null);
Assert.That(kvpArgument.Members.Count, Is.EqualTo(2));
CheckMemberInNewExpression(typeof(KeyValuePair <string, int>), "Key", kvpArgument.Members[0]);
CheckMemberInNewExpression(typeof(KeyValuePair <string, int>), "Value", kvpArgument.Members[1]);
var deArgument = (NewExpression)selector.Arguments[1];
Assert.That(deArgument.Arguments.Count, Is.EqualTo(2));
Assert.That(deArgument.Members, Is.Not.Null);
Assert.That(deArgument.Members.Count, Is.EqualTo(2));
CheckMemberInNewExpression(typeof(DictionaryEntry), "Key", deArgument.Members[0]);
CheckMemberInNewExpression(typeof(DictionaryEntry), "Value", deArgument.Members[1]);
var tupleArgument = (NewExpression)selector.Arguments[2];
Assert.That(tupleArgument.Arguments.Count, Is.EqualTo(2));
Assert.That(tupleArgument.Members, Is.Not.Null);
Assert.That(tupleArgument.Members.Count, Is.EqualTo(2));
CheckMemberInNewExpression(typeof(Tuple <string, int>), "Item1", tupleArgument.Members[0]);
CheckMemberInNewExpression(typeof(Tuple <string, int>), "Item2", tupleArgument.Members[1]);
}
public void GeneralSelectMany ()
{
var expression = FromTestQueryGenerator.CreateMultiFromQuery (QuerySource, QuerySource).Expression;
var queryModel = QueryParser.GetParsedQuery (expression);
var mainFromClause = queryModel.MainFromClause;
CheckConstantQuerySource (mainFromClause.FromExpression, QuerySource);
Assert.That (mainFromClause.ItemName, Is.EqualTo ("s1"));
Assert.That (mainFromClause.ItemType, Is.SameAs (typeof (Cook)));
Assert.That (queryModel.BodyClauses[0], Is.InstanceOf (typeof (AdditionalFromClause)));
var additionalFromClause = (AdditionalFromClause) queryModel.BodyClauses[0];
Assert.That (additionalFromClause.ItemName, Is.EqualTo ("s2"));
CheckConstantQuerySource (additionalFromClause.FromExpression, QuerySource);
var selectClause = queryModel.SelectClause;
CheckResolvedExpression<Cook, Cook> (selectClause.Selector, queryModel.MainFromClause, s1 => s1);
}
public void LongCount()
{
var expression = ExpressionHelper.MakeExpression(() => (from s in QuerySource
select s.ID).LongCount());
var queryModel = QueryParser.GetParsedQuery(expression);
Assert.That(queryModel.GetOutputDataInfo().DataType, Is.SameAs(typeof(long)));
var mainFromClause = queryModel.MainFromClause;
CheckConstantQuerySource(mainFromClause.FromExpression, QuerySource);
Assert.That(queryModel.ResultOperators.Count, Is.EqualTo(1));
Assert.That(queryModel.ResultOperators[0], Is.InstanceOf(typeof(LongCountResultOperator)));
CheckResolvedExpression <Cook, int> (queryModel.SelectClause.Selector, mainFromClause, s => s.ID);
}
public void Contains_Enumerable_OnDictionary_IsTranslatedAsAContainsResultOperator()
{
var dictionary = new Dictionary <string, int>();
var query = from c in QuerySource
where dictionary.Contains(new KeyValuePair <string, int> (c.Name, c.ID))
select c;
var queryModel = QueryParser.GetParsedQuery(query.Expression);
var whereClause = (WhereClause)queryModel.BodyClauses.Single();
Assert.That(whereClause.Predicate, Is.InstanceOf <SubQueryExpression> ());
var subQueryModel = ((SubQueryExpression)whereClause.Predicate).QueryModel;
Assert.That(subQueryModel.ResultOperators, Has.Count.EqualTo(1));
Assert.That(subQueryModel.ResultOperators.Single(), Is.TypeOf <ContainsResultOperator>());
}
public void SubQuery_InMainExpressionNode()
{
var queryExpression = ExpressionHelper.MakeExpression(() => new { Result = (from k in QuerySource select k) }.Result.Count());
var queryModel = QueryParser.GetParsedQuery(queryExpression);
Assert.That(queryModel.IsIdentityQuery(), Is.True);
Assert.That(queryModel.ResultOperators.Count, Is.EqualTo(1));
Assert.That(queryModel.ResultOperators[0], Is.TypeOf(typeof(CountResultOperator)));
var fromExpression = (MemberExpression)queryModel.MainFromClause.FromExpression;
var newExpression = (NewExpression)fromExpression.Expression;
var innerSubQuery = (SubQueryExpression)newExpression.Arguments[0];
Assert.That(innerSubQuery.QueryModel.IsIdentityQuery(), Is.True);
CheckConstantQuerySource(innerSubQuery.QueryModel.MainFromClause.FromExpression, QuerySource);
}
public void SimpleSubQuery_InAdditionalFromClause()
{
var expression = SubQueryTestQueryGenerator.CreateSimpleSubQueryInAdditionalFromClause(QuerySource).Expression;
var queryModel = QueryParser.GetParsedQuery(expression);
Assert.That(queryModel.BodyClauses.Count, Is.EqualTo(1));
var subQueryFromClause = (AdditionalFromClause)queryModel.BodyClauses[0];
var subQueryModel = ((SubQueryExpression)subQueryFromClause.FromExpression).QueryModel;
var subQueryMainFromClause = subQueryModel.MainFromClause;
Assert.That(subQueryMainFromClause.ItemName, Is.EqualTo("s3"));
CheckConstantQuerySource(subQueryMainFromClause.FromExpression, QuerySource);
var subQuerySelectClause = subQueryModel.SelectClause;
CheckResolvedExpression <Cook, Cook> (subQuerySelectClause.Selector, subQueryMainFromClause, s3 => s3);
}
public void WhereAndSelectMannyWithProjection ()
{
var expression = MixedTestQueryGenerator.CreateReverseFromWhereQueryWithProjection (QuerySource, QuerySource).Expression;
var queryModel = QueryParser.GetParsedQuery (expression);
var mainFromClause = queryModel.MainFromClause;
Assert.That (mainFromClause.ItemName, Is.EqualTo ("s1"));
Assert.That (queryModel.BodyClauses.Count, Is.EqualTo (2));
var whereClause = (WhereClause) queryModel.BodyClauses[0];
CheckResolvedExpression<Cook, bool> (whereClause.Predicate, queryModel.MainFromClause, s1 => s1.Name == "Garcia");
var additionalFromClause = (AdditionalFromClause) queryModel.BodyClauses[1];
CheckConstantQuerySource (additionalFromClause.FromExpression, QuerySource);
var selectClause = queryModel.SelectClause;
CheckResolvedExpression<Cook, string> (selectClause.Selector, (AdditionalFromClause) queryModel.BodyClauses.Last(), s2 => s2.Name);
}
public void AsQueryable()
{
var query =
from s in QuerySource.Where(c => c.Assistants.AsQueryable().Any())
select s;
var queryModel = QueryParser.GetParsedQuery(query.Expression);
Assert.That(queryModel.GetOutputDataInfo().DataType, Is.SameAs(typeof(IQueryable <Cook>)));
CheckConstantQuerySource(queryModel.MainFromClause.FromExpression, QuerySource);
var whereClause = (WhereClause)queryModel.BodyClauses[0];
var subQueryModel = ((SubQueryExpression)whereClause.Predicate).QueryModel;
Assert.That(subQueryModel.ResultOperators[0], Is.InstanceOf(typeof(AsQueryableResultOperator)));
Assert.That(subQueryModel.ResultOperators[1], Is.InstanceOf(typeof(AnyResultOperator)));
}
public void Any_WithPredicate()
{
var expression = ExpressionHelper.MakeExpression(() => (from s in QuerySource
select s).Any(s => s.IsFullTimeCook));
var queryModel = QueryParser.GetParsedQuery(expression);
Assert.That(queryModel.GetOutputDataInfo().DataType, Is.SameAs(typeof(bool)));
CheckConstantQuerySource(queryModel.MainFromClause.FromExpression, QuerySource);
Assert.That(queryModel.BodyClauses.Count, Is.EqualTo(1));
Assert.That(queryModel.BodyClauses[0], Is.InstanceOf(typeof(WhereClause)));
CheckResolvedExpression <Cook, bool> (((WhereClause)queryModel.BodyClauses[0]).Predicate, queryModel.MainFromClause, s => s.IsFullTimeCook);
Assert.That(queryModel.ResultOperators.Count, Is.EqualTo(1));
Assert.That(queryModel.ResultOperators[0], Is.InstanceOf(typeof(AnyResultOperator)));
}
public static (SelectExpression, IReadOnlyDictionary <string, object>) Compile(
this DbContext dbContext, Expression linqExpression)
{
QueryContext queryContext = dbContext.GetService <IQueryContextFactory>().Create();
IEvaluatableExpressionFilter evaluatableExpressionFilter = dbContext.GetService <IEvaluatableExpressionFilter>();
linqExpression = new ParameterExtractingExpressionVisitor(
evaluatableExpressionFilter: evaluatableExpressionFilter,
parameterValues: queryContext,
logger: dbContext.GetService <IDiagnosticsLogger <DbLoggerCategory.Query> >(),
context: dbContext,
parameterize: true).ExtractParameters(linqExpression);
QueryParser queryParser = new QueryParser(new ExpressionTreeParser(
nodeTypeProvider: dbContext.GetService <INodeTypeProviderFactory>().Create(),
processor: new CompoundExpressionTreeProcessor(new IExpressionTreeProcessor[]
{
new PartialEvaluatingExpressionTreeProcessor(evaluatableExpressionFilter),
new TransformingExpressionTreeProcessor(ExpressionTransformerRegistry.CreateDefault())
})));
QueryModel queryModel = queryParser.GetParsedQuery(linqExpression);
Type resultType = queryModel.GetResultType();
if (resultType.IsConstructedGenericType && resultType.GetGenericTypeDefinition() == typeof(IQueryable <>))
{
resultType = resultType.GenericTypeArguments.Single();
}
QueryCompilationContext compilationContext = dbContext.GetService <IQueryCompilationContextFactory>()
.Create(async: false);
RelationalQueryModelVisitor queryModelVisitor = (RelationalQueryModelVisitor)compilationContext
.CreateQueryModelVisitor();
queryModelVisitor.GetType()
.GetMethod(nameof(RelationalQueryModelVisitor.CreateQueryExecutor))
.MakeGenericMethod(resultType)
.Invoke(queryModelVisitor, new object[] { queryModel });
SelectExpression databaseExpression = queryModelVisitor.TryGetQuery(queryModel.MainFromClause);
databaseExpression.QuerySource = queryModel.MainFromClause;
return(databaseExpression, queryContext.ParameterValues);
}
public void WhereWithContainsFromNonGenericIListAsParameter()
{
IList list = new List <Cook> ();
var expression = ExpressionHelper.MakeExpression(() => (from s in QuerySource where list.Contains(s) select s));
var queryModel = QueryParser.GetParsedQuery(expression);
CheckConstantQuerySource(queryModel.MainFromClause.FromExpression, QuerySource);
var whereClause = (WhereClause)queryModel.BodyClauses[0];
Assert.That(whereClause.Predicate, Is.TypeOf(typeof(SubQueryExpression)));
var subQueryModel = ((SubQueryExpression)whereClause.Predicate).QueryModel;
Assert.That(subQueryModel.ResultOperators.Count, Is.EqualTo(1));
Assert.That(subQueryModel.ResultOperators[0], Is.InstanceOf(typeof(ContainsResultOperator)));
var selectClause = queryModel.SelectClause;
CheckResolvedExpression <Cook, Cook> (selectClause.Selector, queryModel.MainFromClause, s => s);
}
public void Aggregate_Seed_FuncParameterAssignableFromSeedValue()
{
var expression = ExpressionHelper.MakeExpression(
() => (from s in QuerySource
select s).Aggregate <Cook, IConvertible> ("12", (convertible, s) => convertible.ToInt32(Thread.CurrentThread.CurrentCulture) + s.ID));
var queryModel = QueryParser.GetParsedQuery(expression);
Assert.That(queryModel.GetOutputDataInfo().DataType, Is.SameAs(typeof(IConvertible)));
CheckConstantQuerySource(queryModel.MainFromClause.FromExpression, QuerySource);
Assert.That(queryModel.ResultOperators.Count, Is.EqualTo(1));
Assert.That(queryModel.ResultOperators[0], Is.InstanceOf(typeof(AggregateFromSeedResultOperator)));
var resultOperator = (AggregateFromSeedResultOperator)queryModel.ResultOperators[0];
Assert.That(resultOperator.Seed.Type, Is.SameAs(typeof(string)));
Assert.That(resultOperator.Func.Parameters[0].Type, Is.SameAs(typeof(IConvertible)));
}
public void MultiFromsWithOrderBy()
{
var expression = MixedTestQueryGenerator.CreateMultiFromWhereOrderByQuery(QuerySource, QuerySource).Expression;
var queryModel = QueryParser.GetParsedQuery(expression);
var additionalFromClause = (AdditionalFromClause)queryModel.BodyClauses[0];
CheckConstantQuerySource(additionalFromClause.FromExpression, QuerySource);
var whereClause = (WhereClause)queryModel.BodyClauses[1];
CheckResolvedExpression <Cook, bool> (whereClause.Predicate, queryModel.MainFromClause, s1 => s1.Name == "Garcia");
var orderByClause = (OrderByClause)queryModel.BodyClauses[2];
Assert.That(orderByClause.Orderings[0].OrderingDirection, Is.EqualTo(OrderingDirection.Asc));
CheckResolvedExpression <Cook, string> (orderByClause.Orderings[0].Expression, queryModel.MainFromClause, s1 => s1.FirstName);
Assert.That(orderByClause.Orderings[1].OrderingDirection, Is.EqualTo(OrderingDirection.Desc));
CheckResolvedExpression <Cook, string> (orderByClause.Orderings[1].Expression, additionalFromClause, s2 => s2.Name);
}
public void Contains_NonGenericIList()
{
IList list = new List <Cook> ();
var expression = ExpressionHelper.MakeExpression(() => (from s in QuerySource
select list.Contains(s)));
var queryModel = QueryParser.GetParsedQuery(expression);
Assert.That(queryModel.GetOutputDataInfo().DataType, Is.SameAs(typeof(IQueryable <bool>)));
Assert.That(queryModel.SelectClause.Selector, Is.TypeOf(typeof(SubQueryExpression)));
var subQueryModel = ((SubQueryExpression)queryModel.SelectClause.Selector).QueryModel;
Assert.That(subQueryModel.ResultOperators.Count, Is.EqualTo(1));
Assert.That(subQueryModel.ResultOperators[0], Is.InstanceOf(typeof(ContainsResultOperator)));
var exoectedItemExpression = new QuerySourceReferenceExpression(queryModel.MainFromClause);
ExpressionTreeComparer.CheckAreEqualTrees(exoectedItemExpression, ((ContainsResultOperator)subQueryModel.ResultOperators[0]).Item);
}
public void Reverse()
{
var query = (from s in ExpressionHelper.CreateQueryable <Cook> ()
select s).Reverse();
var queryModel = QueryParser.GetParsedQuery(query.Expression);
Assert.That(queryModel.GetOutputDataInfo().DataType, Is.SameAs(typeof(IQueryable <Cook>)));
var mainFromClause = queryModel.MainFromClause;
Assert.That(queryModel.ResultOperators.Count, Is.EqualTo(1));
Assert.That(queryModel.ResultOperators[0], Is.InstanceOf(typeof(ReverseResultOperator)));
var skipResultOperator = (ReverseResultOperator)queryModel.ResultOperators[0];
Assert.That(skipResultOperator, Is.Not.Null);
var selectClause = queryModel.SelectClause;
Assert.That(((QuerySourceReferenceExpression)selectClause.Selector).ReferencedQuerySource, Is.SameAs(mainFromClause));
}
public void Intersect_FollowedByAll()
{
IEnumerable <Cook> cooks = new[] { new Cook() };
var expression = ExpressionHelper.MakeExpression(() => (from c in QuerySource
select c)
.Intersect(cooks)
.All(c => c.IsFullTimeCook));
var queryModel = QueryParser.GetParsedQuery(expression);
Assert.That(queryModel.GetOutputDataInfo().DataType, Is.SameAs(typeof(bool)));
Assert.That(queryModel.ResultOperators, Has.Count.EqualTo(2));
Assert.That(queryModel.ResultOperators[0], Is.TypeOf <IntersectResultOperator> ());
Assert.That(queryModel.ResultOperators[1], Is.TypeOf <AllResultOperator> ());
var allResultOperator = (AllResultOperator)queryModel.ResultOperators[1];
CheckResolvedExpression <Cook, bool> (allResultOperator.Predicate, queryModel.MainFromClause, c => c.IsFullTimeCook);
}
public void InvocationExpression_AppliedToLambdaExpression()
{
Expression <Func <Cook, bool> > predicate1 = c => c.ID > 100;
Expression <Func <Cook, bool> > predicate2 = c => c.Name != null;
// c => c.ID > 100 && ((c1 => c1.Name != null) (c))
var combinedPredicate =
Expression.Lambda <Func <Cook, bool> > (
Expression.AndAlso(
predicate1.Body,
Expression.Invoke(predicate2, predicate1.Parameters.Cast <Expression> ())
),
predicate1.Parameters);
var query = QuerySource.Where(combinedPredicate);
var queryModel = QueryParser.GetParsedQuery(query.Expression);
var predicate = ((WhereClause)queryModel.BodyClauses[0]).Predicate;
CheckResolvedExpression <Cook, bool> (predicate, queryModel.MainFromClause, c => c.ID > 100 && c.Name != null);
}
public void ContainsWithBackReference()
{
var query =
from s in QuerySource
where s.Assistants.Contains(s)
select s;
var queryModel = QueryParser.GetParsedQuery(query.Expression);
Assert.That(queryModel.GetOutputDataInfo().DataType, Is.SameAs(typeof(IQueryable <Cook>)));
var mainFromClause = queryModel.MainFromClause;
var whereClause = (WhereClause)queryModel.BodyClauses[0];
var subQueryModel = ((SubQueryExpression)whereClause.Predicate).QueryModel;
Assert.That(subQueryModel.ResultOperators[0], Is.InstanceOf(typeof(ContainsResultOperator)));
var containsResultOperator = (ContainsResultOperator)subQueryModel.ResultOperators[0];
CheckResolvedExpression <Cook, Cook> (containsResultOperator.Item, mainFromClause, s => s);
}
public void GroupJoin_WithSubQueryAsFirstQuerySource()
{
var query = from s in QuerySource.Take(2)
join sd in DetailQuerySource on s.ID equals sd.RoomNumber into sds
select Tuple.Create(s, sds);
var queryModel = QueryParser.GetParsedQuery(query.Expression);
Assert.That(queryModel.GetOutputDataInfo().DataType, Is.SameAs(typeof(IQueryable <Tuple <Cook, IEnumerable <Kitchen> > >)));
var mainFromClause = queryModel.MainFromClause;
Assert.That(mainFromClause.ItemType, Is.SameAs(typeof(Cook)));
Assert.That(mainFromClause.ItemName, Is.EqualTo("s"));
var subQueryModel = ((SubQueryExpression)mainFromClause.FromExpression).QueryModel;
var subQueryMainFromClause = subQueryModel.MainFromClause;
Assert.That(subQueryMainFromClause.ItemType, Is.SameAs(typeof(Cook)));
Assert.That(subQueryMainFromClause.ItemName, Is.EqualTo("<generated>_1"));
var groupJoinClause = ((GroupJoinClause)queryModel.BodyClauses[0]);
Assert.That(groupJoinClause.ItemName, Is.SameAs("sds"));
Assert.That(groupJoinClause.ItemType, Is.SameAs(typeof(IEnumerable <Kitchen>)));
CheckConstantQuerySource(groupJoinClause.JoinClause.InnerSequence, DetailQuerySource);
Assert.That(groupJoinClause.JoinClause.ItemType, Is.SameAs(typeof(Kitchen)));
Assert.That(groupJoinClause.JoinClause.ItemName, Is.EqualTo("sd"));
CheckResolvedExpression <Cook, int> (groupJoinClause.JoinClause.OuterKeySelector, mainFromClause, s => s.ID);
CheckResolvedExpression <Kitchen, int> (groupJoinClause.JoinClause.InnerKeySelector, groupJoinClause.JoinClause, sd => sd.RoomNumber);
var selectClause = queryModel.SelectClause;
CheckResolvedExpression <Cook, IEnumerable <Kitchen>, Tuple <Cook, IEnumerable <Kitchen> > > (
selectClause.Selector,
mainFromClause,
groupJoinClause,
(s, sds) => Tuple.Create(s, sds));
}
public void ThreeWheres()
{
var expression = WhereTestQueryGenerator.CreateMultiWhereQuery(QuerySource).Expression;
var queryModel = QueryParser.GetParsedQuery(expression);
Assert.That(queryModel.BodyClauses.Count, Is.EqualTo(3));
var whereClause1 = (WhereClause)queryModel.BodyClauses[0];
CheckResolvedExpression <Cook, bool> (whereClause1.Predicate, queryModel.MainFromClause, s => s.Name == "Garcia");
var whereClause2 = (WhereClause)queryModel.BodyClauses[1];
CheckResolvedExpression <Cook, bool> (whereClause2.Predicate, queryModel.MainFromClause, s => s.FirstName == "Hugo");
var whereClause3 = (WhereClause)queryModel.BodyClauses[2];
CheckResolvedExpression <Cook, bool> (whereClause3.Predicate, queryModel.MainFromClause, s => s.ID > 100);
var selectClause = queryModel.SelectClause;
CheckResolvedExpression <Cook, Cook> (selectClause.Selector, queryModel.MainFromClause, s => s);
}
public void Aggregate_NoSeed()
{
var expression = ExpressionHelper.MakeExpression(() => (from s in QuerySource
select s.Name).Aggregate((allNames, name) => allNames + " " + name));
var queryModel = QueryParser.GetParsedQuery(expression);
Assert.That(queryModel.GetOutputDataInfo().DataType, Is.SameAs(typeof(string)));
CheckConstantQuerySource(queryModel.MainFromClause.FromExpression, QuerySource);
Assert.That(queryModel.ResultOperators.Count, Is.EqualTo(1));
Assert.That(queryModel.ResultOperators[0], Is.InstanceOf(typeof(AggregateResultOperator)));
var resultOperator = (AggregateResultOperator)queryModel.ResultOperators[0];
var expectedFunc = ExpressionHelper.ResolveLambdaParameter <string, Cook, string> (
1,
queryModel.MainFromClause,
(allNames, student) => allNames + " " + student.Name);
ExpressionTreeComparer.CheckAreEqualTrees(expectedFunc, resultOperator.Func);
}
public void Join_InnerSequenceIsNonGenericIEnumerableAsProperty()
{
var query = from s in QuerySource
from s2 in (from s1 in QuerySource join s2 in s.Courses.Cast <Course>() on "special course" equals s2.Name select s2)
select s2;
var queryModel = QueryParser.GetParsedQuery(query.Expression);
var mainFromClause = queryModel.MainFromClause;
var additionalFromClause = (AdditionalFromClause)queryModel.BodyClauses[0];
var innerJoinClause = ((JoinClause)((SubQueryExpression)additionalFromClause.FromExpression).QueryModel.BodyClauses[0]);
Assert.That(innerJoinClause.InnerSequence, Is.TypeOf(typeof(SubQueryExpression)));
var subQueryModel = ((SubQueryExpression)innerJoinClause.InnerSequence).QueryModel;
Assert.That(subQueryModel.MainFromClause.FromExpression, Is.InstanceOf(typeof(MemberExpression)));
var propertyExpression = (MemberExpression)subQueryModel.MainFromClause.FromExpression;
Assert.That(propertyExpression.Member, Is.SameAs(typeof(Cook).GetProperty("Courses")));
Assert.That(innerJoinClause.ItemType, Is.SameAs(typeof(Course)));
Assert.That(innerJoinClause.ItemName, Is.EqualTo("s2"));
}
public void GroupByWithoutElementSelector()
{
var query = QuerySource.GroupBy(s => s.IsStarredCook);
var queryModel = QueryParser.GetParsedQuery(query.Expression);
Assert.That(queryModel.GetOutputDataInfo().DataType, Is.SameAs(typeof(IQueryable <IGrouping <bool, Cook> >)));
var mainFromClause = queryModel.MainFromClause;
CheckConstantQuerySource(mainFromClause.FromExpression, QuerySource);
Assert.That(mainFromClause.ItemType, Is.SameAs(typeof(Cook)));
Assert.That(mainFromClause.ItemName, Is.EqualTo("s"));
var selectClause = queryModel.SelectClause;
CheckResolvedExpression <Cook, Cook> (selectClause.Selector, mainFromClause, s => s);
var groupResultOperator = (GroupResultOperator)queryModel.ResultOperators[0];
CheckResolvedExpression <Cook, bool> (groupResultOperator.KeySelector, mainFromClause, s => s.IsStarredCook);
CheckResolvedExpression <Cook, Cook> (groupResultOperator.ElementSelector, mainFromClause, s => s);
}
public void EmptyParameterNames_CanBeParsed()
{
var parameterExpression = Expression.Parameter(typeof(Cook), "");
var predicate =
Expression.Equal(
Expression.MakeMemberAccess(parameterExpression, typeof(Cook).GetProperty("Name")),
Expression.Constant("Test"));
var selector = Expression.MakeMemberAccess(parameterExpression, typeof(Cook).GetProperty("ID"));
var query = QuerySource
.Where(Expression.Lambda <Func <Cook, bool> > (predicate, parameterExpression))
.Select(Expression.Lambda <Func <Cook, int> > (selector, parameterExpression));
var queryModel = QueryParser.GetParsedQuery(query.Expression);
var whereClause = (WhereClause)queryModel.BodyClauses.Single();
CheckResolvedExpression <Cook, bool> (whereClause.Predicate, queryModel.MainFromClause, c => c.Name == "Test");
var selectClause = queryModel.SelectClause;
CheckResolvedExpression <Cook, int> (selectClause.Selector, queryModel.MainFromClause, c => c.ID);
Assert.That(queryModel.MainFromClause.ItemName, Is.StringStarting("<generated>_"));
}
public void Exception_InEvaluableSubExpression()
{
string nullValue = null;
var query = from c in QuerySource where nullValue != null && c.ID > nullValue.Length select c.Name;
var queryModel = QueryParser.GetParsedQuery(query.Expression);
var whereClause = (WhereClause)queryModel.BodyClauses[0];
// Expected: false && c.ID > Exception (nullValue.Length)
Assert.That(whereClause.Predicate, Is.AssignableTo <BinaryExpression>().With.Property("NodeType").EqualTo(ExpressionType.AndAlso));
var outerBinary = ((BinaryExpression)whereClause.Predicate);
CheckResolvedExpression <Cook, bool> (outerBinary.Left, queryModel.MainFromClause, c => false);
Assert.That(outerBinary.Right, Is.AssignableTo <BinaryExpression> ().With.Property("NodeType").EqualTo(ExpressionType.GreaterThan));
var innerBinary = (BinaryExpression)outerBinary.Right;
CheckResolvedExpression <Cook, int> (innerBinary.Left, queryModel.MainFromClause, c => c.ID);
Assert.That(
innerBinary.Right,
Is.TypeOf <PartialEvaluationExceptionExpression>().With.Property("Exception").InstanceOf <NullReferenceException>());
CheckResolvedExpression <Cook, int> (
((PartialEvaluationExceptionExpression)innerBinary.Right).EvaluatedExpression, queryModel.MainFromClause, c => ((string)null).Length);
}
public void GroupBy_WithResultSelector_BeforeAll()
{
var queryExpression = ExpressionHelper.MakeExpression(
() => QuerySource
.GroupBy(s => s.IsStarredCook, s => s.ID, (key, group) => new NonTransformedTuple <bool, int> (key, group.GetHashCode()))
.All(kvp => kvp.Item2 > 0));
var queryModel = QueryParser.GetParsedQuery(queryExpression);
Assert.That(queryModel.GetOutputDataInfo().DataType, Is.SameAs(typeof(bool)));
var outerMainFromClause = queryModel.MainFromClause;
Assert.That(outerMainFromClause.FromExpression, Is.InstanceOf(typeof(SubQueryExpression)));
Assert.That(outerMainFromClause.ItemType, Is.SameAs(typeof(IGrouping <bool, int>)));
Assert.That(outerMainFromClause.ItemName, Is.EqualTo("kvp"));
Assert.That(queryModel.BodyClauses.Count, Is.EqualTo(0));
var outerSelectClause = queryModel.SelectClause;
CheckResolvedExpression <IGrouping <bool, int>, NonTransformedTuple <bool, int> > (
outerSelectClause.Selector,
outerMainFromClause,
x => new NonTransformedTuple <bool, int> (x.Key, x.GetHashCode()));
Assert.That(queryModel.ResultOperators.Count, Is.EqualTo(1));
Assert.That(queryModel.ResultOperators[0], Is.TypeOf(typeof(AllResultOperator)));
var allResultOperator = (AllResultOperator)queryModel.ResultOperators[0];
CheckResolvedExpression <IGrouping <bool, int>, bool> (
allResultOperator.Predicate,
outerMainFromClause,
x => new NonTransformedTuple <bool, int> (x.Key, x.GetHashCode()).Item2 > 0);
}
public void Concat()
{
IEnumerable <Cook> students = new[] { new Cook() };
var expression = ExpressionHelper.MakeExpression(() => (from s in QuerySource
select s).Concat(students));
var queryModel = QueryParser.GetParsedQuery(expression);
var mainFromClause = queryModel.MainFromClause;
var selectClause = queryModel.SelectClause;
Assert.That(((QuerySourceReferenceExpression)selectClause.Selector).ReferencedQuerySource, Is.SameAs(mainFromClause));
Assert.That(queryModel.ResultOperators.Count, Is.EqualTo(1));
Assert.That(queryModel.ResultOperators[0], Is.InstanceOf(typeof(ConcatResultOperator)));
var ConcatResultOperator = ((ConcatResultOperator)queryModel.ResultOperators[0]);
Assert.That(ConcatResultOperator.GetConstantSource2(), Is.SameAs(students));
var outputDataInfo = (StreamedSequenceInfo)queryModel.GetOutputDataInfo();
Assert.That(outputDataInfo.DataType, Is.SameAs(typeof(IQueryable <Cook>)));
CheckResolvedExpression <Cook, Cook> (outputDataInfo.ItemExpression, ConcatResultOperator, c => c);
}
public void TakeWithBackReference()
{
var query =
from s in QuerySource
from s1 in s.Assistants.Take(s.ID)
select s1;
var queryModel = QueryParser.GetParsedQuery(query.Expression);
Assert.That(queryModel.GetOutputDataInfo().DataType, Is.SameAs(typeof(IQueryable <Cook>)));
var mainFromClause = queryModel.MainFromClause;
var additionalFromClause = (AdditionalFromClause)queryModel.BodyClauses[0];
var subQueryModel = ((SubQueryExpression)additionalFromClause.FromExpression).QueryModel;
Assert.That(subQueryModel.ResultOperators[0], Is.InstanceOf(typeof(TakeResultOperator)));
var takeResultOperator = (TakeResultOperator)subQueryModel.ResultOperators[0];
CheckResolvedExpression <Cook, int> (takeResultOperator.Count, mainFromClause, s => s.ID);
Assert.That(subQueryModel.GetOutputDataInfo().DataType, Is.SameAs(typeof(IQueryable <Cook>)));
}
