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 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 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 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 SameType()
{
var newTableInfo = new ResolvedSimpleTableInfo(typeof(int), "table2", "s");
_sqlTable.TableInfo = newTableInfo;
Assert.That(_sqlTable.TableInfo.ItemType, Is.EqualTo(newTableInfo.ItemType));
}
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 VisitSimpleTableInfo_FullQualifiedTableNameGetsSplit()
{
var simpleTableInfo = new ResolvedSimpleTableInfo(typeof(Cook), "TestDomain.dbo.CookTable", "c");
_generator.VisitSimpleTableInfo(simpleTableInfo);
Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo("[TestDomain].[dbo].[CookTable] AS [c]"));
}
public void VisitSimpleTableInfo()
{
var simpleTableInfo = new ResolvedSimpleTableInfo(typeof(Cook), "CookTable", "c");
_generator.VisitSimpleTableInfo(simpleTableInfo);
Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo("[CookTable] AS [c]"));
}
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 void ResolveTableInfo_SimpleTableInfo()
{
var simpleTableInfo = new ResolvedSimpleTableInfo(typeof(Cook), "CookTable", "c");
var result = ResolvingTableInfoVisitor.ResolveTableInfo(simpleTableInfo, _resolverMock, _generator, _stageMock, _mappingResolutionContext);
_stageMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(simpleTableInfo));
}
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 GenerateSql_LeftJoinSemantics_NonFirstTable()
{
var tableInfo = new ResolvedSimpleTableInfo(typeof(int), "Table", "t");
var sqlTable = new SqlTable(tableInfo, JoinSemantics.Left);
SqlTableAndJoinTextGenerator.GenerateSql(sqlTable, _commandBuilder, _stageMock, isFirstTable: false);
Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo(" OUTER APPLY [Table] AS [t]"));
}
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 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 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 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 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 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 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);
}
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 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 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 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 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 TryResolveOptimizedIdentity_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 result = _mappingResolver.TryResolveOptimizedIdentity(entityRefMemberExpression);
var orderForeignKey = new SqlColumnDefinitionExpression(typeof(int), tableInfo.TableAlias, "VirtualSideID", false);
SqlExpressionTreeComparer.CheckAreEqualTrees(orderForeignKey, result);
}
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 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);
}
