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

Example 6 with Result

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

the class QueryAnalyzerTests method testExtractQueryMetadata_booleanQuery_msm.

public void testExtractQueryMetadata_booleanQuery_msm() {
    BooleanQuery.Builder builder = new BooleanQuery.Builder();
    builder.setMinimumNumberShouldMatch(2);
    Term term1 = new Term("_field", "_term1");
    TermQuery termQuery1 = new TermQuery(term1);
    builder.add(termQuery1, BooleanClause.Occur.SHOULD);
    Term term2 = new Term("_field", "_term2");
    TermQuery termQuery2 = new TermQuery(term2);
    builder.add(termQuery2, BooleanClause.Occur.SHOULD);
    Term term3 = new Term("_field", "_term3");
    TermQuery termQuery3 = new TermQuery(term3);
    builder.add(termQuery3, BooleanClause.Occur.SHOULD);
    BooleanQuery booleanQuery = builder.build();
    Result result = analyze(booleanQuery, Version.CURRENT);
    assertThat(result.verified, is(true));
    assertThat(result.minimumShouldMatch, equalTo(2));
    assertTermsEqual(result.extractions, term1, term2, term3);
    builder = new BooleanQuery.Builder().add(new BooleanQuery.Builder().add(termQuery1, Occur.SHOULD).add(termQuery2, Occur.SHOULD).build(), Occur.SHOULD).add(termQuery3, Occur.SHOULD).setMinimumNumberShouldMatch(2);
    booleanQuery = builder.build();
    result = analyze(booleanQuery, Version.CURRENT);
    assertThat(result.verified, is(false));
    assertThat(result.minimumShouldMatch, equalTo(2));
    assertTermsEqual(result.extractions, term1, term2, term3);
    Term term4 = new Term("_field", "_term4");
    TermQuery termQuery4 = new TermQuery(term4);
    builder = new BooleanQuery.Builder().add(new BooleanQuery.Builder().add(termQuery1, Occur.MUST).add(termQuery2, Occur.FILTER).build(), Occur.SHOULD).add(new BooleanQuery.Builder().add(termQuery3, Occur.MUST).add(termQuery4, Occur.FILTER).build(), Occur.SHOULD);
    booleanQuery = builder.build();
    result = analyze(booleanQuery, Version.CURRENT);
    assertThat(result.verified, is(false));
    assertThat(result.minimumShouldMatch, equalTo(2));
    assertTermsEqual(result.extractions, term1, term2, term3, term4);
    Term term5 = new Term("_field", "_term5");
    TermQuery termQuery5 = new TermQuery(term5);
    builder.add(termQuery5, Occur.SHOULD);
    booleanQuery = builder.build();
    result = analyze(booleanQuery, Version.CURRENT);
    assertThat(result.verified, is(false));
    assertThat(result.minimumShouldMatch, equalTo(1));
    assertTermsEqual(result.extractions, term1, term2, term3, term4, term5);
    builder.setMinimumNumberShouldMatch(2);
    booleanQuery = builder.build();
    result = analyze(booleanQuery, Version.CURRENT);
    assertThat(result.verified, is(false));
    assertThat(result.minimumShouldMatch, equalTo(3));
    assertTermsEqual(result.extractions, term1, term2, term3, term4, term5);
    builder.setMinimumNumberShouldMatch(3);
    booleanQuery = builder.build();
    result = analyze(booleanQuery, Version.CURRENT);
    assertThat(result.verified, is(false));
    assertThat(result.minimumShouldMatch, equalTo(5));
    assertTermsEqual(result.extractions, term1, term2, term3, term4, term5);
    builder = new BooleanQuery.Builder().add(new BooleanQuery.Builder().add(termQuery1, Occur.SHOULD).add(termQuery2, Occur.SHOULD).build(), Occur.SHOULD).add(new BooleanQuery.Builder().setMinimumNumberShouldMatch(1).build(), Occur.SHOULD).setMinimumNumberShouldMatch(2);
    booleanQuery = builder.build();
    result = analyze(booleanQuery, Version.CURRENT);
    // ideally it would return no extractions, but the fact
    // that it doesn't consider them verified is probably good enough
    assertFalse(result.verified);
}

Example 7 with Result

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

the class QueryAnalyzerTests method testExtractQueryMetadata_booleanQuery_onlyShould.

