public void GetExpressionMapping_GetFromParentContext()
{
var querySourceReferenceExpression = new QuerySourceReferenceExpression(_parentSource);
var sqlTableReferenceExpression = new SqlTableReferenceExpression(_parentSqlTable);
_parentContext.AddExpressionMapping(querySourceReferenceExpression, sqlTableReferenceExpression);
Assert.That(_contextWithParent.GetExpressionMapping(querySourceReferenceExpression), Is.SameAs(sqlTableReferenceExpression));
}
public void HandleResultOperator()
{
var resultOperator = new UnionResultOperator("x", typeof(int), ExpressionHelper.CreateExpression(typeof(int[])));
var preparedSource2Statement = SqlStatementModelObjectMother.CreateSqlStatement();
var preparedSource2Expression = new SqlSubStatementExpression(preparedSource2Statement);
_stageMock
.Expect(mock => mock.PrepareResultOperatorItemExpression(resultOperator.Source2, _context))
.Return(preparedSource2Expression);
_handler.HandleResultOperator(resultOperator, _sqlStatementBuilder, UniqueIdentifierGenerator, _stageMock, _context);
_stageMock.VerifyAllExpectations();
// Main functionality
Assert.That(_sqlStatementBuilder.SetOperationCombinedStatements, Has.Count.EqualTo(1));
Assert.That(_sqlStatementBuilder.SetOperationCombinedStatements[0].SetOperation, Is.EqualTo(SetOperation.Union));
Assert.That(_sqlStatementBuilder.SetOperationCombinedStatements[0].SqlStatement, Is.SameAs(preparedSource2Statement));
// Data info
Assert.That(_sqlStatementBuilder.DataInfo, Is.TypeOf(typeof(StreamedSequenceInfo)));
Assert.That(((StreamedSequenceInfo)_sqlStatementBuilder.DataInfo).DataType, Is.EqualTo(typeof(IQueryable <>).MakeGenericType(typeof(int))));
Assert.That(
((StreamedSequenceInfo)_sqlStatementBuilder.DataInfo).ItemExpression,
Is.EqualTo(new QuerySourceReferenceExpression(resultOperator)));
// Everyone referencing the result operator should reference the (outer) select projection instead.
Assert.That(
_context.GetExpressionMapping(new QuerySourceReferenceExpression(resultOperator)),
Is.SameAs(_sqlStatementBuilder.SelectProjection));
}
public void HandleResultOperator_AddsMappingForItemExpression()
{
var originalItemExpression = ((StreamedSequenceInfo)_sqlStatementBuilder.DataInfo).ItemExpression;
var resultOperator = new SkipResultOperator(Expression.Constant(10));
StubStageMock_PrepareSelectExpression();
_handler.HandleResultOperator(resultOperator, _sqlStatementBuilder, UniqueIdentifierGenerator, _stageMock, _context);
Assert.That(_context.GetExpressionMapping(originalItemExpression), Is.EqualTo(_sqlStatementBuilder.SelectProjection));
}
public override Expression Visit(Expression expression)
{
if (expression != null)
{
var replacementExpression = _context.GetExpressionMapping(expression);
if (replacementExpression != null)
{
expression = replacementExpression;
}
}
return(base.Visit(expression));
}
public void HandleResultOperator()
{
var resultOperator = new DefaultIfEmptyResultOperator(Expression.Constant(null));
_handler.HandleResultOperator(resultOperator, _sqlStatementBuilder, _generator, _stage, _context);
Assert.That(_sqlStatementBuilder.SqlTables.Count, Is.EqualTo(1));
Assert.That(_sqlStatementBuilder.SqlTables[0].JoinSemantics, Is.EqualTo(JoinSemantics.Left));
var tableInfo = _sqlStatementBuilder.SqlTables[0].TableInfo;
Assert.That(tableInfo, Is.TypeOf(typeof(ResolvedSubStatementTableInfo)));
Assert.That(_context.GetExpressionMapping(((StreamedSequenceInfo)_sqlStatementBuilder.DataInfo).ItemExpression), Is.Not.Null);
}
public Expression GetExpressionMapping(Expression original)
{
ArgumentUtility.CheckNotNull("original", original);
Expression result;
if (_mapping.TryGetValue(original, out result))
{
return(result);
}
if (_parentContext != null)
{
return(_parentContext.GetExpressionMapping(original));
}
return(null);
}
public void MoveCurrentStatementToSqlTable()
{
var originalStatement = _statementBuilder.GetSqlStatement();
var fakeFromExpressionInfo = CreateFakeFromExpressionInfo(new Ordering[0]);
Func <ITableInfo, SqlTable> tableGenerator = info => new SqlTable(info, JoinSemantics.Inner);
var someOrderingExtractionPolicy = Some.Item(
OrderingExtractionPolicy.DoNotExtractOrderings,
OrderingExtractionPolicy.ExtractOrderingsIntoProjection);
_stageMock
.Expect(mock => mock.PrepareFromExpression(
Arg <SqlSubStatementExpression> .Is.TypeOf,
Arg.Is(_context),
Arg.Is(tableGenerator),
Arg.Is(someOrderingExtractionPolicy)))
.Return(fakeFromExpressionInfo)
.WhenCalled(mi =>
{
var sqlStatement = ((SqlSubStatementExpression)mi.Arguments[0]).SqlStatement;
SqlExpressionTreeComparer.CheckAreEqualTrees(new NamedExpression(null, originalStatement.SelectProjection), sqlStatement.SelectProjection);
Assert.That(sqlStatement.DataInfo, Is.SameAs(originalStatement.DataInfo));
Assert.That(sqlStatement.WhereCondition, Is.SameAs(originalStatement.WhereCondition));
});
_stageMock.Replay();
_handler.MoveCurrentStatementToSqlTable(_statementBuilder, _context, tableGenerator, _stageMock, someOrderingExtractionPolicy);
_stageMock.VerifyAllExpectations();
Assert.That(_statementBuilder.DataInfo, Is.SameAs(originalStatement.DataInfo));
Assert.That(_statementBuilder.SqlTables[0], Is.SameAs(fakeFromExpressionInfo.SqlTable));
Assert.That(_statementBuilder.SelectProjection, Is.SameAs(fakeFromExpressionInfo.ItemSelector));
var mappedItemExpression = _context.GetExpressionMapping(((StreamedSequenceInfo)originalStatement.DataInfo).ItemExpression);
Assert.That(mappedItemExpression, Is.Not.Null);
Assert.That(mappedItemExpression, Is.SameAs(fakeFromExpressionInfo.ItemSelector));
}
public void VisitQuerySourceReferenceExpression()
{
var innerSequenceExpression = Expression.Constant(new[] { new Cook() });
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);
var result = visitor.VisitQuerySourceReference(querySourceReferenceExpression);
_stageMock.VerifyAllExpectations();
Debug.Assert(visitor.FromExpressionInfo != null, "_visitor.FromExpressionInfo != null");
var fromExpressionInfo = (FromExpressionInfo)visitor.FromExpressionInfo;
SqlExpressionTreeComparer.CheckAreEqualTrees(
new SqlTableReferenceExpression(fromExpressionInfo.SqlTable),
_context.GetExpressionMapping(new QuerySourceReferenceExpression(groupJoinClause.JoinClause)));
SqlExpressionTreeComparer.CheckAreEqualTrees(fromExpressionInfo.ItemSelector, result);
Assert.That(((UnresolvedTableInfo)fromExpressionInfo.SqlTable.TableInfo).ItemType, Is.EqualTo(typeof(Cook)));
Assert.That(fromExpressionInfo.WhereCondition, Is.SameAs(fakeWhereExpression));
Assert.That(fromExpressionInfo.ExtractedOrderings.Count, Is.EqualTo(0));
}
public void AddExpressionMapping()
{
_context.AddExpressionMapping(new QuerySourceReferenceExpression(_source), new SqlTableReferenceExpression(_sqlTable));
Assert.That(_context.GetExpressionMapping(new QuerySourceReferenceExpression(_source)), Is.Not.Null);
}
