Java RangeQueryBuilder类代码示例

import org.elasticsearch.index.query.RangeQueryBuilder; //导入依赖的package包/类
private static RangeQueryBuilder createRangeQuery(String name, Map<String, Object> rangeOperation,
    Float boost) {

  RangeQueryBuilder rangeQueryBuilder = QueryBuilders.rangeQuery(name+RAW_APPEND);
  for (Map.Entry<String, Object> it : rangeOperation.entrySet()) {
    if (it.getKey().equalsIgnoreCase(LTE)) {
      rangeQueryBuilder.lte(it.getValue());
    } else if (it.getKey().equalsIgnoreCase(LT)) {
      rangeQueryBuilder.lt(it.getValue());
    } else if (it.getKey().equalsIgnoreCase(GTE)) {
      rangeQueryBuilder.gte(it.getValue());
    } else if (it.getKey().equalsIgnoreCase(GT)) {
      rangeQueryBuilder.gt(it.getValue());
    }
  }
  if (isNotNull(boost)) {
    return rangeQueryBuilder.boost(boost);
  }
  return rangeQueryBuilder;
}
 

import org.elasticsearch.index.query.RangeQueryBuilder; //导入依赖的package包/类
public void testUnsupportedQueries() {
    RangeQueryBuilder rangeQuery1 = new RangeQueryBuilder("field").from("2016-01-01||/D").to("2017-01-01||/D");
    RangeQueryBuilder rangeQuery2 = new RangeQueryBuilder("field").from("2016-01-01||/D").to("now");
    PercolatorFieldMapper.verifyQuery(rangeQuery1);
    expectThrows(IllegalArgumentException.class, () -> PercolatorFieldMapper.verifyQuery(rangeQuery2));
    PercolatorFieldMapper.verifyQuery(new BoolQueryBuilder().must(rangeQuery1));
    expectThrows(IllegalArgumentException.class, () ->
            PercolatorFieldMapper.verifyQuery(new BoolQueryBuilder().must(rangeQuery2)));
    PercolatorFieldMapper.verifyQuery(new ConstantScoreQueryBuilder((rangeQuery1)));
    expectThrows(IllegalArgumentException.class, () ->
            PercolatorFieldMapper.verifyQuery(new ConstantScoreQueryBuilder(rangeQuery2)));
    PercolatorFieldMapper.verifyQuery(new BoostingQueryBuilder(rangeQuery1, new MatchAllQueryBuilder()));
    expectThrows(IllegalArgumentException.class, () ->
            PercolatorFieldMapper.verifyQuery(new BoostingQueryBuilder(rangeQuery2, new MatchAllQueryBuilder())));
    PercolatorFieldMapper.verifyQuery(new FunctionScoreQueryBuilder(rangeQuery1, new RandomScoreFunctionBuilder()));
    expectThrows(IllegalArgumentException.class, () ->
            PercolatorFieldMapper.verifyQuery(new FunctionScoreQueryBuilder(rangeQuery2, new RandomScoreFunctionBuilder())));

    HasChildQueryBuilder hasChildQuery = new HasChildQueryBuilder("_type", new MatchAllQueryBuilder(), ScoreMode.None);
    expectThrows(IllegalArgumentException.class, () -> PercolatorFieldMapper.verifyQuery(hasChildQuery));
    expectThrows(IllegalArgumentException.class, () -> PercolatorFieldMapper.verifyQuery(new BoolQueryBuilder().must(hasChildQuery)));

    HasParentQueryBuilder hasParentQuery = new HasParentQueryBuilder("_type", new MatchAllQueryBuilder(), false);
    expectThrows(IllegalArgumentException.class, () -> PercolatorFieldMapper.verifyQuery(hasParentQuery));
    expectThrows(IllegalArgumentException.class, () -> PercolatorFieldMapper.verifyQuery(new BoolQueryBuilder().must(hasParentQuery)));
}
 

