public void SetUp () { _leftExpression = Expression.Constant (1); _rightExpression = Expression.Constant (2); _expression = new SqlInExpression (_leftExpression, _rightExpression); }
public void HandleResultOperator () { var itemExpression = Expression.Constant (new Cook ()); var resultOperator = new ContainsResultOperator (itemExpression); var sqlStatement = _sqlStatementBuilder.GetSqlStatement (); var preparedExpression = Expression.Constant (new Cook (), typeof (Cook)); _stageMock.Expect (mock => mock.PrepareResultOperatorItemExpression (itemExpression, _context)).Return (preparedExpression); _stageMock.Replay (); _handler.HandleResultOperator (resultOperator, _sqlStatementBuilder, _generator, _stageMock, _context); _stageMock.VerifyAllExpectations (); Assert.That (_sqlStatementBuilder.DataInfo, Is.TypeOf (typeof (StreamedScalarValueInfo))); Assert.That (((StreamedScalarValueInfo) _sqlStatementBuilder.DataInfo).DataType, Is.EqualTo (typeof (Boolean))); var expectedExpression = new SqlInExpression (preparedExpression, new SqlSubStatementExpression (sqlStatement)); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedExpression, _sqlStatementBuilder.SelectProjection); }
public SqlInExpression ResolvePotentialEntityComparison (SqlInExpression inExpression) { ArgumentUtility.CheckNotNull ("inExpression", inExpression); var newLeft = ResolvePotentialEntity (inExpression.LeftExpression); var newRight = ResolvePotentialEntity (inExpression.RightExpression); if (newLeft != inExpression.LeftExpression || newRight != inExpression.RightExpression) return new SqlInExpression (newLeft, newRight); return inExpression; }
public Expression VisitSqlInExpression (SqlInExpression expression) { var baseVisitedExpression = (SqlInExpression) VisitExtensionExpression (expression); var expressionWithSimplifiedEntities = _entityIdentityResolver.ResolvePotentialEntityComparison (baseVisitedExpression); if (expressionWithSimplifiedEntities != baseVisitedExpression) return VisitExpression (expressionWithSimplifiedEntities); return baseVisitedExpression; }
public Expression VisitSqlInExpression (SqlInExpression expression) { try { return VisitChildrenWithGivenSemantics (expression, SqlExpressionContext.SingleValueRequired); } catch (NotSupportedException ex) { var message = string.Format ( "The SQL 'IN' operator (originally probably a call to a 'Contains' method) requires a single value, so the following expression cannot " + "be translated to SQL: '{0}'.", FormattingExpressionTreeVisitor.Format (expression)); throw new NotSupportedException (message, ex); } }
public void VisitSqlInExpression_RevisitingTerminatesAfterInnerChanges_WithoutOuterChanges () { var left = Expression.Constant (0); var right = Expression.Constant (1); var inExpression = new SqlInExpression (left, right); var fakeResolvedLeft = new SqlLiteralExpression (2); _resolverMock.Expect (mock => mock.ResolveConstantExpression (left)).Return (fakeResolvedLeft); var fakeResolvedRight = new SqlLiteralExpression (3); _resolverMock.Expect (mock => mock.ResolveConstantExpression (right)).Return (fakeResolvedRight); _entityIdentityResolverMock .Expect (mock => mock.ResolvePotentialEntityComparison (Arg<SqlInExpression>.Is.Anything)) .Return (null) .WhenCalled (mi => mi.ReturnValue = mi.Arguments[0]); // No revisiting var result = _visitor.VisitExpression (inExpression); _resolverMock.VerifyAllExpectations (); _entityIdentityResolverMock.VerifyAllExpectations (); Assert.That (result, Is.TypeOf<SqlInExpression> ()); Assert.That (((SqlInExpression) result).LeftExpression, Is.SameAs (fakeResolvedLeft)); Assert.That (((SqlInExpression) result).RightExpression, Is.SameAs (fakeResolvedRight)); }
public void VisitSqlInExpression () { var left = Expression.Constant (0); var right = Expression.Constant (1); var inExpression = new SqlInExpression (left, right); var fakeResolvedLeft = new SqlLiteralExpression (2); _resolverMock.Expect (mock => mock.ResolveConstantExpression (left)).Return (fakeResolvedLeft); var fakeResolvedRight = new SqlLiteralExpression (3); _resolverMock.Expect (mock => mock.ResolveConstantExpression (right)).Return (fakeResolvedRight); var fakeResolvedInExpression = new SqlInExpression (Expression.Constant (4), Expression.Constant (5)); _entityIdentityResolverMock .Expect ( mock => mock.ResolvePotentialEntityComparison ( Arg<SqlInExpression>.Matches (e => e.LeftExpression == fakeResolvedLeft && e.RightExpression == fakeResolvedRight))) .Return (fakeResolvedInExpression); // Result is revisited _resolverMock .Expect (mock => mock.ResolveConstantExpression ((ConstantExpression) fakeResolvedInExpression.LeftExpression)) .Return (fakeResolvedInExpression.LeftExpression); _resolverMock .Expect (mock => mock.ResolveConstantExpression ((ConstantExpression) fakeResolvedInExpression.RightExpression)) .Return (fakeResolvedInExpression.RightExpression); _entityIdentityResolverMock .Expect (mock => mock.ResolvePotentialEntityComparison (fakeResolvedInExpression)) .Return (fakeResolvedInExpression); var result = _visitor.VisitExpression (inExpression); _resolverMock.VerifyAllExpectations (); _entityIdentityResolverMock.VerifyAllExpectations (); Assert.That (result, Is.SameAs (fakeResolvedInExpression)); }
public void ResolvePotentialEntityComparison_SqlInExpression_NonEntities_ReturnsSameExpression () { var sqlInExpression = new SqlInExpression (Expression.Constant (0), Expression.Constant (0)); var result = _entityIdentityResolver.ResolvePotentialEntityComparison (sqlInExpression); Assert.That (result, Is.SameAs (sqlInExpression)); }
public void ResolvePotentialEntityComparison_SqlInExpression_EntitiesAreResolvedToIdentity_RightOnly () { var sqlInExpression = new SqlInExpression (Expression.Constant (null, typeof (Cook)), _entityExpression); var result = _entityIdentityResolver.ResolvePotentialEntityComparison (sqlInExpression); var expected = new SqlInExpression (Expression.Constant (null, typeof (Cook)), _entityExpression.GetIdentityExpression ()); SqlExpressionTreeComparer.CheckAreEqualTrees (expected, result); }
public void ResolvePotentialEntityComparison_SqlInExpression_ResolvesEntitiesToIdentity () { var sqlInExpression = new SqlInExpression (_entityExpression, _entityConstantExpression); var result = _entityIdentityResolver.ResolvePotentialEntityComparison (sqlInExpression); var expected = new SqlInExpression (_entityExpression.GetIdentityExpression (), _entityConstantExpression.IdentityExpression); SqlExpressionTreeComparer.CheckAreEqualTrees (expected, result); }
public void VisitSqlInExpression () { var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatementWithCook(); var sqlSubStatementExpression = new SqlSubStatementExpression (sqlStatement); var sqlInExpression = new SqlInExpression (Expression.Constant (1), sqlSubStatementExpression); _stageMock .Expect ( mock => mock.GenerateTextForSqlStatement ( Arg.Is (_commandBuilder), Arg<SqlStatement>.Is.Anything)) .WhenCalled (mi => ((SqlCommandBuilder) mi.Arguments[0]).Append ("test")); _stageMock.Replay(); SqlGeneratingExpressionVisitor.GenerateSql ( sqlInExpression, _commandBuilder, _stageMock); Assert.That (_commandBuilder.GetCommandText(), Is.EqualTo ("@1 IN (test)")); _stageMock.VerifyAllExpectations(); }
public void SqlInExpression_WithInvalidChildren () { var newExpression = CreateNewExpression(); var expression = new SqlInExpression (newExpression, Expression.Constant (new[] { 1, 2, 3 })); Assert.That ( () => _predicateRequiredVisitor.VisitSqlInExpression (expression), Throws.TypeOf<NotSupportedException> ().With.Message.EqualTo ( "The SQL 'IN' operator (originally probably a call to a 'Contains' method) requires a single value, so the following expression " + "cannot be translated to SQL: 'new TypeForNewExpression(0) IN value(System.Int32[])'.")); }
public void SqlInExpression () { var expression = new SqlInExpression (Expression.Constant (true), Expression.Constant (true)); var expectedResult = new SqlInExpression (new SqlConvertedBooleanExpression (Expression.Constant (1)), new SqlConvertedBooleanExpression (Expression.Constant (1))); var result = _predicateRequiredVisitor.VisitSqlInExpression (expression); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedResult, result); }