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()); }
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; }
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; }