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 void SameType ()
{
var newTableInfo = new ResolvedSimpleTableInfo (typeof (int), "table2", "s");
_sqlTable.TableInfo = newTableInfo;
Assert.That (_sqlTable.TableInfo.ItemType, Is.EqualTo (newTableInfo.ItemType));
}
public new void ToString ()
{
var tableInfo = new ResolvedSimpleTableInfo (typeof (Cook), "CookTable", "t0");
var result = tableInfo.ToString ();
Assert.That (result, Is.EqualTo ("[CookTable] [t0]"));
}
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 ApplyContext_ResolvedSimpleTableInfo ()
{
var tableInfo = new ResolvedSimpleTableInfo (typeof (Cook), "CookTable", "c");
var result = SqlContextTableInfoVisitor.ApplyContext (tableInfo, SqlExpressionContext.ValueRequired, _stageMock, _mappingresolutionContext);
Assert.That (result, Is.SameAs (tableInfo));
}
public void ResolveTableInfo_Unresolved ()
{
var resolvedTableInfo = new ResolvedSimpleTableInfo (typeof (int), "Table", "t");
_resolverMock.Expect (mock => mock.ResolveTableInfo (_unresolvedTableInfo, _generator)).Return (resolvedTableInfo);
_resolverMock.Replay();
var result = ResolvingTableInfoVisitor.ResolveTableInfo (resolvedTableInfo, _resolverMock, _generator, _stageMock, _mappingResolutionContext);
Assert.That (result, Is.SameAs (resolvedTableInfo));
}
public void SetUp ()
{
_stageMock = MockRepository.GenerateMock<IMappingResolutionStage>();
_resolverMock = MockRepository.GenerateMock<IMappingResolver>();
_unresolvedTableInfo = SqlStatementModelObjectMother.CreateUnresolvedTableInfo (typeof (Cook));
_resolvedTableInfo = SqlStatementModelObjectMother.CreateResolvedTableInfo (typeof (Cook));
_generator = new UniqueIdentifierGenerator();
_sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement_Resolved (typeof (Cook));
_mappingResolutionContext = new MappingResolutionContext();
}
public void SetUp ()
{
_stageMock = MockRepository.GenerateStrictMock<IMappingResolutionStage>();
_mappingResolutionContext = new MappingResolutionContext();
_visitor = new TestableSqlStatementResolver (_stageMock, _mappingResolutionContext);
_unresolvedTableInfo = SqlStatementModelObjectMother.CreateUnresolvedTableInfo (typeof (Cook));
_sqlTable = SqlStatementModelObjectMother.CreateSqlTable (_unresolvedTableInfo);
_fakeResolvedSimpleTableInfo = SqlStatementModelObjectMother.CreateResolvedTableInfo (typeof (Cook));
}
public void SetUp ()
{
_resolverMock = MockRepository.GenerateMock<IMappingResolver>();
_uniqueIdentifierGenerator = new UniqueIdentifierGenerator();
_unresolvedTableInfo = SqlStatementModelObjectMother.CreateUnresolvedTableInfo (typeof (Cook));
_sqlTable = SqlStatementModelObjectMother.CreateSqlTable (_unresolvedTableInfo);
_fakeResolvedSimpleTableInfo = SqlStatementModelObjectMother.CreateResolvedTableInfo (typeof (Cook));
_stage = new DefaultMappingResolutionStage (_resolverMock, _uniqueIdentifierGenerator);
_mappingResolutionContext = new MappingResolutionContext();
}
public void Accept_ITableInfoVisitor ()
{
var oldJoinInfo = SqlStatementModelObjectMother.CreateUnresolvedJoinInfo_KitchenCook();
var sqlJoinedTable = new SqlJoinedTable (oldJoinInfo, JoinSemantics.Left);
var fakeResult = new ResolvedSimpleTableInfo (typeof (Cook), "CookTable", "c");
var visitorMock = MockRepository.GenerateMock<ITableInfoVisitor>();
visitorMock
.Expect (mock => mock.VisitSqlJoinedTable (sqlJoinedTable))
.Return (fakeResult);
var result = ((ITableInfo) sqlJoinedTable).Accept (visitorMock);
visitorMock.VerifyAllExpectations();
Assert.That (result, Is.SameAs (fakeResult));
}
public void ApplyContext_VisitResolvedJoinInfo_NewForeignTableInfo ()
{
var resolvedJoinInfo = SqlStatementModelObjectMother.CreateResolvedJoinInfo ();
var fakeTableInfo = new ResolvedSimpleTableInfo (typeof (Restaurant), "RestaurantTable", "r");
_stageMock
.Expect (mock => mock.ApplyContext (resolvedJoinInfo.ForeignTableInfo, SqlExpressionContext.ValueRequired, _mappingResolutionContext))
.Return (fakeTableInfo);
_stageMock.Replay ();
var result = SqlContextJoinInfoVisitor.ApplyContext (resolvedJoinInfo, SqlExpressionContext.ValueRequired, _stageMock, _mappingResolutionContext);
_stageMock.VerifyAllExpectations ();
Assert.That (((ResolvedJoinInfo) result).ForeignTableInfo, Is.SameAs (fakeTableInfo));
Assert.That (((ResolvedJoinInfo) result).JoinCondition, Is.SameAs (resolvedJoinInfo.JoinCondition));
}
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 ITableInfo VisitSimpleTableInfo (ResolvedSimpleTableInfo tableInfo)
{
ArgumentUtility.CheckNotNull ("tableInfo", tableInfo);
return tableInfo;
}
public void TryResolveOptimizedMemberExpression_OtherMember ()
{
var tableInfo = new ResolvedSimpleTableInfo (typeof (DataContextTestClass.ClassWithOneToOneRelation_ForeignKeySide), "X", "x");
var originatingEntity = new SqlEntityDefinitionExpression (
tableInfo.ItemType, tableInfo.TableAlias, null, e => e.GetColumn (typeof (int), "ID", true));
var relationMember = tableInfo.ItemType.GetProperty ("VirtualSide");
var entityRefMemberExpression = new SqlEntityRefMemberExpression (originatingEntity, relationMember);
var identityMember = typeof (DataContextTestClass.ClassWithOneToOneRelation_VirtualSide).GetProperty ("OtherMember");
var result = _mappingResolver.TryResolveOptimizedMemberExpression (entityRefMemberExpression, identityMember);
Assert.That (result, Is.Null);
}
public void GetMetaDataMembers_RetrievesSameMembers_AsResolveSimpleTableInfo ()
{
var simpleTableInfo = new ResolvedSimpleTableInfo (typeof (DataContextTestClass.Region), "dbo.Region", "t0");
MetaDataMember[] metaDataMembers = _mappingResolver.GetMetaDataMembers (simpleTableInfo.ItemType);
var actualColumnNames = metaDataMembers.Select (m => m.MappedName).ToArray();
var expectedMatchingEntity = _mappingResolver.ResolveSimpleTableInfo (simpleTableInfo, _generator);
var expectedColumnNames = expectedMatchingEntity.Columns.Select (c => c.ColumnName).ToArray();
Assert.That (actualColumnNames, Is.EqualTo (expectedColumnNames));
}
public void TryResolveOptimizedIdentity_ForeignKeyOnTheRight ()
{
var tableInfo = new ResolvedSimpleTableInfo (typeof (DataContextTestClass.ClassWithOneToOneRelation_VirtualSide), "X", "x");
var originatingEntity = new SqlEntityDefinitionExpression (tableInfo.ItemType, tableInfo.TableAlias, null, e => e);
var relationMember = tableInfo.ItemType.GetProperty ("ForeignKeySide");
var entityRefMemberExpression = new SqlEntityRefMemberExpression (originatingEntity, relationMember);
var result = _mappingResolver.TryResolveOptimizedIdentity (entityRefMemberExpression);
Assert.That (result, Is.Null);
}
public void TryResolveOptimizedMemberExpression_IdentityMember_ForeignKeyOnTheLeft ()
{
var tableInfo = new ResolvedSimpleTableInfo (typeof (DataContextTestClass.ClassWithOneToOneRelation_ForeignKeySide), "X", "x");
var originatingEntity = new SqlEntityDefinitionExpression (
tableInfo.ItemType, tableInfo.TableAlias, null, e => e.GetColumn (typeof (int), "ID", true));
var relationMember = tableInfo.ItemType.GetProperty ("VirtualSide");
var entityRefMemberExpression = new SqlEntityRefMemberExpression (originatingEntity, relationMember);
var identityMember = typeof (DataContextTestClass.ClassWithOneToOneRelation_VirtualSide).GetProperty ("ID");
var result = _mappingResolver.TryResolveOptimizedMemberExpression (entityRefMemberExpression, identityMember);
var orderForeignKey = new SqlColumnDefinitionExpression (typeof (int), tableInfo.TableAlias, "VirtualSideID", false);
SqlExpressionTreeComparer.CheckAreEqualTrees (orderForeignKey, result);
}
public void ResolveSimpleTableInfo_WithInheritanceHierarchy ()
{
var simpleTableInfo = new ResolvedSimpleTableInfo (typeof (ContactWithInheritanceHierarchy), "dbo.Contact", "t0");
SqlEntityDefinitionExpression resolvedExpr = _mappingResolver.ResolveSimpleTableInfo (simpleTableInfo, _generator);
var actualColumnNames = resolvedExpr.Columns.Select (c => c.ColumnName).ToArray ();
var expectedMembersAndDeclaringTypes = new[] { "ContactID", "ContactType", "Password", "PhotoColumn", "HomePage"};
Assert.That (actualColumnNames, Is.EquivalentTo (expectedMembersAndDeclaringTypes));
}
public void ResolveSimpleTableInfo_ShouldThrowUnmappedException ()
{
var simpleTableInfo = new ResolvedSimpleTableInfo (_unmappedType, "dbo.Region", "t0");
_mappingResolver.ResolveSimpleTableInfo (simpleTableInfo, _generator);
}
public void ResolveSimpleTableInfo ()
{
var simpleTableInfo = new ResolvedSimpleTableInfo (typeof (DataContextTestClass.Region), "dbo.Region", "t0");
SqlEntityDefinitionExpression resolvedExpr = _mappingResolver.ResolveSimpleTableInfo (simpleTableInfo, _generator);
SqlColumnExpression expectedPrimaryColumn = new SqlColumnDefinitionExpression (typeof (int), simpleTableInfo.TableAlias, "RegionID", true);
SqlColumnExpression expectedDescriptionColumn =
new SqlColumnDefinitionExpression (typeof (string), simpleTableInfo.TableAlias, "RegionDescription", false);
Assert.That (resolvedExpr.Type, Is.SameAs (typeof (DataContextTestClass.Region)));
Assert.That (resolvedExpr.TableAlias, Is.EqualTo ("t0"));
Assert.That (resolvedExpr.Name, Is.Null);
SqlExpressionTreeComparer.CheckAreEqualTrees (expectedPrimaryColumn, resolvedExpr.GetIdentityExpression());
Assert.That (resolvedExpr.Columns, Has.Count.EqualTo (2));
SqlExpressionTreeComparer.CheckAreEqualTrees (expectedPrimaryColumn, resolvedExpr.Columns[0]);
SqlExpressionTreeComparer.CheckAreEqualTrees (expectedDescriptionColumn, resolvedExpr.Columns[1]);
}
public void ResolveSimpleTableInfo_MultiplePrimaryKeyProperties ()
{
var simpleTableInfo = new ResolvedSimpleTableInfo (typeof (DataContextTestClass.ClassWithCompoundPrimaryKey), "ClassWithCompoundPrimaryKey", "t0");
SqlEntityDefinitionExpression resolvedExpr = _mappingResolver.ResolveSimpleTableInfo (simpleTableInfo, _generator);
SqlColumnExpression expectedPrimaryColumn1 = new SqlColumnDefinitionExpression (typeof (int), simpleTableInfo.TableAlias, "Key1", true);
SqlColumnExpression expectedPrimaryColumn2 = new SqlColumnDefinitionExpression (typeof (string), simpleTableInfo.TableAlias, "Key2", true);
var type = typeof (MappingResolver.CompoundIdentityTuple<int, string>);
var expectedIdentityExpression = Expression.New (
type.GetConstructors().Single(),
new[] { new NamedExpression ("Item1", expectedPrimaryColumn1), new NamedExpression ("Item2", expectedPrimaryColumn2) },
new[] { type.GetProperty ("Item1"), type.GetProperty ("Item2") });
Assert.That (resolvedExpr.Type, Is.SameAs (typeof (DataContextTestClass.ClassWithCompoundPrimaryKey)));
Assert.That (resolvedExpr.TableAlias, Is.EqualTo ("t0"));
Assert.That (resolvedExpr.Name, Is.Null);
SqlExpressionTreeComparer.CheckAreEqualTrees (expectedIdentityExpression, resolvedExpr.GetIdentityExpression ());
}
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 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);
}
private ResolvedJoinInfo CreateResolvedJoinInfo (
Type type, string originalTableAlias, string leftSideKeyName, string joinedTableName, string joinedTableAlias, string rightSideKeyName)
{
var foreignTableSource = new ResolvedSimpleTableInfo (type, joinedTableName, joinedTableAlias);
var primaryColumn = new SqlColumnDefinitionExpression (typeof (int), originalTableAlias, leftSideKeyName, false);
var foreignColumn = new SqlColumnDefinitionExpression (typeof (int), joinedTableAlias, rightSideKeyName, false);
return new ResolvedJoinInfo (foreignTableSource, Expression.Equal (primaryColumn, foreignColumn));
}
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 static SqlTable CreateSqlTable_WithResolvedTableInfo (Type type, string tableName, string tableAlias)
{
var resolvedTableInfo = new ResolvedSimpleTableInfo (type, tableName, tableAlias);
var sqlTable = new SqlTable (resolvedTableInfo, JoinSemantics.Inner);
return sqlTable;
}
public void SetUp ()
{
_oldTableInfo = new ResolvedSimpleTableInfo (typeof (int), "table1", "t");
_newTableInfo = new ResolvedSimpleTableInfo (typeof (string), "table2", "s");
_sqlTable = new SqlTable (_oldTableInfo, JoinSemantics.Inner);
}
public void SetUp ()
{
_tableInfo = SqlStatementModelObjectMother.CreateResolvedTableInfo ();
}
public static ResolvedJoinInfo CreateResolvedJoinInfo (Type type)
{
var primaryColumn = new SqlColumnDefinitionExpression (typeof (int), "k", "ID", false);
var foreignColumn = new SqlColumnDefinitionExpression (typeof (int), "s", "ID", false);
var foreignTableInfo = new ResolvedSimpleTableInfo (type, "Table", "s");
return new ResolvedJoinInfo (foreignTableInfo, Expression.Equal (primaryColumn, foreignColumn));
}
public ITableInfo VisitSimpleTableInfo (ResolvedSimpleTableInfo tableInfo)
{
ArgumentUtility.CheckNotNull ("tableInfo", tableInfo);
string[] identifiers = tableInfo.TableName.Split ('.');
var newTableName = string.Join(".", identifiers.Select (idf => "[" + idf + "]").ToArray());
_commandBuilder.Append (newTableName);
_commandBuilder.Append (" AS ");
_commandBuilder.AppendIdentifier (tableInfo.TableAlias);
return tableInfo;
}
