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); }