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.xcontent.SimpleIndexQueryParserTests.java

License:Apache License

@Test
public void testQueryStringFieldsMatch() throws Exception {
    IndexQueryParser queryParser = queryParser();
    String query = copyToStringFromClasspath("/org/elasticsearch/index/query/xcontent/query-fields-match.json");
    Query parsedQuery = queryParser.parse(query).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("name.first", "test")));
    assertThat(((TermQuery) bQuery.clauses().get(1).getQuery()).getTerm(),
            equalTo(new Term("name.last", "test")));
}

---

From source file:org.elasticsearch.index.search.NestedHelper.java

License:Apache License

/** Returns true if the given query might match nested documents. */
public boolean mightMatchNestedDocs(Query query) {
    if (query instanceof ConstantScoreQuery) {
        return mightMatchNestedDocs(((ConstantScoreQuery) query).getQuery());
    } else if (query instanceof BoostQuery) {
        return mightMatchNestedDocs(((BoostQuery) query).getQuery());
    } else if (query instanceof MatchAllDocsQuery) {
        return true;
    } else if (query instanceof MatchNoDocsQuery) {
        return false;
    } else if (query instanceof TermQuery) {
        // We only handle term queries and range queries, which should already
        // cover a high majority of use-cases
        return mightMatchNestedDocs(((TermQuery) query).getTerm().field());
    } else if (query instanceof PointRangeQuery) {
        return mightMatchNestedDocs(((PointRangeQuery) query).getField());
    } else if (query instanceof IndexOrDocValuesQuery) {
        return mightMatchNestedDocs(((IndexOrDocValuesQuery) query).getIndexQuery());
    } else if (query instanceof BooleanQuery) {
        final BooleanQuery bq = (BooleanQuery) query;
        final boolean hasRequiredClauses = bq.clauses().stream().anyMatch(BooleanClause::isRequired);
        if (hasRequiredClauses) {
            return bq.clauses().stream().filter(BooleanClause::isRequired).map(BooleanClause::getQuery)
                    .allMatch(this::mightMatchNestedDocs);
        } else {/*from   w  w  w  .  j  a  v  a 2  s  .  c o  m*/
            return bq.clauses().stream().filter(c -> c.getOccur() == Occur.SHOULD).map(BooleanClause::getQuery)
                    .anyMatch(this::mightMatchNestedDocs);
        }
    } else if (query instanceof ESToParentBlockJoinQuery) {
        return ((ESToParentBlockJoinQuery) query).getPath() != null;
    } else {
        return true;
    }
}

---

From source file:org.elasticsearch.index.search.NestedHelper.java

License:Apache License

/** Returns true if the given query might match parent documents or documents
 *  that are nested under a different path. */
public boolean mightMatchNonNestedDocs(Query query, String nestedPath) {
    if (query instanceof ConstantScoreQuery) {
        return mightMatchNonNestedDocs(((ConstantScoreQuery) query).getQuery(), nestedPath);
    } else if (query instanceof BoostQuery) {
        return mightMatchNonNestedDocs(((BoostQuery) query).getQuery(), nestedPath);
    } else if (query instanceof MatchAllDocsQuery) {
        return true;
    } else if (query instanceof MatchNoDocsQuery) {
        return false;
    } else if (query instanceof TermQuery) {
        return mightMatchNonNestedDocs(((TermQuery) query).getTerm().field(), nestedPath);
    } else if (query instanceof PointRangeQuery) {
        return mightMatchNonNestedDocs(((PointRangeQuery) query).getField(), nestedPath);
    } else if (query instanceof IndexOrDocValuesQuery) {
        return mightMatchNonNestedDocs(((IndexOrDocValuesQuery) query).getIndexQuery(), nestedPath);
    } else if (query instanceof BooleanQuery) {
        final BooleanQuery bq = (BooleanQuery) query;
        final boolean hasRequiredClauses = bq.clauses().stream().anyMatch(BooleanClause::isRequired);
        if (hasRequiredClauses) {
            return bq.clauses().stream().filter(BooleanClause::isRequired).map(BooleanClause::getQuery)
                    .allMatch(q -> mightMatchNonNestedDocs(q, nestedPath));
        } else {/*from   w  w  w .j  av a 2  s.  co  m*/
            return bq.clauses().stream().filter(c -> c.getOccur() == Occur.SHOULD).map(BooleanClause::getQuery)
                    .anyMatch(q -> mightMatchNonNestedDocs(q, nestedPath));
        }
    } else {
        return true;
    }
}

