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.index.query.json.SimpleJsonIndexQueryParserTests.java

License:Apache License

@Test
public void testQueryStringFields1Builder() throws Exception {
    IndexQueryParser queryParser = newQueryParser();
    Query parsedQuery = queryParser.parse(queryString("test").field("content").field("name").useDisMax(false));
    assertThat(parsedQuery, instanceOf(BooleanQuery.class));
    BooleanQuery bQuery = (BooleanQuery) parsedQuery;
    assertThat(bQuery.clauses().size(), equalTo(2));
    assertThat(((TermQuery) bQuery.clauses().get(0).getQuery()).getTerm(),
            equalTo(new Term("content", "test")));
    assertThat(((TermQuery) bQuery.clauses().get(1).getQuery()).getTerm(), equalTo(new Term("name", "test")));
}

---

From source file:org.elasticsearch.index.query.json.SimpleJsonIndexQueryParserTests.java

License:Apache License

@Test
public void testQueryStringFields1() throws Exception {
    IndexQueryParser queryParser = newQueryParser();
    String query = copyToStringFromClasspath("/org/elasticsearch/index/query/json/query-fields1.json");
    Query parsedQuery = queryParser.parse(query);
    assertThat(parsedQuery, instanceOf(BooleanQuery.class));
    BooleanQuery bQuery = (BooleanQuery) parsedQuery;
    assertThat(bQuery.clauses().size(), equalTo(2));
    assertThat(((TermQuery) bQuery.clauses().get(0).getQuery()).getTerm(),
            equalTo(new Term("content", "test")));
    assertThat(((TermQuery) bQuery.clauses().get(1).getQuery()).getTerm(), equalTo(new Term("name", "test")));
}

---

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

License:Apache License

@Override
protected void doAssertLuceneQuery(MatchQueryBuilder queryBuilder, Query query, QueryShardContext context)
        throws IOException {
    assertThat(query, notNullValue());/*from  w  w  w.  j  ava 2 s. com*/

    if (query instanceof MatchAllDocsQuery) {
        assertThat(queryBuilder.zeroTermsQuery(), equalTo(ZeroTermsQuery.ALL));
        return;
    }

    switch (queryBuilder.type()) {
    case BOOLEAN:
        assertThat(query,
                either(instanceOf(BooleanQuery.class)).or(instanceOf(ExtendedCommonTermsQuery.class))
                        .or(instanceOf(TermQuery.class)).or(instanceOf(FuzzyQuery.class))
                        .or(instanceOf(MatchNoDocsQuery.class)).or(instanceOf(PointRangeQuery.class)));
        break;
    case PHRASE:
        assertThat(query,
                either(instanceOf(BooleanQuery.class)).or(instanceOf(PhraseQuery.class))
                        .or(instanceOf(TermQuery.class)).or(instanceOf(FuzzyQuery.class))
                        .or(instanceOf(PointRangeQuery.class)));
        break;
    case PHRASE_PREFIX:
        assertThat(query,
                either(instanceOf(BooleanQuery.class)).or(instanceOf(MultiPhrasePrefixQuery.class))
                        .or(instanceOf(TermQuery.class)).or(instanceOf(FuzzyQuery.class))
                        .or(instanceOf(PointRangeQuery.class)));
        break;
    }

    MappedFieldType fieldType = context.fieldMapper(queryBuilder.fieldName());
    if (query instanceof TermQuery && fieldType != null) {
        String queryValue = queryBuilder.value().toString();
        if (queryBuilder.analyzer() == null || queryBuilder.analyzer().equals("simple")) {
            queryValue = queryValue.toLowerCase(Locale.ROOT);
        }
        Query expectedTermQuery = fieldType.termQuery(queryValue, context);
        assertEquals(expectedTermQuery, query);
    }

    if (query instanceof BooleanQuery) {
        BooleanQuery bq = (BooleanQuery) query;
        if (queryBuilder.minimumShouldMatch() != null) {
            // calculate expected minimumShouldMatch value
            int optionalClauses = 0;
            for (BooleanClause c : bq.clauses()) {
                if (c.getOccur() == BooleanClause.Occur.SHOULD) {
                    optionalClauses++;
                }
            }
            int msm = Queries.calculateMinShouldMatch(optionalClauses, queryBuilder.minimumShouldMatch());
            assertThat(bq.getMinimumNumberShouldMatch(), equalTo(msm));
        }
        if (queryBuilder.analyzer() == null && queryBuilder.value().toString().length() > 0) {
            assertEquals(bq.clauses().size(), queryBuilder.value().toString().split(" ").length);
        }
    }

    if (query instanceof ExtendedCommonTermsQuery) {
        assertTrue(queryBuilder.cutoffFrequency() != null);
        ExtendedCommonTermsQuery ectq = (ExtendedCommonTermsQuery) query;
        assertEquals(queryBuilder.cutoffFrequency(), ectq.getMaxTermFrequency(), Float.MIN_VALUE);
    }

    if (query instanceof FuzzyQuery) {
        assertTrue(queryBuilder.fuzziness() != null);
        FuzzyQuery fuzzyQuery = (FuzzyQuery) query;
        // depending on analyzer being set or not we can have term lowercased along the way, so to simplify test we just
        // compare lowercased terms here
        String originalTermLc = queryBuilder.value().toString().toLowerCase(Locale.ROOT);
        String actualTermLc = fuzzyQuery.getTerm().text().toLowerCase(Locale.ROOT);
        Matcher<String> termLcMatcher = equalTo(originalTermLc);
        if ("false".equals(originalTermLc) || "true".equals(originalTermLc)) {
            // Booleans become t/f when querying a boolean field
            termLcMatcher = either(termLcMatcher).or(equalTo(originalTermLc.substring(0, 1)));
        }
        assertThat(actualTermLc, termLcMatcher);
        assertThat(queryBuilder.prefixLength(), equalTo(fuzzyQuery.getPrefixLength()));
        assertThat(queryBuilder.fuzzyTranspositions(), equalTo(fuzzyQuery.getTranspositions()));
    }

    if (query instanceof PointRangeQuery) {
        // TODO
    }
}

