Example usage for org.apache.lucene.search BooleanQuery clauses

Introduction

In this page you can find the example usage for org.apache.lucene.search BooleanQuery clauses.

Prototype

List clauses

To view the source code for org.apache.lucene.search BooleanQuery clauses.

Click Source Link

Usage

From source file:org.elasticsearch.common.lucene.search.morelikethis.XMoreLikeThisTests.java

License:Apache License

@Test
public void testTopN() throws Exception {
    int numDocs = 100;
    int topN = 25;

    // add series of docs with terms of decreasing df
    Directory dir = newDirectory();//w  w  w .  jav a 2s.c  o  m
    RandomIndexWriter writer = new RandomIndexWriter(random(), dir);
    for (int i = 0; i < numDocs; i++) {
        addDoc(writer, generateStrSeq(0, i + 1));
    }
    IndexReader reader = writer.getReader();
    writer.close();

    // setup MLT query
    MoreLikeThis mlt = new MoreLikeThis(reader);
    mlt.setAnalyzer(new MockAnalyzer(random(), MockTokenizer.WHITESPACE, false));
    mlt.setMaxQueryTerms(topN);
    mlt.setMinDocFreq(1);
    mlt.setMinTermFreq(1);
    mlt.setMinWordLen(1);
    mlt.setFieldNames(new String[] { "text" });

    // perform MLT query
    String likeText = "";
    for (String text : generateStrSeq(0, numDocs)) {
        likeText += text + " ";
    }
    BooleanQuery query = (BooleanQuery) mlt.like("text", new StringReader(likeText));

    // check best terms are topN of highest idf
    List<BooleanClause> clauses = query.clauses();
    assertEquals("Expected" + topN + "clauses only!", topN, clauses.size());

    Term[] expectedTerms = new Term[topN];
    int idx = 0;
    for (String text : generateStrSeq(numDocs - topN, topN)) {
        expectedTerms[idx++] = new Term("text", text);
    }
    for (BooleanClause clause : clauses) {
        Term term = ((TermQuery) clause.getQuery()).getTerm();
        assertTrue(Arrays.asList(expectedTerms).contains(term));
    }

    // clean up
    reader.close();
    dir.close();
}

---

From source file:org.elasticsearch.common.lucene.search.Queries.java

License:Apache License

public static void applyMinimumShouldMatch(BooleanQuery query, @Nullable String minimumShouldMatch) {
    if (minimumShouldMatch == null) {
        return;//from  www .  ja v  a 2s . c om
    }
    int optionalClauses = 0;
    for (BooleanClause c : query.clauses()) {
        if (c.getOccur() == BooleanClause.Occur.SHOULD) {
            optionalClauses++;
        }
    }

    int msm = calculateMinShouldMatch(optionalClauses, minimumShouldMatch);
    if (0 < msm) {
        query.setMinimumNumberShouldMatch(msm);
    }
}

---

From source file:org.elasticsearch.index.percolator.ExtractQueryTermsServiceTests.java

License:Apache License

public void testCreateQueryMetadataQuery() throws Exception {
    MemoryIndex memoryIndex = new MemoryIndex(false);
    memoryIndex.addField("field1", "the quick brown fox jumps over the lazy dog", new WhitespaceAnalyzer());
    memoryIndex.addField("field2", "some more text", new WhitespaceAnalyzer());
    memoryIndex.addField("_field3", "unhide me", new WhitespaceAnalyzer());
    memoryIndex.addField("field4", "123", new WhitespaceAnalyzer());

    IndexReader indexReader = memoryIndex.createSearcher().getIndexReader();
    Query query = ExtractQueryTermsService.createQueryTermsQuery(indexReader, QUERY_TERMS_FIELD,
            UNKNOWN_QUERY_FIELD);
    assertThat(query, instanceOf(TermsQuery.class));

    // no easy way to get to the terms in TermsQuery,
    // if there a less then 16 terms then it gets rewritten to bq and then we can easily check the terms
    BooleanQuery booleanQuery = (BooleanQuery) ((ConstantScoreQuery) query.rewrite(indexReader)).getQuery();
    assertThat(booleanQuery.clauses().size(), equalTo(15));
    assertClause(booleanQuery, 0, QUERY_TERMS_FIELD, "_field3\u0000me");
    assertClause(booleanQuery, 1, QUERY_TERMS_FIELD, "_field3\u0000unhide");
    assertClause(booleanQuery, 2, QUERY_TERMS_FIELD, "field1\u0000brown");
    assertClause(booleanQuery, 3, QUERY_TERMS_FIELD, "field1\u0000dog");
    assertClause(booleanQuery, 4, QUERY_TERMS_FIELD, "field1\u0000fox");
    assertClause(booleanQuery, 5, QUERY_TERMS_FIELD, "field1\u0000jumps");
    assertClause(booleanQuery, 6, QUERY_TERMS_FIELD, "field1\u0000lazy");
    assertClause(booleanQuery, 7, QUERY_TERMS_FIELD, "field1\u0000over");
    assertClause(booleanQuery, 8, QUERY_TERMS_FIELD, "field1\u0000quick");
    assertClause(booleanQuery, 9, QUERY_TERMS_FIELD, "field1\u0000the");
    assertClause(booleanQuery, 10, QUERY_TERMS_FIELD, "field2\u0000more");
    assertClause(booleanQuery, 11, QUERY_TERMS_FIELD, "field2\u0000some");
    assertClause(booleanQuery, 12, QUERY_TERMS_FIELD, "field2\u0000text");
    assertClause(booleanQuery, 13, QUERY_TERMS_FIELD, "field4\u0000123");
    assertClause(booleanQuery, 14, UNKNOWN_QUERY_FIELD, "");
}

