public void ResolveSqlTable_ResolvesJoinInfo ()
{
var memberInfo = typeof (Kitchen).GetProperty ("Cook");
var entityExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression (typeof (Kitchen));
var unresolvedJoinInfo = new UnresolvedJoinInfo (entityExpression, memberInfo, JoinCardinality.One);
var join = _sqlTable.GetOrAddLeftJoin (unresolvedJoinInfo, memberInfo);
var fakeResolvedJoinInfo = SqlStatementModelObjectMother.CreateResolvedJoinInfo (typeof (Cook));
using (_stageMock.GetMockRepository().Ordered())
{
_stageMock
.Expect (mock => mock.ResolveTableInfo (_unresolvedTableInfo, _mappingResolutionContext))
.Return (_fakeResolvedSimpleTableInfo);
_stageMock
.Expect (mock => mock.ResolveJoinInfo (join.JoinInfo, _mappingResolutionContext))
.Return (fakeResolvedJoinInfo);
}
_stageMock.Replay();
_visitor.ResolveSqlTable (_sqlTable);
_stageMock.VerifyAllExpectations();
Assert.That (join.JoinInfo, Is.SameAs (fakeResolvedJoinInfo));
}
public void SetUp ()
{
_resolverMock = MockRepository.GenerateStrictMock<IMappingResolver>();
_unresolvedJoinInfo = SqlStatementModelObjectMother.CreateUnresolvedJoinInfo_KitchenCook();
_generator = new UniqueIdentifierGenerator();
_stageMock = MockRepository.GenerateStrictMock<IMappingResolutionStage> ();
_mappingResolutionContext = new MappingResolutionContext();
}
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 ResolveJoinInfo_ForeignKeyOnTheRight()
{
var customerTableInfo = new ResolvedSimpleTableInfo (typeof (DataContextTestClass.Customer), "dbo.Customers", "t1");
var customerPrimaryKey = new SqlColumnDefinitionExpression (typeof (string), customerTableInfo.TableAlias, "CustomerID", true);
var customerEntity = new SqlEntityDefinitionExpression (customerTableInfo.ItemType, customerTableInfo.TableAlias, null, e => e);
var ordersMember = customerTableInfo.ItemType.GetProperty ("Orders");
var unresolvedJoinInfo = new UnresolvedJoinInfo (customerEntity, ordersMember, JoinCardinality.Many);
var resolvedJoinInfo = _mappingResolver.ResolveJoinInfo (unresolvedJoinInfo, _generator);
var expectedOrderTableInfo = new ResolvedSimpleTableInfo (typeof (DataContextTestClass.Order), "dbo.Order", "t0");
var expectedOrderForeignKey = new SqlColumnDefinitionExpression (typeof (string), expectedOrderTableInfo.TableAlias, "CustomerID", false);
SqlExpressionTreeComparer.CheckAreEqualTrees (Expression.Equal (customerPrimaryKey, expectedOrderForeignKey), resolvedJoinInfo.JoinCondition);
Assert.That (resolvedJoinInfo.ItemType, Is.EqualTo (expectedOrderTableInfo.ItemType));
Assert.That (resolvedJoinInfo.ForeignTableInfo.ItemType, Is.EqualTo (expectedOrderTableInfo.ItemType));
Assert.That (resolvedJoinInfo.ForeignTableInfo.TableAlias, Is.EqualTo (expectedOrderTableInfo.TableAlias));
}
public static SqlJoinedTable CreateSqlJoinedTable_WithUnresolvedJoinInfo ()
{
var entityExpression = CreateSqlEntityDefinitionExpression (typeof (Cook));
var joinInfo = new UnresolvedJoinInfo (entityExpression, typeof (Cook).GetProperty ("FirstName"), JoinCardinality.One);
return new SqlJoinedTable (joinInfo, JoinSemantics.Left);
}
public void ResolveJoinInfo_ShouldThrowUnmappedExceptionForMember ()
{
var customerTableInfo = new ResolvedSimpleTableInfo (typeof (DataContextTestClass.Customer), "dbo.Customers", "t1");
var customerDefinition = new SqlEntityDefinitionExpression (customerTableInfo.ItemType, customerTableInfo.TableAlias, null, e => e);
var joinInfo = new UnresolvedJoinInfo (customerDefinition, _unmappedInfo, JoinCardinality.One);
_mappingResolver.ResolveJoinInfo (joinInfo, _generator);
}
public void ResolveJoinInfo_OneNullableColumn_TheOtherNot_LeadsToConversion ()
{
var regionTableInfo = new ResolvedSimpleTableInfo (typeof (DataContextTestClass.Region), "dbo.Regions", "t1");
var regionEntity = new SqlEntityDefinitionExpression (regionTableInfo.ItemType, regionTableInfo.TableAlias, null, e => e);
var territoriesMember = regionTableInfo.ItemType.GetProperty ("Territories");
var unresolvedJoinInfo = new UnresolvedJoinInfo (regionEntity, territoriesMember, JoinCardinality.Many);
var resolvedJoinInfo = _mappingResolver.ResolveJoinInfo (unresolvedJoinInfo, _generator);
var regionPrimaryKey = new SqlColumnDefinitionExpression (typeof (int), regionTableInfo.TableAlias, "RegionID", true);
var expectedTerritoryTableInfo = new ResolvedSimpleTableInfo (typeof (DataContextTestClass.Territory), "dbo.Territories", "t0");
var expectedTerritoryForeignKey = new SqlColumnDefinitionExpression (typeof (int?), expectedTerritoryTableInfo.TableAlias, "RegionID", false);
SqlExpressionTreeComparer.CheckAreEqualTrees (
Expression.Equal (
Expression.Convert (regionPrimaryKey, typeof (int?)),
expectedTerritoryForeignKey), resolvedJoinInfo.JoinCondition);
}
IJoinInfo IJoinInfoVisitor.VisitUnresolvedJoinInfo (UnresolvedJoinInfo tableSource)
{
throw new InvalidOperationException ("UnresolvedJoinInfo is not valid at this point.");
}
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);
}
public ResolvedJoinInfo ResolveJoinInfo (UnresolvedJoinInfo joinInfo, UniqueIdentifierGenerator generator)
{
if (joinInfo.MemberInfo.DeclaringType == typeof (Cook))
{
switch (joinInfo.MemberInfo.Name)
{
case "Substitution":
return CreateResolvedJoinInfo (
joinInfo.OriginatingEntity,
"ID",
typeof (int),
true,
CreateResolvedTableInfo (joinInfo.ItemType, generator),
"SubstitutedID",
typeof (int),
false);
case "Substituted":
return CreateResolvedJoinInfo (
joinInfo.OriginatingEntity,
"SubstitutedID",
typeof (int),
false,
CreateResolvedTableInfo (joinInfo.ItemType, generator),
"ID",
typeof (int),
true);
case "Assistants":
return CreateResolvedJoinInfo (
joinInfo.OriginatingEntity,
"ID",
typeof (int),
true,
CreateResolvedTableInfo (joinInfo.ItemType, generator),
"AssistedID",
typeof (int),
false);
case "Kitchen":
return CreateResolvedJoinInfo (
joinInfo.OriginatingEntity,
"KitchenID",
typeof (int),
false,
CreateResolvedTableInfo (joinInfo.ItemType, generator),
"ID",
typeof (int),
true);
case "Knife":
var joinedTableInfo = CreateResolvedTableInfo (joinInfo.ItemType, generator);
var leftKey = ResolveMemberExpression (joinInfo.OriginatingEntity, typeof (Cook).GetProperty ("KnifeID"));
var rightKey = ResolveSimpleTableInfo (joinedTableInfo, generator).GetIdentityExpression();
return new ResolvedJoinInfo (joinedTableInfo, Expression.Equal (leftKey, rightKey));
}
}
else if (joinInfo.MemberInfo.DeclaringType == typeof (Kitchen))
{
switch (joinInfo.MemberInfo.Name)
{
case "Cook":
return CreateResolvedJoinInfo (
joinInfo.OriginatingEntity,
"ID", typeof (int), true, CreateResolvedTableInfo (joinInfo.ItemType, generator), "KitchenID", typeof (int), false);
case "Restaurant":
return CreateResolvedJoinInfo (
joinInfo.OriginatingEntity,
"RestaurantID", typeof (int), false, CreateResolvedTableInfo (joinInfo.ItemType, generator), "ID", typeof (int), true);
}
}
else if (joinInfo.MemberInfo.DeclaringType == typeof (Restaurant))
{
switch (joinInfo.MemberInfo.Name)
{
case "SubKitchen":
return CreateResolvedJoinInfo (
joinInfo.OriginatingEntity,
"ID", typeof (int), true, CreateResolvedTableInfo (joinInfo.ItemType, generator), "RestaurantID", typeof (int), false);
case "Cooks":
return CreateResolvedJoinInfo (
joinInfo.OriginatingEntity,
"ID", typeof (int), true, CreateResolvedTableInfo (joinInfo.ItemType, generator), "RestaurantID", typeof (int), false);
case "CompanyIfAny":
return CreateResolvedJoinInfo (
joinInfo.OriginatingEntity,
"CompanyID",
typeof (int?),
false,
CreateResolvedTableInfo (joinInfo.ItemType, generator),
"ID",
typeof (int),
true);
}
}
else if (joinInfo.MemberInfo.DeclaringType == typeof (Company))
{
switch (joinInfo.MemberInfo.Name)
{
case "AllRestaurants":
return CreateResolvedJoinInfo (
joinInfo.OriginatingEntity,
"ID",
typeof (int), true, CreateResolvedTableInfo (joinInfo.ItemType, generator), "CompanyID", typeof (int?), false);
}
}
throw new UnmappedItemException ("Member " + joinInfo.MemberInfo + " is not a valid join member.");
}
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 ItemType_CardinalityOne ()
{
var joinInfo = new UnresolvedJoinInfo (_entityExpression, typeof (Cook).GetProperty ("Substitution"), JoinCardinality.One);
Assert.That (joinInfo.ItemType, Is.SameAs (typeof (Cook)));
}
public void ResolveSqlTable_ResolvesJoinInfo_Recursive ()
{
var memberInfo1 = typeof (Kitchen).GetProperty ("Cook");
var entityExpression1 = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression (typeof (Kitchen));
var unresolvedJoinInfo1 = new UnresolvedJoinInfo (entityExpression1, memberInfo1, JoinCardinality.One);
var memberInfo2 = typeof (Cook).GetProperty ("Substitution");
var entityExpression2 = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression (typeof (Cook));
var unresolvedJoinInfo2 = new UnresolvedJoinInfo (entityExpression2, memberInfo2, JoinCardinality.One);
var memberInfo3 = typeof (Cook).GetProperty ("Name");
var entityExpression3 = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression (typeof (Cook));
var unresolvedJoinInfo3 = new UnresolvedJoinInfo (entityExpression3, memberInfo3, JoinCardinality.One);
var join1 = _sqlTable.GetOrAddLeftJoin (unresolvedJoinInfo1, memberInfo1);
var join2 = join1.GetOrAddLeftJoin (unresolvedJoinInfo2, memberInfo2);
var join3 = join1.GetOrAddLeftJoin (unresolvedJoinInfo3, memberInfo3);
var fakeResolvedJoinInfo1 = SqlStatementModelObjectMother.CreateResolvedJoinInfo (typeof (Cook));
var fakeResolvedJoinInfo2 = SqlStatementModelObjectMother.CreateResolvedJoinInfo (typeof (Cook));
var fakeResolvedJoinInfo3 = SqlStatementModelObjectMother.CreateResolvedJoinInfo (typeof (string));
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
.Expect (mock => mock.ResolveJoinInfo (join3.JoinInfo, _mappingResolutionContext))
.Return (fakeResolvedJoinInfo3);
}
_stageMock.Replay();
_visitor.ResolveSqlTable (_sqlTable);
_stageMock.VerifyAllExpectations();
Assert.That (join1.JoinInfo, Is.SameAs (fakeResolvedJoinInfo1));
Assert.That (join2.JoinInfo, Is.SameAs (fakeResolvedJoinInfo2));
Assert.That (join3.JoinInfo, Is.SameAs (fakeResolvedJoinInfo3));
}
public IJoinInfo VisitUnresolvedJoinInfo (UnresolvedJoinInfo joinInfo)
{
ArgumentUtility.CheckNotNull ("joinInfo", joinInfo);
return joinInfo;
}
public virtual Expression VisitSqlEntityRefMemberExpression (SqlEntityRefMemberExpression expression)
{
ArgumentUtility.CheckNotNull ("expression", expression);
if (!_resolveEntityRefMemberExpressions)
return VisitExtensionExpression (expression);
var unresolvedJoinInfo = new UnresolvedJoinInfo (expression.OriginatingEntity, expression.MemberInfo, JoinCardinality.One);
// No revisiting required since this visitor does not handle ISqlEntityExpressions.
return _stage.ResolveEntityRefMemberExpression (expression, unresolvedJoinInfo, _context);
}
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."));
}
private Expression GetIdentityExpressionForReferencedEntity (SqlEntityRefMemberExpression expression)
{
var optimizedIdentity = _resolver.TryResolveOptimizedIdentity (expression);
if (optimizedIdentity != null)
return optimizedIdentity;
var unresolvedJoinInfo = new UnresolvedJoinInfo (expression.OriginatingEntity, expression.MemberInfo, JoinCardinality.One);
return _stage.ResolveEntityRefMemberExpression (expression, unresolvedJoinInfo, _context).GetIdentityExpression ();
}
public IJoinInfo VisitUnresolvedJoinInfo (UnresolvedJoinInfo joinInfo)
{
ArgumentUtility.CheckNotNull ("joinInfo", joinInfo);
var result = _resolver.ResolveJoinInfo (joinInfo, _generator);
return result.Accept (this);
}