---

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

License:Apache License

public void testToQueryMultipleTermsBooleanQuery() throws Exception {
    assumeTrue("test runs only when at least a type is registered", getCurrentTypes().length > 0);
    Query query = multiMatchQuery("test1 test2").field(STRING_FIELD_NAME).useDisMax(false)
            .toQuery(createShardContext());
    assertThat(query, instanceOf(BooleanQuery.class));
    BooleanQuery bQuery = (BooleanQuery) query;
    assertThat(bQuery.clauses().size(), equalTo(2));
    assertThat(assertBooleanSubQuery(query, TermQuery.class, 0).getTerm(),
            equalTo(new Term(STRING_FIELD_NAME, "test1")));
    assertThat(assertBooleanSubQuery(query, TermQuery.class, 1).getTerm(),
            equalTo(new Term(STRING_FIELD_NAME, "test2")));
}

---

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

License:Apache License

public void testToQueryMultipleFieldsBooleanQuery() throws Exception {
    assumeTrue("test runs only when at least a type is registered", getCurrentTypes().length > 0);
    Query query = multiMatchQuery("test").field(STRING_FIELD_NAME).field(STRING_FIELD_NAME_2).useDisMax(false)
            .toQuery(createShardContext());
    assertThat(query, instanceOf(BooleanQuery.class));
    BooleanQuery bQuery = (BooleanQuery) query;
    assertThat(bQuery.clauses().size(), equalTo(2));
    assertThat(assertBooleanSubQuery(query, TermQuery.class, 0).getTerm(),
            equalTo(new Term(STRING_FIELD_NAME, "test")));
    assertThat(assertBooleanSubQuery(query, TermQuery.class, 1).getTerm(),
            equalTo(new Term(STRING_FIELD_NAME_2, "test")));
}

---

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

License:Apache License

public void testToQueryFieldsWildcard() throws Exception {
    assumeTrue("test runs only when at least a type is registered", getCurrentTypes().length > 0);
    Query query = multiMatchQuery("test").field("mapped_str*").useDisMax(false).toQuery(createShardContext());
    assertThat(query, instanceOf(BooleanQuery.class));
    BooleanQuery bQuery = (BooleanQuery) query;
    assertThat(bQuery.clauses().size(), equalTo(2));
    assertThat(assertBooleanSubQuery(query, TermQuery.class, 0).getTerm(),
            equalTo(new Term(STRING_FIELD_NAME, "test")));
    assertThat(assertBooleanSubQuery(query, TermQuery.class, 1).getTerm(),
            equalTo(new Term(STRING_FIELD_NAME_2, "test")));
}

---

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

License:Apache License

@Override
protected void doAssertLuceneQuery(NotQueryBuilder queryBuilder, Query query, QueryShardContext context)
        throws IOException {
    Query filter = queryBuilder.innerQuery().toQuery(context);
    if (filter == null) {
        assertThat(query, nullValue());//from  w  ww  .j av  a  2s  .co  m
    } else {
        assertThat(query, instanceOf(BooleanQuery.class));
        BooleanQuery booleanQuery = (BooleanQuery) query;
        assertThat(booleanQuery.clauses().size(), equalTo(2));
        assertThat(booleanQuery.clauses().get(0).getOccur(), equalTo(BooleanClause.Occur.MUST));
        assertThat(booleanQuery.clauses().get(0).getQuery(), instanceOf(MatchAllDocsQuery.class));
        assertThat(booleanQuery.clauses().get(1).getOccur(), equalTo(BooleanClause.Occur.MUST_NOT));
        assertThat(booleanQuery.clauses().get(1).getQuery(), instanceOf(filter.getClass()));
    }
}