---

From source file:org.elasticsearch.index.percolator.ExtractQueryTermsServiceTests.java

License:Apache License

private void assertClause(BooleanQuery booleanQuery, int i, String expectedField, String expectedValue) {
    assertThat(booleanQuery.clauses().get(i).getOccur(), equalTo(BooleanClause.Occur.SHOULD));
    assertThat(((TermQuery) booleanQuery.clauses().get(i).getQuery()).getTerm().field(),
            equalTo(expectedField));/*from w w  w  .jav a 2  s .co m*/
    assertThat(((TermQuery) booleanQuery.clauses().get(i).getQuery()).getTerm().bytes().utf8ToString(),
            equalTo(expectedValue));
}

---

From source file:org.elasticsearch.index.query.BoolQueryBuilderTests.java

License:Apache License

@Override
protected void doAssertLuceneQuery(BoolQueryBuilder queryBuilder, Query query, QueryShardContext context)
        throws IOException {
    if (!queryBuilder.hasClauses()) {
        assertThat(query, instanceOf(MatchAllDocsQuery.class));
    } else {/*  w w w  . j a  v a  2  s. com*/
        List<BooleanClause> clauses = new ArrayList<>();
        clauses.addAll(getBooleanClauses(queryBuilder.must(), BooleanClause.Occur.MUST, context));
        clauses.addAll(getBooleanClauses(queryBuilder.mustNot(), BooleanClause.Occur.MUST_NOT, context));
        clauses.addAll(getBooleanClauses(queryBuilder.should(), BooleanClause.Occur.SHOULD, context));
        clauses.addAll(getBooleanClauses(queryBuilder.filter(), BooleanClause.Occur.FILTER, context));

        if (clauses.isEmpty()) {
            assertThat(query, instanceOf(MatchAllDocsQuery.class));
        } else {
            assertThat(query, instanceOf(BooleanQuery.class));
            BooleanQuery booleanQuery = (BooleanQuery) query;
            assertThat(booleanQuery.isCoordDisabled(), equalTo(queryBuilder.disableCoord()));
            if (queryBuilder.adjustPureNegative()) {
                boolean isNegative = true;
                for (BooleanClause clause : clauses) {
                    if (clause.isProhibited() == false) {
                        isNegative = false;
                        break;
                    }
                }
                if (isNegative) {
                    clauses.add(new BooleanClause(new MatchAllDocsQuery(), BooleanClause.Occur.MUST));
                }
            }
            assertThat(booleanQuery.clauses().size(), equalTo(clauses.size()));
            Iterator<BooleanClause> clauseIterator = clauses.iterator();
            for (BooleanClause booleanClause : booleanQuery.clauses()) {
                assertThat(booleanClause, instanceOf(clauseIterator.next().getClass()));
            }
        }
    }
}

---

From source file:org.elasticsearch.index.query.BoolQueryBuilderTests.java

License:Apache License

