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