Examples with Result org.opensearch.percolator.QueryAnalyzer.Result used on opensource projects

Example 21 with Result

use of org.opensearch.percolator.QueryAnalyzer.Result in project OpenSearch by opensearch-project.

the class QueryAnalyzerTests method testExactMatch_booleanQuery.

public void testExactMatch_booleanQuery() {
    BooleanQuery.Builder builder = new BooleanQuery.Builder();
    TermQuery termQuery1 = new TermQuery(new Term("_field", "_term1"));
    builder.add(termQuery1, BooleanClause.Occur.SHOULD);
    TermQuery termQuery2 = new TermQuery(new Term("_field", "_term2"));
    builder.add(termQuery2, BooleanClause.Occur.SHOULD);
    Result result = analyze(builder.build(), Version.CURRENT);
    assertThat("All clauses are exact, so candidate matches are verified", result.verified, is(true));
    assertThat(result.minimumShouldMatch, equalTo(1));
    builder = new BooleanQuery.Builder();
    builder.add(termQuery1, BooleanClause.Occur.SHOULD);
    PhraseQuery phraseQuery1 = new PhraseQuery("_field", "_term1", "_term2");
    builder.add(phraseQuery1, BooleanClause.Occur.SHOULD);
    result = analyze(builder.build(), Version.CURRENT);
    assertThat("Clause isn't exact, so candidate matches are not verified", result.verified, is(false));
    assertThat(result.minimumShouldMatch, equalTo(1));
    builder = new BooleanQuery.Builder();
    builder.add(phraseQuery1, BooleanClause.Occur.SHOULD);
    PhraseQuery phraseQuery2 = new PhraseQuery("_field", "_term3", "_term4");
    builder.add(phraseQuery2, BooleanClause.Occur.SHOULD);
    result = analyze(builder.build(), Version.CURRENT);
    assertThat("No clause is exact, so candidate matches are not verified", result.verified, is(false));
    assertThat(result.minimumShouldMatch, equalTo(2));
    builder = new BooleanQuery.Builder();
    builder.add(termQuery1, BooleanClause.Occur.MUST_NOT);
    builder.add(termQuery2, BooleanClause.Occur.SHOULD);
    result = analyze(builder.build(), Version.CURRENT);
    assertThat("There is a must_not clause, so candidate matches are not verified", result.verified, is(false));
    assertThat(result.minimumShouldMatch, equalTo(1));
    builder = new BooleanQuery.Builder();
    int msm = randomIntBetween(2, 3);
    builder.setMinimumNumberShouldMatch(msm);
    TermQuery termQuery3 = new TermQuery(new Term("_field", "_term3"));
    builder.add(termQuery1, BooleanClause.Occur.SHOULD);
    builder.add(termQuery2, BooleanClause.Occur.SHOULD);
    builder.add(termQuery3, BooleanClause.Occur.SHOULD);
    result = analyze(builder.build(), Version.CURRENT);
    assertThat("Minimum match has no impact on whether the result is verified", result.verified, is(true));
    assertThat("msm is at least two so result.minimumShouldMatch should 2 too", result.minimumShouldMatch, equalTo(msm));
    builder = new BooleanQuery.Builder();
    builder.add(termQuery1, randomBoolean() ? BooleanClause.Occur.MUST : BooleanClause.Occur.FILTER);
    result = analyze(builder.build(), Version.CURRENT);
    assertThat("Also required clauses are taken into account whether the result is verified", result.verified, is(true));
    assertThat(result.minimumShouldMatch, equalTo(1));
    builder = new BooleanQuery.Builder();
    builder.add(termQuery1, randomBoolean() ? BooleanClause.Occur.MUST : BooleanClause.Occur.FILTER);
    builder.add(termQuery2, randomBoolean() ? BooleanClause.Occur.MUST : BooleanClause.Occur.FILTER);
    result = analyze(builder.build(), Version.CURRENT);
    assertThat("Also required clauses are taken into account whether the result is verified", result.verified, is(true));
    assertThat(result.minimumShouldMatch, equalTo(2));
    builder = new BooleanQuery.Builder();
    builder.add(termQuery1, randomBoolean() ? BooleanClause.Occur.MUST : BooleanClause.Occur.FILTER);
    builder.add(termQuery2, BooleanClause.Occur.MUST_NOT);
    result = analyze(builder.build(), Version.CURRENT);
    assertThat("Prohibited clause, so candidate matches are not verified", result.verified, is(false));
    assertThat(result.minimumShouldMatch, equalTo(1));
    builder = new BooleanQuery.Builder();
    builder.add(termQuery1, randomBoolean() ? BooleanClause.Occur.MUST : BooleanClause.Occur.FILTER);
    builder.add(termQuery2, BooleanClause.Occur.MUST_NOT);
    result = analyze(builder.build(), Version.CURRENT);
    assertThat("Prohibited clause, so candidate matches are not verified", result.verified, is(false));
    assertThat(result.minimumShouldMatch, equalTo(1));
    builder = new BooleanQuery.Builder().add(new BooleanQuery.Builder().add(termQuery1, Occur.FILTER).add(termQuery2, Occur.FILTER).build(), Occur.SHOULD).add(termQuery3, Occur.SHOULD);
    result = analyze(builder.build(), Version.CURRENT);
    assertThat("Inner clause that is not a pure disjunction, so candidate matches are not verified", result.verified, is(false));
    assertThat(result.minimumShouldMatch, equalTo(1));
    builder = new BooleanQuery.Builder().add(new BooleanQuery.Builder().add(termQuery1, Occur.SHOULD).add(termQuery2, Occur.SHOULD).build(), Occur.SHOULD).add(termQuery3, Occur.SHOULD);
    result = analyze(builder.build(), Version.CURRENT);
    assertThat("Inner clause that is a pure disjunction, so candidate matches are verified", result.verified, is(true));
    assertThat(result.minimumShouldMatch, equalTo(1));
    builder = new BooleanQuery.Builder().add(new BooleanQuery.Builder().add(termQuery1, Occur.SHOULD).add(termQuery2, Occur.SHOULD).build(), Occur.MUST).add(termQuery3, Occur.FILTER);
    result = analyze(builder.build(), Version.CURRENT);
    assertThat("Disjunctions of conjunctions can't be verified", result.verified, is(false));
    assertThat(result.minimumShouldMatch, equalTo(2));
    builder = new BooleanQuery.Builder().add(new BooleanQuery.Builder().add(termQuery1, Occur.MUST).add(termQuery2, Occur.FILTER).build(), Occur.SHOULD).add(termQuery3, Occur.SHOULD);
    result = analyze(builder.build(), Version.CURRENT);
    assertThat("Conjunctions of disjunctions can't be verified", result.verified, is(false));
    assertThat(result.minimumShouldMatch, equalTo(1));
}

