/// <summary>
/// Create the Json HTTP request body for this request given the search query and connection.
/// </summary>
/// <returns>Json to be used to execute this query by Elasticsearch.</returns>
JObject CreateBody()
{
var root = new JObject();
if (searchRequest.Fields.Any())
{
root.Add("_source", new JArray(searchRequest.Fields));
}
if (searchRequest.MinScore.HasValue)
{
root.Add("min_score", searchRequest.MinScore.Value);
}
var queryRoot = root;
if (searchRequest.Query != null)
{
queryRoot.Add("query", Build(QueryCriteriaRewriter.Compensate(searchRequest.Query)));
}
if (searchRequest.SortOptions.Any())
{
root.Add("sort", Build(searchRequest.SortOptions));
}
if (searchRequest.From > 0)
{
root.Add("from", searchRequest.From);
}
if (searchRequest.Highlight != null)
{
root.Add("highlight", Build(searchRequest.Highlight));
}
if (searchRequest.Indexer != null)
{
root.Add(Build(searchRequest.Indexer));
}
long?size = searchRequest.Size ?? connection.Options.SearchSizeDefault;
if (size.HasValue)
{
root.Add("size", size.Value);
}
if (searchRequest.TrackTotalHits.HasValue)
{
root.Add("track_total_hits", searchRequest.TrackTotalHits);
}
if (connection.Timeout != TimeSpan.Zero)
{
root.Add("timeout", Format(connection.Timeout));
}
return(root);
}
public void NotWithOrBecomesBoolWithMustNot()
{
ICriteria[] expected = { new RangeCriteria("fieldOne", memberInfo, RangeComparison.LessThan, 2), new RangeCriteria("fieldTwo", memberInfo, RangeComparison.GreaterThan, 4) };
var actual = QueryCriteriaRewriter.Compensate(NotCriteria.Create(OrCriteria.Combine(expected)));
var boolActual = Assert.IsType <BoolCriteria>(actual);
Assert.Equal(boolActual.MustNot.AsEnumerable(), expected);
Assert.Empty(boolActual.Should);
Assert.Empty(boolActual.Must);
}
public void AndWithNotsBecomesBoolWithMustNots()
{
var expectedMustNots = new[] { new RangeCriteria("field1", memberInfo, RangeComparison.LessThan, 2), new RangeCriteria("field2", memberInfo, RangeComparison.GreaterThan, 4) };
var actual = QueryCriteriaRewriter.Compensate(AndCriteria.Combine(expectedMustNots.Select(NotCriteria.Create).ToArray()));
var boolActual = Assert.IsType <BoolCriteria>(actual);
Assert.Equal(boolActual.MustNot.AsEnumerable(), expectedMustNots);
Assert.Empty(boolActual.Should);
Assert.Empty(boolActual.Must);
}
public void AndWithOrsBecomesBoolWithShould()
{
var expected1 = new[] { new RangeCriteria("field1", memberInfo, RangeComparison.LessThan, 2), new RangeCriteria("field2", memberInfo, RangeComparison.GreaterThan, 4) };
var expected2 = new[] { new RangeCriteria("field3", memberInfo, RangeComparison.LessThan, 2), new RangeCriteria("field4", memberInfo, RangeComparison.GreaterThan, 4) };
var actual = QueryCriteriaRewriter.Compensate(AndCriteria.Combine(OrCriteria.Combine(expected1), OrCriteria.Combine(expected2)));
var boolActual = Assert.IsType <BoolCriteria>(actual);
Assert.Equal(boolActual.Should.AsEnumerable(), expected1.Concat(expected2));
Assert.Empty(boolActual.Must);
Assert.Empty(boolActual.MustNot);
}
public void AndWithMixedContentBecomesBoolWithShouldMustAndMustNot()
{
ICriteria[] expectedShould = { new RangeCriteria("field1", memberInfo, RangeComparison.LessThan, 2), new RangeCriteria("field2", memberInfo, RangeComparison.GreaterThan, 4) };
var expectedMust = new RangeCriteria("field3", memberInfo, RangeComparison.LessThan, 2);
var expectedMustNot = new PrefixCriteria("field5", "prefix");
var actual = QueryCriteriaRewriter.Compensate(AndCriteria.Combine(OrCriteria.Combine(expectedShould), expectedMust, NotCriteria.Create(expectedMustNot)));
var boolActual = Assert.IsType <BoolCriteria>(actual);
Assert.Equal(boolActual.Should.AsEnumerable(), expectedShould);
Assert.Single(boolActual.Must, expectedMust);
Assert.Single(boolActual.MustNot, expectedMustNot);
}
public void NotWithAndBecomesBoolWithMustNotBool()
{
var expected = new[] { new RangeCriteria("fieldOne", memberInfo, RangeComparison.LessThan, 2), new RangeCriteria("fieldTwo", memberInfo, RangeComparison.GreaterThan, 4) };
var actual = QueryCriteriaRewriter.Compensate(NotCriteria.Create(AndCriteria.Combine(expected)));
var boolActual = Assert.IsType <BoolCriteria>(actual);
Assert.Empty(boolActual.Should);
Assert.Empty(boolActual.Must);
Assert.Single(boolActual.MustNot);
var subBoolActual = Assert.IsType <BoolCriteria>(boolActual.MustNot.First());
Assert.Equal(subBoolActual.Must.AsEnumerable(), expected);
Assert.Empty(subBoolActual.Should);
Assert.Empty(subBoolActual.MustNot);
}
ElasticTranslateResult Translate(Expression e)
{
var evaluated = PartialEvaluator.Evaluate(e);
var aggregated = FacetExpressionVisitor.Rebind(Mapping, SourceType, evaluated);
if (aggregated.Collected.Count > 0)
{
this.CompleteFacetTranslation(aggregated);
}
else
{
this.CompleteHitTranslation(evaluated);
}
this.searchRequest.Query = QueryCriteriaRewriter.Compensate(this.searchRequest.Query);
this.searchRequest.Filter = ConstantCriteriaFilterReducer.Reduce(this.searchRequest.Filter);
this.ApplyTypeSelectionCriteria();
return(new ElasticTranslateResult(this.searchRequest, this.materializer));
}
public void AndWithNestedOrsBecomesBoolWithMustAndNestedShould()
{
ICriteria[] expected1 = { new RangeCriteria("field1", memberInfo, RangeComparison.LessThan, 2), new RangeCriteria("field2", memberInfo, RangeComparison.GreaterThan, 4) };
ICriteria[] expected2 = { new RangeCriteria("field3", memberInfo, RangeComparison.LessThan, 2), new RangeCriteria("field4", memberInfo, RangeComparison.GreaterThan, 4) };
var actual = QueryCriteriaRewriter.Compensate(AndCriteria.Combine(OrCriteria.Combine(expected1), OrCriteria.Combine(expected2)));
var boolActual = Assert.IsType <BoolCriteria>(actual);
Assert.Empty(boolActual.Should);
Assert.Empty(boolActual.MustNot);
Assert.Equal(2, boolActual.Must.Count);
Assert.All(boolActual.Must, c =>
{
var boolSub = Assert.IsType <BoolCriteria>(c);
Assert.Empty(boolSub.Must);
Assert.Empty(boolSub.MustNot);
Assert.Equal(2, boolSub.Should.Count);
Assert.All(boolSub.Should, s =>
{
Assert.IsType <RangeCriteria>(s);
});
});
}
