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; }