Example usage for org.apache.lucene.search DisjunctionMaxQuery getDisjuncts

Introduction

In this page you can find the example usage for org.apache.lucene.search DisjunctionMaxQuery getDisjuncts.

Prototype

public List<Query> getDisjuncts() 

Source Link

Usage

From source file:com.xiaomi.linden.core.TestLindenCore.java

License:Apache License

@Test
public void testBoosts() throws Exception {
    String bql = "select * from linden by title = \"lucene\" and field1 = \"aaa\" boost by 2";
    LindenSearchRequest request = bqlCompiler.compile(bql).getSearchRequest();
    Query query = QueryConstructor.constructQuery(request.getQuery(), lindenConfig);
    Assert.assertTrue(query instanceof BooleanQuery);
    Assert.assertEquals(2f, query.getBoost(), DELTA5);

    bql = "select * from linden by title = \"lucene\" boost by 3";
    request = bqlCompiler.compile(bql).getSearchRequest();
    query = QueryConstructor.constructQuery(request.getQuery(), lindenConfig);
    Assert.assertTrue(query instanceof TermQuery);
    Assert.assertEquals(3f, query.getBoost(), DELTA5);

    bql = "select * from linden by Query is 'title:lucene' subBoost by 4 or tagstr = 'MI4'";
    request = bqlCompiler.compile(bql).getSearchRequest();
    query = QueryConstructor.constructQuery(request.getQuery(), lindenConfig);
    Assert.assertTrue(query instanceof BooleanQuery);
    BooleanQuery booleanQuery = (BooleanQuery) query;
    Assert.assertEquals(4f, booleanQuery.clauses().get(0).getQuery().getBoost(), DELTA5);
    Assert.assertEquals(1f, booleanQuery.clauses().get(1).getQuery().getBoost(), DELTA5);
    request = bqlCompiler.compile(bql).getSearchRequest();
    LindenResult result = lindenCore.search(request);
    Assert.assertEquals(5, result.getHitsSize());
    Assert.assertEquals("1", result.getHits().get(0).getId());

    bql = "select * from linden by Query is 'title:lucene' subBoost by 4 or tagstr = 'MI4' subBoost by 2";
    request = bqlCompiler.compile(bql).getSearchRequest();
    query = QueryConstructor.constructQuery(request.getQuery(), lindenConfig);
    Assert.assertTrue(query instanceof BooleanQuery);
    booleanQuery = (BooleanQuery) query;
    Assert.assertEquals(4f, booleanQuery.clauses().get(0).getQuery().getBoost(), DELTA5);
    Assert.assertEquals(2f, booleanQuery.clauses().get(1).getQuery().getBoost(), DELTA5);
    request = bqlCompiler.compile(bql).getSearchRequest();
    result = lindenCore.search(request);
    Assert.assertEquals(5, result.getHitsSize());
    Assert.assertEquals("6", result.getHits().get(0).getId());

    bql = "select * from linden by rank > 4 subBoost by 4 or tagstr = 'MI4'";
    request = bqlCompiler.compile(bql).getSearchRequest();
    query = QueryConstructor.constructQuery(request.getQuery(), lindenConfig);
    Assert.assertTrue(query instanceof BooleanQuery);
    booleanQuery = (BooleanQuery) query;
    Assert.assertEquals(4f, booleanQuery.clauses().get(0).getQuery().getBoost(), DELTA5);
    Assert.assertEquals(1f, booleanQuery.clauses().get(1).getQuery().getBoost(), DELTA5);
    request = bqlCompiler.compile(bql).getSearchRequest();
    result = lindenCore.search(request);
    Assert.assertEquals(4, result.getHitsSize());
    Assert.assertEquals("2", result.getHits().get(0).getId());

    bql = "select * from linden by rank > 4 subBoost by 4 or tagstr = 'MI4' subBoost by 2.0";
    request = bqlCompiler.compile(bql).getSearchRequest();
    query = QueryConstructor.constructQuery(request.getQuery(), lindenConfig);
    Assert.assertTrue(query instanceof BooleanQuery);
    booleanQuery = (BooleanQuery) query;
    Assert.assertEquals(4f, booleanQuery.clauses().get(0).getQuery().getBoost(), DELTA5);
    Assert.assertEquals(2f, booleanQuery.clauses().get(1).getQuery().getBoost(), DELTA5);
    request = bqlCompiler.compile(bql).getSearchRequest();
    result = lindenCore.search(request);
    Assert.assertEquals(4, result.getHitsSize());
    Assert.assertEquals("6", result.getHits().get(0).getId());

    // this boolean query case, does not support term query boost
    bql = "select * from linden by title = \"lucene\" and field1 = \"aaa\" boost by 2"
            + "|select * from linden by title = \"lucene\" boost by 3";
    request = bqlCompiler.compile(bql).getSearchRequest();
    query = QueryConstructor.constructQuery(request.getQuery(), lindenConfig);
    Assert.assertTrue(query instanceof DisjunctionMaxQuery);
    DisjunctionMaxQuery disjunctionMaxQuery = (DisjunctionMaxQuery) query;
    Assert.assertEquals(2f, disjunctionMaxQuery.getDisjuncts().get(0).getBoost(), DELTA5);
    Assert.assertEquals(3f, disjunctionMaxQuery.getDisjuncts().get(1).getBoost(), DELTA5);
    Assert.assertEquals("(((+title:lucene +field1:aaa)^2.0) | title:lucene^3.0)~0.1", query.toString());

    bql = "select * from linden by query is \"title:(lucene test)^2\" where rank > 1 boost by 2";
    request = bqlCompiler.compile(bql).getSearchRequest();
    query = QueryConstructor.constructQuery(request.getQuery(), lindenConfig);
    Assert.assertTrue(query instanceof BooleanQuery);
    Assert.assertEquals("(title:lucene title:test)^4.0", query.toString());

    bql = "select * from linden by flexible_query is \"lucene test\" in (title)\n"
            + "using model test(Float m = 10)\n" + "begin\n" + "    return score();\n"
            + "end where rank > 1 source explain boost by 2";
    request = bqlCompiler.compile(bql).getSearchRequest();
    query = QueryConstructor.constructQuery(request.getQuery(), lindenConfig);
    Assert.assertEquals("FlexibleQuery([title]:[lucene,test])^2.0", query.toString());

    bql = "select * from linden by query is \"title:lucene^2\" where rank > 1 order by rank, field1 desc source boost by 2"
            + "|select * from linden by query is \"title:test^3 field1:aaa\" where rank > 1 order by rank, field1 desc source boost by 0.03";
    request = bqlCompiler.compile(bql).getSearchRequest();
    query = QueryConstructor.constructQuery(request.getQuery(), lindenConfig);
    Assert.assertTrue(query instanceof DisjunctionMaxQuery);
    disjunctionMaxQuery = (DisjunctionMaxQuery) query;
    // subQuery 1 is filterQuery which contains a termQuery
    Assert.assertTrue(disjunctionMaxQuery.getDisjuncts().get(0) instanceof FilteredQuery);
    FilteredQuery filteredQuery = (FilteredQuery) disjunctionMaxQuery.getDisjuncts().get(0);
    Assert.assertTrue(filteredQuery.getQuery() instanceof TermQuery);
    Assert.assertEquals(4f, filteredQuery.getQuery().getBoost(), DELTA5);
    // subQuery 2 is filterQuery which contains a booleanQuery
    Assert.assertTrue(disjunctionMaxQuery.getDisjuncts().get(1) instanceof FilteredQuery);
    filteredQuery = (FilteredQuery) disjunctionMaxQuery.getDisjuncts().get(1);
    Assert.assertTrue(filteredQuery.getQuery() instanceof BooleanQuery);
    Assert.assertEquals(0.03f, filteredQuery.getQuery().getBoost(), DELTA5);
    Assert.assertEquals(/*from ww  w.j  av a 2  s  .  c  om*/
            "(filtered(title:lucene^4.0)->rank:{1.0 TO *} | filtered((title:test^3.0 field1:aaa)^0.03)->rank:{1.0 TO *})~0.1",
            query.toString());

    // test FlexibleQuery
    bql = "select * from linden by flexible_query is \"lucene\" in (title)\n"
            + "using model test(Float m = 10)\n" + "begin\n" + "    float sum = 0f;\n"
            + "    for (int i = 0; i < getFieldLength(); ++i) {\n"
            + "        for (int j = 0; j < getTermLength(); ++j) {\n"
            + "            sum += 10 * getScore(i, j);\n"
            + "            addTermExpl(i, j, 10, getExpl(\"[%.2f]\", sum));\n" + "        }\n"
            + "        addFieldExpl(i, 20, getExpl(\"[%.2f]\", sum * m));\n" + "    }\n"
            + "    return sum * m;\n" + "end where rank > 1 source explain";
    bql = bql + "|select * from linden by flexible_query is \"test^3\" in (field1)\n"
            + "using model test(Float m = 10)\n" + "begin\n" + "    float sum = 0f;\n"
            + "    for (int i = 0; i < getFieldLength(); ++i) {\n"
            + "        for (int j = 0; j < getTermLength(); ++j) {\n"
            + "            sum += 10 * getScore(i, j);\n"
            + "            addTermExpl(i, j, 10, getExpl(\"[%.2f]\", sum));\n" + "        }\n"
            + "        addFieldExpl(i, 20, getExpl(\"[%.2f]\", sum * m));\n" + "    }\n"
            + "    return sum * m;\n" + "end where rank > 1 source explain boost by 0.5";
    request = bqlCompiler.compile(bql).getSearchRequest();
    query = QueryConstructor.constructQuery(request.getQuery(), lindenConfig);
    Assert.assertTrue(query instanceof DisjunctionMaxQuery);
    disjunctionMaxQuery = (DisjunctionMaxQuery) query;
    // subQuery 1 is a FilteredQuery which contains a FlexibleQuery
    Assert.assertTrue(disjunctionMaxQuery.getDisjuncts().get(0) instanceof FilteredQuery);
    filteredQuery = (FilteredQuery) disjunctionMaxQuery.getDisjuncts().get(0);
    Assert.assertTrue(filteredQuery.getQuery() instanceof FlexibleQuery);
    Assert.assertEquals(1f, filteredQuery.getQuery().getBoost(), DELTA5);
    // subQuery 2 is a FilteredQuery which contains a FlexibleQuery
    Assert.assertTrue(disjunctionMaxQuery.getDisjuncts().get(1) instanceof FilteredQuery);
    filteredQuery = (FilteredQuery) disjunctionMaxQuery.getDisjuncts().get(1);
    Assert.assertTrue(filteredQuery.getQuery() instanceof FlexibleQuery);
    Assert.assertEquals(0.5f, filteredQuery.getQuery().getBoost(), DELTA5);
    Assert.assertEquals(
            "(filtered(FlexibleQuery([title]:[lucene]))->rank:{1.0 TO *} | filtered(FlexibleQuery([field1]:[test^3.0])^0.5)->rank:{1.0 TO *})~0.1",
            query.toString());
}