Example 22 with Result

use of org.opensearch.percolator.QueryAnalyzer.Result in project OpenSearch by opensearch-project.

the class QueryAnalyzerTests method testCombinedRangeAndTermWithMinimumShouldMatch.

public void testCombinedRangeAndTermWithMinimumShouldMatch() {
    Query disj = new BooleanQuery.Builder().add(IntPoint.newRangeQuery("i", 0, 10), Occur.SHOULD).add(new TermQuery(new Term("f", "v1")), Occur.SHOULD).add(new TermQuery(new Term("f", "v1")), Occur.SHOULD).setMinimumNumberShouldMatch(2).build();
    Result r = analyze(disj, Version.CURRENT);
    assertThat(r.minimumShouldMatch, equalTo(1));
    assertThat(r.extractions, hasSize(2));
    assertFalse(r.matchAllDocs);
    assertFalse(r.verified);
    Query q = new BooleanQuery.Builder().add(IntPoint.newRangeQuery("i", 0, 10), Occur.SHOULD).add(new TermQuery(new Term("f", "v1")), Occur.SHOULD).add(new TermQuery(new Term("f", "v1")), Occur.SHOULD).add(new TermQuery(new Term("f", "v1")), Occur.FILTER).setMinimumNumberShouldMatch(2).build();
    Result result = analyze(q, Version.CURRENT);
    assertThat(result.minimumShouldMatch, equalTo(1));
    assertThat(result.extractions.size(), equalTo(2));
    assertFalse(result.verified);
    assertFalse(result.matchAllDocs);
    q = new BooleanQuery.Builder().add(q, Occur.MUST).add(q, Occur.MUST).build();
    result = analyze(q, Version.CURRENT);
    assertThat(result.minimumShouldMatch, equalTo(1));
    assertThat(result.extractions.size(), equalTo(2));
    assertFalse(result.verified);
    assertFalse(result.matchAllDocs);
    Query q2 = new BooleanQuery.Builder().add(new TermQuery(new Term("f", "v1")), Occur.FILTER).add(IntPoint.newRangeQuery("i", 15, 20), Occur.SHOULD).add(new TermQuery(new Term("f", "v2")), Occur.SHOULD).add(new TermQuery(new Term("f", "v2")), Occur.MUST).setMinimumNumberShouldMatch(1).build();
    result = analyze(q2, Version.CURRENT);
    assertThat(result.minimumShouldMatch, equalTo(2));
    assertThat(result.extractions, hasSize(3));
    assertFalse(result.verified);
    assertFalse(result.matchAllDocs);
    // multiple range queries on different fields
    Query q3 = new BooleanQuery.Builder().add(IntPoint.newRangeQuery("i", 15, 20), Occur.SHOULD).add(IntPoint.newRangeQuery("i2", 15, 20), Occur.SHOULD).add(new TermQuery(new Term("f", "v1")), Occur.SHOULD).add(new TermQuery(new Term("f", "v2")), Occur.MUST).setMinimumNumberShouldMatch(1).build();
    result = analyze(q3, Version.CURRENT);
    assertThat(result.minimumShouldMatch, equalTo(2));
    assertThat(result.extractions, hasSize(4));
    assertFalse(result.verified);
    assertFalse(result.matchAllDocs);
    // multiple disjoint range queries on the same field
    Query q4 = new BooleanQuery.Builder().add(IntPoint.newRangeQuery("i", 15, 20), Occur.SHOULD).add(IntPoint.newRangeQuery("i", 25, 30), Occur.SHOULD).add(IntPoint.newRangeQuery("i", 35, 40), Occur.SHOULD).add(new TermQuery(new Term("f", "v1")), Occur.SHOULD).add(new TermQuery(new Term("f", "v2")), Occur.MUST).setMinimumNumberShouldMatch(1).build();
    result = analyze(q4, Version.CURRENT);
    assertThat(result.minimumShouldMatch, equalTo(2));
    assertThat(result.extractions, hasSize(5));
    assertFalse(result.verified);
    assertFalse(result.matchAllDocs);
    // multiple conjunction range queries on the same field
    Query q5 = new BooleanQuery.Builder().add(new BooleanQuery.Builder().add(IntPoint.newRangeQuery("i", 15, 20), Occur.MUST).add(IntPoint.newRangeQuery("i", 25, 30), Occur.MUST).build(), Occur.MUST).add(IntPoint.newRangeQuery("i", 35, 40), Occur.MUST).add(new TermQuery(new Term("f", "v2")), Occur.MUST).build();
    result = analyze(q5, Version.CURRENT);
    assertThat(result.minimumShouldMatch, equalTo(2));
    assertThat(result.extractions, hasSize(4));
    assertFalse(result.verified);
    assertFalse(result.matchAllDocs);
    // multiple conjunction range queries on different fields
    Query q6 = new BooleanQuery.Builder().add(new BooleanQuery.Builder().add(IntPoint.newRangeQuery("i", 15, 20), Occur.MUST).add(IntPoint.newRangeQuery("i2", 25, 30), Occur.MUST).build(), Occur.MUST).add(IntPoint.newRangeQuery("i", 35, 40), Occur.MUST).add(new TermQuery(new Term("f", "v2")), Occur.MUST).build();
    result = analyze(q6, Version.CURRENT);
    assertThat(result.minimumShouldMatch, equalTo(3));
    assertThat(result.extractions, hasSize(4));
    assertFalse(result.verified);
    assertFalse(result.matchAllDocs);
    // mixed term and range conjunctions
    Query q7 = new BooleanQuery.Builder().add(new BooleanQuery.Builder().add(IntPoint.newRangeQuery("i", 1, 2), Occur.MUST).add(new TermQuery(new Term("f", "1")), Occur.MUST).build(), Occur.MUST).add(new BooleanQuery.Builder().add(IntPoint.newRangeQuery("i", 1, 2), Occur.MUST).add(new TermQuery(new Term("f", "2")), Occur.MUST).build(), Occur.MUST).build();
    result = analyze(q7, Version.CURRENT);
    assertThat(result.minimumShouldMatch, equalTo(3));
    assertThat(result.extractions, hasSize(3));
    assertFalse(result.verified);
    assertFalse(result.matchAllDocs);
}

