public void SetUp() { _context = new MappingResolutionContext(); _entityExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Cook), null, "c"); _groupingSelectExpression = new SqlGroupingSelectExpression(Expression.Constant("key"), Expression.Constant("element")); _sqlTable = new SqlTable(new ResolvedSimpleTableInfo(typeof(Cook), "CookTable", "c"), JoinSemantics.Inner); }
public void ResolveJoinInfo_ResolvesCollectionJoinInfo() { var memberInfo = typeof(Cook).GetProperty("IllnessDays"); var unresolvedCollectionJoinInfo = new UnresolvedCollectionJoinInfo(Expression.Constant(new Cook()), memberInfo); var sqlEntityExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Cook)); var fakeResolvedJoinInfo = SqlStatementModelObjectMother.CreateResolvedJoinInfo(); _stageMock .Expect(mock => mock.ResolveCollectionSourceExpression(unresolvedCollectionJoinInfo.SourceExpression, _mappingResolutionContext)) .Return(sqlEntityExpression); _resolverMock .Expect( mock => mock.ResolveJoinInfo( Arg <UnresolvedJoinInfo> .Matches(a => a.MemberInfo == memberInfo && a.OriginatingEntity.Type == typeof(Cook)), Arg.Is(_generator))) .Return(fakeResolvedJoinInfo); _stageMock .Expect(mock => mock.ResolveTableInfo(fakeResolvedJoinInfo.ForeignTableInfo, _mappingResolutionContext)) .Return(fakeResolvedJoinInfo.ForeignTableInfo); _stageMock .Expect(mock => mock.ResolveJoinCondition(fakeResolvedJoinInfo.JoinCondition, _mappingResolutionContext)) .Return(fakeResolvedJoinInfo.JoinCondition); var resolvedJoinInfo = ResolvingJoinInfoVisitor.ResolveJoinInfo(unresolvedCollectionJoinInfo, _resolverMock, _generator, _stageMock, _mappingResolutionContext); Assert.That(resolvedJoinInfo, Is.SameAs(fakeResolvedJoinInfo)); _stageMock.VerifyAllExpectations(); _resolverMock.VerifyAllExpectations(); }
public void ItemType_CardinalityMany() { var entityExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Restaurant)); var joinInfo = new UnresolvedJoinInfo(entityExpression, typeof(Restaurant).GetProperty("Cooks"), JoinCardinality.Many); Assert.That(joinInfo.ItemType, Is.SameAs(typeof(Cook))); }
public void ResolveSqlTable_ResolvesJoinInfo_Multiple() { var memberInfo1 = typeof(Kitchen).GetProperty("Cook"); var entityExpression1 = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Kitchen)); var unresolvedJoinInfo1 = new UnresolvedJoinInfo(entityExpression1, memberInfo1, JoinCardinality.One); var memberInfo2 = typeof(Kitchen).GetProperty("Restaurant"); var entityExpression2 = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Cook)); var unresolvedJoinInfo2 = new UnresolvedJoinInfo(entityExpression2, memberInfo2, JoinCardinality.One); var join1 = _sqlTable.GetOrAddLeftJoin(unresolvedJoinInfo1, memberInfo1); var join2 = _sqlTable.GetOrAddLeftJoin(unresolvedJoinInfo2, memberInfo2); var fakeResolvedJoinInfo1 = SqlStatementModelObjectMother.CreateResolvedJoinInfo(typeof(Cook)); var fakeResolvedJoinInfo2 = SqlStatementModelObjectMother.CreateResolvedJoinInfo(typeof(Restaurant)); using (_stageMock.GetMockRepository().Ordered()) { _stageMock .Expect(mock => mock.ResolveTableInfo(_unresolvedTableInfo, _mappingResolutionContext)) .Return(_fakeResolvedSimpleTableInfo); _stageMock .Expect(mock => mock.ResolveJoinInfo(join1.JoinInfo, _mappingResolutionContext)) .Return(fakeResolvedJoinInfo1); _stageMock .Expect(mock => mock.ResolveJoinInfo(join2.JoinInfo, _mappingResolutionContext)) .Return(fakeResolvedJoinInfo2); } _stageMock.Replay(); _visitor.ResolveSqlTable(_sqlTable); _stageMock.VerifyAllExpectations(); Assert.That(join1.JoinInfo, Is.SameAs(fakeResolvedJoinInfo1)); Assert.That(join2.JoinInfo, Is.SameAs(fakeResolvedJoinInfo2)); }
public void ResolveMemberAccess_OnEntityRefMemberExpression_NoOptimization() { var memberInfo = typeof(Cook).GetProperty("Substitution"); var entityRefMemberExpression = SqlStatementModelObjectMother.CreateSqlEntityRefMemberExpression(); _resolverMock .Stub(mock => mock.TryResolveOptimizedMemberExpression(entityRefMemberExpression, memberInfo)) .Return(null); var fakeEntityExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Cook)); _stageMock .Expect( mock => mock.ResolveEntityRefMemberExpression( Arg.Is(entityRefMemberExpression), Arg <UnresolvedJoinInfo> .Matches(j => j.OriginatingEntity == entityRefMemberExpression.OriginatingEntity && j.MemberInfo == entityRefMemberExpression.MemberInfo && j.Cardinality == JoinCardinality.One), Arg.Is(_mappingResolutionContext))) .Return(fakeEntityExpression); var fakeResult = Expression.Constant(0); _resolverMock .Expect(mock => mock.ResolveMemberExpression(fakeEntityExpression, memberInfo)) .Return(fakeResult); var result = MemberAccessResolver.ResolveMemberAccess(entityRefMemberExpression, memberInfo, _resolverMock, _stageMock, _mappingResolutionContext); _stageMock.VerifyAllExpectations(); _resolverMock.VerifyAllExpectations(); Assert.That(result, Is.SameAs(fakeResult)); }
public void VisitMemberExpression_ResolvesSourceExpression() { var memberInfo = typeof(Cook).GetProperty("ID"); var expression = Expression.Constant(null, typeof(Cook)); var memberExpression = Expression.MakeMemberAccess(expression, memberInfo); var fakeResolvedSourceExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Cook)); _resolverMock .Expect(mock => mock.ResolveConstantExpression(expression)) .Return(fakeResolvedSourceExpression); _resolverMock.Replay(); var fakeResolvedExpression = new SqlLiteralExpression(1); _stageMock .Expect(mock => mock.ResolveMemberAccess(fakeResolvedSourceExpression, memberInfo, _resolverMock, _mappingResolutionContext)) .Return(fakeResolvedExpression); _stageMock.Replay(); _visitor.Visit(memberExpression); _resolverMock.VerifyAllExpectations(); _stageMock.VerifyAllExpectations(); }
public void ResolveMemberAccess_OnEntity_WithCollectionMember() { var memberInfo = typeof(Cook).GetProperty("Courses"); var sqlEntityExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Cook), null, "c"); MemberAccessResolver.ResolveMemberAccess(sqlEntityExpression, memberInfo, _resolverMock, _stageMock, _mappingResolutionContext); }
public void ToString_NamedEntity() { var namedEntity = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Cook), "e1", "t"); var result = namedEntity.ToString(); Assert.That(result, Is.EqualTo("[t] AS [e1]")); }
public void ToString_WithEntityName() { var referencedEntity = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Cook), "e1"); var columnExpression = new SqlColumnReferenceExpression(typeof(int), "t0", "ID", true, referencedEntity); var result = columnExpression.ToString(); Assert.That(result, Is.EqualTo("[t0].[e1_ID] (REF)")); }
public void GenerateSql_VisitSqlColumnReferenceExpression_WithNamedEntity() { var entityExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Cook), "Test"); var sqlColumnExpression = new SqlColumnReferenceExpression(typeof(int), "s", "ID", false, entityExpression); SqlGeneratingExpressionVisitor.GenerateSql(sqlColumnExpression, _commandBuilder, _stageMock); Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo("[s].[Test_ID]")); }
public void VisitEntityRefMemberExpression_ThrowsNotSupportException() { var memberInfo = typeof(Restaurant).GetProperty("Cooks"); var entityExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Restaurant)); var expression = new SqlEntityRefMemberExpression(entityExpression, memberInfo); SqlPreparationFromExpressionVisitor.AnalyzeFromExpression( expression, _stageMock, _generator, _methodCallTransformerProvider, _context, null); }
public void VisitSqlEntityRefMemberExpression() { var memberInfo = typeof(Restaurant).GetProperty("Cooks"); var entityExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Restaurant)); var expression = new SqlEntityRefMemberExpression(entityExpression, memberInfo); SqlPreparationFromExpressionVisitor.AnalyzeFromExpression( expression, _stageMock, _generator, _methodCallTransformerProvider, _context, _tableGenerator, _someOrderingExtractionPolicy); }
public void ApplyContext_VisitUnresolvedJoinInfo() { var entityExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Cook)); var unresolvedJoinInfo = new UnresolvedJoinInfo(entityExpression, typeof(Cook).GetProperty("ID"), JoinCardinality.One); var result = SqlContextJoinInfoVisitor.ApplyContext(unresolvedJoinInfo, SqlExpressionContext.ValueRequired, _stageMock, _mappingResolutionContext); Assert.That(result, Is.SameAs(unresolvedJoinInfo)); }
public void ToString_UnnamedReferencedEntity() { var referencedEntity = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Cook), null); var entityReferenceExpression = new SqlEntityReferenceExpression(typeof(Cook), "q0", null, referencedEntity); var result = entityReferenceExpression.ToString(); Assert.That(result, Is.EqualTo("[q0] (ENTITY-REF)")); }
public void ResolveTableReferenceExpression() { var expression = new SqlTableReferenceExpression(SqlStatementModelObjectMother.CreateSqlTable_WithResolvedTableInfo(typeof(Cook))); var fakeResult = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Cook)); _resolverMock .Expect(mock => mock.ResolveSimpleTableInfo(expression.SqlTable.GetResolvedTableInfo(), _uniqueIdentifierGenerator)) .Return(fakeResult); var result = _stage.ResolveTableReferenceExpression(expression, _mappingResolutionContext); Assert.That(result, Is.SameAs(fakeResult)); }
public void UpdateEntityAndAddMapping() { var entity = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Cook)); var sqlTable = SqlStatementModelObjectMother.CreateSqlTable(typeof(Cook)); _context.AddSqlEntityMapping(entity, sqlTable); var result = (SqlEntityDefinitionExpression)_context.UpdateEntityAndAddMapping(entity, entity.Type, "newAlias", "newName"); Assert.That(result.TableAlias, Is.EqualTo("newAlias")); Assert.That(result.Name, Is.EqualTo("newName")); Assert.That(_context.GetSqlTableForEntityExpression(result), Is.SameAs(sqlTable)); }
public void GenerateSql_WithUnresolvedJoinInfo() { var originalTable = new SqlTable(new ResolvedSimpleTableInfo(typeof(Cook), "CookTable", "c"), JoinSemantics.Inner); var kitchenCookMember = typeof(Kitchen).GetProperty("Cook"); var entityExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Kitchen)); var unresolvedJoinInfo = new UnresolvedJoinInfo(entityExpression, kitchenCookMember, JoinCardinality.One); originalTable.GetOrAddLeftJoin(unresolvedJoinInfo, kitchenCookMember); Assert.That( () => SqlTableAndJoinTextGenerator.GenerateSql(originalTable, _commandBuilder, _stageMock, false), Throws.TypeOf <InvalidOperationException>().With.Message.EqualTo("UnresolvedJoinInfo is not valid at this point.")); }
public void RemoveNamesAndUpdateMapping_NameAroundEntity() { var entity = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(name: "X"); var sqlTable = SqlStatementModelObjectMother.CreateSqlTable(typeof(Cook)); _context.AddSqlEntityMapping(entity, sqlTable); var result = _context.RemoveNamesAndUpdateMapping(new NamedExpression("X", entity)); Assert.That(result, Is.TypeOf(entity.GetType())); Assert.That(((SqlEntityExpression)result).Name, Is.Null); Assert.That(_context.GetSqlTableForEntityExpression((SqlEntityExpression)result), Is.SameAs(sqlTable)); }
public void SetUp() { _stageMock = MockRepository.GenerateStrictMock <IMappingResolutionStage>(); _resolverMock = MockRepository.GenerateStrictMock <IMappingResolver>(); _context = new MappingResolutionContext(); _entityIdentityResolver = new EntityIdentityResolver(_stageMock, _resolverMock, _context); _entityExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Cook), primaryKeyType: typeof(int)); _entityConstantExpression = new SqlEntityConstantExpression(typeof(Cook), new Cook(), Expression.Constant(0)); _entityRefMemberExpression = new SqlEntityRefMemberExpression( SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Kitchen)), typeof(Kitchen).GetProperty("Cook")); }
public void ResolveGroupByExpression_EntityRetained() { var expression = Expression.Constant(true); var fakeEntityExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(); _resolverMock .Expect(mock => mock.ResolveConstantExpression(expression)) .Return(fakeEntityExpression); _resolverMock.Replay(); var result = _stage.ResolveGroupByExpression(expression, _mappingResolutionContext); _resolverMock.VerifyAllExpectations(); Assert.That(result, Is.SameAs(fakeEntityExpression)); }
public void ResolveMemberAccess_OnEntity() { var memberInfo = typeof(Cook).GetProperty("Substitution"); var sqlEntityExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Cook)); var fakeResult = Expression.Constant(0); _resolverMock .Expect(mock => mock.ResolveMemberExpression(sqlEntityExpression, memberInfo)) .Return(fakeResult); _resolverMock.Replay(); var result = MemberAccessResolver.ResolveMemberAccess(sqlEntityExpression, memberInfo, _resolverMock, _stageMock, _mappingResolutionContext); _resolverMock.VerifyAllExpectations(); Assert.That(result, Is.SameAs(fakeResult)); }
public void ResolveSubStatementReferenceExpression_RegistersEntityTable_WithinUnknownExpression() { var referencedExpression = Expression.Convert(SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Cook)), typeof(Chef)); var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement(referencedExpression); var tableInfo = new ResolvedSubStatementTableInfo("q0", sqlStatement); var sqlTable = new SqlTable(tableInfo, JoinSemantics.Inner); var result = SubStatementReferenceResolver.ResolveSubStatementReferenceExpression( referencedExpression, tableInfo, sqlTable, _context); Assert.That(result.NodeType, Is.EqualTo(ExpressionType.Convert)); var entityReference = (SqlEntityExpression)((UnaryExpression)result).Operand; Assert.That(_context.GetSqlTableForEntityExpression(entityReference), Is.SameAs(sqlTable)); }
public void ProcessNames_SqlEntityExpression() { var entityExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Cook), "test2"); var namedExpression = new NamedExpression("test", entityExpression); var tableRegisteredForEntity = SqlStatementModelObjectMother.CreateSqlTable(); _context.AddSqlEntityMapping(entityExpression, tableRegisteredForEntity); var result = _namedExpressionCombiner.ProcessNames(namedExpression); Assert.That(result, Is.Not.SameAs(namedExpression)); Assert.That(result, Is.TypeOf(typeof(SqlEntityDefinitionExpression))); Assert.That(((SqlEntityDefinitionExpression)result).Name, Is.EqualTo("test_test2")); Assert.That(_context.GetSqlTableForEntityExpression((SqlEntityExpression)result), Is.SameAs(tableRegisteredForEntity)); }
public void VisitMemberExpression() { var memberInfo = typeof(Cook).GetProperty("ID"); var expression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Cook)); var memberExpression = Expression.MakeMemberAccess(expression, memberInfo); var fakeResolvedExpression = new SqlLiteralExpression(1); _stageMock .Expect(mock => mock.ResolveMemberAccess(expression, memberInfo, _resolverMock, _mappingResolutionContext)) .Return(fakeResolvedExpression); _stageMock.Replay(); var result = ResolvingExpressionVisitor.ResolveExpression(memberExpression, _resolverMock, _stageMock, _mappingResolutionContext, _generator); _stageMock.VerifyAllExpectations(); Assert.That(result, Is.SameAs(fakeResolvedExpression)); }
public void ResolveReference() { var sqlTable = new SqlTable(_tableInfo, JoinSemantics.Inner); var fakeResult = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Cook)); var generator = new UniqueIdentifierGenerator(); var resolverMock = MockRepository.GenerateStrictMock <IMappingResolver>(); var mappingResolutionContext = new MappingResolutionContext(); resolverMock .Expect(mock => mock.ResolveSimpleTableInfo(_tableInfo, generator)) .Return(fakeResult); resolverMock.Replay(); var result = _tableInfo.ResolveReference(sqlTable, resolverMock, mappingResolutionContext, generator); resolverMock.VerifyAllExpectations(); Assert.That(result, Is.SameAs(fakeResult)); Assert.That(mappingResolutionContext.GetSqlTableForEntityExpression((SqlEntityExpression)result), Is.SameAs(sqlTable)); }
public void ResolveSubStatementReferenceExpression_CreatesEntityReference_ForEntities() { var entityDefinitionExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Cook)); var sqlStatement = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatement_Resolved(typeof(Cook))) { SelectProjection = entityDefinitionExpression, DataInfo = new StreamedSequenceInfo(typeof(Cook[]), Expression.Constant(new Cook())) }.GetSqlStatement(); var tableInfo = new ResolvedSubStatementTableInfo("q0", sqlStatement); var sqlTable = new SqlTable(tableInfo, JoinSemantics.Inner); var result = SubStatementReferenceResolver.ResolveSubStatementReferenceExpression(entityDefinitionExpression, tableInfo, sqlTable, _context); Assert.That(result, Is.TypeOf(typeof(SqlEntityReferenceExpression))); Assert.That(_context.GetSqlTableForEntityExpression((SqlEntityReferenceExpression)result), Is.SameAs(sqlTable)); var expectedResult = entityDefinitionExpression.CreateReference("q0", tableInfo.SqlStatement.SelectProjection.Type); SqlExpressionTreeComparer.CheckAreEqualTrees(expectedResult, result); }
public void ResolveSqlStatement() { var sqlTable = SqlStatementModelObjectMother.CreateSqlTable_WithUnresolvedTableInfo(typeof(Cook)); var tableReferenceExpression = new SqlTableReferenceExpression(new SqlTable(_fakeResolvedSimpleTableInfo, JoinSemantics.Inner)); var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement(tableReferenceExpression, new[] { sqlTable }); var fakeEntityExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Cook)); _resolverMock .Expect(mock => mock.ResolveTableInfo((UnresolvedTableInfo)((SqlTable)sqlStatement.SqlTables[0]).TableInfo, _uniqueIdentifierGenerator)) .Return(_fakeResolvedSimpleTableInfo); _resolverMock .Expect(mock => mock.ResolveSimpleTableInfo(tableReferenceExpression.SqlTable.GetResolvedTableInfo(), _uniqueIdentifierGenerator)) .Return(fakeEntityExpression); _resolverMock.Replay(); var newSqlStatment = _stage.ResolveSqlStatement(sqlStatement, _mappingResolutionContext); _resolverMock.VerifyAllExpectations(); Assert.That(((SqlTable)newSqlStatment.SqlTables[0]).TableInfo, Is.SameAs(_fakeResolvedSimpleTableInfo)); Assert.That(newSqlStatment.SelectProjection, Is.SameAs(fakeEntityExpression)); }
public void ResolveCollectionSourceExpression() { var constantExpression = Expression.Constant(new Cook()); var expression = Expression.MakeMemberAccess(constantExpression, typeof(Cook).GetProperty("FirstName")); var sqlColumnExpression = new SqlColumnDefinitionExpression(typeof(string), "c", "Name", false); var fakeResult = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Cook)); _resolverMock .Expect(mock => mock.ResolveConstantExpression(constantExpression)) .Return(sqlColumnExpression); _resolverMock .Expect(mock => mock.ResolveMemberExpression(sqlColumnExpression, expression.Member)) .Return(fakeResult); _resolverMock.Replay(); var result = _stage.ResolveCollectionSourceExpression(expression, _mappingResolutionContext); _resolverMock.VerifyAllExpectations(); Assert.That(result, Is.SameAs(fakeResult)); }
public void ResolveExpression_OptimizesEntityRefMemberComparisons() { // This test proves that the first stage (without resolving SqlEntityRefMemberExpressions) is executed. var memberInfo = typeof(Kitchen).GetProperty("Cook"); var entityExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Kitchen)); var fakeOptimizedRefIdentity = new SqlColumnDefinitionExpression(typeof(int), "c", "KitchenID", false); var entityRefMemberExpression = new SqlEntityRefMemberExpression(entityExpression, memberInfo); _resolverMock .Stub(stub => stub.TryResolveOptimizedIdentity(entityRefMemberExpression)) .Return(fakeOptimizedRefIdentity); var entity = CreateEntityExpressionWithIdentity(typeof(Cook), typeof(int)); var binary = Expression.Equal(entityRefMemberExpression, entity); var result = ResolvingExpressionVisitor.ResolveExpression(binary, _resolverMock, _stageMock, _mappingResolutionContext, _generator); var expected = Expression.Equal(fakeOptimizedRefIdentity, entity.GetIdentityExpression()); SqlExpressionTreeComparer.CheckAreEqualTrees(expected, result); }
public void ResolveSubStatementReferenceExpression_CreatesSqlGroupingReferenceExpression_ForSqlGroupingSelectExpression() { var groupingSelectExpression = new SqlGroupingSelectExpression( SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Cook), "key"), new NamedExpression("element", Expression.Constant(0)), new[] { new NamedExpression("a0", Expression.Constant(1)) }); var sqlStatement = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatement_Resolved(typeof(Cook))) { SelectProjection = groupingSelectExpression, DataInfo = new StreamedSequenceInfo(typeof(IGrouping <int, int>[]), Expression.Constant(null, typeof(IGrouping <int, int>))) }.GetSqlStatement(); var tableInfo = new ResolvedSubStatementTableInfo("q0", sqlStatement); var sqlTable = new SqlTable(tableInfo, JoinSemantics.Inner); var result = SubStatementReferenceResolver.ResolveSubStatementReferenceExpression(groupingSelectExpression, tableInfo, sqlTable, _context); Assert.That(result, Is.TypeOf(typeof(SqlGroupingSelectExpression))); var referencedKeyExpression = ((SqlGroupingSelectExpression)result).KeyExpression; var expectedReferencedKeyExpression = new NamedExpression("key", new SqlEntityReferenceExpression( typeof(Cook), "q0", null, (SqlEntityExpression)groupingSelectExpression.KeyExpression)); SqlExpressionTreeComparer.CheckAreEqualTrees(expectedReferencedKeyExpression, referencedKeyExpression); var referencedElementExpression = ((SqlGroupingSelectExpression)result).ElementExpression; var expectedReferencedElementExpression = new NamedExpression("element", new SqlColumnDefinitionExpression(typeof(int), "q0", "element", false)); SqlExpressionTreeComparer.CheckAreEqualTrees(expectedReferencedElementExpression, referencedElementExpression); Assert.That(((SqlGroupingSelectExpression)result).AggregationExpressions.Count, Is.EqualTo(1)); var referencedAggregationExpression = ((SqlGroupingSelectExpression)result).AggregationExpressions[0]; var expectedReferencedAggregationExpression = new NamedExpression("a0", new SqlColumnDefinitionExpression(typeof(int), "q0", "a0", false)); SqlExpressionTreeComparer.CheckAreEqualTrees(expectedReferencedAggregationExpression, referencedAggregationExpression); Assert.That(_context.GetReferencedGroupSource(((SqlGroupingSelectExpression)result)), Is.SameAs(sqlTable)); }