---

From source file:org.apache.solr.search.TestExtendedDismaxParser.java

License:Apache License

private boolean containsClause(DisjunctionMaxQuery query, String field, String value, int boost,
        boolean fuzzy) {
    for (Query disjunct : query.getDisjuncts()) {
        if (containsClause(disjunct, field, value, boost, fuzzy)) {
            return true;
        }//  w  w  w  . j  av  a 2s  . c  om
    }
    return false;
}

---

From source file:org.apache.solr.search.TestMaxScoreQueryParser.java

License:Apache License

@Test
public void testBoost() {
    // Simple term query
    q = parse("foo^3.0");
    assertEquals(3.0, q.getBoost(), 1e-15);

    // Some DMQ and one plain required
    q = parse("foo^5.0 bar^6.0 +baz^7");
    clauses = clauses(q);//from  w  w w  . j av  a  2  s  .  c o m
    assertEquals(2, clauses.length);
    assertTrue(clauses[0].getQuery() instanceof DisjunctionMaxQuery);
    DisjunctionMaxQuery dmq = ((DisjunctionMaxQuery) clauses[0].getQuery());
    float fooClause = ((BooleanQuery) dmq.getDisjuncts().get(0)).clauses().get(0).getQuery().getBoost();
    assertEquals(5.0, fooClause, 1e-15);
    float barClause = ((BooleanQuery) dmq.getDisjuncts().get(1)).clauses().get(0).getQuery().getBoost();
    assertEquals(6.0, barClause, 1e-15);
    assertEquals(7.0, clauses[1].getQuery().getBoost(), 1e-15);
    assertEquals(1.0, q.getBoost(), 1e-15);

    // Grouped with parens on top level
    q = parse("(foo^2.0 bar)^3.0");
    clauses = clauses(q);
    assertEquals(1, clauses.length);
    assertTrue(clauses[0].getQuery() instanceof DisjunctionMaxQuery);
    dmq = ((DisjunctionMaxQuery) clauses[0].getQuery());
    fooClause = ((BooleanQuery) dmq.getDisjuncts().get(0)).clauses().get(0).getQuery().getBoost();
    assertEquals(2.0, fooClause, 1e-15);
    barClause = ((BooleanQuery) dmq.getDisjuncts().get(1)).clauses().get(0).getQuery().getBoost();
    assertEquals(1.0, barClause, 1e-15);
    assertEquals(3.0, q.getBoost(), 1e-15);
}

