protected override Expression VisitLuceneQueryFieldExpression(LuceneQueryFieldExpression expression)
{
if (expression.Type != typeof(bool) || IsAlreadyInEqualityExpression())
{
return(base.VisitLuceneQueryFieldExpression(expression));
}
return(Expression.MakeBinary(ExpressionType.Equal, expression, Expression.Constant(!negate)));
}
public void IgnoresWhenAlreadyInBinaryExpression()
{
// where doc.SomeFlag == true
var flag = new LuceneQueryFieldExpression(typeof(bool), "SomeFlag");
var binary = Expression.MakeBinary(ExpressionType.Equal, flag, Expression.Constant(true));
var result = (BinaryExpression)visitor.VisitExpression(binary);
Assert.That(result, Is.SameAs(binary));
}
public void Inverse()
{
// "where !doc.SomeFlag"
var flag = new LuceneQueryFieldExpression(typeof(bool), "SomeFlag");
var expression = Expression.MakeUnary(ExpressionType.Not, flag, typeof(bool));
var result = visitor.VisitExpression(expression) as BinaryExpression;
Assert.That(result, Is.Not.Null, "Expected BinaryExpression to be returned.");
Assert.That(result.Left, Is.SameAs(flag));
Assert.That(result.Right, Is.InstanceOf <ConstantExpression>());
Assert.That(((ConstantExpression)result.Right).Value, Is.EqualTo(false));
}
public void ConvertFlag()
{
// "where doc.SomeFlag"
var expression = new LuceneQueryFieldExpression(typeof(bool), "SomeFlag");
var result = visitor.VisitExpression(expression) as BinaryExpression;
Assert.That(result, Is.Not.Null, "Expected BinaryExpression to be returned.");
Assert.That(result.Left, Is.SameAs(expression));
Assert.That(result.Right, Is.InstanceOf <ConstantExpression>());
Assert.That(((ConstantExpression)result.Right).Value, Is.EqualTo(true));
}
public void ConvertEnum()
{
var luceneQueryFieldExpression = new LuceneQueryFieldExpression(typeof(Enum), "field_name");
var binary = Expression.MakeBinary(ExpressionType.Equal,
Expression.Convert(luceneQueryFieldExpression, typeof(Int32)),
Expression.Constant(0));
var result = (BinaryExpression)visitor.VisitExpression(binary);
Assert.That(result.Left, Is.SameAs(luceneQueryFieldExpression));
Assert.That(result.Right, Is.InstanceOf <ConstantExpression>());
}
protected override Expression VisitQuerySourceReferenceExpression(QuerySourceReferenceExpression expression)
{
var propertyInfo = parent.Member as PropertyInfo;
if (propertyInfo == null)
{
throw new NotSupportedException("Only MemberExpression of type PropertyInfo may be used on QuerySourceReferenceExpression.");
}
queryField = new LuceneQueryFieldExpression(propertyInfo.PropertyType, propertyInfo.Name);
return(base.VisitQuerySourceReferenceExpression(expression));
}
public void Stage0_Transform()
{
var methodInfo = ReflectionUtility.GetMethod(() => LuceneMethods.Boost <string>(null, 0f));
var fieldExpression = new LuceneQueryFieldExpression(typeof(string), "Name");
const float boostAmount = 5.5f;
// LuceneField(Name).Boost(5.5)
var call = Expression.Call(methodInfo, fieldExpression, Expression.Constant(boostAmount));
var result = visitor.VisitExpression(call);
Assert.That(result, Is.SameAs(fieldExpression));
Assert.That(((LuceneQueryFieldExpression)result).Boost, Is.EqualTo(boostAmount));
}
public void ConvertNestedMethodCall()
{
// where !doc.Name.StartsWith("foo")
var field = new LuceneQueryFieldExpression(typeof(string), "Name");
var startsWith = Expression.Call(field, "StartsWith", null, Expression.Constant("foo"));
var expression = Expression.MakeUnary(ExpressionType.Not, startsWith, typeof(bool));
var result = visitor.VisitExpression(expression) as BinaryExpression;
Assert.That(result, Is.Not.Null, "Expected BinaryExpression to be returned.");
Assert.That(result.Left, Is.SameAs(startsWith));
Assert.That(result.Right, Is.InstanceOf <ConstantExpression>());
Assert.That(result.NodeType, Is.EqualTo(ExpressionType.Equal));
Assert.That(((ConstantExpression)result.Right).Value, Is.EqualTo(false));
}
public void ConvertFlagNestedInCompoundBinaryRight()
{
// where doc.Name == "foo" || doc.SomeFlag
var flag = new LuceneQueryFieldExpression(typeof(bool), "SomeFlag");
var binary = Expression.MakeBinary(ExpressionType.Equal, new LuceneQueryFieldExpression(typeof(string), "Name"), Expression.Constant("foo"));
var topBinary = Expression.MakeBinary(ExpressionType.OrElse, binary, flag);
var result = visitor.VisitExpression(topBinary) as BinaryExpression;
Assert.That(result, Is.Not.Null, "Expected BinaryExpression to be returned.");
Assert.That(result.Left, Is.SameAs(binary));
Assert.That(result.Right, Is.InstanceOf <BinaryExpression>());
Assert.That(((BinaryExpression)result.Right).Left, Is.SameAs(flag));
Assert.That(((BinaryExpression)result.Right).Right, Is.InstanceOf <ConstantExpression>());
}
public void Stage1_Transform()
{
visitor = new BoostMethodCallTreeVisitor(1);
var methodInfo = ReflectionUtility.GetMethod(() => false.Boost(0f));
var fieldExpression = new LuceneQueryFieldExpression(typeof(string), "Name");
var query = new LuceneQueryPredicateExpression(fieldExpression, Expression.Constant("foo"), Occur.SHOULD);
const float boostAmount = 0.5f;
// (LuceneQuery[Default](+Name:"foo")).Boost(0.5f)
var call = Expression.Call(methodInfo, query, Expression.Constant(boostAmount));
var result = visitor.VisitExpression(call);
Assert.That(result, Is.SameAs(query));
Assert.That(((LuceneQueryPredicateExpression)result).Boost, Is.EqualTo(boostAmount));
}
protected virtual Expression VisitLuceneQueryFieldExpression(LuceneQueryFieldExpression expression)
{
return(expression);
}