import org.elasticsearch.index.query.RangeQueryBuilder; //导入依赖的package包/类
/**
 * @param operator operator <,>,<=,>=
 * @param field field name
 * @param stringValue field value
 * @return a range query
 */
static QueryBuilder range(String operator, String field, String stringValue) {
	String key = StringUtils.replaceAll(field, "[<>=\\s]+$", "");
	boolean nestedMode = nestedMode() && field.startsWith(PROPS_PREFIX);
	RangeQueryBuilder rfb = rangeQuery(nestedMode ? getValueFieldName(stringValue) : key);
	if (">".equals(operator)) {
		rfb.gt(getNumericValue(stringValue));
	} else if ("<".equals(operator)) {
		rfb.lt(getNumericValue(stringValue));
	} else if (">=".equals(operator)) {
		rfb.gte(getNumericValue(stringValue));
	} else if ("<=".equals(operator)) {
		rfb.lte(getNumericValue(stringValue));
	}
	if (nestedMode) {
		return nestedPropsQuery(keyValueBoolQuery(key, stringValue, rfb));
	} else {
		return rfb;
	}
}
 

import org.elasticsearch.index.query.RangeQueryBuilder; //导入依赖的package包/类
private static QueryBuilder termRange(Query q) {
	QueryBuilder qb = null;
	TermRangeQuery trq = (TermRangeQuery) q;
	if (!StringUtils.isBlank(trq.getField())) {
		String from = trq.getLowerTerm() != null ? Term.toString(trq.getLowerTerm()) : "*";
		String to = trq.getUpperTerm() != null ? Term.toString(trq.getUpperTerm()) : "*";
		boolean nestedMode = nestedMode() && trq.getField().matches(PROPS_REGEX);
		qb = rangeQuery(nestedMode ? getValueFieldNameFromRange(from, to) : trq.getField());
		if ("*".equals(from) && "*".equals(to)) {
			qb = matchAllQuery();
		}
		if (!"*".equals(from)) {
			((RangeQueryBuilder) qb).from(getNumericValue(from)).includeLower(trq.includesLower());
		}
		if (!"*".equals(to)) {
			((RangeQueryBuilder) qb).to(getNumericValue(to)).includeUpper(trq.includesUpper());
		}
		if (nestedMode) {
			qb = nestedPropsQuery(keyValueBoolQuery(trq.getField(), qb));
		}
	}
	return qb;
}
 

import org.elasticsearch.index.query.RangeQueryBuilder; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Before
public void setUp() throws Exception {
    doReturn(classValue).when(visitor).doGetPrimitiveFieldClass(any(PrimitiveStatement.class));

    doReturn(wildcardQueryBuilder).when(visitor).createWildcardQuery(anyString(), anyString());
    doReturn(boolQueryBuilder).when(visitor).createBoolQueryBuilder();
    doReturn(termQueryBuilder).when(visitor).createTermQuery(anyString(), any());
    doReturn(rangeQueryBuilder).when(visitor).createRangeQuery(anyString());

    doReturn(boolQueryBuilder).when(boolQueryBuilder).mustNot(any(QueryBuilder.class));
    doReturn(rangeQueryBuilder).when(rangeQueryBuilder).lt(any(RangeQueryBuilder.class));
    doReturn(rangeQueryBuilder).when(rangeQueryBuilder).lte(any(RangeQueryBuilder.class));
    doReturn(rangeQueryBuilder).when(rangeQueryBuilder).gt(any(RangeQueryBuilder.class));
    doReturn(rangeQueryBuilder).when(rangeQueryBuilder).gte(any(RangeQueryBuilder.class));

    // We'll test our enum-safe getter separately.
    doAnswer(answer -> answer.getArgumentAt(0, TestSearchConditionVisitor.ClassValue.class).getValue())
            .when(visitor).getEnumSafeValue(classValue);
}
 

import org.elasticsearch.index.query.RangeQueryBuilder; //导入依赖的package包/类
/**
 * Tests {@link ElasticsearchQueryBuilderVisitor#buildSimpleExpression(PrimitiveStatement)} for the case where
 * we're building a {@link ConditionType#LESS_THAN} expression.
 */
