public void HandleResultOperator ()
{
var keySelector = new SqlColumnDefinitionExpression(typeof(string), "c", "Name", false);
var elementSelector = Expression.Constant ("elementSelector");
var resultOperator = new GroupResultOperator ("itemName", keySelector, elementSelector);
_stageMock
.Expect (mock => mock.PrepareResultOperatorItemExpression (keySelector, _context))
.Return (keySelector);
_stageMock
.Expect (mock => mock.PrepareResultOperatorItemExpression (elementSelector, _context))
.Return (elementSelector);
_stageMock.Replay();
_handler.HandleResultOperator (resultOperator, _sqlStatementBuilder, _generator, _stageMock, _context);
_stageMock.VerifyAllExpectations();
Assert.That (_sqlStatementBuilder.GroupByExpression, Is.SameAs (keySelector));
var expectedSelectProjection = new SqlGroupingSelectExpression (
new NamedExpression ("key", keySelector),
new NamedExpression ("element", elementSelector));
SqlExpressionTreeComparer.CheckAreEqualTrees (expectedSelectProjection, _sqlStatementBuilder.SelectProjection);
Assert.That (
_sqlStatementBuilder.DataInfo.DataType,
Is.EqualTo (typeof (IQueryable<>).MakeGenericType (typeof (IGrouping<,>).MakeGenericType (typeof (string), typeof (string)))));
}
public void GenerateSql_VisitSqlColumnDefinitionExpression ()
{
var sqlColumnExpression = new SqlColumnDefinitionExpression (typeof (int), "s", "ID", false);
SqlGeneratingExpressionVisitor.GenerateSql (sqlColumnExpression, _commandBuilder, _stageMock);
Assert.That (_commandBuilder.GetCommandText(), Is.EqualTo ("[s].[ID]"));
}
public void GenerateSql_VisitSqlColumnExpressionWithStar ()
{
var sqlColumnExpression = new SqlColumnDefinitionExpression (typeof (Cook), "c", "*", false);
SqlGeneratingExpressionVisitor.GenerateSql (sqlColumnExpression, _commandBuilder, _stageMock);
Assert.That (_commandBuilder.GetCommandText(), Is.EqualTo ("[c].*"));
}
public void VisitNamedExpression_NameIsNotNull ()
{
var columnExpression = new SqlColumnDefinitionExpression (typeof (string), "c", "Name", false);
var expression = new NamedExpression ("test", columnExpression);
SqlGeneratingSelectExpressionVisitor.GenerateSql (expression, _commandBuilder, _stageMock);
Assert.That (_commandBuilder.GetCommandText (), Is.EqualTo ("[c].[Name] AS [test]"));
}
public void Update ()
{
var columnExpression = new SqlColumnDefinitionExpression (typeof (string), "c", "columnName", false);
var result = columnExpression.Update (typeof (char), "f", "test", false);
var expectedResult = new SqlColumnDefinitionExpression (typeof (char), "f", "test", false);
SqlExpressionTreeComparer.CheckAreEqualTrees (result, expectedResult);
}
public void HandleResultOperator_NoConstantExpression ()
{
var takeExpression = new SqlColumnDefinitionExpression (typeof (int), "c", "ID", true);
var resultOperator = new TakeResultOperator (takeExpression);
_handler.HandleResultOperator (resultOperator, _sqlStatementBuilder, _generator, _stage, _context);
Assert.That ( _sqlStatementBuilder.TopExpression, Is.SameAs (takeExpression));
Assert.That (_sqlStatementBuilder.DataInfo, Is.TypeOf (typeof (StreamedSequenceInfo)));
Assert.That (((StreamedSequenceInfo) _sqlStatementBuilder.DataInfo).DataType, Is.EqualTo (typeof (IQueryable<>).MakeGenericType (typeof (Cook))));
}
public void ResolveSubStatementReferenceExpression_CreatesColumnExpression_ForNamedExpression ()
{
var referencedExpression = new NamedExpression ("test", Expression.Constant (0));
var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement (referencedExpression);
var tableInfo = new ResolvedSubStatementTableInfo ("q0", sqlStatement);
var sqlTable = new SqlTable (tableInfo, JoinSemantics.Inner);
var result = SubStatementReferenceResolver.ResolveSubStatementReferenceExpression (
referencedExpression, tableInfo, sqlTable, _context);
var expectedResult = new SqlColumnDefinitionExpression (typeof (int), "q0", "test", false);
SqlExpressionTreeComparer.CheckAreEqualTrees (expectedResult, result);
}
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 SetUp ()
{
_dataInfo = new StreamedScalarValueInfo (typeof (int));
_resolvedElementExpressionReference = new SqlColumnDefinitionExpression (typeof (string), "q0", "element", false);
_resolvedSelectProjection = new NamedExpression (
null,
new AggregationExpression (typeof (int), _resolvedElementExpressionReference, AggregationModifier.Min));
_associatedGroupingSelectExpression = new SqlGroupingSelectExpression (
new NamedExpression ("key", Expression.Constant ("k")),
new NamedExpression ("element", Expression.Constant ("e")));
_resolvedJoinedGroupingSubStatement = SqlStatementModelObjectMother.CreateSqlStatement (_associatedGroupingSelectExpression);
_resolvedJoinedGroupingTable = new SqlTable (
new ResolvedJoinedGroupingTableInfo (
"q1",
_resolvedJoinedGroupingSubStatement,
_associatedGroupingSelectExpression,
"q0"), JoinSemantics.Inner);
_simplifiableResolvedSqlStatement = new SqlStatement (
_dataInfo,
_resolvedSelectProjection,
new[] { _resolvedJoinedGroupingTable },
null,
null,
new Ordering[0],
null,
false,
Expression.Constant (0),
Expression.Constant (0));
_simplifiableUnresolvedProjection = new AggregationExpression (
typeof (int),
new SqlTableReferenceExpression (_resolvedJoinedGroupingTable),
AggregationModifier.Count);
_stageMock = MockRepository.GenerateStrictMock<IMappingResolutionStage> ();
_context = new MappingResolutionContext();
_groupAggregateSimplifier = new GroupAggregateSimplifier (_stageMock, _context);
}
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 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 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_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 ()
{
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 Build_WithOrderByClause ()
{
var columnExpression = new SqlColumnDefinitionExpression (typeof (string), "t", "Name", false);
var orderByClause = new Ordering (columnExpression, OrderingDirection.Asc);
var sqlStatement = new SqlStatement (
new TestStreamedValueInfo (typeof (int)),
_entityExpression,
new[] { _sqlTable },
null,
null,
new[] { orderByClause },
null,
false,
null,
null);
_stageMock.Expect (
mock => mock.GenerateTextForSelectExpression (_commandBuilder, sqlStatement.SelectProjection))
.WhenCalled (mi => ((SqlCommandBuilder) mi.Arguments[0]).Append ("[t].[ID],[t].[Name],[t].[City]"));
_stageMock.Expect (mock => mock.GenerateTextForFromTable (_commandBuilder, sqlStatement.SqlTables[0], true))
.WhenCalled (mi => ((SqlCommandBuilder) mi.Arguments[0]).Append ("[Table] AS [t]"));
_stageMock.Expect (mock => mock.GenerateTextForOrdering (_commandBuilder, sqlStatement.Orderings[0]))
.WhenCalled (mi => ((SqlCommandBuilder) mi.Arguments[0]).Append ("[t].[Name] ASC"));
_stageMock.Replay();
_generator.Build (sqlStatement, _commandBuilder, false);
_commandBuilder.SetInMemoryProjectionBody (Expression.Constant (0));
var result = _commandBuilder.GetCommand();
Assert.That (result.CommandText, Is.EqualTo ("SELECT [t].[ID],[t].[Name],[t].[City] FROM [Table] AS [t] ORDER BY [t].[Name] ASC"));
_stageMock.VerifyAllExpectations();
}
public void HandleResultOperator_GroupByAfterTopExpression ()
{
var topExpression = Expression.Constant ("top");
_sqlStatementBuilder.TopExpression = topExpression;
var keySelector = new SqlColumnDefinitionExpression(typeof(string), "c", "Name", false);
var elementSelector = Expression.Constant ("elementSelector");
var resultOperator = new GroupResultOperator ("itemName", keySelector, elementSelector);
var originalStatement = _sqlStatementBuilder.GetSqlStatement ();
var originalDataInfo = _sqlStatementBuilder.DataInfo;
var fakeFromExpressionInfo = new FromExpressionInfo (
new SqlTable (new ResolvedSubStatementTableInfo("sc", originalStatement), JoinSemantics.Inner), new Ordering[0], elementSelector, null);
_stageMock
.Expect (mock => mock.PrepareResultOperatorItemExpression (keySelector, _context))
.Return (keySelector);
_stageMock
.Expect (mock => mock.PrepareResultOperatorItemExpression (elementSelector, _context))
.Return (elementSelector);
_stageMock
.Expect (
mock => mock.PrepareFromExpression (Arg<Expression>.Is.Anything, Arg.Is (_context), Arg<Func<ITableInfo, SqlTable>>.Is.Anything))
.Return (fakeFromExpressionInfo)
.WhenCalled (mi =>
{
var fromExpression = (Expression) mi.Arguments[0];
CheckExpressionMovedIntoSubStatement (fromExpression, originalStatement);
});
_handler.HandleResultOperator (resultOperator, _sqlStatementBuilder, _generator, _stageMock, _context);
_stageMock.VerifyAllExpectations();
Assert.That (_sqlStatementBuilder.GroupByExpression, Is.SameAs (keySelector));
Assert.That (_sqlStatementBuilder.SqlTables.Count, Is.EqualTo (1));
Assert.That (_sqlStatementBuilder.SqlTables[0], Is.SameAs (fakeFromExpressionInfo.SqlTable));
Assert.That (_sqlStatementBuilder.DataInfo, Is.Not.SameAs (originalDataInfo));
Assert.That (
_sqlStatementBuilder.DataInfo.DataType,
Is.EqualTo (typeof (IQueryable<>).MakeGenericType (typeof (IGrouping<,>).MakeGenericType (typeof (string), typeof (string)))));
}
public void GenerateTextForJoinKeyExpression ()
{
var expression = new SqlColumnDefinitionExpression (typeof (int), "c", "ID", false);
var stageMock = MockRepository.GeneratePartialMock<DefaultSqlGenerationStage>();
stageMock
.Expect (mock => CallGenerateTextForNonSelectExpression (mock, expression))
.WhenCalled (c => _commandBuilder.Append ("test"));
stageMock.Replay();
stageMock.GenerateTextForJoinCondition (_commandBuilder, expression);
stageMock.VerifyAllExpectations();
Assert.That (_commandBuilder.GetCommandText(), Is.EqualTo ("test"));
}
public void BuildOrderBy_WithMultipleOrderByClauses ()
{
var columnExpression1 = new SqlColumnDefinitionExpression (typeof (string), "t", "ID", false);
var orderByClause1 = new Ordering (columnExpression1, OrderingDirection.Asc);
var columnExpression2 = new SqlColumnDefinitionExpression (typeof (string), "t", "Name", false);
var orderByClause2 = new Ordering (columnExpression2, OrderingDirection.Desc);
var columnExpression3 = new SqlColumnDefinitionExpression (typeof (string), "t", "City", false);
var orderByClause3 = new Ordering (columnExpression3, OrderingDirection.Desc);
var sqlStatement = new SqlStatement (
new TestStreamedValueInfo (typeof (int)),
_entityExpression,
new[] { _sqlTable },
null,
null,
new[] { orderByClause1, orderByClause2, orderByClause3 },
null,
false,
null,
null);
_stageMock.Expect (mock => mock.GenerateTextForOrdering (_commandBuilder, sqlStatement.Orderings[0]))
.WhenCalled (mi => ((SqlCommandBuilder) mi.Arguments[0]).Append ("[t].[ID] ASC"));
_stageMock.Expect (mock => mock.GenerateTextForOrdering (_commandBuilder, sqlStatement.Orderings[1]))
.WhenCalled (mi => ((SqlCommandBuilder) mi.Arguments[0]).Append ("[t].[Name] DESC"));
_stageMock.Expect (mock => mock.GenerateTextForOrdering (_commandBuilder, sqlStatement.Orderings[2]))
.WhenCalled (mi => ((SqlCommandBuilder) mi.Arguments[0]).Append ("[t].[City] DESC"));
_stageMock.Replay();
_generator.BuildOrderByPart (sqlStatement, _commandBuilder);
Assert.That (_commandBuilder.GetCommandText(), Is.EqualTo (" ORDER BY [t].[ID] ASC, [t].[Name] DESC, [t].[City] DESC"));
_stageMock.VerifyAllExpectations();
}
public void VisitChildren_ChangeColumn ()
{
var newColumnExpression = new SqlColumnDefinitionExpression (typeof (string), "o", "Test", false);
var visitorMock = MockRepository.GenerateMock<ExpressionTreeVisitor>();
var expectedColumns = new[] { _columnExpression1, newColumnExpression, _columnExpression3 };
visitorMock.Expect (mock => mock.VisitAndConvert (_originalColumnsReadonly, "VisitChildren")).Return (Array.AsReadOnly (expectedColumns));
visitorMock.Replay();
var expression = (SqlEntityExpression) ExtensionExpressionTestHelper.CallVisitChildren (_entityExpression, visitorMock);
Assert.That (expression, Is.Not.SameAs (_entityExpression));
Assert.That (expression.Type, Is.SameAs (_entityExpression.Type));
Assert.That (expression.Columns, Is.EqualTo (expectedColumns));
}
public void ResolveExpression_OptimizesEntityRefMemberComparisons ()
{
// This test proves that the first stage (without resolving SqlEntityRefMemberExpressions) is executed.
var memberInfo = typeof (Kitchen).GetProperty ("Cook");
var entityExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression (typeof (Kitchen));
var fakeOptimizedRefIdentity = new SqlColumnDefinitionExpression (typeof (int), "c", "KitchenID", false);
var entityRefMemberExpression = new SqlEntityRefMemberExpression (entityExpression, memberInfo);
_resolverMock
.Stub (stub => stub.TryResolveOptimizedIdentity (entityRefMemberExpression))
.Return (fakeOptimizedRefIdentity);
var entity = CreateEntityExpressionWithIdentity (typeof (Cook), typeof (int));
var binary = Expression.Equal (entityRefMemberExpression, entity);
var result = ResolvingExpressionVisitor.ResolveExpression (binary, _resolverMock, _stageMock, _mappingResolutionContext, _generator);
var expected = Expression.Equal (fakeOptimizedRefIdentity, entity.GetIdentityExpression ());
SqlExpressionTreeComparer.CheckAreEqualTrees (expected, result);
}
public void VisitAggregationExpression_Count ()
{
var columnExpression = new SqlColumnDefinitionExpression (typeof (string), "c", "Name", false);
var expression = new AggregationExpression (typeof (int), columnExpression, AggregationModifier.Count);
SqlGeneratingExpressionVisitor.GenerateSql (expression, _commandBuilder, _stageMock);
Assert.That (_commandBuilder.GetCommandText(), Is.EqualTo ("COUNT(*)"));
}
public void ResolveMemberExpression_WithSqlColumnExpression ()
{
var columnExpression = new SqlColumnDefinitionExpression (typeof (string), "c", "CustomerID", true);
var memberInfo = typeof (DataContextTestClass.Customer).GetProperty ("CustomerID");
var result = _mappingResolver.ResolveMemberExpression (columnExpression, memberInfo);
var expectedExpression = columnExpression;
SqlExpressionTreeComparer.CheckAreEqualTrees (expectedExpression, result);
}
public void SimplifyIfPossible_SimplifiableStatement_AddsAggregationAndReturnsReference ()
{
Assert.That (_associatedGroupingSelectExpression.AggregationExpressions.Count, Is.EqualTo (0));
var expression = new SqlSubStatementExpression (_simplifiableResolvedSqlStatement);
var preparedResolvedAggregate = new AggregationExpression (
typeof (int),
new NamedExpression ("element", Expression.Constant ("e")),
AggregationModifier.Count);
_stageMock
.Expect (mock => mock.ResolveAggregationExpression(Arg<Expression>.Is.Anything, Arg.Is (_context)))
.Return (preparedResolvedAggregate)
.WhenCalled (mi => {
var expectedReplacedAggregate = new AggregationExpression (
typeof (int),
((NamedExpression) _associatedGroupingSelectExpression.ElementExpression).Expression,
AggregationModifier.Count);
SqlExpressionTreeComparer.CheckAreEqualTrees (expectedReplacedAggregate, (Expression) mi.Arguments[0]);
});
_stageMock.Replay();
var result = _groupAggregateSimplifier.SimplifyIfPossible (expression, _simplifiableUnresolvedProjection);
_stageMock.VerifyAllExpectations();
Assert.That (_associatedGroupingSelectExpression.AggregationExpressions.Count, Is.EqualTo (1));
Assert.That (
((NamedExpression) _associatedGroupingSelectExpression.AggregationExpressions[0]).Expression,
Is.SameAs (preparedResolvedAggregate));
var expected = new SqlColumnDefinitionExpression (typeof (int), "q0", "a0", false);
SqlExpressionTreeComparer.CheckAreEqualTrees (expected, result);
}
public void ResolveCollectionSourceExpression ()
{
var constantExpression = Expression.Constant (new Cook());
var expression = Expression.MakeMemberAccess (constantExpression, typeof (Cook).GetProperty ("FirstName"));
var sqlColumnExpression = new SqlColumnDefinitionExpression (typeof (string), "c", "Name", false);
var fakeResult = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression (typeof (Cook));
_resolverMock
.Expect (mock => mock.ResolveConstantExpression (constantExpression))
.Return (sqlColumnExpression);
_resolverMock
.Expect (mock => mock.ResolveMemberExpression (sqlColumnExpression, expression.Member))
.Return (fakeResult);
_resolverMock.Replay();
var result = _stage.ResolveCollectionSourceExpression (expression, _mappingResolutionContext);
_resolverMock.VerifyAllExpectations();
Assert.That (result, Is.SameAs (fakeResult));
}
public void ResolveMemberAccess ()
{
var sourceExpression = new SqlColumnDefinitionExpression (typeof (Cook), "c", "Substitution", false);
var memberInfo = typeof (Cook).GetProperty ("Name");
var fakeResolvedExpression = new SqlLiteralExpression ("Hugo");
_resolverMock
.Expect (mock => mock.ResolveMemberExpression (sourceExpression, memberInfo))
.Return (fakeResolvedExpression);
_resolverMock.Replay();
var result = _stage.ResolveMemberAccess (sourceExpression, memberInfo, _resolverMock, _mappingResolutionContext);
_resolverMock.VerifyAllExpectations();
Assert.That (result, Is.SameAs (fakeResolvedExpression));
}
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);
}
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 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 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);
}
