public void testTimezone() throws Exception {
    assumeTrue("test runs only when at least a type is registered", getCurrentTypes().length > 0);
    String queryAsString =
        "{\n"
            + "    \"query_string\":{\n"
            + "        \"time_zone\":\"Europe/Paris\",\n"
            + "        \"query\":\""
            + DATE_FIELD_NAME
            + ":[2012 TO 2014]\"\n"
            + "    }\n"
            + "}";
    QueryBuilder<?> queryBuilder = parseQuery(queryAsString);
    assertThat(queryBuilder, instanceOf(QueryStringQueryBuilder.class));
    QueryStringQueryBuilder queryStringQueryBuilder = (QueryStringQueryBuilder) queryBuilder;
    assertThat(queryStringQueryBuilder.timeZone(), equalTo(DateTimeZone.forID("Europe/Paris")));

    try {
      queryAsString =
          "{\n"
              + "    \"query_string\":{\n"
              + "        \"time_zone\":\"This timezone does not exist\",\n"
              + "        \"query\":\""
              + DATE_FIELD_NAME
              + ":[2012 TO 2014]\"\n"
              + "    }\n"
              + "}";
      parseQuery(queryAsString);
      fail("we expect a ParsingException as we are providing an unknown time_zome");
    } catch (IllegalArgumentException e) {
      // We expect this one
    }
  }
  public void testFromJson() throws IOException {
    String json =
        "{\n"
            + "  \"query_string\" : {\n"
            + "    \"query\" : \"this AND that OR thus\",\n"
            + "    \"default_field\" : \"content\",\n"
            + "    \"fields\" : [ ],\n"
            + "    \"use_dis_max\" : true,\n"
            + "    \"tie_breaker\" : 0.0,\n"
            + "    \"default_operator\" : \"or\",\n"
            + "    \"auto_generated_phrase_queries\" : false,\n"
            + "    \"max_determined_states\" : 10000,\n"
            + "    \"lowercase_expanded_terms\" : true,\n"
            + "    \"enable_position_increment\" : true,\n"
            + "    \"fuzziness\" : \"AUTO\",\n"
            + "    \"fuzzy_prefix_length\" : 0,\n"
            + "    \"fuzzy_max_expansions\" : 50,\n"
            + "    \"phrase_slop\" : 0,\n"
            + "    \"locale\" : \"und\",\n"
            + "    \"escape\" : false,\n"
            + "    \"boost\" : 1.0\n"
            + "  }\n"
            + "}";

    QueryStringQueryBuilder parsed = (QueryStringQueryBuilder) parseQuery(json);
    checkGeneratedJson(json, parsed);

    assertEquals(json, "this AND that OR thus", parsed.queryString());
    assertEquals(json, "content", parsed.defaultField());
  }
Esempio n. 3
0
  private SearchRequestBuilder standardSearchRequest(
      String query, Set<String> indices, int limit, int offset, TimeRange range, Sorting sort)
      throws IndexHelper.InvalidRangeFormatException {
    if (query == null || query.trim().isEmpty()) {
      query = "*";
    }

    SearchRequestBuilder srb = c.prepareSearch();
    srb.setIndices(indices.toArray(new String[] {}));

    if (query.trim().equals("*")) {
      srb.setQuery(matchAllQuery());
    } else {
      QueryStringQueryBuilder qs = queryString(query);
      qs.allowLeadingWildcard(server.getConfiguration().isAllowLeadingWildcardSearches());
      srb.setQuery(qs);
    }

    srb.setFrom(offset);

    if (limit > 0) {
      srb.setSize(limit);
    }

    if (range != null) {
      srb.setFilter(IndexHelper.getTimestampRangeFilter(range));
    }

    if (sort != null) {
      srb.addSort(sort.getField(), sort.asElastic());
    }

    return srb;
  }