@SuppressWarnings("unchecked")
@Test
public void testBuildSimpleLessThanExpression() throws Exception {
    final Object value = "hello";
    final String property = "property";

    doReturn(value).when(classValue).getValue();
    doReturn(LESS_THAN).when(statement).getCondition();
    doReturn(property).when(statement).getProperty();

    assertThat(visitor.buildSimpleExpression(statement), instanceOf(RangeQueryBuilder.class));

    verify(visitor).buildSimpleExpression(statement);
    verify(visitor).doGetPrimitiveFieldClass(statement);
    verify(visitor).validateNotCollectionCheck(statement, classValue);
    verify(visitor).createRangeQuery(property);
    verify(visitor).getEnumSafeValue(classValue);

    verify(statement).getProperty();
    verify(statement).getCondition();

    verify(rangeQueryBuilder).lt(value);

    verifyNoMoreCollaboration();
}
 

import org.elasticsearch.index.query.RangeQueryBuilder; //导入依赖的package包/类
/**
 * Tests {@link ElasticsearchQueryBuilderVisitor#buildSimpleExpression(PrimitiveStatement)} for the case where
 * we're building a {@link ConditionType#LESS_OR_EQUALS} expression.
 */
@SuppressWarnings("unchecked")
@Test
public void testBuildSimpleLessThanOrEqualsExpression() throws Exception {
    final Object value = "hello";
    final String property = "property";

    doReturn(value).when(classValue).getValue();
    doReturn(LESS_OR_EQUALS).when(statement).getCondition();
    doReturn(property).when(statement).getProperty();

    assertThat(visitor.buildSimpleExpression(statement), instanceOf(RangeQueryBuilder.class));

    verify(visitor).buildSimpleExpression(statement);
    verify(visitor).doGetPrimitiveFieldClass(statement);
    verify(visitor).validateNotCollectionCheck(statement, classValue);
    verify(visitor).createRangeQuery(property);
    verify(visitor).getEnumSafeValue(classValue);

    verify(statement).getProperty();
    verify(statement).getCondition();

    verify(rangeQueryBuilder).lte(value);

    verifyNoMoreCollaboration();
}
 

import org.elasticsearch.index.query.RangeQueryBuilder; //导入依赖的package包/类
/**
 * Tests {@link ElasticsearchQueryBuilderVisitor#buildSimpleExpression(PrimitiveStatement)} for the case where
 * we're building a {@link ConditionType#GREATER_THAN} expression.
 */
@SuppressWarnings("unchecked")
@Test
public void testBuildSimpleGreaterThanExpression() throws Exception {
    final Object value = "hello";
    final String property = "property";

    doReturn(value).when(classValue).getValue();
    doReturn(GREATER_THAN).when(statement).getCondition();
    doReturn(property).when(statement).getProperty();

    assertThat(visitor.buildSimpleExpression(statement), instanceOf(RangeQueryBuilder.class));

    verify(visitor).buildSimpleExpression(statement);
    verify(visitor).doGetPrimitiveFieldClass(statement);
    verify(visitor).validateNotCollectionCheck(statement, classValue);
    verify(visitor).createRangeQuery(property);
    verify(visitor).getEnumSafeValue(classValue);

    verify(statement).getProperty();
    verify(statement).getCondition();

    verify(rangeQueryBuilder).gt(value);

    verifyNoMoreCollaboration();
}
 

import org.elasticsearch.index.query.RangeQueryBuilder; //导入依赖的package包/类
/**
 * Tests {@link ElasticsearchQueryBuilderVisitor#buildSimpleExpression(PrimitiveStatement)} for the case where
 * we're building a {@link ConditionType#GREATER_OR_EQUALS} expression.
 */