---

From source file:org.elasticsearch.join.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(TermInSetQuery.class));
    TermInSetQuery termsQuery = (TermInSetQuery) 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(IdFieldMapper.NAME));
    assertThat(termQuery.getTerm().bytes(), equalTo(Uid.encodeId(id)));
    //check the type filter
    assertThat(booleanQuery.clauses().get(1).getOccur(), equalTo(BooleanClause.Occur.FILTER));
    assertEquals(new TermQuery(new Term("join_field", type)), booleanQuery.clauses().get(1).getQuery());
}

---

From source file:org.elasticsearch.join.query.LegacyHasChildQueryBuilderTests.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(TermInSetQuery.class));
    TermInSetQuery termsQuery = (TermInSetQuery) 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.TypesQuery(new BytesRef(type)), booleanQuery.clauses().get(1).getQuery());
}

---

From source file:org.elasticsearch.join.query.LegacyParentIdQueryBuilderTests.java

License:Apache License

@Override
protected void doAssertLuceneQuery(ParentIdQueryBuilder queryBuilder, Query query, SearchContext 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,//from   w  w  w  . jav a  2  s .c  o  m
            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.join.query.ParentIdQueryBuilderTests.java

License:Apache License

@Override
protected void doAssertLuceneQuery(ParentIdQueryBuilder queryBuilder, Query query, SearchContext context)
        throws IOException {
    assertThat(query, Matchers.instanceOf(BooleanQuery.class));
    BooleanQuery booleanQuery = (BooleanQuery) query;
    assertThat(booleanQuery.clauses().size(), Matchers.equalTo(2));
    BooleanQuery expected = new BooleanQuery.Builder()
            .add(new TermQuery(new Term(JOIN_FIELD_NAME + "#" + PARENT_NAME, queryBuilder.getId())),
                    BooleanClause.Occur.MUST)
            .add(new TermQuery(new Term(JOIN_FIELD_NAME, queryBuilder.getType())), BooleanClause.Occur.FILTER)
            .build();/*from w w w . j a va2  s .c  om*/
    assertThat(expected, equalTo(query));
}

---

From source file:org.elasticsearch.percolator.ExtractQueryTermsService.java

License:Apache License

static Function<Query, Result> booleanQuery() {
    return query -> {
        BooleanQuery bq = (BooleanQuery) query;
        List<BooleanClause> clauses = bq.clauses();
        int minimumShouldMatch = bq.getMinimumNumberShouldMatch();
        int numRequiredClauses = 0;
        int numOptionalClauses = 0;
        int numProhibitedClauses = 0;
        for (BooleanClause clause : clauses) {
            if (clause.isRequired()) {
                numRequiredClauses++;//from www.j  a va  2 s .  com
            }
            if (clause.isProhibited()) {
                numProhibitedClauses++;
            }
            if (clause.getOccur() == BooleanClause.Occur.SHOULD) {
                numOptionalClauses++;
            }
        }
        if (numRequiredClauses > 0) {
            Set<Term> bestClause = null;
            UnsupportedQueryException uqe = null;
            for (BooleanClause clause : clauses) {
                if (clause.isRequired() == false) {
                    // skip must_not clauses, we don't need to remember the things that do *not* match...
                    // skip should clauses, this bq has must clauses, so we don't need to remember should clauses,
                    // since they are completely optional.
                    continue;
                }

                Result temp;
                try {
                    temp = extractQueryTerms(clause.getQuery());
                } catch (UnsupportedQueryException e) {
                    uqe = e;
                    continue;
                }
                bestClause = selectTermListWithTheLongestShortestTerm(temp.terms, bestClause);
            }
            if (bestClause != null) {
                return new Result(false, bestClause);
            } else {
                if (uqe != null) {
                    // we're unable to select the best clause and an exception occurred, so we bail
                    throw uqe;
                } else {
                    // We didn't find a clause and no exception occurred, so this bq only contained MatchNoDocsQueries,
                    return new Result(true, Collections.emptySet());
                }
            }
        } else {
            List<Query> disjunctions = new ArrayList<>(numOptionalClauses);
            for (BooleanClause clause : clauses) {
                if (clause.getOccur() == BooleanClause.Occur.SHOULD) {
                    disjunctions.add(clause.getQuery());
                }
            }
            return handleDisjunction(disjunctions, minimumShouldMatch, numProhibitedClauses > 0);
        }
    };
}

---

From source file:org.elasticsearch.percolator.PercolateQueryBuilderTests.java

License:Apache License

public void testCreateMultiDocumentSearcher() throws Exception {
    int numDocs = randomIntBetween(2, 8);
    List<ParseContext.Document> docs = new ArrayList<>(numDocs);
    for (int i = 0; i < numDocs; i++) {
        docs.add(new ParseContext.Document());
    }//from   www.j  av  a 2  s. co m

    Analyzer analyzer = new WhitespaceAnalyzer();
    ParsedDocument parsedDocument = new ParsedDocument(null, "_id", "_type", null, -1L, -1L, docs, null, null);
    IndexSearcher indexSearcher = PercolateQueryBuilder.createMultiDocumentSearcher(analyzer, parsedDocument);
    assertThat(indexSearcher.getIndexReader().numDocs(), equalTo(numDocs));

    // ensure that any query get modified so that the nested docs are never included as hits:
    Query query = new MatchAllDocsQuery();
    BooleanQuery result = (BooleanQuery) indexSearcher.createNormalizedWeight(query, true).getQuery();
    assertThat(result.clauses().size(), equalTo(2));
    assertThat(result.clauses().get(0).getQuery(), sameInstance(query));
    assertThat(result.clauses().get(0).getOccur(), equalTo(BooleanClause.Occur.MUST));
    assertThat(result.clauses().get(1).getOccur(), equalTo(BooleanClause.Occur.MUST_NOT));
}

---

From source file:org.elasticsearch.percolator.QueryAnalyzer.java

License:Apache License

static Function<Query, Result> booleanQuery() {
    return query -> {
        BooleanQuery bq = (BooleanQuery) query;
        List<BooleanClause> clauses = bq.clauses();
        int minimumShouldMatch = bq.getMinimumNumberShouldMatch();
        int numRequiredClauses = 0;
        int numOptionalClauses = 0;
        int numProhibitedClauses = 0;
        for (BooleanClause clause : clauses) {
            if (clause.isRequired()) {
                numRequiredClauses++;/*  www  . j  a  v  a 2  s .  c o m*/
            }
            if (clause.isProhibited()) {
                numProhibitedClauses++;
            }
            if (clause.getOccur() == BooleanClause.Occur.SHOULD) {
                numOptionalClauses++;
            }
        }
        if (numRequiredClauses > 0) {
            Set<Term> bestClause = null;
            UnsupportedQueryException uqe = null;
            for (BooleanClause clause : clauses) {
                if (clause.isRequired() == false) {
                    // skip must_not clauses, we don't need to remember the things that do *not* match...
                    // skip should clauses, this bq has must clauses, so we don't need to remember should clauses,
                    // since they are completely optional.
                    continue;
                }

                Result temp;
                try {
                    temp = analyze(clause.getQuery());
                } catch (UnsupportedQueryException e) {
                    uqe = e;
                    continue;
                }
                bestClause = selectTermListWithTheLongestShortestTerm(temp.terms, bestClause);
            }
            if (bestClause != null) {
                return new Result(false, bestClause);
            } else {
                if (uqe != null) {
                    // we're unable to select the best clause and an exception occurred, so we bail
                    throw uqe;
                } else {
                    // We didn't find a clause and no exception occurred, so this bq only contained MatchNoDocsQueries,
                    return new Result(true, Collections.emptySet());
                }
            }
        } else {
            List<Query> disjunctions = new ArrayList<>(numOptionalClauses);
            for (BooleanClause clause : clauses) {
                if (clause.getOccur() == BooleanClause.Occur.SHOULD) {
                    disjunctions.add(clause.getQuery());
                }
            }
            return handleDisjunction(disjunctions, minimumShouldMatch, numProhibitedClauses > 0);
        }
    };
}

---

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