Example usage for org.apache.lucene.search ConstantScoreQuery getQuery

List of usage examples for org.apache.lucene.search ConstantScoreQuery getQuery

  1. HOME
  2. Java
  3. org.apache.lucene
  4. org.apache.lucene.search.*
  5. ConstantScoreQuery
  6. getQuery

Introduction

In this page you can find the example usage for org.apache.lucene.search ConstantScoreQuery getQuery.

Prototype

public Query getQuery()

Source Link

Document

Returns the encapsulated query.

Usage

From source file:io.crate.lucene.CommonQueryBuilderTest.java

License:Apache License

/**
 * Make sure we still sport the fast Lucene regular
 * expression engine when not using PCRE features.
 *///  ww  w.  j a v  a 2s .c  om
@Test
public void testRegexQueryFast() throws Exception {
    Query query = convert("name ~ '[a-z]'");
    assertThat(query, instanceOf(ConstantScoreQuery.class));
    ConstantScoreQuery scoreQuery = (ConstantScoreQuery) query;
    assertThat(scoreQuery.getQuery(), instanceOf(RegexpQuery.class));
}

From source file:org.elasticsearch.action.debugquery.QueryToMapTransformer.java

License:Apache License

@Override
public Map visit(ConstantScoreQuery query) throws Exception {
    final Object child = QueryAcceptor.accept(query.getQuery(), this);
    final Map map = newQuery(query);
    map.put("query", child);
    return map;/*from   ww  w  . java  2 s  . c o m*/
}

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

License:Apache License

public void testDefaultMinShouldMatch() throws Exception {
    // Queries have a minShouldMatch of 0
    BooleanQuery bq = (BooleanQuery) parseQuery(boolQuery().must(termQuery("foo", "bar")).buildAsBytes())
            .toQuery(createShardContext());
    assertEquals(0, bq.getMinimumNumberShouldMatch());

    bq = (BooleanQuery) parseQuery(boolQuery().should(termQuery("foo", "bar")).buildAsBytes())
            .toQuery(createShardContext());
    assertEquals(0, bq.getMinimumNumberShouldMatch());

    // Filters have a minShouldMatch of 0/1
    ConstantScoreQuery csq = (ConstantScoreQuery) parseQuery(
            constantScoreQuery(boolQuery().must(termQuery("foo", "bar"))).buildAsBytes())
                    .toQuery(createShardContext());
    bq = (BooleanQuery) csq.getQuery();
    assertEquals(0, bq.getMinimumNumberShouldMatch());

    csq = (ConstantScoreQuery) parseQuery(
            constantScoreQuery(boolQuery().should(termQuery("foo", "bar"))).buildAsBytes())
                    .toQuery(createShardContext());
    bq = (BooleanQuery) csq.getQuery();/* w  ww .j  av  a2 s. c o  m*/
    assertEquals(1, bq.getMinimumNumberShouldMatch());
}

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

License:Apache License

@Override
protected void doAssertLuceneQuery(ConstantScoreQueryBuilder queryBuilder, Query query,
        QueryShardContext context) throws IOException {
    Query innerQuery = queryBuilder.innerQuery().toQuery(context);
    if (innerQuery == null) {
        assertThat(query, nullValue());/* w w  w.  ja va 2  s  .  c  om*/
    } else {
        assertThat(query, instanceOf(ConstantScoreQuery.class));
        ConstantScoreQuery constantScoreQuery = (ConstantScoreQuery) query;
        assertThat(constantScoreQuery.getQuery(), instanceOf(innerQuery.getClass()));
    }
}

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.  j av a  2 s  .  c  o  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 w ww  .ja  v a 2 s  . c o m*/
            }
        } 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());
}

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

License:Apache License

@Override
protected void doAssertLuceneQuery(QueryFilterBuilder queryBuilder, Query query, QueryShardContext context)
        throws IOException {
    Query innerQuery = queryBuilder.innerQuery().toQuery(context);
    if (innerQuery == null) {
        assertThat(query, nullValue());/*from   ww  w .  j  a va 2 s .c  o m*/
    } else {
        assertThat(query, instanceOf(ConstantScoreQuery.class));
        ConstantScoreQuery constantScoreQuery = (ConstantScoreQuery) query;
        assertThat(constantScoreQuery.getQuery(), equalTo(innerQuery));
    }
}

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());
}