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

Example 1 with Result

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

the class QueryAnalyzerTests method testExtractQueryMetadata_spanOrQuery.

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

Example 2 with Result

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

the class QueryAnalyzerTests method testExtractQueryMetadata_duplicatedClauses.

public void testExtractQueryMetadata_duplicatedClauses() {
    BooleanQuery.Builder builder = new BooleanQuery.Builder();
    builder.add(new BooleanQuery.Builder().add(new TermQuery(new Term("field", "value1")), BooleanClause.Occur.MUST).add(new TermQuery(new Term("field", "value2")), BooleanClause.Occur.MUST).build(), BooleanClause.Occur.MUST);
    builder.add(new BooleanQuery.Builder().add(new TermQuery(new Term("field", "value2")), BooleanClause.Occur.MUST).add(new TermQuery(new Term("field", "value3")), BooleanClause.Occur.MUST).build(), BooleanClause.Occur.MUST);
    builder.add(new BooleanQuery.Builder().add(new TermQuery(new Term("field", "value3")), BooleanClause.Occur.MUST).add(new TermQuery(new Term("field", "value4")), BooleanClause.Occur.MUST).build(), BooleanClause.Occur.MUST);
    Result result = analyze(builder.build(), Version.CURRENT);
    assertThat(result.verified, is(false));
    assertThat(result.matchAllDocs, is(false));
    assertThat(result.minimumShouldMatch, equalTo(4));
    assertTermsEqual(result.extractions, new Term("field", "value1"), new Term("field", "value2"), new Term("field", "value3"), new Term("field", "value4"));
    builder = new BooleanQuery.Builder().setMinimumNumberShouldMatch(2);
    builder.add(new BooleanQuery.Builder().add(new TermQuery(new Term("field", "value1")), BooleanClause.Occur.MUST).add(new TermQuery(new Term("field", "value2")), BooleanClause.Occur.MUST).build(), BooleanClause.Occur.SHOULD);
    builder.add(new BooleanQuery.Builder().add(new TermQuery(new Term("field", "value2")), BooleanClause.Occur.MUST).add(new TermQuery(new Term("field", "value3")), BooleanClause.Occur.MUST).build(), BooleanClause.Occur.SHOULD);
    builder.add(new BooleanQuery.Builder().add(new TermQuery(new Term("field", "value3")), BooleanClause.Occur.MUST).add(new TermQuery(new Term("field", "value4")), BooleanClause.Occur.MUST).build(), BooleanClause.Occur.SHOULD);
    result = analyze(builder.build(), Version.CURRENT);
    assertThat(result.verified, is(false));
    assertThat(result.matchAllDocs, is(false));
    assertThat(result.minimumShouldMatch, equalTo(2));
    assertTermsEqual(result.extractions, new Term("field", "value1"), new Term("field", "value2"), new Term("field", "value3"), new Term("field", "value4"));
}

Example 3 with Result

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

the class QueryAnalyzerTests method testExtractQueryMetadata_commonTermsQuery.

