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