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 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 ResolveMemberExpression_ShouldThrowUnmappedExceptionForMember()
{
var sqlEntityExpression = new SqlEntityDefinitionExpression (typeof (PersonTestClass), "p", null, e => e);
var memberInfoStub = MockRepository.GenerateStub<MemberInfo>();
memberInfoStub
.Stub (stub => stub.DeclaringType)
.Return (typeof (PersonTestClass));
memberInfoStub
.Stub (stub => stub.Name)
.Return ("stub");
_mappingResolver.ResolveMemberExpression (sqlEntityExpression, memberInfoStub);
}
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 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 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 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 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_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 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 SetUp ()
{
var columns = new[] { new SqlColumnDefinitionExpression (typeof (string), "c", "Name", false) };
_entityDefinitionExpression = new SqlEntityDefinitionExpression (typeof (Cook), "c", null, e => e, columns);
}
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 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 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 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 SetUp ()
{
_entityExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression();
_columnExpression = new SqlColumnReferenceExpression (typeof (string), "c", "columnName", false, _entityExpression);
}