---

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

License:Apache License

@Override
public Map visit(DisjunctionMaxQuery query) throws Exception {
    final Map map = newQuery(query);
    map.put("tieBreaker", query.getTieBreakerMultiplier());
    final ArrayList children = new ArrayList(query.getDisjuncts().size());
    map.put("disjuncts", children);
    for (final Query childQuery : query.getDisjuncts()) {
        final Object childObj = QueryAcceptor.accept(childQuery, this);
        children.add(childObj);/* w  ww  .  j  ava  2  s  . c  om*/
    }
    return map;
}

---

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

License:Apache License

@Override
protected void doAssertLuceneQuery(DisMaxQueryBuilder queryBuilder, Query query, QueryShardContext context)
        throws IOException {
    Collection<Query> queries = AbstractQueryBuilder.toQueries(queryBuilder.innerQueries(), context);
    assertThat(query, instanceOf(DisjunctionMaxQuery.class));
    DisjunctionMaxQuery disjunctionMaxQuery = (DisjunctionMaxQuery) query;
    assertThat(disjunctionMaxQuery.getTieBreakerMultiplier(), equalTo(queryBuilder.tieBreaker()));
    assertThat(disjunctionMaxQuery.getDisjuncts().size(), equalTo(queries.size()));
    Iterator<Query> queryIterator = queries.iterator();
    for (int i = 0; i < disjunctionMaxQuery.getDisjuncts().size(); i++) {
        assertThat(disjunctionMaxQuery.getDisjuncts().get(i), equalTo(queryIterator.next()));
    }/*from  w  w  w  . j a v a  2  s .  c  om*/
}

