public void Evaluate_PartialEvaluationExceptionExpression_NotEvaluatable()
{
var expression = new PartialEvaluationExceptionExpression(new Exception(), Expression.Constant(1));
var result = PartialEvaluatingExpressionVisitor.EvaluateIndependentSubtrees(expression, new TestEvaluatableExpressionFilter());
Assert.That(result, Is.SameAs(expression));
}
public void EvaluateWholeQueryTree()
{
// ReSharper disable ConvertToConstant.Local
var i = 1;
// ReSharper restore ConvertToConstant.Local
var source1 = ExpressionHelper.CreateQueryable <Cook> ();
var source2 = ExpressionHelper.CreateQueryable <Cook> ();
var query = from s1 in source1
from s2 in source2
where 2 > i + 5
select s1.ID + (1 + i);
var partiallyEvaluatedExpression = PartialEvaluatingExpressionVisitor.EvaluateIndependentSubtrees(
query.Expression,
new TestEvaluatableExpressionFilter());
var selectMethodCallExpression = (MethodCallExpression)partiallyEvaluatedExpression;
var whereMethodCallExpression = (MethodCallExpression)selectMethodCallExpression.Arguments[0];
var selectManyMethodCallExpression = (MethodCallExpression)whereMethodCallExpression.Arguments[0];
var selectSelectorNavigator = new ExpressionTreeNavigator(selectMethodCallExpression.Arguments[1]);
var wherePredicateNavigator = new ExpressionTreeNavigator(whereMethodCallExpression.Arguments[1]);
var selectManyCollectionSelectorNavigator = new ExpressionTreeNavigator(selectManyMethodCallExpression.Arguments[1]);
Assert.That(selectSelectorNavigator.Operand.Body.Right.Value, Is.EqualTo(2));
Assert.That(wherePredicateNavigator.Operand.Body.Value, Is.EqualTo(false));
Assert.That(selectManyCollectionSelectorNavigator.Operand.Body.Value, Is.SameAs(source2));
}
public void EvaluateTopLambda()
{
Expression treeRoot = Expression.Lambda(Expression.Constant(0), Expression.Parameter(typeof(string), "s"));
Expression result = PartialEvaluatingExpressionVisitor.EvaluateIndependentSubtrees(treeRoot, new TestEvaluatableExpressionFilter());
Assert.That(result, Is.SameAs(result));
}
public void VisitNewExpression_ForObjectID_GeneratesNullCheckInInMemoryProjection()
{
var constructorInfo = typeof(ObjectID).GetConstructor(new[] { typeof(string), typeof(object) });
Assertion.IsNotNull(constructorInfo);
var newObjectIDExpression = Expression.New(
constructorInfo,
new SqlColumnDefinitionExpression(typeof(string), "t0", "CustomerClassID", false),
Expression.Convert(new SqlColumnDefinitionExpression(typeof(Guid), "t0", "CustomerID", false), typeof(object)));
var compoundExpression = NamedExpression.CreateNewExpressionWithNamedArguments(newObjectIDExpression);
ExtendedSqlGeneratingOuterSelectExpressionVisitor.GenerateSql(compoundExpression, _commandBuilder, _stageMock, _someSetOperationsMode);
Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo("[t0].[CustomerClassID] AS [m0],[t0].[CustomerID] AS [m1]"));
Expression <Func <IDatabaseResultRow, ObjectID> > expectedInMemoryProjection =
row => ExtendedSqlGeneratingOuterSelectExpressionVisitor.GetObjectIDOrNull(
row.GetValue <string> (new ColumnID("m0", 0)),
row.GetValue <object> (new ColumnID("m1", 1)));
var expectedInMemoryProjectionBody = PartialEvaluatingExpressionVisitor.EvaluateIndependentSubtrees(
expectedInMemoryProjection.Body,
new TestEvaluatableExpressionFilter());
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedInMemoryProjectionBody, _commandBuilder.GetInMemoryProjectionBody());
}
public void VisitUnknownNonExtensionExpression_Ignored()
{
var expression = new UnknownExpression(typeof(object));
var result = PartialEvaluatingExpressionVisitor.EvaluateIndependentSubtrees(expression, new TestEvaluatableExpressionFilter());
Assert.That(result, Is.SameAs(expression));
}
public void Evaluate_VBStringComparisonExpression_IsNotPartiallyEvaluated()
{
var expression = new VBStringComparisonExpression(Expression.Equal(Expression.Constant("a"), Expression.Constant("b")), true);
var result = PartialEvaluatingExpressionVisitor.EvaluateIndependentSubtrees(expression, new TestEvaluatableExpressionFilter());
ExpressionTreeComparer.CheckAreEqualTrees(new VBStringComparisonExpression(Expression.Constant(false), true), result);
}
public void EvaluateOrdinaryConstant_Ignored()
{
var expression = Expression.Constant(0);
var result = PartialEvaluatingExpressionVisitor.EvaluateIndependentSubtrees(expression, new TestEvaluatableExpressionFilter());
Assert.That(result, Is.SameAs(expression));
}
public void EvaluateTopBinary()
{
Expression treeRoot = Expression.Add(Expression.Constant(1), Expression.Constant(2));
Expression result = PartialEvaluatingExpressionVisitor.EvaluateIndependentSubtrees(treeRoot, new TestEvaluatableExpressionFilter());
Expression expected = Expression.Constant(3);
ExpressionTreeComparer.CheckAreEqualTrees(expected, result);
}
public void EvalueQueryableConstant_Inlined()
{
var query = ExpressionHelper.CreateQueryable <Cook> ();
var expression = Expression.Constant(query);
var result = PartialEvaluatingExpressionVisitor.EvaluateIndependentSubtrees(expression, new TestEvaluatableExpressionFilter());
Assert.That(result, Is.SameAs(query.Expression));
}
public object Execute(Expression expression)
{
expression = PartialEvaluatingExpressionVisitor.EvaluateIndependentSubtrees(expression, new EvaluatableExpressionFilter());
var v = MakeVisitor();
var visitResult = v.Visit(expression);
var constExp = visitResult as ConstantExpression;
return(constExp?.Value);
}
public void EvaluateLambdaWithParameterFromOutside()
{
ParameterExpression outsideParameter = Expression.Parameter(typeof(int), "p");
LambdaExpression lambdaExpression = Expression.Lambda(outsideParameter);
Expression result = PartialEvaluatingExpressionVisitor.EvaluateIndependentSubtrees(lambdaExpression, new TestEvaluatableExpressionFilter());
Assert.That(result, Is.SameAs(lambdaExpression));
}
public void EvaluateBinaryInLambdaWithoutParameter()
{
Expression treeRoot = Expression.Lambda(Expression.Add(Expression.Constant(5), Expression.Constant(1)),
Expression.Parameter(typeof(string), "s"));
Expression result = PartialEvaluatingExpressionVisitor.EvaluateIndependentSubtrees(treeRoot, new TestEvaluatableExpressionFilter());
Expression expected = Expression.Lambda(Expression.Constant(6), Expression.Parameter(typeof(string), "s"));
ExpressionTreeComparer.CheckAreEqualTrees(expected, result);
}
public void EvaluateLambdaWithSubQuery()
{
var subQuery = new SubQueryExpression(ExpressionHelper.CreateQueryModel <Cook>());
LambdaExpression lambdaExpression = Expression.Lambda(subQuery);
Expression result = PartialEvaluatingExpressionVisitor.EvaluateIndependentSubtrees(lambdaExpression, new TestEvaluatableExpressionFilter());
Assert.That(result, Is.SameAs(lambdaExpression));
}
public void Parse_InvalidParameters_ThrowsNotSupportedException()
{
Func <int, int> func = i => i;
var methodCallExpression = (MethodCallExpression)
PartialEvaluatingExpressionVisitor.EvaluateIndependentSubtrees(
ExpressionHelper.MakeExpression <IQueryable <int>, IEnumerable <int> > (q => q.Select(func)),
new TestEvaluatableExpressionFilter());
ParseMethodCallExpression(methodCallExpression);
}
public void EvaluateTopMemberAccess()
{
Tuple <int, int> tuple = Tuple.Create(1, 2);
Expression treeRoot = Expression.MakeMemberAccess(Expression.Constant(tuple), typeof(Tuple <int, int>).GetProperty("Item1"));
Expression result = PartialEvaluatingExpressionVisitor.EvaluateIndependentSubtrees(treeRoot, new TestEvaluatableExpressionFilter());
Expression expected = Expression.Constant(1);
ExpressionTreeComparer.CheckAreEqualTrees(expected, result);
}
public static Expression EvaluateIndependentSubtrees(
Expression expression,
ISessionFactoryImplementor sessionFactory)
{
var evaluatedExpression = PartialEvaluatingExpressionVisitor.EvaluateIndependentSubtrees(
expression,
new NhEvaluatableExpressionFilter(sessionFactory));
return(new NhPartialEvaluatingExpressionVisitor(sessionFactory).Visit(evaluatedExpression));
}
public T Execute <T>(Expression expression)
{
expression = PartialEvaluatingExpressionVisitor.EvaluateIndependentSubtrees(expression, new EvaluatableExpressionFilter());
var v = MakeVisitor();
Expression visitResult = v.Visit(expression);
var constExp = visitResult as ConstantExpression;
T ret = (T)constExp?.Value;
return(ret);
}
public void VisitExtensionExpression()
{
var innerExpression = Expression.MakeBinary(ExpressionType.Equal, Expression.Constant(0), Expression.Constant(0));
var extensionExpression = new ReducibleExtensionExpression(innerExpression);
var result = PartialEvaluatingExpressionVisitor.EvaluateIndependentSubtrees(extensionExpression, new TestEvaluatableExpressionFilter());
var expected = new ReducibleExtensionExpression(Expression.Constant(true));
ExpressionTreeComparer.CheckAreEqualTrees(expected, result);
}
public void EvaluateQueryableConstant_InlinedPart_IsPartiallyEvaluated()
{
var querySource = ExpressionHelper.CreateQueryable <Cook> ();
var query = querySource.Where(c => "1" == 1.ToString ());
var expression = Expression.Constant(query);
var result = PartialEvaluatingExpressionVisitor.EvaluateIndependentSubtrees(expression, new TestEvaluatableExpressionFilter());
var expectedExpression = querySource.Where(c => true).Expression;
ExpressionTreeComparer.CheckAreEqualTrees(expectedExpression, result);
}
public void EvaluateListInitialization_WithParametersInMemberAssignments_IsNotEvaluated()
{
var queryExpression = ExpressionHelper.MakeExpression <int, List <int> > (i => new List <int> {
i, 1
});
var partiallyEvaluatedExpression = PartialEvaluatingExpressionVisitor.EvaluateIndependentSubtrees(
queryExpression,
new TestEvaluatableExpressionFilter());
Assert.That(partiallyEvaluatedExpression, Is.SameAs(queryExpression));
}
public void Parse_InvalidParameters_ExceptionCanBeSerialized()
{
Func <int, int> func = i => i;
var methodCallExpression = (MethodCallExpression)
PartialEvaluatingExpressionVisitor.EvaluateIndependentSubtrees(
ExpressionHelper.MakeExpression <IQueryable <int>, IEnumerable <int> > (q => q.Select(func)),
new TestEvaluatableExpressionFilter());
var exception = Assert.Throws <NotSupportedException> (() => ParseMethodCallExpression(methodCallExpression));
var deserialized = Serializer.SerializeAndDeserialize(exception);
Assert.That(deserialized.Message, Is.EqualTo(exception.Message));
}
public void VisitExtensionExpression_ChildrenAreEvaluated()
{
var subQuery = ExpressionHelper.MakeExpression(() => (from s in ExpressionHelper.CreateQueryable <Cook> () select s).Any());
var extensionExpression = new VBStringComparisonExpression(subQuery, true);
// evaluate the ExpressionHelper.CreateQueryable<Cook> () method
var inputExpression = PartialEvaluatingExpressionVisitor.EvaluateIndependentSubtrees(
extensionExpression,
new TestEvaluatableExpressionFilter());
var result = SubQueryFindingExpressionVisitor.Process(inputExpression, _methodInfoBasedNodeTypeRegistry);
Assert.That(((VBStringComparisonExpression)result).Comparison, Is.TypeOf(typeof(SubQueryExpression)));
}
public void EvaluateWholeQueryTree_WithoutLambdas()
{
var source = ExpressionHelper.CreateQueryable <Cook> ();
var queryExpression = ExpressionHelper.MakeExpression(() => source.Count());
var partiallyEvaluatedExpression = PartialEvaluatingExpressionVisitor.EvaluateIndependentSubtrees(
queryExpression,
new TestEvaluatableExpressionFilter());
var countMethodCallExpression = (MethodCallExpression)partiallyEvaluatedExpression;
Assert.That(countMethodCallExpression.Method.Name, Is.EqualTo("Count"));
}
public void EvaluateListInitialization_WithoutParametersInMemberAssignments_IsEvaluated()
{
var queryExpression = ExpressionHelper.MakeExpression <int, List <int> > (i => new List <int> {
2, 1
});
var partiallyEvaluatedExpression = PartialEvaluatingExpressionVisitor.EvaluateIndependentSubtrees(
queryExpression,
new TestEvaluatableExpressionFilter());
Assert.That(((ConstantExpression)partiallyEvaluatedExpression).Value, Is.InstanceOf(typeof(List <int>)));
Assert.That(((ConstantExpression)partiallyEvaluatedExpression).Value, Is.EqualTo(new[] { 2, 1 }));
}
public void EvaluateMemberInitialization_WithoutParametersInMemberAssignments_IsEvaluated()
{
var queryExpression = ExpressionHelper.MakeExpression <int, AnonymousType> (i => new AnonymousType {
a = 2, b = 1
});
var partiallyEvaluatedExpression = PartialEvaluatingExpressionVisitor.EvaluateIndependentSubtrees(
queryExpression,
new TestEvaluatableExpressionFilter());
Assert.That(((ConstantExpression)partiallyEvaluatedExpression).Value, Is.InstanceOf(typeof(AnonymousType)));
Assert.That(((AnonymousType)((ConstantExpression)partiallyEvaluatedExpression).Value).a, Is.EqualTo(2));
Assert.That(((AnonymousType)((ConstantExpression)partiallyEvaluatedExpression).Value).b, Is.EqualTo(1));
}
public void EvaluateBinaryInLambdaWithParameter()
{
ParameterExpression parameter = Expression.Parameter(typeof(int), "p");
Expression constant1 = Expression.Constant(3);
Expression constant2 = Expression.Constant(4);
Expression constant3 = Expression.Constant(3);
Expression multiply1 = Expression.Multiply(parameter, constant1);
Expression multiply2 = Expression.Multiply(constant2, constant3);
Expression add = Expression.Add(multiply1, multiply2);
Expression treeRoot = Expression.Lambda(typeof(Func <int, int>), add, parameter);
Expression result = PartialEvaluatingExpressionVisitor.EvaluateIndependentSubtrees(treeRoot, new TestEvaluatableExpressionFilter());
Expression expected = Expression.Lambda(Expression.Add(Expression.Multiply(parameter, constant1), Expression.Constant(12)), parameter);
ExpressionTreeComparer.CheckAreEqualTrees(expected, result);
}
public void EvaluateQueryableConstant_InClosureMember()
{
var innerQuery = from c in ExpressionHelper.CreateQueryable <Cook>() where c != null select c;
var outerExpression = ExpressionHelper.MakeExpression(() => innerQuery);
Assert.That(outerExpression.NodeType, Is.EqualTo(ExpressionType.MemberAccess));
// outerExpression: <DisplayClass>.innerQuery
// innerQuery.Expression: constantCookQueryable.Where (c => c != null)
// transformation 1: constantInnerQuery
// transformation 2: constantCookQueryable.Where (c => c != null)
var result = PartialEvaluatingExpressionVisitor.EvaluateIndependentSubtrees(outerExpression, new TestEvaluatableExpressionFilter());
Assert.That(result, Is.SameAs(innerQuery.Expression));
}
public void VisitorUsesNodeTypeRegistry_ToParseAndAnalyzeSubQueries()
{
Expression subQuery = ExpressionHelper.MakeExpression(() => CustomSelect(ExpressionHelper.CreateQueryable <Cook>(), s => s));
Expression surroundingExpression = Expression.Lambda(subQuery);
// evaluate the ExpressionHelper.CreateQueryable<Cook> () method
var inputExpression = PartialEvaluatingExpressionVisitor.EvaluateIndependentSubtrees(
surroundingExpression,
new TestEvaluatableExpressionFilter());
var emptyNodeTypeRegistry = new MethodInfoBasedNodeTypeRegistry();
emptyNodeTypeRegistry.Register(new[] { ((MethodCallExpression)subQuery).Method }, typeof(SelectExpressionNode));
var newLambdaExpression =
(LambdaExpression)SubQueryFindingExpressionVisitor.Process(inputExpression, emptyNodeTypeRegistry);
Assert.That(newLambdaExpression.Body, Is.InstanceOf(typeof(SubQueryExpression)));
}
public void EvaluateIndependentSubtrees_WithFilter_IsNotEvaluatable_ReturnsOriginalExpression()
{
var left = Expression.Constant(1);
var right = Expression.Constant(2);
var expression = Expression.MakeBinary(ExpressionType.Add, left, right);
var filterMock = MockRepository.GenerateStrictMock <IEvaluatableExpressionFilter>();
filterMock.Expect(_ => _.IsEvaluatableBinary(expression)).Repeat.Never();
filterMock.Expect(_ => _.IsEvaluatableConstant(left)).Return(false);
filterMock.Expect(_ => _.IsEvaluatableConstant(right)).Return(true);
filterMock.Replay();
var result = PartialEvaluatingExpressionVisitor.EvaluateIndependentSubtrees(expression, filterMock);
Assert.That(result, Is.SameAs(expression));
filterMock.VerifyAllExpectations();
}
public void EvaluateWholeQueryTree_WhoseLambdasAreInMemberExpressions_InsteadOfUnaryExpressions()
{
var source = ExpressionHelper.CreateQueryable <Cook> ();
Expression <Func <Cook, bool> > predicate = s1 => false;
var queryExpression = ExpressionHelper.MakeExpression(() => source.Where(predicate));
Assert.That(((MethodCallExpression)queryExpression).Arguments[1].NodeType, Is.EqualTo(ExpressionType.MemberAccess),
"Usually, this would be a UnaryExpression (Quote containing the Lambda); but we pass a MemberExpression containing the lambda.");
var partiallyEvaluatedExpression = PartialEvaluatingExpressionVisitor.EvaluateIndependentSubtrees(
queryExpression,
new TestEvaluatableExpressionFilter());
var whereMethodCallExpression = (MethodCallExpression)partiallyEvaluatedExpression;
var wherePredicateNavigator = new ExpressionTreeNavigator(whereMethodCallExpression.Arguments[1]);
var wherePredicateLambdaNavigator = new ExpressionTreeNavigator((Expression)wherePredicateNavigator.Value);
Assert.That(wherePredicateLambdaNavigator.Body.Value, Is.EqualTo(false));
}
