public void ResolveWhereCondition_ResolvesExpression()
{
var expression = new SqlTableReferenceExpression(_sqlTable);
var fakeResult = Expression.Constant(0);
_stageMock
.Expect(mock => mock.ResolveWhereExpression(expression, _mappingResolutionContext))
.Return(fakeResult);
_stageMock.Replay();
var result = _visitor.ResolveWhereCondition(expression);
_stageMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(fakeResult));
}
public void VisitQuerySourceReferenceExpression_WithNonNullWhereCondition()
{
var memberInfo = typeof(Cook).GetProperty("Assistants");
var sqlTableReferenceExpression = new SqlTableReferenceExpression(SqlStatementModelObjectMother.CreateSqlTable(typeof(Cook)));
var innerSequenceExpression =
Expression.MakeMemberAccess(
sqlTableReferenceExpression, memberInfo);
var joinClause = new JoinClause(
"x",
typeof(Cook[]),
innerSequenceExpression,
Expression.Constant(new Cook()),
Expression.Constant(new Cook()));
var groupJoinClause = new GroupJoinClause("g", typeof(Cook[]), joinClause);
var querySourceReferenceExpression = new QuerySourceReferenceExpression(groupJoinClause);
var fakeWhereExpression = Expression.Constant(true);
_stageMock
.Expect(mock => mock.PrepareWhereExpression(Arg <Expression> .Matches(e => e is BinaryExpression), Arg.Is(_context)))
.WhenCalled(
mi =>
SqlExpressionTreeComparer.CheckAreEqualTrees(
Expression.Equal(groupJoinClause.JoinClause.OuterKeySelector, groupJoinClause.JoinClause.InnerKeySelector),
(Expression)mi.Arguments[0]))
.Return(fakeWhereExpression);
_stageMock.Replay();
var visitor = CreateTestableVisitor(_someOrderingExtractionPolicy);
visitor.VisitQuerySourceReference(querySourceReferenceExpression);
_stageMock.VerifyAllExpectations();
Assert.That(visitor.FromExpressionInfo != null); // inline condition because of ReSharper
var fromExpressionInfo = (FromExpressionInfo)visitor.FromExpressionInfo;
Assert.That(fromExpressionInfo.WhereCondition, Is.AssignableTo(typeof(BinaryExpression)));
Assert.That(fromExpressionInfo.WhereCondition.NodeType, Is.EqualTo(ExpressionType.AndAlso));
Assert.That(((BinaryExpression)fromExpressionInfo.WhereCondition).Left, Is.TypeOf(typeof(JoinConditionExpression)));
Assert.That(((JoinConditionExpression)((BinaryExpression)fromExpressionInfo.WhereCondition).Left).JoinedTable.JoinInfo, Is.TypeOf(typeof(UnresolvedCollectionJoinInfo)));
Assert.That(
((UnresolvedCollectionJoinInfo)((JoinConditionExpression)((BinaryExpression)fromExpressionInfo.WhereCondition).Left).JoinedTable.JoinInfo).SourceExpression, Is.SameAs(sqlTableReferenceExpression));
Assert.That(
((UnresolvedCollectionJoinInfo)((JoinConditionExpression)((BinaryExpression)fromExpressionInfo.WhereCondition).Left).JoinedTable.JoinInfo).MemberInfo, Is.SameAs(memberInfo));
Assert.That(((JoinConditionExpression)((BinaryExpression)fromExpressionInfo.WhereCondition).Left).JoinedTable.JoinSemantics, Is.EqualTo(JoinSemantics.Inner));
Assert.That(((BinaryExpression)fromExpressionInfo.WhereCondition).Right, Is.SameAs(fakeWhereExpression));
}
public void ResolveSelectProjection_ResolvesExpression()
{
var expression = new SqlTableReferenceExpression(_sqlTable);
var sqlStatementBuilder = new SqlStatementBuilder();
var fakeResult = Expression.Constant(0);
_stageMock
.Expect(mock => mock.ResolveSelectExpression(expression, sqlStatementBuilder, _mappingResolutionContext))
.Return(fakeResult);
_stageMock.Replay();
var result = _visitor.ResolveSelectProjection(expression, sqlStatementBuilder);
_stageMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(fakeResult));
}
public void HandleResultOperator_DetectConstantKeysAndReplaceWithSubStatement()
{
var keySelector = Expression.Constant("keySelector");
var elementSelector = Expression.Constant("elementSelector");
var resultOperator = new GroupResultOperator("itemName", keySelector, elementSelector);
var preparedConstantKeySelector = Expression.Constant("test");
_stageMock
.Expect(mock => mock.PrepareResultOperatorItemExpression(keySelector, _context))
.Return(preparedConstantKeySelector);
_stageMock
.Expect(mock => mock.PrepareResultOperatorItemExpression(elementSelector, _context))
.Return(elementSelector);
_stageMock.Replay();
_handler.HandleResultOperator(resultOperator, _sqlStatementBuilder, _generator, _stageMock, _context);
_stageMock.VerifyAllExpectations();
Assert.That(_sqlStatementBuilder.SqlTables.Count, Is.EqualTo(2));
Assert.That(_sqlStatementBuilder.SqlTables[1], Is.TypeOf(typeof(SqlTable)));
Assert.That(((SqlTable)_sqlStatementBuilder.SqlTables[1]).TableInfo, Is.TypeOf(typeof(ResolvedSubStatementTableInfo)));
var groupKeyTableTableInfo = (ResolvedSubStatementTableInfo)((SqlTable)_sqlStatementBuilder.SqlTables[1]).TableInfo;
var expectedSelectExpression = new NamedExpression(null, preparedConstantKeySelector);
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedSelectExpression, groupKeyTableTableInfo.SqlStatement.SelectProjection);
var expectedStatement = new SqlStatementBuilder
{
DataInfo = new StreamedSequenceInfo(typeof(IEnumerable <string>), groupKeyTableTableInfo.SqlStatement.SelectProjection),
SelectProjection = groupKeyTableTableInfo.SqlStatement.SelectProjection
}
.GetSqlStatement();
Assert.That(groupKeyTableTableInfo.SqlStatement, Is.EqualTo(expectedStatement));
var expectedGroupGyExpression = new SqlTableReferenceExpression(_sqlStatementBuilder.SqlTables[1]);
SqlExpressionTreeComparer.CheckAreEqualTrees(_sqlStatementBuilder.GroupByExpression, expectedGroupGyExpression);
SqlExpressionTreeComparer.CheckAreEqualTrees(
_sqlStatementBuilder.SelectProjection,
SqlGroupingSelectExpression.CreateWithNames(expectedGroupGyExpression, elementSelector));
}
public override Expression VisitSqlSubStatement(SqlSubStatementExpression expression)
{
var newExpression = base.VisitSqlSubStatement(expression);
var newExpressionAsSqlSubStatementExpression = newExpression as SqlSubStatementExpression;
// Substatements returning a single value need to be moved to the FROM part of the SQL statement because they might return more than one column.
// Since a SqlSubStatementExpression must return a single row anyway, we can do this.
// (However, errors that would have arisen because the statement does not return exactly one row will not be found.)
if (newExpressionAsSqlSubStatementExpression != null &&
newExpressionAsSqlSubStatementExpression.SqlStatement.DataInfo is StreamedSingleValueInfo)
{
var sqlTable = newExpressionAsSqlSubStatementExpression.ConvertToSqlTable(Generator.GetUniqueIdentifier("q"));
var sqlTableReferenceExpression = new SqlTableReferenceExpression(sqlTable);
Context.AddSqlTable(sqlTable, _sqlStatementBuilder);
return(Visit(sqlTableReferenceExpression));
}
return(newExpression);
}
public void HandleResultOperator_TransformSubqueriesUsedAsGroupByKeys()
{
var keySelector = Expression.Constant("keySelector");
var elementSelector = Expression.Constant("elementSelector");
var resultOperator = new GroupResultOperator("itemName", keySelector, elementSelector);
var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement_Single();
var preparedSubStatementKeySelector = new SqlSubStatementExpression(sqlStatement);
_stageMock
.Expect(mock => mock.PrepareResultOperatorItemExpression(keySelector, _context))
.Return(preparedSubStatementKeySelector);
_stageMock
.Expect(mock => mock.PrepareResultOperatorItemExpression(elementSelector, _context))
.Return(elementSelector);
_stageMock.Replay();
_handler.HandleResultOperator(resultOperator, _sqlStatementBuilder, _generator, _stageMock, _context);
_stageMock.VerifyAllExpectations();
Assert.That(_sqlStatementBuilder.SqlTables.Count, Is.EqualTo(2));
Assert.That(_sqlStatementBuilder.SqlTables[1], Is.TypeOf(typeof(SqlTable)));
Assert.That(((SqlTable)_sqlStatementBuilder.SqlTables[1]).TableInfo, Is.TypeOf(typeof(ResolvedSubStatementTableInfo)));
var groupKeyTableTableInfo = (ResolvedSubStatementTableInfo)((SqlTable)_sqlStatementBuilder.SqlTables[1]).TableInfo;
var expectedStatement = new SqlStatementBuilder(sqlStatement)
{
DataInfo = new StreamedSequenceInfo(typeof(IEnumerable <int>), sqlStatement.SelectProjection)
}
.GetSqlStatement();
Assert.That(groupKeyTableTableInfo.SqlStatement, Is.EqualTo(expectedStatement));
var expectedGroupGyExpression = new SqlTableReferenceExpression(_sqlStatementBuilder.SqlTables[1]);
SqlExpressionTreeComparer.CheckAreEqualTrees(_sqlStatementBuilder.GroupByExpression, expectedGroupGyExpression);
SqlExpressionTreeComparer.CheckAreEqualTrees(
_sqlStatementBuilder.SelectProjection,
SqlGroupingSelectExpression.CreateWithNames(expectedGroupGyExpression, elementSelector));
}
public void VisitSelectClause_CreatesSelectProjection()
{
var preparedExpression = new SqlTableReferenceExpression(SqlStatementModelObjectMother.CreateSqlTable(typeof(Cook)));
_stageMock
.Expect(
mock =>
mock.PrepareSelectExpression(
Arg <Expression> .Matches(e => e == _selectClause.Selector),
Arg <ISqlPreparationContext> .Matches(c => c != _context)))
.Return(preparedExpression);
_stageMock.Replay();
_visitor.VisitSelectClause(_selectClause, _queryModel);
_stageMock.VerifyAllExpectations();
Assert.That(_visitor.SqlStatementBuilder.SelectProjection, Is.SameAs(preparedExpression));
Assert.That(_visitor.SqlStatementBuilder.DataInfo, Is.TypeOf(typeof(StreamedSequenceInfo)));
Assert.That(((StreamedSequenceInfo)_visitor.SqlStatementBuilder.DataInfo).DataType, Is.EqualTo(_selectClause.GetOutputDataInfo().DataType));
}
public void VisitSqlTableReferenceExpression_RevisitsResult()
{
var tableReferenceExpression = new SqlTableReferenceExpression(_sqlTable);
var fakeResult = Expression.Constant(0);
_stageMock
.Expect(mock => mock.ResolveTableReferenceExpression(tableReferenceExpression, _mappingResolutionContext))
.Return(fakeResult);
_stageMock.Replay();
_resolverMock
.Expect(mock => mock.ResolveConstantExpression(fakeResult))
.Return(fakeResult);
_resolverMock.Replay();
var result = _visitor.Visit(tableReferenceExpression);
_stageMock.VerifyAllExpectations();
_resolverMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(fakeResult));
}
public void SetUp()
{
_stageMock = MockRepository.GenerateMock <ISqlPreparationStage> ();
_generator = new UniqueIdentifierGenerator();
_context = SqlStatementModelObjectMother.CreateSqlPreparationContext();
_handler = new SkipResultOperatorHandler();
_sqlTable = new SqlTable(new UnresolvedTableInfo(typeof(Cook)), JoinSemantics.Inner);
_selectProjection = new SqlTableReferenceExpression(_sqlTable);
_ordering = new Ordering(Expression.Constant(7), OrderingDirection.Asc);
_sqlStatementBuilder = new SqlStatementBuilder
{
SelectProjection = _selectProjection,
DataInfo = new StreamedSequenceInfo(typeof(Cook[]), Expression.Constant(new Cook())),
SqlTables = { _sqlTable },
};
_tupleCtor = _tupleCtor = typeof(KeyValuePair <Cook, int>).GetConstructor(new[] { typeof(Cook), typeof(int) });
}
public void ResolveSqlStatement()
{
var sqlTable = SqlStatementModelObjectMother.CreateSqlTable_WithUnresolvedTableInfo(typeof(Cook));
var tableReferenceExpression = new SqlTableReferenceExpression(new SqlTable(_fakeResolvedSimpleTableInfo, JoinSemantics.Inner));
var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement(tableReferenceExpression, new[] { sqlTable });
var fakeEntityExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Cook));
_resolverMock
.Expect(mock => mock.ResolveTableInfo((UnresolvedTableInfo)((SqlTable)sqlStatement.SqlTables[0]).TableInfo, _uniqueIdentifierGenerator))
.Return(_fakeResolvedSimpleTableInfo);
_resolverMock
.Expect(mock => mock.ResolveSimpleTableInfo(tableReferenceExpression.SqlTable.GetResolvedTableInfo(), _uniqueIdentifierGenerator))
.Return(fakeEntityExpression);
_resolverMock.Replay();
var newSqlStatment = _stage.ResolveSqlStatement(sqlStatement, _mappingResolutionContext);
_resolverMock.VerifyAllExpectations();
Assert.That(((SqlTable)newSqlStatment.SqlTables[0]).TableInfo, Is.SameAs(_fakeResolvedSimpleTableInfo));
Assert.That(newSqlStatment.SelectProjection, Is.SameAs(fakeEntityExpression));
}
public void CreateSqlTableForSubStatement_WithoutOrderings()
{
var statementWithoutOrderings = SqlStatementModelObjectMother.CreateSqlStatementWithCook();
var result = _factory.CreateSqlTableForStatement(statementWithoutOrderings, info => new SqlTable(info, JoinSemantics.Inner));
_stageMock.VerifyAllExpectations();
var tableInfo = ((SqlTable)result.SqlTable).TableInfo;
Assert.That(tableInfo, Is.TypeOf(typeof(ResolvedSubStatementTableInfo)));
var subStatement = ((ResolvedSubStatementTableInfo)tableInfo).SqlStatement;
Assert.That(subStatement, Is.SameAs(statementWithoutOrderings));
Assert.That(result.WhereCondition, Is.Null);
Assert.That(result.ExtractedOrderings, Is.Empty);
var expectedItemSelector = new SqlTableReferenceExpression(result.SqlTable);
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedItemSelector, result.ItemSelector);
}
public void SetUp()
{
_tableReferenceExpression = new SqlTableReferenceExpression(SqlStatementModelObjectMother.CreateSqlTable(typeof(Cook)));
}
public void VisitQuerySourceReferenceExpression_WithOrderings_AndExtractOrdingsPolicy()
{
var sqlTable = SqlStatementModelObjectMother.CreateSqlTable(typeof(Cook));
var sqlTableReferenceExpression = new SqlTableReferenceExpression(sqlTable);
var selectProjection = new NamedExpression("test", Expression.MakeMemberAccess(sqlTableReferenceExpression, typeof(Cook).GetProperty("Name")));
var orderingExpression = Expression.MakeMemberAccess(sqlTableReferenceExpression, typeof(Cook).GetProperty("ID"));
var sqlStatement = new SqlStatementBuilder
{
DataInfo = new StreamedSequenceInfo(typeof(DateTime[]), Expression.Constant(new DateTime(2000, 1, 1))),
SelectProjection = selectProjection,
SqlTables = { sqlTable },
Orderings =
{ new Ordering(orderingExpression, OrderingDirection.Asc) }
}.GetSqlStatement();
var fakeSelectExpression = Expression.Constant(new KeyValuePair <string, int>("test", 5));
var fakeWhereExpression = Expression.Constant(true);
var innerSequenceExpression = new SqlSubStatementExpression(sqlStatement);
var joinClause = new JoinClause(
"x",
typeof(Cook[]),
innerSequenceExpression,
Expression.Constant(new Cook()),
Expression.Constant(new Cook()));
var groupJoinClause = new GroupJoinClause("g", typeof(Cook[]), joinClause);
var querySourceReferenceExpression = new QuerySourceReferenceExpression(groupJoinClause);
_stageMock
.Expect(mock => mock.PrepareSelectExpression(Arg <Expression> .Is.Anything, Arg <ISqlPreparationContext> .Is.Anything))
.Return(fakeSelectExpression);
_stageMock
.Expect(mock => mock.PrepareWhereExpression(Arg <Expression> .Matches(e => e is BinaryExpression), Arg.Is(_context)))
.WhenCalled(
mi =>
SqlExpressionTreeComparer.CheckAreEqualTrees(
Expression.Equal(groupJoinClause.JoinClause.OuterKeySelector, groupJoinClause.JoinClause.InnerKeySelector),
(Expression)mi.Arguments[0]))
.Return(fakeWhereExpression);
_stageMock.Replay();
var visitor = CreateTestableVisitor(OrderingExtractionPolicy.ExtractOrderingsIntoProjection);
visitor.VisitQuerySourceReference(querySourceReferenceExpression);
_stageMock.VerifyAllExpectations();
Assert.That(visitor.FromExpressionInfo != null); // inline condition because of ReSharper
var fromExpressionInfo = (FromExpressionInfo)visitor.FromExpressionInfo;
Assert.That(fromExpressionInfo.ExtractedOrderings.Count, Is.EqualTo(1));
Assert.That(fromExpressionInfo.ExtractedOrderings[0].Expression, Is.AssignableTo(typeof(MemberExpression)));
Assert.That(((MemberExpression)fromExpressionInfo.ExtractedOrderings[0].Expression).Expression, Is.TypeOf(typeof(SqlTableReferenceExpression)));
Assert.That(
((SqlTableReferenceExpression)((MemberExpression)fromExpressionInfo.ExtractedOrderings[0].Expression).Expression).SqlTable, Is.TypeOf(typeof(SqlTable)));
Assert.That(
((SqlTable)((SqlTableReferenceExpression)((MemberExpression)fromExpressionInfo.ExtractedOrderings[0].Expression).Expression).SqlTable).TableInfo, Is.TypeOf(typeof(ResolvedSubStatementTableInfo)));
var resolvedSubStatementtableInfo =
(ResolvedSubStatementTableInfo)((SqlTable)((SqlTableReferenceExpression)((MemberExpression)fromExpressionInfo.ExtractedOrderings[0].Expression).Expression).SqlTable).TableInfo;
Assert.That(resolvedSubStatementtableInfo.SqlStatement.SelectProjection, Is.SameAs(fakeSelectExpression));
Assert.That(resolvedSubStatementtableInfo.SqlStatement.Orderings.Count, Is.EqualTo(0));
Assert.That(((MemberExpression)fromExpressionInfo.ExtractedOrderings[0].Expression).Member, Is.EqualTo(typeof(KeyValuePair <,>).MakeGenericType(typeof(string), typeof(int)).GetProperty("Value")));
Assert.That(fromExpressionInfo.ItemSelector, Is.AssignableTo(typeof(MemberExpression)));
Assert.That(((MemberExpression)fromExpressionInfo.ItemSelector).Expression, Is.TypeOf(typeof(SqlTableReferenceExpression)));
Assert.That(((SqlTableReferenceExpression)((MemberExpression)fromExpressionInfo.ItemSelector).Expression).SqlTable, Is.TypeOf(typeof(SqlTable)));
Assert.That(
((SqlTable)((SqlTableReferenceExpression)((MemberExpression)fromExpressionInfo.ItemSelector).Expression).SqlTable).TableInfo, Is.TypeOf(typeof(ResolvedSubStatementTableInfo)));
Assert.That(((MemberExpression)fromExpressionInfo.ItemSelector).Member, Is.EqualTo(typeof(KeyValuePair <,>).MakeGenericType(typeof(string), typeof(int)).GetProperty("Key")));
}
