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 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);
}
public Expression VisitSqlEntityRefMember(SqlEntityRefMemberExpression expression)
{
ArgumentUtility.CheckNotNull("expression", expression);
// Scenario: entityRef.Member
var result = _mappingResolver.TryResolveOptimizedMemberExpression(expression, _memberInfo);
if (result != null)
{
return(result);
}
// Optimized member access didn't work, so resolve the entity reference (adding joins and such), then retry.
var unresolvedJoinInfo = new UnresolvedJoinInfo(expression.OriginatingEntity, expression.MemberInfo, JoinCardinality.One);
var entityExpression = _stage.ResolveEntityRefMemberExpression(expression, unresolvedJoinInfo, _context);
return(Visit(entityExpression));
}
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 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_CardinalityOne()
{
var joinInfo = new UnresolvedJoinInfo(_entityExpression, typeof(Cook).GetProperty("Substitution"), JoinCardinality.One);
Assert.That(joinInfo.ItemType, Is.SameAs(typeof(Cook)));
}
public IJoinInfo VisitUnresolvedJoinInfo(UnresolvedJoinInfo joinInfo)
{
ArgumentUtility.CheckNotNull("joinInfo", joinInfo);
return(joinInfo);
}
IJoinInfo IJoinInfoVisitor.VisitUnresolvedJoinInfo(UnresolvedJoinInfo tableSource)
{
throw new InvalidOperationException("UnresolvedJoinInfo is not valid at this point.");
}