public void testMinShouldMatchFilterWithoutShouldClauses() throws Exception {
    BoolQueryBuilder boolQueryBuilder = new BoolQueryBuilder();
    boolQueryBuilder.filter(new BoolQueryBuilder().must(new MatchAllQueryBuilder()));
    Query query = boolQueryBuilder.toQuery(createShardContext());
    assertThat(query, instanceOf(BooleanQuery.class));
    BooleanQuery booleanQuery = (BooleanQuery) query;
    assertThat(booleanQuery.getMinimumNumberShouldMatch(), equalTo(0));
    assertThat(booleanQuery.clauses().size(), equalTo(1));
    BooleanClause booleanClause = booleanQuery.clauses().get(0);
    assertThat(booleanClause.getOccur(), equalTo(BooleanClause.Occur.FILTER));
    assertThat(booleanClause.getQuery(), instanceOf(BooleanQuery.class));
    BooleanQuery innerBooleanQuery = (BooleanQuery) booleanClause.getQuery();
    //we didn't set minimum should match initially, there are no should clauses so it should be 0
    assertThat(innerBooleanQuery.getMinimumNumberShouldMatch(), equalTo(0));
    assertThat(innerBooleanQuery.clauses().size(), equalTo(1));
    BooleanClause innerBooleanClause = innerBooleanQuery.clauses().get(0);
    assertThat(innerBooleanClause.getOccur(), equalTo(BooleanClause.Occur.MUST));
    assertThat(innerBooleanClause.getQuery(), instanceOf(MatchAllDocsQuery.class));
}

---

From source file:org.elasticsearch.index.query.BoolQueryBuilderTests.java

License:Apache License

public void testMinShouldMatchFilterWithShouldClauses() throws Exception {
    BoolQueryBuilder boolQueryBuilder = new BoolQueryBuilder();
    boolQueryBuilder/*from   w  ww  . j a  va 2s . co m*/
            .filter(new BoolQueryBuilder().must(new MatchAllQueryBuilder()).should(new MatchAllQueryBuilder()));
    Query query = boolQueryBuilder.toQuery(createShardContext());
    assertThat(query, instanceOf(BooleanQuery.class));
    BooleanQuery booleanQuery = (BooleanQuery) query;
    assertThat(booleanQuery.getMinimumNumberShouldMatch(), equalTo(0));
    assertThat(booleanQuery.clauses().size(), equalTo(1));
    BooleanClause booleanClause = booleanQuery.clauses().get(0);
    assertThat(booleanClause.getOccur(), equalTo(BooleanClause.Occur.FILTER));
    assertThat(booleanClause.getQuery(), instanceOf(BooleanQuery.class));
    BooleanQuery innerBooleanQuery = (BooleanQuery) booleanClause.getQuery();
    //we didn't set minimum should match initially, but there are should clauses so it should be 1
    assertThat(innerBooleanQuery.getMinimumNumberShouldMatch(), equalTo(1));
    assertThat(innerBooleanQuery.clauses().size(), equalTo(2));
    BooleanClause innerBooleanClause1 = innerBooleanQuery.clauses().get(0);
    assertThat(innerBooleanClause1.getOccur(), equalTo(BooleanClause.Occur.MUST));
    assertThat(innerBooleanClause1.getQuery(), instanceOf(MatchAllDocsQuery.class));
    BooleanClause innerBooleanClause2 = innerBooleanQuery.clauses().get(1);
    assertThat(innerBooleanClause2.getOccur(), equalTo(BooleanClause.Occur.SHOULD));
    assertThat(innerBooleanClause2.getQuery(), instanceOf(MatchAllDocsQuery.class));
}

---

From source file:org.elasticsearch.index.query.ExistsQueryBuilderTests.java

License:Apache License

@Override
protected void doAssertLuceneQuery(ExistsQueryBuilder queryBuilder, Query query, QueryShardContext context)
        throws IOException {
    String fieldPattern = queryBuilder.fieldName();
    Collection<String> fields = context.simpleMatchToIndexNames(fieldPattern);
    if (getCurrentTypes().length == 0) {
        assertThat(query, instanceOf(MatchNoDocsQuery.class));
        MatchNoDocsQuery matchNoDocsQuery = (MatchNoDocsQuery) query;
        assertThat(matchNoDocsQuery.toString(null), containsString("Missing types in \"exists\" query."));
    } else {/*from   w w w.ja v  a  2s  .  co m*/
        assertThat(query, instanceOf(ConstantScoreQuery.class));
        ConstantScoreQuery constantScoreQuery = (ConstantScoreQuery) query;
        assertThat(constantScoreQuery.getQuery(), instanceOf(BooleanQuery.class));
        BooleanQuery booleanQuery = (BooleanQuery) constantScoreQuery.getQuery();
        assertThat(booleanQuery.clauses().size(), equalTo(fields.size()));
        for (int i = 0; i < fields.size(); i++) {
            BooleanClause booleanClause = booleanQuery.clauses().get(i);
            assertThat(booleanClause.getOccur(), equalTo(BooleanClause.Occur.SHOULD));
        }
    }
}