Example 23 with Result

use of org.opensearch.percolator.QueryAnalyzer.Result in project OpenSearch by opensearch-project.

the class QueryAnalyzerTests method testPointRangeQuery_lowerUpperReversed.

public void testPointRangeQuery_lowerUpperReversed() {
    Query query = IntPoint.newRangeQuery("_field", 20, 10);
    Result result = analyze(query, Version.CURRENT);
    assertTrue(result.verified);
    assertThat(result.minimumShouldMatch, equalTo(0));
    assertThat(result.extractions.size(), equalTo(0));
}

Example 24 with Result

use of org.opensearch.percolator.QueryAnalyzer.Result in project OpenSearch by opensearch-project.

the class QueryAnalyzerTests method testExtractQueryMetadata_termsQuery.

public void testExtractQueryMetadata_termsQuery() {
    TermInSetQuery termsQuery = new TermInSetQuery("_field", new BytesRef("_term1"), new BytesRef("_term2"));
    Result result = analyze(termsQuery, Version.CURRENT);
    assertThat(result.verified, is(true));
    assertThat(result.minimumShouldMatch, equalTo(1));
    List<QueryExtraction> terms = new ArrayList<>(result.extractions);
    terms.sort(Comparator.comparing(qt -> qt.term));
    assertThat(terms.size(), equalTo(2));
    assertThat(terms.get(0).field(), equalTo("_field"));
    assertThat(terms.get(0).text(), equalTo("_term1"));
    assertThat(terms.get(1).field(), equalTo("_field"));
    assertThat(terms.get(1).text(), equalTo("_term2"));
}