---

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

License:Apache License

public void testToQueryInnerPrefixQuery() throws Exception {
    assumeTrue("test runs only when at least a type is registered", getCurrentTypes().length > 0);
    String queryAsString = "{\n" + "    \"dis_max\":{\n" + "        \"queries\":[\n" + "            {\n"
            + "                \"prefix\":{\n" + "                    \"" + STRING_FIELD_NAME + "\":{\n"
            + "                        \"value\":\"sh\",\n" + "                        \"boost\":1.2\n"
            + "                    }\n" + "                }\n" + "            }\n" + "        ]\n" + "    }\n"
            + "}";
    Query query = parseQuery(queryAsString).toQuery(createShardContext());
    assertThat(query, instanceOf(DisjunctionMaxQuery.class));
    DisjunctionMaxQuery disjunctionMaxQuery = (DisjunctionMaxQuery) query;

    List<Query> disjuncts = disjunctionMaxQuery.getDisjuncts();
    assertThat(disjuncts.size(), equalTo(1));

    assertThat(disjuncts.get(0), instanceOf(BoostQuery.class));
    BoostQuery boostQuery = (BoostQuery) disjuncts.get(0);
    assertThat((double) boostQuery.getBoost(), closeTo(1.2, 0.00001));
    assertThat(boostQuery.getQuery(), instanceOf(PrefixQuery.class));
    PrefixQuery firstQ = (PrefixQuery) boostQuery.getQuery();
    // since age is automatically registered in data, we encode it as numeric
    assertThat(firstQ.getPrefix(), equalTo(new Term(STRING_FIELD_NAME, "sh")));

}

