public void ResolveJoinInfo_ResolvesUnresolvedJoinInfo_AndResolvesJoinedTable ()
{
var foreignTableInfo = new ResolvedSimpleTableInfo (typeof (string), "Cook", "c");
var condition = ExpressionHelper.CreateExpression (typeof (bool));
var resolvedJoinInfo = new ResolvedJoinInfo (foreignTableInfo, condition);
_resolverMock
.Expect (mock => mock.ResolveJoinInfo (_unresolvedJoinInfo, _generator))
.Return (resolvedJoinInfo);
var fakeResolvedForeignTableInfo = SqlStatementModelObjectMother.CreateResolvedTableInfo (typeof (string));
_stageMock
.Expect (mock => mock.ResolveTableInfo (foreignTableInfo, _mappingResolutionContext))
.Return (fakeResolvedForeignTableInfo);
_stageMock
.Expect (mock => mock.ResolveJoinCondition (condition, _mappingResolutionContext))
.Return (condition);
var result = ResolvingJoinInfoVisitor.ResolveJoinInfo (_unresolvedJoinInfo, _resolverMock, _generator, _stageMock, _mappingResolutionContext);
Assert.That (result, Is.Not.SameAs (resolvedJoinInfo));
Assert.That (result.ForeignTableInfo, Is.SameAs (fakeResolvedForeignTableInfo));
Assert.That (result.JoinCondition, Is.SameAs (condition));
_resolverMock.VerifyAllExpectations ();
_stageMock.VerifyAllExpectations ();
}
public new void ToString ()
{
var foreignTableInfo = new ResolvedSimpleTableInfo (typeof (Cook), "CookTable", "c");
var joinInfo = new ResolvedJoinInfo (foreignTableInfo, Expression.Equal (Expression.Constant (0), Expression.Constant (1)));
var result = joinInfo.ToString ();
Assert.That (result, Is.EqualTo ("[CookTable] [c] ON (0 == 1)"));
}
public void ToString_Resolved ()
{
var resolvedJoinInfo = new ResolvedJoinInfo (new ResolvedSimpleTableInfo (typeof (Cook), "CookTable", "c"), Expression.Constant (true));
var expression = new JoinConditionExpression (new SqlJoinedTable (resolvedJoinInfo, JoinSemantics.Left));
var result = expression.ToString();
Assert.That (result, Is.EqualTo ("CONDITION(LEFT JOIN [CookTable] [c] ON True)"));
}
public IJoinInfo VisitResolvedJoinInfo (ResolvedJoinInfo joinInfo)
{
ArgumentUtility.CheckNotNull ("joinInfo", joinInfo);
var newTableInfo = (IResolvedTableInfo) _stage.ApplyContext (joinInfo.ForeignTableInfo, _expressionContext, _mappingResolutionContext);
if (joinInfo.ForeignTableInfo != newTableInfo)
return new ResolvedJoinInfo (newTableInfo, joinInfo.JoinCondition);
return joinInfo;
}
public void Initialization_NullableBooleanJoinCondition ()
{
var foreignTableInfo = SqlStatementModelObjectMother.CreateResolvedTableInfo ();
var joinCondition = ExpressionHelper.CreateExpression (typeof (bool?));
var joinInfo = new ResolvedJoinInfo (foreignTableInfo, joinCondition);
Assert.That (joinInfo.ForeignTableInfo, Is.SameAs (foreignTableInfo));
Assert.That (joinInfo.JoinCondition, Is.SameAs (joinCondition));
}
public IJoinInfo VisitResolvedJoinInfo (ResolvedJoinInfo joinInfo)
{
ArgumentUtility.CheckNotNull ("joinInfo", joinInfo);
joinInfo.ForeignTableInfo.Accept (this);
_commandBuilder.Append (" ON ");
_stage.GenerateTextForJoinCondition (_commandBuilder, joinInfo.JoinCondition);
return joinInfo;
}
public void VisitJoinConditionExpression ()
{
var resolvedTableInfo = new ResolvedSimpleTableInfo (typeof (Cook), "CookTable", "c");
var leftKey = new SqlColumnDefinitionExpression (typeof (Cook), "c", "ID", false);
var rightKey = new SqlColumnDefinitionExpression (typeof (Cook), "a", "FK", false);
var joinInfo = new ResolvedJoinInfo (resolvedTableInfo, Expression.Equal (leftKey, rightKey));
var sqlTable = new SqlJoinedTable (joinInfo, JoinSemantics.Left);
var joinConditionExpression = new JoinConditionExpression (sqlTable);
_entityIdentityResolverMock
.Expect (
mock => mock.ResolvePotentialEntityComparison (
Arg<BinaryExpression>.Matches (b => b.Left == leftKey && b.Right == rightKey)))
.Return (null)
.WhenCalled (mi => mi.ReturnValue = mi.Arguments[0]);
_compoundComparisonSplitterMock
.Expect (
mock => mock.SplitPotentialCompoundComparison (
Arg<BinaryExpression>.Matches (b => b.Left == leftKey && b.Right == rightKey)))
.Return (null)
.WhenCalled (mi => mi.ReturnValue = mi.Arguments[0]);
var result = _visitor.VisitExpression (joinConditionExpression);
_entityIdentityResolverMock.VerifyAllExpectations();
_compoundComparisonSplitterMock.VerifyAllExpectations();
var expectedExpression = Expression.Equal (leftKey, rightKey);
SqlExpressionTreeComparer.CheckAreEqualTrees (expectedExpression, result);
}
public void GenerateSql_JoinedTable_WithInnerJoinSemantics ()
{
var condition = Expression.Constant (true);
var joinInfo = new ResolvedJoinInfo (new ResolvedSimpleTableInfo (typeof (Cook), "CookTable", "c"), condition);
var sqlTable = new SqlTable (new SqlJoinedTable (joinInfo, JoinSemantics.Inner), JoinSemantics.Inner);
Assert.That (
() => SqlTableAndJoinTextGenerator.GenerateSql (sqlTable, _commandBuilder, _stageMock, isFirstTable: true),
Throws.TypeOf<InvalidOperationException>().With.Message.EqualTo ("SqlJoinedTable as TableInfo is not valid at this point."));
}
public void VisitResolvedJoinInfo ()
{
var condition = Expression.Constant (true);
var resolvedJoinInfo = new ResolvedJoinInfo (new ResolvedSimpleTableInfo (typeof (Cook), "CookTable", "c"), condition);
_stageMock
.Expect (mock => mock.GenerateTextForJoinCondition (_commandBuilder, condition))
.WhenCalled (mi => ((SqlCommandBuilder) mi.Arguments[0]).Append ("condition"));
_stageMock.Replay();
_generator.VisitResolvedJoinInfo (resolvedJoinInfo);
_stageMock.VerifyAllExpectations();
Assert.That (_commandBuilder.GetCommandText (), Is.EqualTo ("[CookTable] AS [c] ON condition"));
}
public void GenerateSql_JoinedTable_WithLeftJoinSemantics ()
{
var condition = Expression.Constant (true);
var joinInfo = new ResolvedJoinInfo (new ResolvedSimpleTableInfo (typeof (Cook), "CookTable", "c"), condition);
var sqlTable = SqlStatementModelObjectMother.CreateSqlTable_WithResolvedTableInfo("KitchenTable", "k", JoinSemantics.Inner);
sqlTable.GetOrAddLeftJoin (joinInfo, ExpressionHelper.GetMember<Kitchen> (k => k.Cook));
_stageMock
.Expect (mock => mock.GenerateTextForJoinCondition (_commandBuilder, condition))
.WhenCalled (mi => ((SqlCommandBuilder) mi.Arguments[0]).Append ("condition"));
SqlTableAndJoinTextGenerator.GenerateSql (sqlTable, _commandBuilder, _stageMock, isFirstTable: true);
Assert.That (_commandBuilder.GetCommandText (), Is.EqualTo ("[KitchenTable] AS [k] LEFT OUTER JOIN [CookTable] AS [c] ON condition"));
}
public void ApplyContext_JoinInfo ()
{
var sqlStatement = new SqlStatementBuilder (SqlStatementModelObjectMother.CreateSqlStatement_Resolved (typeof (Cook)))
{
SelectProjection = Expression.Constant (true),
DataInfo = new StreamedSequenceInfo (typeof (Cook[]), Expression.Constant (new Cook()))
}.GetSqlStatement();
var tableInfo = new ResolvedSubStatementTableInfo ("c", sqlStatement);
var joinInfo = new ResolvedJoinInfo (tableInfo, Expression.Equal (new SqlLiteralExpression (1), new SqlLiteralExpression (1)));
var result = _stage.ApplyContext (joinInfo, SqlExpressionContext.ValueRequired, _mappingResolutionContext);
Assert.That (result, Is.Not.SameAs (joinInfo));
Assert.That (
((ResolvedSubStatementTableInfo) ((ResolvedJoinInfo) result).ForeignTableInfo).SqlStatement.SelectProjection,
Is.TypeOf (typeof (SqlConvertedBooleanExpression)));
Assert.That (
((ConstantExpression)
((SqlConvertedBooleanExpression) ((ResolvedSubStatementTableInfo) ((ResolvedJoinInfo) result).ForeignTableInfo).SqlStatement.SelectProjection)
.Expression).Value,
Is.EqualTo (1));
}
public IJoinInfo VisitResolvedJoinInfo (ResolvedJoinInfo joinInfo)
{
ArgumentUtility.CheckNotNull ("joinInfo", joinInfo);
var newForeignTableInfo = _stage.ResolveTableInfo (joinInfo.ForeignTableInfo, _context);
var newCondition = _stage.ResolveJoinCondition (joinInfo.JoinCondition, _context);
if (newForeignTableInfo != joinInfo.ForeignTableInfo || newCondition != joinInfo.JoinCondition)
return new ResolvedJoinInfo (newForeignTableInfo, newCondition );
return joinInfo;
}