Example 25 with Result

use of org.opensearch.percolator.QueryAnalyzer.Result in project OpenSearch by opensearch-project.

the class QueryAnalyzerTests method testBooleanQueryWithMustAndShouldClauses.

public void testBooleanQueryWithMustAndShouldClauses() {
    BooleanQuery.Builder builder = new BooleanQuery.Builder();
    TermQuery termQuery1 = new TermQuery(new Term("_field", "_term1"));
    builder.add(termQuery1, BooleanClause.Occur.SHOULD);
    TermQuery termQuery2 = new TermQuery(new Term("_field", "_term2"));
    builder.add(termQuery2, BooleanClause.Occur.SHOULD);
    TermQuery termQuery3 = new TermQuery(new Term("_field", "_term3"));
    builder.add(termQuery3, BooleanClause.Occur.MUST);
    Result result = analyze(builder.build(), Version.CURRENT);
    assertThat("Must clause is exact, so this is a verified candidate match", result.verified, is(true));
    assertThat(result.minimumShouldMatch, equalTo(1));
    assertThat(result.extractions.size(), equalTo(1));
    List<QueryExtraction> extractions = new ArrayList<>(result.extractions);
    assertThat(extractions.get(0).term, equalTo(new Term("_field", "_term3")));
    builder.setMinimumNumberShouldMatch(1);
    result = analyze(builder.build(), Version.CURRENT);
    assertThat("Must clause is exact, but m_s_m is 1 so one should clause must match too", result.verified, is(false));
    assertThat(result.minimumShouldMatch, equalTo(2));
    assertTermsEqual(result.extractions, termQuery1.getTerm(), termQuery2.getTerm(), termQuery3.getTerm());
    builder = new BooleanQuery.Builder();
    BooleanQuery.Builder innerBuilder = new BooleanQuery.Builder();
    innerBuilder.setMinimumNumberShouldMatch(2);
    innerBuilder.add(termQuery1, BooleanClause.Occur.SHOULD);
    innerBuilder.add(termQuery2, BooleanClause.Occur.SHOULD);
    builder.add(innerBuilder.build(), BooleanClause.Occur.MUST);
    builder.add(termQuery3, BooleanClause.Occur.MUST);
    result = analyze(builder.build(), Version.CURRENT);
    assertThat("Verified, because m_s_m is specified in an inner clause and not top level clause", result.verified, is(true));
    assertThat(result.minimumShouldMatch, equalTo(3));
    assertThat(result.extractions.size(), equalTo(3));
    extractions = new ArrayList<>(result.extractions);
    extractions.sort(Comparator.comparing(key -> key.term));
    assertThat(extractions.get(0).term, equalTo(new Term("_field", "_term1")));
    assertThat(extractions.get(1).term, equalTo(new Term("_field", "_term2")));
    assertThat(extractions.get(2).term, equalTo(new Term("_field", "_term3")));
    builder = new BooleanQuery.Builder();
    builder.add(innerBuilder.build(), BooleanClause.Occur.SHOULD);
    builder.add(termQuery3, BooleanClause.Occur.MUST);
    result = analyze(builder.build(), Version.CURRENT);
    assertThat("Verified, because m_s_m is specified in an inner clause and not top level clause", result.verified, is(true));
    assertThat(result.minimumShouldMatch, equalTo(1));
    assertThat(result.extractions.size(), equalTo(1));
    extractions = new ArrayList<>(result.extractions);
    assertThat(extractions.get(0).term, equalTo(new Term("_field", "_term3")));
}