public void Initialization_NullableBoolean () { var innerExpression = Expression.Constant (1, typeof (int?)); var convertedExpression = new SqlConvertedBooleanExpression (innerExpression); Assert.That (convertedExpression.Type, Is.SameAs (typeof (bool?))); Assert.That (convertedExpression.Expression, Is.SameAs (innerExpression)); }
public void ApplyContext () { var valueExpression = Expression.Constant (0); var predicateExpression = Expression.Constant (true); var convertedValue = SqlContextExpressionVisitor.ApplySqlExpressionContext ( new SqlConvertedBooleanExpression (valueExpression), SqlExpressionContext.PredicateRequired, _stageMock, _mappingResolutionContext); var convertedPredicate = SqlContextExpressionVisitor.ApplySqlExpressionContext ( predicateExpression, SqlExpressionContext.SingleValueRequired, _stageMock, _mappingResolutionContext); var expectedConvertedValue = Expression.Equal (valueExpression, new SqlLiteralExpression (1)); var expectedConvertedPredicate = new SqlConvertedBooleanExpression (Expression.Constant (1)); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedConvertedValue, convertedValue); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedConvertedPredicate, convertedPredicate); }
public virtual Expression VisitSqlConvertedBooleanExpression (SqlConvertedBooleanExpression expression) { ArgumentUtility.CheckNotNull ("expression", expression); var namedExpression = expression.Expression as NamedExpression; if (namedExpression != null) { // Since ADO.NET returns bit columns as actual boolean values (not as integer values), we need to convert the NamedExpression back to be // of type bool/bool? instead of int/int?. var conversionToBool = GetBitConversionExpression ( sourceType: namedExpression.Type, targetType: expression.Type, convertedExpression: namedExpression.Expression); var newNamedExpression = new NamedExpression (namedExpression.Name, conversionToBool); return VisitExpression (newNamedExpression); } else { VisitExpression (expression.Expression); return expression; } }
public void VisitSqlConvertedBooleanExpression_WithAnInnerNamedExpression_NullableBool_EmitsBitConversion_AndUsesNullableBoolInProjection () { var namedNullableIntExpression = new NamedExpression ("test", Expression.Constant (0, typeof (int?))); var sqlConvertedBooleanExpression = new SqlConvertedBooleanExpression (namedNullableIntExpression); _visitor.VisitSqlConvertedBooleanExpression (sqlConvertedBooleanExpression); var expectedProjection = GetExpectedProjectionForNamedExpression (_commandBuilder.InMemoryProjectionRowParameter, "test", 0, typeof (bool?)); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedProjection, _commandBuilder.GetInMemoryProjectionBody()); Assert.That (_commandBuilder.GetCommandText(), Is.EqualTo ("CONVERT(BIT, @1) AS [test]")); }
public void VisitNamedExpression_MovesNameIntoSqlConvertedBooleanExpression () { var namedExpression = new NamedExpression ("Name", Expression.Constant (true)); var result = _valueRequiredVisitor.VisitExpression (namedExpression); var expected = new SqlConvertedBooleanExpression (new NamedExpression ("Name", Expression.Constant (1))); SqlExpressionTreeComparer.CheckAreEqualTrees (expected, result); }
public void VisitSqlConvertedBooleanExpression_WithAnInnerNamedExpression_ReturnsAdaptedNamedExpressionOfCorrectType () { var sqlConvertedBooleanExpression = new SqlConvertedBooleanExpression (_namedIntExpression); var result = _visitor.VisitSqlConvertedBooleanExpression (sqlConvertedBooleanExpression); var expectedResult = new NamedExpression (_namedIntExpression.Name, new SqlConvertExpression (typeof (bool), _namedIntExpression.Expression)); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedResult, result); }
public Expression VisitSqlConvertedBooleanExpression (SqlConvertedBooleanExpression expression) { ArgumentUtility.CheckNotNull ("expression", expression); var newInner = ApplyValueContext (expression.Expression); Assertion.DebugAssert ( newInner == expression.Expression, "There is currently no visit method that would change an int-typed expression with ValueRequired."); // This condition cannot be true at the moment because there currently is no int-typed expression that would be changed by ValueRequired. //if (newInner != expression.Expression) // return new ConvertedBooleanExpression (newInner); return expression; }
public void VisitSqlCaseExpression_AppliesValueContext () { var case1 = new SqlCaseExpression.CaseWhenPair (Expression.Constant (true), Expression.Constant (true)); var case2 = new SqlCaseExpression.CaseWhenPair (Expression.Constant (false), Expression.Constant (false)); var elseCase = Expression.Constant (true); var expression = new SqlCaseExpression (typeof (bool), new[] { case1, case2 }, elseCase); var result = _valueRequiredVisitor.VisitSqlCaseExpression (expression); var expectedCase1 = new SqlCaseExpression.CaseWhenPair ( Expression.Equal (Expression.Constant (1), new SqlLiteralExpression (1)), new SqlConvertedBooleanExpression (Expression.Constant (1))); var expectedCase2 = new SqlCaseExpression.CaseWhenPair ( Expression.Equal (Expression.Constant (0), new SqlLiteralExpression (1)), new SqlConvertedBooleanExpression (Expression.Constant (0))); var expectedElseCase = new SqlConvertedBooleanExpression (Expression.Constant (1)); var expectedExpression = new SqlCaseExpression (typeof (bool), new[] { expectedCase1, expectedCase2 }, expectedElseCase); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedExpression, result); }
public void VisitSqlConvertedBooleanExpression_WithADifferentExpression_VisitsInnerExpressionAndReturnsInputExpression () { var sqlConvertedBooleanExpression = new SqlConvertedBooleanExpression (new SqlLiteralExpression (0)); var result = _visitor.VisitSqlConvertedBooleanExpression (sqlConvertedBooleanExpression); Assert.That (_commandBuilder.GetCommandText(), Is.EqualTo ("0")); Assert.That (result, Is.SameAs (sqlConvertedBooleanExpression)); }
public void ResolveWhereExpression () { var expression = Expression.Constant (true); var fakeResult = new SqlConvertedBooleanExpression (Expression.Constant (0)); _resolverMock .Expect (mock => mock.ResolveConstantExpression (expression)) .Return (fakeResult); _resolverMock .Expect (mock => mock.ResolveConstantExpression ((ConstantExpression) fakeResult.Expression)) .Return (fakeResult.Expression); _resolverMock.Replay(); var result = _stage.ResolveWhereExpression (expression, _mappingResolutionContext); _resolverMock.VerifyAllExpectations(); Assert.That (((BinaryExpression) result).Left, Is.SameAs (fakeResult.Expression)); Assert.That (((SqlLiteralExpression) ((BinaryExpression) result).Right).Value, Is.EqualTo (1)); }
public void VisitSqlColumnExpression_BoolColumn_ConvertedToIntColumn_IsPrimaryColumn_ValueRequired () { var column = new SqlColumnDefinitionExpression (typeof (bool), "x", "y", true); var result = _valueRequiredVisitor.VisitSqlColumnExpression (column); var expectedExpression = new SqlConvertedBooleanExpression (new SqlColumnDefinitionExpression (typeof (int), "x", "y", true)); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedExpression, result); }
public void VisitSqlColumnExpression_BoolColumn_ConvertedToIntColumn_PredicateRequired () { var nullableColumn = new SqlColumnDefinitionExpression (typeof (bool?), "x", "y", false); var column = new SqlColumnDefinitionExpression (typeof (bool), "x", "y", false); var result = _predicateRequiredVisitor.VisitSqlColumnExpression (column); var nullableResult = _predicateRequiredVisitor.VisitSqlColumnExpression (nullableColumn); var expectedExpression = new SqlConvertedBooleanExpression (new SqlColumnDefinitionExpression (typeof (int), "x", "y", false)); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedExpression, result); var expectedNullableExpression = new SqlConvertedBooleanExpression (new SqlColumnDefinitionExpression (typeof (int?), "x", "y", false)); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedNullableExpression, nullableResult); }
public void VisitSqlConvertedBooleanExpression_InnerUnchanged () { var converted = new SqlConvertedBooleanExpression (Expression.Constant (0)); var result = _valueRequiredVisitor.VisitSqlConvertedBooleanExpression (converted); Assert.That (result, Is.SameAs (converted)); }
public void VisitConstantExpression_BoolConstants_PredicateRequired () { var constantTrue = Expression.Constant (true); var constantFalse = Expression.Constant (false); var constantNullableTrue = Expression.Constant (true, typeof (bool?)); var constantNullableFalse = Expression.Constant (false, typeof (bool?)); var constantNullableNull = Expression.Constant (null, typeof (bool?)); var resultTrue = _predicateRequiredVisitor.VisitConstantExpression (constantTrue); var resultFalse = _predicateRequiredVisitor.VisitConstantExpression (constantFalse); var resultNullableTrue = _predicateRequiredVisitor.VisitConstantExpression (constantNullableTrue); var resultNullableFalse = _predicateRequiredVisitor.VisitConstantExpression (constantNullableFalse); var resultNullableNull = _predicateRequiredVisitor.VisitConstantExpression (constantNullableNull); var expectedExpressionTrue = new SqlConvertedBooleanExpression (Expression.Constant (1)); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedExpressionTrue, resultTrue); var expectedExpressionFalse = new SqlConvertedBooleanExpression (Expression.Constant (0)); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedExpressionFalse, resultFalse); var expectedExpressionNullableTrue = new SqlConvertedBooleanExpression (Expression.Constant (1, typeof (int?))); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedExpressionNullableTrue, resultNullableTrue); var expectedExpressionNullableFalse = new SqlConvertedBooleanExpression (Expression.Constant (0, typeof (int?))); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedExpressionNullableFalse, resultNullableFalse); var expectedExpressionNullableNull = new SqlConvertedBooleanExpression (Expression.Constant (null, typeof (int?))); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedExpressionNullableNull, resultNullableNull); }
public void VisitExpression_ConvertedInt_ToPredicate () { var expression = new SqlConvertedBooleanExpression (new CustomExpression (typeof (int))); var nullableExpression = new SqlConvertedBooleanExpression (new CustomExpression (typeof (int?))); var visitor = new TestableSqlContextExpressionVisitor (SqlExpressionContext.PredicateRequired, _stageMock, _mappingResolutionContext); var result = visitor.VisitExpression (expression); var resultNullable = visitor.VisitExpression (nullableExpression); var expected = Expression.Equal (expression.Expression, new SqlLiteralExpression (1)); SqlExpressionTreeComparer.CheckAreEqualTrees (expected, result); var expectedNullable = Expression.Equal (nullableExpression.Expression, new SqlLiteralExpression (1, true), true, null); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedNullable, resultNullable); }
public void VisitExpression_ValueSemantics_LeavesExistingSqlConvertedBooleanExpression () { var convertedBooleanExpression = new SqlConvertedBooleanExpression (Expression.Constant (1)); var result = _valueRequiredVisitor.VisitExpression (convertedBooleanExpression); Assert.That (result, Is.SameAs (convertedBooleanExpression)); }
public void VisitExpression_SingleValueRequired_ConvertsBool_ToSingleValue () { var expression = new CustomExpression (typeof (bool)); var nullableExpression = new CustomExpression (typeof (bool?)); var visitor = new TestableSqlContextExpressionVisitor (SqlExpressionContext.SingleValueRequired, _stageMock, _mappingResolutionContext); var result = visitor.VisitExpression (expression); var resultNullable = visitor.VisitExpression (nullableExpression); var expected = new SqlConvertedBooleanExpression (GetNonNullablePredicateAsValueExpression (expression)); SqlExpressionTreeComparer.CheckAreEqualTrees (expected, result); var expectedNullable = new SqlConvertedBooleanExpression (GetNullablePredicateAsValueExpression (nullableExpression)); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedNullable, resultNullable); }
public void VisitSqlConvertedBooleanExpression_WithAnInnerNamedExpression_NullableBool_ReturnsAdaptedNamedExpressionOfCorrectType () { var namedNullableIntExpression = new NamedExpression ("test", Expression.Constant (0, typeof (int?))); var sqlConvertedBooleanExpression = new SqlConvertedBooleanExpression (namedNullableIntExpression); var result = _visitor.VisitSqlConvertedBooleanExpression (sqlConvertedBooleanExpression); var expectedResult = new NamedExpression ( namedNullableIntExpression.Name, new SqlConvertExpression (typeof (bool?), namedNullableIntExpression.Expression)); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedResult, result); }
public void VisitBinaryExpression_BinaryBoolExpression_Coalesce () { // nullableBool ?? bool is converted not as ConvertedBool (nullableInt) ?? ConvertedBool (int), but as ConvertedBool (nullableInt ?? int). var expression = Expression.Coalesce (Expression.Constant (false, typeof (bool?)), Expression.Constant (true)); var nullableExpression = Expression.Coalesce (Expression.Constant (false, typeof (bool?)), Expression.Constant (true, typeof (bool?))); var result = _valueRequiredVisitor.VisitBinaryExpression (expression); var nullableResult = _valueRequiredVisitor.VisitBinaryExpression (nullableExpression); var resultForPredicateSemantics = _predicateRequiredVisitor.VisitBinaryExpression (expression); var expectedExpression = new SqlConvertedBooleanExpression (Expression.Coalesce ( Expression.Constant (0, typeof (int?)), Expression.Constant (1))); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedExpression, result); var expectedNullableExpression = new SqlConvertedBooleanExpression (Expression.Coalesce ( Expression.Constant (0, typeof (int?)), Expression.Constant (1, typeof (int?)))); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedNullableExpression, nullableResult); var expectedResultForPredicateSemantics = new SqlConvertedBooleanExpression (Expression.Coalesce ( Expression.Constant (0, typeof (int?)), Expression.Constant (1))); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedResultForPredicateSemantics, resultForPredicateSemantics); }
public void VisitSqlConvertedBooleanExpression_WithAnInnerNamedExpression_OmitsSqlConversion_ForColumns () { var namedIntColumnExpression = new NamedExpression ("col", SqlStatementModelObjectMother.CreateSqlColumn (typeof (int))); var sqlConvertedBooleanExpression = new SqlConvertedBooleanExpression (namedIntColumnExpression); Assert.That (_visitor.ColumnPosition, Is.EqualTo (0)); _visitor.VisitSqlConvertedBooleanExpression (sqlConvertedBooleanExpression); Assert.That (_visitor.ColumnPosition, Is.EqualTo (1)); var expectedProjection = GetExpectedProjectionForNamedExpression (_commandBuilder.InMemoryProjectionRowParameter, "col", 0, typeof (bool)); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedProjection, _commandBuilder.GetInMemoryProjectionBody()); Assert.That (_commandBuilder.GetCommandText(), Is.EqualTo ("[t0].[column] AS [col]")); }
public void Reduce_Nullable () { var innerExpression = Expression.Constant (1, typeof (int?)); var convertedExpression = new SqlConvertedBooleanExpression (innerExpression); var result = convertedExpression.Reduce (); var expectedResult = Expression.Convert ( innerExpression, typeof (bool?), typeof (BooleanUtility).GetMethod ("ConvertNullableIntToNullableBool", new[] { typeof (int?) })); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedResult, result); }
public void VisitSqlConvertedBooleanExpression () { var expression = new SqlConvertedBooleanExpression (Expression.Constant (1)); SqlGeneratingExpressionVisitor.GenerateSql (expression, _commandBuilder, _stageMock); Assert.That (_commandBuilder.GetCommandText (), Is.EqualTo ("@1")); Assert.That (_commandBuilder.GetCommandParameters ()[0].Value, Is.EqualTo (1)); }
public void VisitBinaryExpression_BinaryBoolExpression_Coalesce_OptimizationForCoalesceToFalse () { // With predicate semantics, nullableBool ?? false is optimized to be the same as Convert (nullableBool, typeof (bool)) because SQL handles // NULL in a falsey way in predicates, and the generated SQL is nicer. // With value semantics, this is not optimized. var expression = Expression.Coalesce (Expression.Constant (true, typeof (bool?)), Expression.Constant (false)); var resultForValueSemantics = _valueRequiredVisitor.VisitBinaryExpression (expression); var resultForPredicateSemantics = _predicateRequiredVisitor.VisitBinaryExpression (expression); var expectedExpressionForValueSemantics = new SqlConvertedBooleanExpression (Expression.Coalesce ( Expression.Constant (1, typeof (int?)), Expression.Constant (0))); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedExpressionForValueSemantics, resultForValueSemantics); var expectedResultForPredicateSemantics = Expression.Convert ( Expression.Equal (Expression.Constant (1, typeof (int?)), new SqlLiteralExpression (1, true), true, null), typeof (bool)); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedResultForPredicateSemantics, resultForPredicateSemantics); }
public void ResolveSubStatementReferenceExpression_ResolvesChildren_ForUnknownExpression () { var referencedExpression = new SqlConvertedBooleanExpression (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 SqlConvertedBooleanExpression (new SqlColumnDefinitionExpression (typeof (int), "q0", "test", false)); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedResult, result); }
public void VisitUnaryExpression_SqlConvertedBooleanExpression () { var convertToBoolExpression = Expression.Convert (Expression.Constant (true, typeof (bool?)), typeof (bool)); var convertToNullableBoolExpression = Expression.Convert (Expression.Constant (true), typeof (bool?)); var result = _valueRequiredVisitor.VisitUnaryExpression (convertToBoolExpression); var resultNullable = _valueRequiredVisitor.VisitUnaryExpression (convertToNullableBoolExpression); var expectedExpression = new SqlConvertedBooleanExpression (Expression.Convert (Expression.Constant (1, typeof (int?)), typeof (int))); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedExpression, result); var expectedNullableExpression = new SqlConvertedBooleanExpression (Expression.Convert (Expression.Constant (1), typeof (int?))); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedNullableExpression, resultNullable); }
public void Reduce_NonNullable () { var innerExpression = Expression.Constant (1); var convertedExpression = new SqlConvertedBooleanExpression (innerExpression); var result = convertedExpression.Reduce(); var expectedResult = Expression.Convert (innerExpression, typeof (bool), typeof (Convert).GetMethod ("ToBoolean", new[] { typeof (int) })); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedResult, result); }
public void SetUp () { _innerExpression = Expression.Constant (1); _sqlConvertedBooleanExpression = new SqlConvertedBooleanExpression (_innerExpression); }