@SuppressWarnings("unchecked")
@Test
public void testBuildSimpleGreaterThanOrEqualsExpression() throws Exception {
    final Object value = "hello";
    final String property = "property";

    doReturn(value).when(classValue).getValue();
    doReturn(GREATER_OR_EQUALS).when(statement).getCondition();
    doReturn(property).when(statement).getProperty();

    assertThat(visitor.buildSimpleExpression(statement), instanceOf(RangeQueryBuilder.class));

    verify(visitor).buildSimpleExpression(statement);
    verify(visitor).doGetPrimitiveFieldClass(statement);
    verify(visitor).validateNotCollectionCheck(statement, classValue);
    verify(visitor).createRangeQuery(property);
    verify(visitor).getEnumSafeValue(classValue);

    verify(statement).getProperty();
    verify(statement).getCondition();

    verify(rangeQueryBuilder).gte(value);

    verifyNoMoreCollaboration();
}
 

import org.elasticsearch.index.query.RangeQueryBuilder; //导入依赖的package包/类
/**
 * Tests {@link ElasticsearchQueryBuilderVisitor#mergeQueryParts(QueryBuilder, QueryBuilder)} for the case where our
 * current query part is a less than/less than or equal to.
 */
@Test
public void testMergeQueryPartsForLessThan() throws Exception {
    final RangeQueryBuilder previousPart = mock(RangeQueryBuilder.class);
    final RangeQueryBuilder currentPart = mock(RangeQueryBuilder.class);
    final String toValue = "4000";
    final boolean includeUpper = true;

    doReturn(toValue).when(currentPart).to();
    doReturn(includeUpper).when(currentPart).includeUpper();

    visitor.mergeQueryParts(previousPart, currentPart);

    verify(visitor).mergeQueryParts(previousPart, currentPart);

    verify(previousPart).to(toValue);
    verify(previousPart).includeUpper(includeUpper);

    verify(currentPart, times(2)).to();
    verify(currentPart).includeUpper();

    verifyNoMoreCollaboration(previousPart, currentPart);
}
 

import org.elasticsearch.index.query.RangeQueryBuilder; //导入依赖的package包/类
/**
 * Tests {@link ElasticsearchQueryBuilderVisitor#mergeQueryParts(QueryBuilder, QueryBuilder)} for the case where our
 * current query part is a greater than/greater than or equal to.
 */
@Test
public void testMergeQueryPartsForGreaterThan() throws Exception {
    final RangeQueryBuilder previousPart = mock(RangeQueryBuilder.class);
    final RangeQueryBuilder currentPart = mock(RangeQueryBuilder.class);
    final String fromValue = "4000";
    final boolean includeLower = true;

    doReturn(fromValue).when(currentPart).from();
    doReturn(includeLower).when(currentPart).includeLower();

    visitor.mergeQueryParts(previousPart, currentPart);

    verify(visitor).mergeQueryParts(previousPart, currentPart);

    verify(previousPart).from(fromValue);
    verify(previousPart).includeLower(includeLower);

    verify(currentPart).to();
    verify(currentPart).from();
    verify(currentPart).includeLower();

    verifyNoMoreCollaboration(previousPart, currentPart);
}
 

import org.elasticsearch.index.query.RangeQueryBuilder; //导入依赖的package包/类
@Test
public void assertMultipleMetricAggregationWithScriptError() {
    String indexName = "test1";
    int size = 1;

    Map<String, Integer> termsFactor = new HashMap<String, Integer>();
    termsFactor.put("foo", 1);
    
    buildTestDataset(1, indexName, "type1", size, termsFactor);
    
    SearchResponse searchResponse = client().prepareSearch(indexName)
            .setQuery(matchAllQuery())
            .addAggregation(new MultipleMetricBuilder("metrics")
            		.script(new ScriptBuilder("ratio").script(new Script("value1 / value2")))
            		.field(new SumBuilder("value1").field("value1"))
            		.field(new CountBuilder("value2").field("value2").filter(new RangeQueryBuilder("value1").gt(1000))))
            .execute().actionGet();
    
    MultipleMetric metrics = searchResponse.getAggregations().get("metrics");
    assertEquals(metrics.getValue("value1"), 45.0 * size, 0.0);
    assertEquals(metrics.getValue("value2"), 0.0 * size, 0.0);
    assertEquals(metrics.getValue("ratio"), Double.POSITIVE_INFINITY, 0.0);
    
    assertEquals(metrics.getDocCount("value1"), 10);
    assertEquals(metrics.getDocCount("value2"), 0);
}
 