---

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

License:Apache License

@Override
protected void doAssertLuceneQuery(ParentIdQueryBuilder queryBuilder, Query query, QueryShardContext context)
        throws IOException {
    assertThat(query, Matchers.instanceOf(BooleanQuery.class));
    BooleanQuery booleanQuery = (BooleanQuery) query;
    assertThat(booleanQuery.clauses().size(), Matchers.equalTo(2));
    DocValuesTermsQuery idQuery = (DocValuesTermsQuery) booleanQuery.clauses().get(0).getQuery();
    // there are no getters to get the field and terms on DocValuesTermsQuery, so lets validate by creating a
    // new query based on the builder:
    assertThat(idQuery,//  ww w.j a v  a  2s.  com
            Matchers.equalTo(new DocValuesTermsQuery("_parent#" + PARENT_TYPE, queryBuilder.getId())));

    TermQuery typeQuery = (TermQuery) booleanQuery.clauses().get(1).getQuery();
    assertThat(typeQuery.getTerm().field(), Matchers.equalTo(TypeFieldMapper.NAME));
    assertThat(typeQuery.getTerm().text(), Matchers.equalTo(queryBuilder.getType()));
}

---

From source file:org.elasticsearch.index.query.plugin.CustomQueryParserIT.java

License:Apache License

@Test //see #11120
public void testBooleanParsesFilter() throws Exception {
    IndexQueryParserService queryParser = queryParser();
    // single clause, serialized as inner object
    Query q = queryParser.parse(boolQuery().should(new DummyQueryParserPlugin.DummyQueryBuilder())
            .must(new DummyQueryParserPlugin.DummyQueryBuilder())
            .filter(new DummyQueryParserPlugin.DummyQueryBuilder())
            .mustNot(new DummyQueryParserPlugin.DummyQueryBuilder())).query();
    assertThat(q, instanceOf(BooleanQuery.class));
    BooleanQuery bq = (BooleanQuery) q;
    assertEquals(4, bq.clauses().size());
    for (BooleanClause clause : bq.clauses()) {
        DummyQueryParserPlugin.DummyQuery dummy = (DummyQueryParserPlugin.DummyQuery) clause.getQuery();
        switch (clause.getOccur()) {
        case FILTER:
        case MUST_NOT:
            assertEquals(true, dummy.isFilter);
            break;
        case MUST:
        case SHOULD:
            assertEquals(false, dummy.isFilter);
            break;
        default://from   www  .j  a va  2  s . c o m
            throw new AssertionError();
        }
    }

    // multiple clauses, serialized as inner arrays
    q = queryParser.parse(boolQuery().should(new DummyQueryParserPlugin.DummyQueryBuilder())
            .should(new DummyQueryParserPlugin.DummyQueryBuilder())
            .must(new DummyQueryParserPlugin.DummyQueryBuilder())
            .must(new DummyQueryParserPlugin.DummyQueryBuilder())
            .filter(new DummyQueryParserPlugin.DummyQueryBuilder())
            .filter(new DummyQueryParserPlugin.DummyQueryBuilder())
            .mustNot(new DummyQueryParserPlugin.DummyQueryBuilder())
            .mustNot(new DummyQueryParserPlugin.DummyQueryBuilder())).query();
    assertThat(q, instanceOf(BooleanQuery.class));
    bq = (BooleanQuery) q;
    assertEquals(8, bq.clauses().size());
    for (BooleanClause clause : bq.clauses()) {
        DummyQueryParserPlugin.DummyQuery dummy = (DummyQueryParserPlugin.DummyQuery) clause.getQuery();
        switch (clause.getOccur()) {
        case FILTER:
        case MUST_NOT:
            assertEquals(true, dummy.isFilter);
            break;
        case MUST:
        case SHOULD:
            assertEquals(false, dummy.isFilter);
            break;
        default:
            throw new AssertionError();
        }
    }
}

---

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

License:Apache License

public void testToQueryMultipleTermsBooleanQuery() throws Exception {
    assumeTrue("test runs only when at least a type is registered", getCurrentTypes().length > 0);
    Query query = queryStringQuery("test1 test2").field(STRING_FIELD_NAME).useDisMax(false)
            .toQuery(createShardContext());
    assertThat(query, instanceOf(BooleanQuery.class));
    BooleanQuery bQuery = (BooleanQuery) query;
    assertThat(bQuery.clauses().size(), equalTo(2));
    assertThat(assertBooleanSubQuery(query, TermQuery.class, 0).getTerm(),
            equalTo(new Term(STRING_FIELD_NAME, "test1")));
    assertThat(assertBooleanSubQuery(query, TermQuery.class, 1).getTerm(),
            equalTo(new Term(STRING_FIELD_NAME, "test2")));
}

---

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