private static void AssertResult(LuceneQueryPredicateExpression result, Occur expectedOccur)
{
Assert.That(result, Is.Not.Null, "Expected LuceneQueryPredicateExpression to be returned.");
Assert.That(result, Is.Not.SameAs(predicate));
Assert.That(result.QueryField, Is.SameAs(predicate.QueryField));
Assert.That(result.QueryPattern, Is.SameAs(predicate.QueryPattern));
Assert.That(result.QueryType, Is.EqualTo(predicate.QueryType));
Assert.That(result.Occur, Is.EqualTo(expectedOccur));
Assert.That(result.Boost, Is.EqualTo(predicate.Boost));
Assert.That(result.AllowSpecialCharacters, Is.EqualTo(predicate.AllowSpecialCharacters));
}
protected virtual Expression VisitLuceneQueryPredicateExpression(LuceneQueryPredicateExpression expression)
{
var field = (LuceneQueryFieldExpression)VisitExpression(expression.QueryField);
var pattern = VisitExpression(expression.QueryPattern);
if (field != expression.QueryField || pattern != expression.QueryPattern)
{
return new LuceneQueryPredicateExpression(field, pattern, expression.Occur, expression.QueryType);
}
return expression;
}
public void LessThan()
{
var expression = new LuceneQueryPredicateExpression(
new LuceneQueryFieldExpression(typeof(string), "Name"),
Expression.Constant("SampleName"),
Occur.MUST,
QueryType.LessThan);
builder.VisitExpression(expression);
Assert.That(builder.Query.ToString(), Is.EqualTo("+Name:[* TO SampleName}"));
}
private Expression VisitQueryPredicateExpression(LuceneQueryPredicateExpression expression)
{
parent = expression;
var result = base.VisitExtensionExpression(expression);
if (allowed && result is LuceneQueryPredicateExpression)
{
((LuceneQueryPredicateExpression)result).AllowSpecialCharacters = true;
}
parent = null;
return result;
}
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"), BooleanClause.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 override Expression VisitLuceneQueryPredicateExpression(LuceneQueryPredicateExpression expression)
{
if (expression.QueryField is LuceneQueryAnyFieldExpression)
{
AddMultiFieldQuery(expression);
return base.VisitLuceneQueryPredicateExpression(expression);
}
var mapping = fieldMappingInfoProvider.GetMappingInfo(expression.QueryField.FieldName);
var pattern = GetPattern(expression, mapping);
var occur = expression.Occur;
if (string.IsNullOrEmpty(pattern))
{
pattern = "*";
occur = Negate(occur);
}
Query query;
if (expression.QueryType == QueryType.GreaterThan || expression.QueryType == QueryType.GreaterThanOrEqual)
{
query = CreateRangeQuery(mapping, expression.QueryType, expression, null);
}
else if (expression.QueryType == QueryType.LessThan || expression.QueryType == QueryType.LessThanOrEqual)
{
query = CreateRangeQuery(mapping, expression.QueryType, null, expression);
}
else
{
query = mapping.CreateQuery(pattern);
}
var booleanQuery = new BooleanQuery();
query.Boost = expression.Boost;
booleanQuery.Add(query, occur);
queries.Push(booleanQuery);
return base.VisitLuceneQueryPredicateExpression(expression);
}
public void MergeExclusionaryRangeReverseOrder()
{
var lowerLess = new LuceneQueryPredicateExpression(new LuceneQueryFieldExpression(typeof(int), "percentile"),
Expression.Constant(40), Occur.MUST, QueryType.LessThanOrEqual);
var upperGreater = new LuceneQueryPredicateExpression(new LuceneQueryFieldExpression(typeof(int), "percentile"),
Expression.Constant(60), Occur.MUST, QueryType.GreaterThanOrEqual);
var binary = Expression.MakeBinary(ExpressionType.OrElse, upperGreater, lowerLess);
var result = visitor.VisitExpression(binary);
Assert.That(result, Is.InstanceOf<LuceneRangeQueryExpression>());
var expr = (LuceneRangeQueryExpression)result;
Assert.That(expr.Lower, Is.SameAs(lowerLess.QueryPattern));
Assert.That(expr.LowerQueryType, Is.EqualTo(QueryType.GreaterThan));
Assert.That(expr.Upper, Is.SameAs(upperGreater.QueryPattern));
Assert.That(expr.UpperQueryType, Is.EqualTo(QueryType.LessThan));
Assert.That(expr.Occur, Is.EqualTo(Occur.MUST_NOT));
}
private Query CreateRangeQuery(IFieldMappingInfo mapping, QueryType queryType, LuceneQueryPredicateExpression lowerBoundExpression, LuceneQueryPredicateExpression upperBoundExpression)
{
var lowerBound = lowerBoundExpression == null ? null : EvaluateExpression(lowerBoundExpression);
var upperBound = upperBoundExpression == null ? null : EvaluateExpression(upperBoundExpression);
var lowerRange = RangeType.Inclusive;
var upperRange = (queryType == QueryType.LessThan || queryType == QueryType.GreaterThan) ? RangeType.Exclusive : RangeType.Inclusive;
if (upperBoundExpression == null)
{
lowerRange = upperRange;
upperRange = RangeType.Inclusive;
}
return mapping.CreateRangeQuery(lowerBound, upperBound, lowerRange, upperRange);
}
private void AddMultiFieldQuery(LuceneQueryPredicateExpression expression)
{
var query = new BooleanQuery();
query.Add(new BooleanClause(fieldMappingInfoProvider.CreateMultiFieldQuery(GetPattern(expression, null)), expression.Occur));
queries.Push(query);
}
private string GetPattern(LuceneQueryPredicateExpression expression, IFieldMappingInfo mapping)
{
var pattern = EvaluateExpressionToString(expression, mapping);
switch (expression.QueryType)
{
case QueryType.Prefix:
pattern += "*";
break;
case QueryType.Wildcard:
pattern = "*" + pattern + "*";
break;
case QueryType.Suffix:
pattern = "*" + pattern;
break;
}
return pattern;
}
public void IgnoreNonRangeQueryExpression()
{
var equal = new LuceneQueryPredicateExpression(new LuceneQueryFieldExpression(typeof(int), "percentile"), Expression.Constant(50), Occur.MUST, QueryType.Default);
var binary = Expression.MakeBinary(ExpressionType.AndAlso, lower, equal);
var result = visitor.VisitExpression(binary);
Assert.That(result, Is.SameAs(binary));
}
public void LessThan_DateTime()
{
var dateTime = new DateTime(2012, 4, 18, 11, 22, 33);
var expression = new LuceneQueryPredicateExpression(
new LuceneQueryFieldExpression(typeof(DateTime), "Published"),
Expression.Constant(dateTime),
BooleanClause.Occur.MUST,
QueryType.LessThan);
builder.VisitExpression(expression);
Assert.That(builder.Query.ToString(), Is.EqualTo("+Published:[" + DateTime.MinValue.ToUniversalTime().Ticks + " TO " + dateTime.ToUniversalTime().Ticks + "}"));
}
public void GreaterThan_AnalyzesTerm()
{
fieldMappingInfoProvider.IsNumeric = false;
var expression = new LuceneQueryPredicateExpression(
new LuceneQueryFieldExpression(typeof(string), "Name"),
Expression.Constant("SampleName"),
BooleanClause.Occur.MUST,
QueryType.GreaterThan);
builder.VisitExpression(expression);
Assert.That(builder.Query.ToString(), Is.EqualTo("+Name:{samplename TO *]"));
}
private object EvaluateExpression(LuceneQueryPredicateExpression expression)
{
var lambda = Expression.Lambda(expression.QueryPattern).Compile();
return lambda.DynamicInvoke();
}
private static IComparable GetQueryPatternAsConstComparable(LuceneQueryPredicateExpression expression)
{
var constant = expression.QueryPattern as ConstantExpression;
if (constant == null) return null;
return constant.Value as IComparable;
}
private object EvaluateExpression(LuceneQueryPredicateExpression expression)
{
return EvaluateExpression(expression.QueryPattern);
}
public void IgnoreDifferentFields()
{
var otherUpper = new LuceneQueryPredicateExpression(new LuceneQueryFieldExpression(typeof(int), "id"), Expression.Constant(80), Occur.MUST, QueryType.LessThanOrEqual);
var binary = Expression.MakeBinary(ExpressionType.AndAlso, lower, otherUpper);
var result = visitor.VisitExpression(binary);
Assert.That(result, Is.SameAs(binary));
}
private string EvaluateExpressionToString(LuceneQueryPredicateExpression expression, IFieldMappingInfo mapping)
{
var result = EvaluateExpression(expression);
var str = mapping == null ? result.ToString() : mapping.ConvertToQueryExpression(result);
if (expression.AllowSpecialCharacters)
return str;
return mapping != null ? mapping.EscapeSpecialCharacters(str) : str;
}
private void AddMultiFieldQuery(LuceneQueryPredicateExpression expression)
{
var query = new BooleanQuery();
var parser = new MultiFieldQueryParser(context.Version,
fieldMappingInfoProvider.AllFields.ToArray(),
context.Analyzer);
query.Add(new BooleanClause(parser.Parse(GetPattern(expression, null)), expression.Occur));
queries.Push(query);
}
private Query CreateRangeQuery(IFieldMappingInfo mapping, QueryType queryType, LuceneQueryPredicateExpression lowerBoundExpression, LuceneQueryPredicateExpression upperBoundExpression)
{
var lowerRange = RangeType.Inclusive;
var upperRange = (queryType == QueryType.LessThan || queryType == QueryType.GreaterThan) ? RangeType.Exclusive : RangeType.Inclusive;
if (upperBoundExpression == null)
{
lowerRange = upperRange;
upperRange = RangeType.Inclusive;
}
if (mapping.IsNumericField)
{
var lowerBound = lowerBoundExpression == null ? null : EvaluateExpression(lowerBoundExpression);
var upperBound = upperBoundExpression == null ? null : EvaluateExpression(upperBoundExpression);
return NumericRangeUtils.CreateNumericRangeQuery(mapping.FieldName, (ValueType)lowerBound, (ValueType)upperBound, lowerRange, upperRange);
}
else
{
var minInclusive = lowerRange == RangeType.Inclusive;
var maxInclusive = upperRange == RangeType.Inclusive;
var lowerBound = lowerBoundExpression == null ? null : EvaluateExpressionToStringAndAnalyze(lowerBoundExpression, mapping);
var upperBound = upperBoundExpression == null ? null : EvaluateExpressionToStringAndAnalyze(upperBoundExpression, mapping);
return new TermRangeQuery(mapping.FieldName, lowerBound, upperBound, minInclusive, maxInclusive);
}
}
private string EvaluateExpressionToStringAndAnalyze(LuceneQueryPredicateExpression expression, IFieldMappingInfo mapping)
{
return context.Analyzer.Analyze(mapping.FieldName, EvaluateExpressionToString(expression, mapping));
}
public void GreaterThanOrEqual()
{
var expression = new LuceneQueryPredicateExpression(
new LuceneQueryFieldExpression(typeof(float), "Count"),
Expression.Constant(6f),
BooleanClause.Occur.MUST,
QueryType.GreaterThanOrEqual);
builder.VisitExpression(expression);
Assert.That(builder.Query.ToString(), Is.EqualTo("+Count:[6 TO " + float.MaxValue + "]"));
}
public void GreaterThan()
{
var expression = new LuceneQueryPredicateExpression(
new LuceneQueryFieldExpression(typeof (int), "Count"),
Expression.Constant(5),
Occur.MUST,
QueryType.GreaterThan);
builder.VisitExpression(expression);
Assert.That(builder.Query.ToString(), Is.EqualTo("+Count:{5 TO " + int.MaxValue + "]"));
}
public void LessThanOrEqual()
{
var expression = new LuceneQueryPredicateExpression(
new LuceneQueryFieldExpression(typeof(DateTime), "Average"),
Expression.Constant(11.5d),
BooleanClause.Occur.MUST,
QueryType.LessThanOrEqual);
builder.VisitExpression(expression);
Assert.That(builder.Query.ToString(), Is.EqualTo("+Average:[" + double.MinValue + " TO 11.5]"));
}
private string GetPattern(LuceneQueryPredicateExpression expression, IFieldMappingInfo mapping)
{
var pattern = EvaluateExpressionToString(expression, mapping);
switch (expression.QueryType)
{
case QueryType.Prefix:
pattern += "*";
break;
case QueryType.Wildcard:
pattern = "*" + pattern + "*";
break;
case QueryType.Suffix:
pattern = "*" + pattern;
break;
}
if (expression.Fuzzy.HasValue)
{
pattern += string.Format(
CultureInfo.InvariantCulture,
"~{0}",
expression.Fuzzy.Value);
}
return pattern;
}
