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 IJoinInfo VisitUnresolvedCollectionJoinInfo(UnresolvedCollectionJoinInfo joinInfo)
{
ArgumentUtility.CheckNotNull("joinInfo", joinInfo);
var resolvedExpression = _stage.ResolveCollectionSourceExpression(joinInfo.SourceExpression, _context);
while (resolvedExpression is UnaryExpression)
{
resolvedExpression = _stage.ResolveCollectionSourceExpression(((UnaryExpression)resolvedExpression).Operand, _context);
}
var resolvedExpressionAsEntity = resolvedExpression as SqlEntityExpression;
if (resolvedExpressionAsEntity != null)
{
var unresolvedJoinInfo = new UnresolvedJoinInfo(resolvedExpressionAsEntity, joinInfo.MemberInfo, JoinCardinality.Many);
return(unresolvedJoinInfo.Accept(this));
}
var message = string.Format(
"Only entities can be used as the collection source in from expressions, '{0}' cannot. Member: '{1}'",
resolvedExpression,
joinInfo.MemberInfo);
throw new NotSupportedException(message);
}
public void ApplyContext_VisitUnresolvedCollectionJoinInfo()
{
var unresolvedJoinInfo = new UnresolvedCollectionJoinInfo(Expression.Constant(new Cook()), typeof(Cook).GetProperty("IllnessDays"));
var result = SqlContextJoinInfoVisitor.ApplyContext(unresolvedJoinInfo, SqlExpressionContext.ValueRequired, _stageMock, _mappingResolutionContext);
Assert.That(result, Is.SameAs(unresolvedJoinInfo));
}
public void GenerateSql_WithUnresolvedCollectionJoinInfo()
{
var originalTable = new SqlTable(new ResolvedSimpleTableInfo(typeof(Cook), "CookTable", "c"), JoinSemantics.Inner);
var memberInfo = typeof(Restaurant).GetProperty("Cooks");
var collectionJoinInfo = new UnresolvedCollectionJoinInfo(Expression.Constant(new Cook[] { }), memberInfo);
originalTable.GetOrAddLeftJoin(collectionJoinInfo, memberInfo);
Assert.That(
() => SqlTableAndJoinTextGenerator.GenerateSql(originalTable, _commandBuilder, _stageMock, false),
Throws.TypeOf <InvalidOperationException>().With.Message.EqualTo("UnresolvedCollectionJoinInfo is not valid at this point."));
}
public void ResolveJoinInfo_ResolvesCollectionJoinInfo_NoEntity()
{
var memberInfo = typeof(Cook).GetProperty("IllnessDays");
var unresolvedCollectionJoinInfo = new UnresolvedCollectionJoinInfo(Expression.Constant(new Cook()), memberInfo);
var fakeExpression = Expression.Constant(1);
_stageMock
.Expect(mock => mock.ResolveCollectionSourceExpression(unresolvedCollectionJoinInfo.SourceExpression, _mappingResolutionContext))
.Return(fakeExpression);
ResolvingJoinInfoVisitor.ResolveJoinInfo(unresolvedCollectionJoinInfo, _resolverMock, _generator, _stageMock, _mappingResolutionContext);
}
protected override Expression VisitMemberExpression(MemberExpression expression)
{
ArgumentUtility.CheckNotNull("expression", expression);
var preparedMemberExpression = (MemberExpression)TranslateExpression(expression, Context, Stage, MethodCallTransformerProvider);
var joinInfo = new UnresolvedCollectionJoinInfo(preparedMemberExpression.Expression, preparedMemberExpression.Member);
var joinedTable = new SqlJoinedTable(joinInfo, JoinSemantics.Inner);
var oldStyleJoinedTable = _tableGenerator(joinedTable);
var sqlTableReferenceExpression = new SqlTableReferenceExpression(oldStyleJoinedTable);
FromExpressionInfo = new FromExpressionInfo(
oldStyleJoinedTable, new Ordering[0], sqlTableReferenceExpression, new JoinConditionExpression(joinedTable));
return(sqlTableReferenceExpression);
}
public void SetUp()
{
_joinInfo = SqlStatementModelObjectMother.CreateUnresolvedCollectionJoinInfo_RestaurantCooks();
}
public IJoinInfo VisitUnresolvedCollectionJoinInfo(UnresolvedCollectionJoinInfo joinInfo)
{
ArgumentUtility.CheckNotNull("joinInfo", joinInfo);
return(joinInfo);
}
IJoinInfo IJoinInfoVisitor.VisitUnresolvedCollectionJoinInfo(UnresolvedCollectionJoinInfo joinInfo)
{
throw new InvalidOperationException("UnresolvedCollectionJoinInfo is not valid at this point.");
}