---

From source file:org.elasticsearch.index.query.GeoBoundingBoxQueryBuilderTests.java

License:Apache License

public void testNormalization() throws IOException {
    assumeTrue("test runs only when at least a type is registered", getCurrentTypes().length > 0);
    GeoBoundingBoxQueryBuilder qb = createTestQueryBuilder();
    if (getCurrentTypes().length != 0 && "mapped_geo".equals(qb.fieldName())) {
        // only execute this test if we are running on a valid geo field
        qb.setCorners(200, 200, qb.bottomRight().getLat(), qb.bottomRight().getLon());
        qb.setValidationMethod(GeoValidationMethod.COERCE);
        Query query = qb.toQuery(createShardContext());
        if (query instanceof ConstantScoreQuery) {
            ConstantScoreQuery result = (ConstantScoreQuery) query;
            BooleanQuery bboxFilter = (BooleanQuery) result.getQuery();
            for (BooleanClause clause : bboxFilter.clauses()) {
                LegacyNumericRangeQuery boundary = (LegacyNumericRangeQuery) clause.getQuery();
                if (boundary.getMax() != null) {
                    assertTrue("If defined, non of the maximum range values should be larger than 180",
                            boundary.getMax().intValue() <= 180);
                }/*from   ww w  .  j a va  2s . com*/
            }
        } else {
            assertTrue("memory queries should result in LegacyInMemoryGeoBoundingBoxQuery",
                    query instanceof LegacyInMemoryGeoBoundingBoxQuery);
        }
    }
}

---

From source file:org.elasticsearch.index.query.HasChildQueryBuilderTests.java

License:Apache License

static void assertLateParsingQuery(Query query, String type, String id) throws IOException {
    assertThat(query, instanceOf(HasChildQueryBuilder.LateParsingQuery.class));
    HasChildQueryBuilder.LateParsingQuery lateParsingQuery = (HasChildQueryBuilder.LateParsingQuery) query;
    assertThat(lateParsingQuery.getInnerQuery(), instanceOf(BooleanQuery.class));
    BooleanQuery booleanQuery = (BooleanQuery) lateParsingQuery.getInnerQuery();
    assertThat(booleanQuery.clauses().size(), equalTo(2));
    //check the inner ids query, we have to call rewrite to get to check the type it's executed against
    assertThat(booleanQuery.clauses().get(0).getOccur(), equalTo(BooleanClause.Occur.MUST));
    assertThat(booleanQuery.clauses().get(0).getQuery(), instanceOf(TermsQuery.class));
    TermsQuery termsQuery = (TermsQuery) booleanQuery.clauses().get(0).getQuery();
    Query rewrittenTermsQuery = termsQuery.rewrite(null);
    assertThat(rewrittenTermsQuery, instanceOf(ConstantScoreQuery.class));
    ConstantScoreQuery constantScoreQuery = (ConstantScoreQuery) rewrittenTermsQuery;
    assertThat(constantScoreQuery.getQuery(), instanceOf(BooleanQuery.class));
    BooleanQuery booleanTermsQuery = (BooleanQuery) constantScoreQuery.getQuery();
    assertThat(booleanTermsQuery.clauses().toString(), booleanTermsQuery.clauses().size(), equalTo(1));
    assertThat(booleanTermsQuery.clauses().get(0).getOccur(), equalTo(BooleanClause.Occur.SHOULD));
    assertThat(booleanTermsQuery.clauses().get(0).getQuery(), instanceOf(TermQuery.class));
    TermQuery termQuery = (TermQuery) booleanTermsQuery.clauses().get(0).getQuery();
    assertThat(termQuery.getTerm().field(), equalTo(UidFieldMapper.NAME));
    //we want to make sure that the inner ids query gets executed against the child type rather than the main type we initially set to the context
    BytesRef[] ids = Uid.createUidsForTypesAndIds(Collections.singletonList(type),
            Collections.singletonList(id));
    assertThat(termQuery.getTerm().bytes(), equalTo(ids[0]));
    //check the type filter
    assertThat(booleanQuery.clauses().get(1).getOccur(), equalTo(BooleanClause.Occur.FILTER));
    assertEquals(new TypeFieldMapper.TypeQuery(new BytesRef(type)), booleanQuery.clauses().get(1).getQuery());
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• »