public void testExtractQueryMetadata_booleanQuery_onlyShould() {
    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);
    BooleanQuery.Builder subBuilder = new BooleanQuery.Builder();
    TermQuery termQuery3 = new TermQuery(new Term("_field1", "_term"));
    subBuilder.add(termQuery3, BooleanClause.Occur.SHOULD);
    TermQuery termQuery4 = new TermQuery(new Term("_field3", "_long_term"));
    subBuilder.add(termQuery4, BooleanClause.Occur.SHOULD);
    builder.add(subBuilder.build(), BooleanClause.Occur.SHOULD);
    BooleanQuery booleanQuery = builder.build();
    Result result = analyze(booleanQuery, Version.CURRENT);
    assertThat(result.verified, is(true));
    assertThat(result.minimumShouldMatch, equalTo(1));
    List<QueryAnalyzer.QueryExtraction> terms = new ArrayList<>(result.extractions);
    terms.sort(Comparator.comparing(qt -> qt.term));
    assertThat(terms.size(), equalTo(4));
    assertThat(terms.get(0).field(), equalTo(termQuery1.getTerm().field()));
    assertThat(terms.get(0).bytes(), equalTo(termQuery1.getTerm().bytes()));
    assertThat(terms.get(1).field(), equalTo(termQuery2.getTerm().field()));
    assertThat(terms.get(1).bytes(), equalTo(termQuery2.getTerm().bytes()));
    assertThat(terms.get(2).field(), equalTo(termQuery3.getTerm().field()));
    assertThat(terms.get(2).bytes(), equalTo(termQuery3.getTerm().bytes()));
    assertThat(terms.get(3).field(), equalTo(termQuery4.getTerm().field()));
    assertThat(terms.get(3).bytes(), equalTo(termQuery4.getTerm().bytes()));
}

Example 8 with Result

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

the class QueryAnalyzerTests method testExtractQueryMetadata_spanNotQuery.

public void testExtractQueryMetadata_spanNotQuery() {
    SpanTermQuery spanTermQuery1 = new SpanTermQuery(new Term("_field", "_short_term"));
    SpanTermQuery spanTermQuery2 = new SpanTermQuery(new Term("_field", "_very_long_term"));
    SpanNotQuery spanNotQuery = new SpanNotQuery(spanTermQuery1, spanTermQuery2);
    Result result = analyze(spanNotQuery, Version.CURRENT);
    assertThat(result.verified, is(false));
    assertThat(result.minimumShouldMatch, equalTo(1));
    assertTermsEqual(result.extractions, spanTermQuery1.getTerm());
}

Example 9 with Result

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

the class QueryAnalyzerTests method testExtractQueryMetadata_termQuery.

public void testExtractQueryMetadata_termQuery() {
    TermQuery termQuery = new TermQuery(new Term("_field", "_term"));
    Result result = analyze(termQuery, Version.CURRENT);
    assertThat(result.verified, is(true));
    assertThat(result.minimumShouldMatch, equalTo(1));
    List<QueryExtraction> terms = new ArrayList<>(result.extractions);
    assertThat(terms.size(), equalTo(1));
    assertThat(terms.get(0).field(), equalTo(termQuery.getTerm().field()));
    assertThat(terms.get(0).bytes(), equalTo(termQuery.getTerm().bytes()));
}

Example 10 with Result

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

the class QueryAnalyzerTests method testExtractQueryMetadata_unsupportedQueryInBoolQueryWithMustClauses.

public void testExtractQueryMetadata_unsupportedQueryInBoolQueryWithMustClauses() {
    TermRangeQuery unsupportedQuery = new TermRangeQuery("_field", null, null, true, false);
    TermQuery termQuery1 = new TermQuery(new Term("_field", "_term"));
    BooleanQuery.Builder builder = new BooleanQuery.Builder();
    builder.add(termQuery1, BooleanClause.Occur.MUST);
    builder.add(unsupportedQuery, BooleanClause.Occur.MUST);
    BooleanQuery bq1 = builder.build();
    Result result = analyze(bq1, Version.CURRENT);
    assertThat(result.verified, is(false));
    assertThat(result.minimumShouldMatch, equalTo(1));
    assertTermsEqual(result.extractions, termQuery1.getTerm());
    TermQuery termQuery2 = new TermQuery(new Term("_field", "_longer_term"));
    builder = new BooleanQuery.Builder();
    builder.add(termQuery1, BooleanClause.Occur.MUST);
    builder.add(termQuery2, BooleanClause.Occur.MUST);
    builder.add(unsupportedQuery, BooleanClause.Occur.MUST);
    bq1 = builder.build();
    result = analyze(bq1, Version.CURRENT);
    assertThat(result.verified, is(false));
    assertThat(result.minimumShouldMatch, equalTo(2));
    assertTermsEqual(result.extractions, termQuery1.getTerm(), termQuery2.getTerm());
    builder = new BooleanQuery.Builder();
    builder.add(unsupportedQuery, BooleanClause.Occur.MUST);
    builder.add(unsupportedQuery, BooleanClause.Occur.MUST);
    BooleanQuery bq2 = builder.build();
    assertEquals(Result.UNKNOWN, analyze(bq2, Version.CURRENT));
}