---

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

License:Apache License

public void testToQueryMultipleFieldsDisMaxQuery() 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(true)
            .toQuery(createShardContext());
    assertThat(query, instanceOf(DisjunctionMaxQuery.class));
    DisjunctionMaxQuery disMaxQuery = (DisjunctionMaxQuery) query;
    List<Query> disjuncts = disMaxQuery.getDisjuncts();
    assertThat(disjuncts.get(0), instanceOf(TermQuery.class));
    assertThat(((TermQuery) disjuncts.get(0)).getTerm(), equalTo(new Term(STRING_FIELD_NAME, "test")));
    assertThat(disjuncts.get(1), instanceOf(TermQuery.class));
    assertThat(((TermQuery) disjuncts.get(1)).getTerm(), equalTo(new Term(STRING_FIELD_NAME_2, "test")));
}

---

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

License:Apache License

public void testToQueryPhraseQuery() throws IOException {
    assumeTrue("test runs only when at least a type is registered", getCurrentTypes().length > 0);
    Query query = queryStringQuery("\"term1 term2\"").defaultField(STRING_FIELD_NAME).phraseSlop(3)
            .toQuery(createShardContext());
    assertThat(query, instanceOf(DisjunctionMaxQuery.class));
    DisjunctionMaxQuery disjunctionMaxQuery = (DisjunctionMaxQuery) query;
    assertThat(disjunctionMaxQuery.getDisjuncts().size(), equalTo(1));
    assertThat(disjunctionMaxQuery.getDisjuncts().get(0), instanceOf(PhraseQuery.class));
    PhraseQuery phraseQuery = (PhraseQuery) disjunctionMaxQuery.getDisjuncts().get(0);
    assertThat(phraseQuery.getTerms().length, equalTo(2));
    assertThat(phraseQuery.getTerms()[0], equalTo(new Term(STRING_FIELD_NAME, "term1")));
    assertThat(phraseQuery.getTerms()[1], equalTo(new Term(STRING_FIELD_NAME, "term2")));
    assertThat(phraseQuery.getSlop(), equalTo(3));
}

---

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

License:Apache License

public void testToQueryMultipleFieldsDisMaxQuery() throws Exception {
    assumeTrue("test runs only when at least a type is registered", getCurrentTypes().length > 0);
    Query query = queryStringQuery("test").field(STRING_FIELD_NAME).field(STRING_FIELD_NAME_2).useDisMax(true)
            .toQuery(createShardContext());
    assertThat(query, instanceOf(DisjunctionMaxQuery.class));
    DisjunctionMaxQuery disMaxQuery = (DisjunctionMaxQuery) query;
    List<Query> disjuncts = disMaxQuery.getDisjuncts();
    assertThat(((TermQuery) disjuncts.get(0)).getTerm(), equalTo(new Term(STRING_FIELD_NAME, "test")));
    assertThat(((TermQuery) disjuncts.get(1)).getTerm(), equalTo(new Term(STRING_FIELD_NAME_2, "test")));
}

---

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

License:Apache License

public void testToQueryDisMaxQuery() throws Exception {
    assumeTrue("test runs only when at least a type is registered", getCurrentTypes().length > 0);
    Query query = queryStringQuery("test").field(STRING_FIELD_NAME, 2.2f).field(STRING_FIELD_NAME_2)
            .useDisMax(true).toQuery(createShardContext());
    assertThat(query, instanceOf(DisjunctionMaxQuery.class));
    DisjunctionMaxQuery disMaxQuery = (DisjunctionMaxQuery) query;
    List<Query> disjuncts = disMaxQuery.getDisjuncts();
    assertTermOrBoostQuery(disjuncts.get(0), STRING_FIELD_NAME, "test", 2.2f);
    assertTermOrBoostQuery(disjuncts.get(1), STRING_FIELD_NAME_2, "test", 1.0f);
}

---

• «
• 1
• 2
• »