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 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}'",
FormattingExpressionTreeVisitor.Format (resolvedExpression),
joinInfo.MemberInfo);
throw new NotSupportedException (message);
}
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 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);
}
public void ResolveJoinInfo_ResolvesCollectionJoinInfo_UnaryExpression ()
{
var memberInfo = typeof (Cook).GetProperty ("IllnessDays");
var unresolvedCollectionJoinInfo = new UnresolvedCollectionJoinInfo (Expression.Constant (new Cook ()), memberInfo);
var sqlEntityExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression (typeof (Cook));
var fakeUnaryExpression = Expression.Not(Expression.Constant(1));
var fakeResolvedJoinInfo = SqlStatementModelObjectMother.CreateResolvedJoinInfo();
_stageMock
.Expect (mock => mock.ResolveCollectionSourceExpression (unresolvedCollectionJoinInfo.SourceExpression, _mappingResolutionContext))
.Return (fakeUnaryExpression);
_stageMock
.Expect (mock => mock.ResolveCollectionSourceExpression (fakeUnaryExpression.Operand, _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 ();
}
IJoinInfo IJoinInfoVisitor.VisitUnresolvedCollectionJoinInfo (UnresolvedCollectionJoinInfo joinInfo)
{
throw new InvalidOperationException ("UnresolvedCollectionJoinInfo is not valid at this point.");
}
public void SetUp ()
{
_joinInfo = SqlStatementModelObjectMother.CreateUnresolvedCollectionJoinInfo_RestaurantCooks ();
}
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 IJoinInfo VisitUnresolvedCollectionJoinInfo (UnresolvedCollectionJoinInfo joinInfo)
{
ArgumentUtility.CheckNotNull ("joinInfo", joinInfo);
return joinInfo;
}