import org.elasticsearch.index.query.RangeQueryBuilder; //导入依赖的package包/类
@Test
public void assertMultipleMetricAggregationWithFilter() {
    String indexName = "test2";
    int size = 1;

    Map<String, Integer> termsFactor = new HashMap<String, Integer>();
    termsFactor.put("foo", 1);
    
    buildTestDataset(1, indexName, "type1", size, termsFactor);
    
    SearchResponse searchResponse = client().prepareSearch(indexName)
            .setQuery(matchAllQuery())
            .addAggregation(new MultipleMetricBuilder("metrics")
            		.script(new ScriptBuilder("ratio").script(new Script("value1 / value2")))
            		.field(new SumBuilder("value1").field("value1").filter(new RangeQueryBuilder("value1").gt(5)))
            		.field(new CountBuilder("value2").field("value2")))
            .execute().actionGet();
    
    MultipleMetric metrics = searchResponse.getAggregations().get("metrics");
    assertEquals(metrics.getValue("value1"), 30.0 * size, 0.0);
    assertEquals(metrics.getValue("value2"), 10.0 * size, 0.0);
    assertEquals(metrics.getValue("ratio"), metrics.getValue("value1") / metrics.getValue("value2"), 0.0);
    
    assertEquals(metrics.getDocCount("value1"), 4);
    assertEquals(metrics.getDocCount("value2"), 10);
}
 

import org.elasticsearch.index.query.RangeQueryBuilder; //导入依赖的package包/类
@Test
public void assertMultipleMetricAggregationWithUnmappedField() {
    String indexName = "test3";
    int size = 1;

    Map<String, Integer> termsFactor = new HashMap<String, Integer>();
    termsFactor.put("foo", 1);
    
    buildTestDataset(1, indexName, "type1", size, termsFactor);
    
    SearchResponse searchResponse = client().prepareSearch(indexName)
            .setQuery(matchAllQuery())
            .addAggregation(new MultipleMetricBuilder("metrics")
            		.script(new ScriptBuilder("ratio").script(new Script("value1 + value2")))
            		.field(new SumBuilder("value1").field("value4").filter(new RangeQueryBuilder("value1").gt(5)))
            		.field(new CountBuilder("value2").field("value5")))
            .execute().actionGet();
    
    MultipleMetric metrics = searchResponse.getAggregations().get("metrics");
    assertEquals(metrics.getValue("value1"), 0.0, 0.0);
    assertEquals(metrics.getValue("value2"), 0.0, 0.0);
    assertEquals(metrics.getValue("ratio"), metrics.getValue("value1") + metrics.getValue("value2"), 0.0);
    
    assertEquals(metrics.getDocCount("value1"), 0);
    assertEquals(metrics.getDocCount("value2"), 0);
}
 

import org.elasticsearch.index.query.RangeQueryBuilder; //导入依赖的package包/类
@Override
protected SearchRequestBuilder adaptRequestBuilder(final Client esClient,
		final SearchRequestBuilder requestBuilder) {
	QueryBuilder filter = null;
	if (from != null || to != null) {
		final RangeQueryBuilder occRange = QueryBuilders.rangeQuery(Event.FIELD_TIMESTAMP);
		if (from != null) {
			occRange.gte(from.getTime());
		}
		if (to != null) {
			occRange.lte(to.getTime());
		}
		filter = occRange;
	}
	if (filter != null) {
		requestBuilder.setQuery(filter);
	}
	return requestBuilder;
}