Esempio n. 4
0
  public HistogramResult histogram(
      String query, Indexer.DateHistogramInterval interval, String filter, TimeRange range)
      throws IndexHelper.InvalidRangeFormatException {
    DateHistogramFacetBuilder fb =
        FacetBuilders.dateHistogramFacet("histogram")
            .field("timestamp")
            .interval(interval.toString().toLowerCase());

    fb.facetFilter(standardFilters(range, filter));

    QueryStringQueryBuilder qs = queryString(query);
    qs.allowLeadingWildcard(server.getConfiguration().isAllowLeadingWildcardSearches());

    SearchRequestBuilder srb = c.prepareSearch();
    srb.setIndices(IndexHelper.determineAffectedIndices(server, range).toArray(new String[] {}));
    srb.setQuery(qs);
    srb.addFacet(fb);

    final SearchRequest request = srb.request();
    SearchResponse r = c.search(request).actionGet();
    return new DateHistogramResult(
        (DateHistogramFacet) r.getFacets().facet("histogram"),
        query,
        request.source(),
        interval,
        r.getTook());
  }
 public void testToQueryPhraseQueryBoostAndSlop() throws IOException {
   assumeTrue("test runs only when at least a type is registered", getCurrentTypes().length > 0);
   QueryStringQueryBuilder queryStringQueryBuilder =
       new QueryStringQueryBuilder("\"test phrase\"~2").field(STRING_FIELD_NAME, 5f);
   Query query = queryStringQueryBuilder.toQuery(createShardContext());
   assertThat(query, instanceOf(DisjunctionMaxQuery.class));
   DisjunctionMaxQuery disjunctionMaxQuery = (DisjunctionMaxQuery) query;
   assertThat(disjunctionMaxQuery.getDisjuncts().size(), equalTo(1));
   assertThat(disjunctionMaxQuery.getDisjuncts().get(0), instanceOf(BoostQuery.class));
   BoostQuery boostQuery = (BoostQuery) disjunctionMaxQuery.getDisjuncts().get(0);
   assertThat(boostQuery.getBoost(), equalTo(5f));
   assertThat(boostQuery.getQuery(), instanceOf(PhraseQuery.class));
   PhraseQuery phraseQuery = (PhraseQuery) boostQuery.getQuery();
   assertThat(phraseQuery.getSlop(), Matchers.equalTo(2));
   assertThat(phraseQuery.getTerms().length, equalTo(2));
 }
  public void testToQueryBooleanQueryMultipleBoosts() throws Exception {
    assumeTrue("test runs only when at least a type is registered", getCurrentTypes().length > 0);
    int numBoosts = randomIntBetween(2, 10);
    float[] boosts = new float[numBoosts + 1];
    String queryStringPrefix = "";
    String queryStringSuffix = "";
    for (int i = 0; i < boosts.length - 1; i++) {
      float boost = 2.0f / randomIntBetween(3, 20);
      boosts[i] = boost;
      queryStringPrefix += "(";
      queryStringSuffix += ")^" + boost;
    }
    String queryString = queryStringPrefix + "foo bar" + queryStringSuffix;

    float mainBoost = 2.0f / randomIntBetween(3, 20);
    boosts[boosts.length - 1] = mainBoost;
    QueryStringQueryBuilder queryStringQueryBuilder =
        new QueryStringQueryBuilder(queryString)
            .field(STRING_FIELD_NAME)
            .minimumShouldMatch("2")
            .boost(mainBoost);
    Query query = queryStringQueryBuilder.toQuery(createShardContext());

    for (int i = boosts.length - 1; i >= 0; i--) {
      assertThat(query, instanceOf(BoostQuery.class));
      BoostQuery boostQuery = (BoostQuery) query;
      assertThat(boostQuery.getBoost(), equalTo(boosts[i]));
      query = boostQuery.getQuery();
    }

    assertThat(query, instanceOf(BooleanQuery.class));
    BooleanQuery booleanQuery = (BooleanQuery) query;
    assertThat(booleanQuery.getMinimumNumberShouldMatch(), equalTo(2));
    assertThat(booleanQuery.clauses().get(0).getOccur(), equalTo(BooleanClause.Occur.SHOULD));
    assertThat(
        booleanQuery.clauses().get(0).getQuery(),
        equalTo(new TermQuery(new Term(STRING_FIELD_NAME, "foo"))));
    assertThat(booleanQuery.clauses().get(1).getOccur(), equalTo(BooleanClause.Occur.SHOULD));
    assertThat(
        booleanQuery.clauses().get(1).getQuery(),
        equalTo(new TermQuery(new Term(STRING_FIELD_NAME, "bar"))));
  }
 @Override
 protected void doAssertLuceneQuery(
     QueryStringQueryBuilder queryBuilder, Query query, QueryShardContext context)
     throws IOException {
   if ("".equals(queryBuilder.queryString())) {
     assertThat(query, instanceOf(MatchNoDocsQuery.class));
   } else {
     assertThat(
         query,
         either(instanceOf(TermQuery.class))
             .or(instanceOf(AllTermQuery.class))
             .or(instanceOf(BooleanQuery.class))
             .or(instanceOf(DisjunctionMaxQuery.class)));
   }
 }
  public void testToQueryBoosts() throws Exception {
    assumeTrue("test runs only when at least a type is registered", getCurrentTypes().length > 0);
    QueryShardContext shardContext = createShardContext();
    QueryStringQueryBuilder queryStringQuery = queryStringQuery(STRING_FIELD_NAME + ":boosted^2");
    Query query = queryStringQuery.toQuery(shardContext);
    assertThat(query, instanceOf(BoostQuery.class));
    BoostQuery boostQuery = (BoostQuery) query;
    assertThat(boostQuery.getBoost(), equalTo(2.0f));
    assertThat(boostQuery.getQuery(), instanceOf(TermQuery.class));
    assertThat(
        ((TermQuery) boostQuery.getQuery()).getTerm(),
        equalTo(new Term(STRING_FIELD_NAME, "boosted")));
    queryStringQuery.boost(2.0f);
    query = queryStringQuery.toQuery(shardContext);
    assertThat(query, instanceOf(BoostQuery.class));
    boostQuery = (BoostQuery) query;
    assertThat(boostQuery.getBoost(), equalTo(2.0f));
    assertThat(boostQuery.getQuery(), instanceOf(BoostQuery.class));
    boostQuery = (BoostQuery) boostQuery.getQuery();
    assertThat(boostQuery.getBoost(), equalTo(2.0f));

    queryStringQuery =
        queryStringQuery(
            "((" + STRING_FIELD_NAME + ":boosted^2) AND (" + STRING_FIELD_NAME + ":foo^1.5))^3");
    query = queryStringQuery.toQuery(shardContext);
    assertThat(query, instanceOf(BoostQuery.class));
    boostQuery = (BoostQuery) query;
    assertThat(boostQuery.getBoost(), equalTo(3.0f));
    BoostQuery boostQuery1 = assertBooleanSubQuery(boostQuery.getQuery(), BoostQuery.class, 0);
    assertThat(boostQuery1.getBoost(), equalTo(2.0f));
    assertThat(boostQuery1.getQuery(), instanceOf(TermQuery.class));
    assertThat(
        ((TermQuery) boostQuery1.getQuery()).getTerm(),
        equalTo(new Term(STRING_FIELD_NAME, "boosted")));
    BoostQuery boostQuery2 = assertBooleanSubQuery(boostQuery.getQuery(), BoostQuery.class, 1);
    assertThat(boostQuery2.getBoost(), equalTo(1.5f));
    assertThat(boostQuery2.getQuery(), instanceOf(TermQuery.class));
    assertThat(
        ((TermQuery) boostQuery2.getQuery()).getTerm(),
        equalTo(new Term(STRING_FIELD_NAME, "foo")));
    queryStringQuery.boost(2.0f);
    query = queryStringQuery.toQuery(shardContext);
    assertThat(query, instanceOf(BoostQuery.class));
    boostQuery = (BoostQuery) query;
    assertThat(boostQuery.getBoost(), equalTo(2.0f));
  }
 @Override
 protected QueryStringQueryBuilder doCreateTestQueryBuilder() {
   int numTerms = randomIntBetween(0, 5);
   String query = "";
   for (int i = 0; i < numTerms; i++) {
     // min length 4 makes sure that the text is not an operator (AND/OR) so toQuery won't break
     query +=
         (randomBoolean() ? STRING_FIELD_NAME + ":" : "")
             + randomAsciiOfLengthBetween(4, 10)
             + " ";
   }
   QueryStringQueryBuilder queryStringQueryBuilder = new QueryStringQueryBuilder(query);
   if (randomBoolean()) {
     queryStringQueryBuilder.defaultField(
         randomBoolean() ? STRING_FIELD_NAME : randomAsciiOfLengthBetween(1, 10));
   }
   if (randomBoolean()) {
     int numFields = randomIntBetween(1, 5);
     for (int i = 0; i < numFields; i++) {
       String fieldName = randomBoolean() ? STRING_FIELD_NAME : randomAsciiOfLengthBetween(1, 10);
       if (randomBoolean()) {
         queryStringQueryBuilder.field(fieldName);
       } else {
         queryStringQueryBuilder.field(fieldName, randomFloat());
       }
     }
   }
   if (randomBoolean()) {
     queryStringQueryBuilder.defaultOperator(randomFrom(Operator.values()));
   }
   if (randomBoolean()) {
     // we only use string fields (either mapped or unmapped)
     queryStringQueryBuilder.fuzziness(randomFuzziness(STRING_FIELD_NAME));
   }
   if (randomBoolean()) {
     queryStringQueryBuilder.analyzer(randomAnalyzer());
   }
   if (randomBoolean()) {
     queryStringQueryBuilder.quoteAnalyzer(randomAnalyzer());
   }
   if (randomBoolean()) {
     queryStringQueryBuilder.allowLeadingWildcard(randomBoolean());
   }
   if (randomBoolean()) {
     queryStringQueryBuilder.analyzeWildcard(randomBoolean());
   }
   if (randomBoolean()) {
     queryStringQueryBuilder.maxDeterminizedStates(randomIntBetween(1, 100));
   }
   if (randomBoolean()) {
     queryStringQueryBuilder.lowercaseExpandedTerms(randomBoolean());
   }
   if (randomBoolean()) {
     queryStringQueryBuilder.autoGeneratePhraseQueries(randomBoolean());
   }
   if (randomBoolean()) {
     queryStringQueryBuilder.enablePositionIncrements(randomBoolean());
   }
   if (randomBoolean()) {
     queryStringQueryBuilder.lenient(randomBoolean());
   }
   if (randomBoolean()) {
     queryStringQueryBuilder.escape(randomBoolean());
   }
   if (randomBoolean()) {
     queryStringQueryBuilder.phraseSlop(randomIntBetween(0, 10));
   }
   if (randomBoolean()) {
     queryStringQueryBuilder.fuzzyMaxExpansions(randomIntBetween(0, 100));
   }
   if (randomBoolean()) {
     queryStringQueryBuilder.fuzzyPrefixLength(randomIntBetween(0, 10));
   }
   if (randomBoolean()) {
     queryStringQueryBuilder.fuzzyRewrite(getRandomRewriteMethod());
   }
   if (randomBoolean()) {
     queryStringQueryBuilder.rewrite(getRandomRewriteMethod());
   }
   if (randomBoolean()) {
     queryStringQueryBuilder.quoteFieldSuffix(randomAsciiOfLengthBetween(1, 3));
   }
   if (randomBoolean()) {
     queryStringQueryBuilder.tieBreaker(randomFloat());
   }
   if (randomBoolean()) {
     queryStringQueryBuilder.minimumShouldMatch(randomMinimumShouldMatch());
   }
   if (randomBoolean()) {
     queryStringQueryBuilder.useDisMax(randomBoolean());
   }
   if (randomBoolean()) {
     queryStringQueryBuilder.locale(randomLocale(getRandom()));
   }
   if (randomBoolean()) {
     queryStringQueryBuilder.timeZone(randomTimeZone());
   }
   return queryStringQueryBuilder;
 }