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 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 ResolveMemberExpression_NonPrimaryKey()
{
var sqlEntityExpression = new SqlEntityDefinitionExpression(typeof(DataContextTestClass.Customer), "c", null, e => e);
var memberInfo = typeof(DataContextTestClass.Customer).GetProperty("CompanyName");
Expression result = _mappingResolver.ResolveMemberExpression(sqlEntityExpression, memberInfo);
var expectedExpression = new SqlColumnDefinitionExpression(typeof(string), "c", "CompanyName", false);
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedExpression, result);
}
public void ResolveMemberExpression()
{
var sqlEntityExpression = new SqlEntityDefinitionExpression(typeof(PersonTestClass), "p", null, e => e);
var memberInfo = typeof(PersonTestClass).GetProperty("First");
Expression result = _mappingResolver.ResolveMemberExpression(sqlEntityExpression, memberInfo);
var expectedExpression = new SqlColumnDefinitionExpression(typeof(string), "p", "FirstName", true);
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedExpression, result);
}
public void ResolveMemberExpression_ShouldThrowUnmappedExceptionForType()
{
var sqlEntityExpression = new SqlEntityDefinitionExpression(typeof(PersonTestClass), "p", null, e => e);
var memberInfoStub = MockRepository.GenerateStub <MemberInfo>();
memberInfoStub
.Stub(stub => stub.DeclaringType)
.Return(_unmappedType);
_mappingResolver.ResolveMemberExpression(sqlEntityExpression, memberInfoStub);
}
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 ResolveMemberExpression_Association()
{
var referencedSqlExpression = new SqlEntityDefinitionExpression(typeof(DataContextTestClass.Customer), "c", null, e => e);
var sqlEntityExpression = new SqlEntityReferenceExpression(typeof(DataContextTestClass.Order), "o", null, referencedSqlExpression);
var memberInfo = typeof(DataContextTestClass.Order).GetProperty("Customer");
var result = _mappingResolver.ResolveMemberExpression(sqlEntityExpression, memberInfo);
var expectedExpression = new SqlEntityRefMemberExpression(sqlEntityExpression, memberInfo);
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedExpression, result);
}
public void GenerateSql_VisitSqlColumnReferenceExpression_WithNamedEntity_WithStarColumn()
{
var entityExpression = new SqlEntityDefinitionExpression(
typeof(Cook),
"c",
"Test",
e => e.GetColumn(typeof(int), "ID", true),
new SqlColumnDefinitionExpression(typeof(Cook), "c", "*", false));
var sqlColumnExpression = new SqlColumnReferenceExpression(typeof(int), "s", "ID", false, entityExpression);
SqlGeneratingExpressionVisitor.GenerateSql(sqlColumnExpression, _commandBuilder, _stageMock);
Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo("[s].[ID]"));
}
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 GenerateSql_VisitSqlEntityExpression_NamedEntity_StarColumn()
{
var sqlColumnListExpression = new SqlEntityDefinitionExpression(
typeof(string),
"t",
"Test",
e => e.GetColumn(typeof(int), "ID", true),
new[]
{
new SqlColumnDefinitionExpression(typeof(string), "t", "*", false)
});
SqlGeneratingSelectExpressionVisitor.GenerateSql(sqlColumnListExpression, _commandBuilder, _stageMock);
Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo("[t].*"));
}
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 Update()
{
var columns = new[]
{
new SqlColumnDefinitionExpression(typeof(string), "c", "Name", false),
new SqlColumnDefinitionExpression(typeof(string), "c", "FirstName", false)
};
var entityExpression = new SqlEntityDefinitionExpression(typeof(Cook), "c", null, e => e.GetColumn(typeof(int), "ID", true), columns);
var result = entityExpression.Update(typeof(Kitchen), "f", null);
var expectedResult = new SqlEntityDefinitionExpression(typeof(Kitchen), "f", null, entityExpression.IdentityExpressionGenerator, columns);
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedResult, result);
}
public void CreateReference()
{
var columns = new[]
{
new SqlColumnDefinitionExpression(typeof(string), "c", "Name", false),
new SqlColumnDefinitionExpression(typeof(string), "c", "FirstName", false)
};
var entityExpression = new SqlEntityDefinitionExpression(typeof(Cook), "c", null, e => e.GetColumn(typeof(int), "ID", true), columns);
var result = entityExpression.CreateReference("c1", typeof(Cook));
var expectedResult = new SqlEntityReferenceExpression(typeof(Cook), "c1", null, entityExpression);
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedResult, result);
}
public void GenerateSql_VisitSqlEntityExpression_NamedEntity_ReferencingNamed()
{
var referencedEntity = new SqlEntityDefinitionExpression(
typeof(Cook),
"c",
"Cook",
e => e,
new[]
{
new SqlColumnDefinitionExpression(typeof(string), "t", "Name", false),
new SqlColumnDefinitionExpression(typeof(string), "t", "City", false)
});
var entityExpression = new SqlEntityReferenceExpression(typeof(Cook), "c", "ref", referencedEntity);
SqlGeneratingSelectExpressionVisitor.GenerateSql(entityExpression, _commandBuilder, _stageMock);
Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo("[c].[Cook_Name] AS [ref_Name],[c].[Cook_City] AS [ref_City]"));
}
public void SetUp()
{
_stageMock = MockRepository.GenerateStrictMock <ISqlGenerationStage> ();
_commandBuilder = new SqlCommandBuilder();
_visitor = new TestableSqlGeneratingOuterSelectExpressionVisitor(_commandBuilder, _stageMock);
_namedIntExpression = new NamedExpression("test", Expression.Constant(0));
_nameColumnExpression = new SqlColumnDefinitionExpression(typeof(string), "c", "Name", false);
_entityExpression = new SqlEntityDefinitionExpression(
typeof(Cook),
"c",
"test",
e => e,
new SqlColumnDefinitionExpression(typeof(int), "c", "ID", true),
_nameColumnExpression,
new SqlColumnDefinitionExpression(typeof(string), "c", "FirstName", false)
);
}
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 GenerateSql_VisitSqlEntityExpression_UnnamedEntity()
{
var sqlColumnListExpression = new SqlEntityDefinitionExpression(
typeof(string),
"t",
null,
e => e,
new[]
{
new SqlColumnDefinitionExpression(typeof(string), "t", "ID", true),
new SqlColumnDefinitionExpression(typeof(string), "t", "Name", false),
new SqlColumnDefinitionExpression(typeof(string), "t", "City", false)
});
SqlGeneratingSelectExpressionVisitor.GenerateSql(
sqlColumnListExpression, _commandBuilder, _stageMock);
Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo("[t].[ID],[t].[Name],[t].[City]"));
}
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 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_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 void SetUp()
{
_stageMock = MockRepository.GenerateStrictMock <ISqlGenerationStage> ();
_commandBuilder = new SqlCommandBuilder();
_someSetOperationsMode = Some.Item(SetOperationsMode.StatementIsSetCombined, SetOperationsMode.StatementIsNotSetCombined);
_visitor = CreateVisitor(_someSetOperationsMode);
_namedIntExpression = new NamedExpression("test", Expression.Constant(0));
var nameColumnExpression = new SqlColumnDefinitionExpression(typeof(string), "c", "Name", false);
_namedNameColumnExpression = new NamedExpression("SomeName", nameColumnExpression);
_entityExpression = new SqlEntityDefinitionExpression(
typeof(Cook),
"c",
"test",
e => e,
new SqlColumnDefinitionExpression(typeof(int), "c", "ID", true),
nameColumnExpression,
new SqlColumnDefinitionExpression(typeof(string), "c", "FirstName", false)
);
}
private static object GetColumnValue(object entity, MappingResolverStub mappingResolver, SqlEntityDefinitionExpression sqlEntityDefinition, string columnName)
{
var propertiesWithColumnName =
entity.GetType()
.GetProperties()
.SelectMany(p => TryResolveProperty(mappingResolver, sqlEntityDefinition, p, entity), (p, t) => new { Property = p, ColumnNameAndValue = t })
.ToArray();
var matchingProperty = propertiesWithColumnName.FirstOrDefault(d => d.ColumnNameAndValue.Key == columnName);
// Assert.That (matchingProperties, Has.Length.LessThanOrEqualTo (1), entity.GetType().Name + ": " + string.Join (",", matchingProperties));
Assert.IsNotNull(
matchingProperty,
"No member found for column '{0}' on entity type '{1}'.\r\n(Found: {2})",
columnName,
entity.GetType().Name,
string.Join(",", propertiesWithColumnName.Select(p => p.ToString())));
return(matchingProperty.ColumnNameAndValue.Value);
}
public void SetUp()
{
_entityExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression();
_columnExpression = new SqlColumnReferenceExpression(typeof(string), "c", "columnName", false, _entityExpression);
}
public void SetUp()
{
var columns = new[] { new SqlColumnDefinitionExpression(typeof(string), "c", "Name", false) };
_entityDefinitionExpression = new SqlEntityDefinitionExpression(typeof(Cook), "c", null, e => e, columns);
}