public void testExtractQueryMetadata_commonTermsQuery() {
    CommonTermsQuery commonTermsQuery = new CommonTermsQuery(BooleanClause.Occur.SHOULD, BooleanClause.Occur.SHOULD, 100);
    commonTermsQuery.add(new Term("_field", "_term1"));
    commonTermsQuery.add(new Term("_field", "_term2"));
    Result result = analyze(commonTermsQuery, Version.CURRENT);
    assertThat(result.verified, is(false));
    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(result.minimumShouldMatch, equalTo(1));
    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 4 with Result

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

the class QueryAnalyzerTests method testPointRangeQuery.

public void testPointRangeQuery() {
    // int ranges get converted to long ranges:
    Query query = IntPoint.newRangeQuery("_field", 10, 20);
    Result result = analyze(query, Version.CURRENT);
    assertFalse(result.verified);
    assertThat(result.minimumShouldMatch, equalTo(1));
    List<QueryAnalyzer.QueryExtraction> ranges = new ArrayList<>(result.extractions);
    assertThat(ranges.size(), equalTo(1));
    assertNull(ranges.get(0).term);
    assertEquals("_field", ranges.get(0).range.fieldName);
    assertDimension(ranges.get(0).range.lowerPoint, bytes -> IntPoint.encodeDimension(10, bytes, 0));
    assertDimension(ranges.get(0).range.upperPoint, bytes -> IntPoint.encodeDimension(20, bytes, 0));
    query = LongPoint.newRangeQuery("_field", 10L, 21L);
    result = analyze(query, Version.CURRENT);
    assertThat(result.minimumShouldMatch, equalTo(1));
    assertFalse(result.verified);
    ranges = new ArrayList<>(result.extractions);
    assertThat(ranges.size(), equalTo(1));
    assertNull(ranges.get(0).term);
    assertEquals("_field", ranges.get(0).range.fieldName);
    assertDimension(ranges.get(0).range.lowerPoint, bytes -> LongPoint.encodeDimension(10L, bytes, 0));
    assertDimension(ranges.get(0).range.upperPoint, bytes -> LongPoint.encodeDimension(21L, bytes, 0));
    // Half float ranges get converted to double ranges:
    query = HalfFloatPoint.newRangeQuery("_field", 10F, 20F);
    result = analyze(query, Version.CURRENT);
    assertThat(result.minimumShouldMatch, equalTo(1));
    assertFalse(result.verified);
    ranges = new ArrayList<>(result.extractions);
    assertThat(ranges.size(), equalTo(1));
    assertNull(ranges.get(0).term);
    assertEquals("_field", ranges.get(0).range.fieldName);
    assertDimension(ranges.get(0).range.lowerPoint, bytes -> HalfFloatPoint.encodeDimension(10F, bytes, 0));
    assertDimension(ranges.get(0).range.upperPoint, bytes -> HalfFloatPoint.encodeDimension(20F, bytes, 0));
    // Float ranges get converted to double ranges:
    query = FloatPoint.newRangeQuery("_field", 10F, 20F);
    result = analyze(query, Version.CURRENT);
    assertThat(result.minimumShouldMatch, equalTo(1));
    assertFalse(result.verified);
    ranges = new ArrayList<>(result.extractions);
    assertThat(ranges.size(), equalTo(1));
    assertNull(ranges.get(0).term);
    assertEquals("_field", ranges.get(0).range.fieldName);
    assertDimension(ranges.get(0).range.lowerPoint, bytes -> FloatPoint.encodeDimension(10F, bytes, 0));
    assertDimension(ranges.get(0).range.upperPoint, bytes -> FloatPoint.encodeDimension(20F, bytes, 0));
    query = DoublePoint.newRangeQuery("_field", 10D, 20D);
    result = analyze(query, Version.CURRENT);
    assertThat(result.minimumShouldMatch, equalTo(1));
    assertFalse(result.verified);
    ranges = new ArrayList<>(result.extractions);
    assertThat(ranges.size(), equalTo(1));
    assertNull(ranges.get(0).term);
    assertEquals("_field", ranges.get(0).range.fieldName);
    assertDimension(ranges.get(0).range.lowerPoint, bytes -> DoublePoint.encodeDimension(10D, bytes, 0));
    assertDimension(ranges.get(0).range.upperPoint, bytes -> DoublePoint.encodeDimension(20D, bytes, 0));
    query = InetAddressPoint.newRangeQuery("_field", InetAddresses.forString("192.168.1.0"), InetAddresses.forString("192.168.1.255"));
    result = analyze(query, Version.CURRENT);
    assertThat(result.minimumShouldMatch, equalTo(1));
    assertFalse(result.verified);
    ranges = new ArrayList<>(result.extractions);
    assertThat(ranges.size(), equalTo(1));
    assertNull(ranges.get(0).term);
    assertEquals("_field", ranges.get(0).range.fieldName);
    assertArrayEquals(ranges.get(0).range.lowerPoint, InetAddressPoint.encode(InetAddresses.forString("192.168.1.0")));
    assertArrayEquals(ranges.get(0).range.upperPoint, InetAddressPoint.encode(InetAddresses.forString("192.168.1.255")));
}

Example 5 with Result

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

the class QueryAnalyzerTests method testExtractQueryMetadata_booleanQuery.

public void testExtractQueryMetadata_booleanQuery() {
    BooleanQuery.Builder builder = new BooleanQuery.Builder();
    TermQuery termQuery1 = new TermQuery(new Term("_field", "term0"));
    builder.add(termQuery1, BooleanClause.Occur.SHOULD);
    PhraseQuery phraseQuery = new PhraseQuery("_field", "term1", "term2");
    builder.add(phraseQuery, BooleanClause.Occur.SHOULD);
    BooleanQuery.Builder subBuilder = new BooleanQuery.Builder();
    TermQuery termQuery2 = new TermQuery(new Term("_field1", "term4"));
    subBuilder.add(termQuery2, BooleanClause.Occur.MUST);
    TermQuery termQuery3 = new TermQuery(new Term("_field3", "term5"));
    subBuilder.add(termQuery3, BooleanClause.Occur.MUST);
    builder.add(subBuilder.build(), BooleanClause.Occur.SHOULD);
    BooleanQuery booleanQuery = builder.build();
    Result result = analyze(booleanQuery, Version.CURRENT);
    assertThat("Should clause with phrase query isn't verified, so entire query can't be verified", result.verified, is(false));
    assertThat(result.minimumShouldMatch, equalTo(1));
    List<QueryExtraction> terms = new ArrayList<>(result.extractions);
    terms.sort(Comparator.comparing(qt -> qt.term));
    assertThat(terms.size(), equalTo(5));
    assertThat(terms.get(0).field(), equalTo(termQuery1.getTerm().field()));
    assertThat(terms.get(0).bytes(), equalTo(termQuery1.getTerm().bytes()));
    assertThat(terms.get(1).field(), equalTo(phraseQuery.getTerms()[0].field()));
    assertThat(terms.get(1).bytes(), equalTo(phraseQuery.getTerms()[0].bytes()));
    assertThat(terms.get(2).field(), equalTo(phraseQuery.getTerms()[1].field()));
    assertThat(terms.get(2).bytes(), equalTo(phraseQuery.getTerms()[1].bytes()));
    assertThat(terms.get(3).field(), equalTo(termQuery2.getTerm().field()));
    assertThat(terms.get(3).bytes(), equalTo(termQuery2.getTerm().bytes()));
    assertThat(terms.get(4).field(), equalTo(termQuery3.getTerm().field()));
    assertThat(terms.get(4).bytes(), equalTo(termQuery3.getTerm().bytes()));
}