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.Visit(joinConditionExpression);
_entityIdentityResolverMock.VerifyAllExpectations();
_compoundComparisonSplitterMock.VerifyAllExpectations();
var expectedExpression = Expression.Equal(leftKey, rightKey);
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedExpression, result);
}
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 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 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 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);
}
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 IJoinInfo VisitResolvedJoinInfo(ResolvedJoinInfo joinInfo)
{
ArgumentUtility.CheckNotNull("joinInfo", joinInfo);
joinInfo.ForeignTableInfo.Accept(this);
_commandBuilder.Append(" ON ");
_stage.GenerateTextForJoinCondition(_commandBuilder, joinInfo.JoinCondition);
return(joinInfo);
}
public override void SetUp()
{
base.SetUp();
_storageSpecificExpressionResolverStub = MockRepository.GenerateStub <IStorageSpecificExpressionResolver>();
_storageNameProviderStub = MockRepository.GenerateStub <IStorageNameProvider>();
_storageNameProviderStub.Stub(stub => stub.GetIDColumnName()).Return("ID");
_storageNameProviderStub.Stub(stub => stub.GetClassIDColumnName()).Return("ClassID");
_storageNameProviderStub.Stub(stub => stub.GetTimestampColumnName()).Return("Timestamp");
_resolver = new MappingResolver(_storageSpecificExpressionResolverStub);
_generator = new UniqueIdentifierGenerator();
_orderTable = new SqlTable(new ResolvedSimpleTableInfo(typeof(Order), "Order", "o"), JoinSemantics.Inner);
_fakeSimpleTableInfo = new ResolvedSimpleTableInfo(typeof(Order), "OrderTable", "o");
_fakeColumnDefinitionExpression = new SqlColumnDefinitionExpression(typeof(int), "o", "ColumnName", false);
_fakeJoinInfo = new ResolvedJoinInfo(_fakeSimpleTableInfo, Expression.Constant(true));
}
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));
}