Example usage for org.apache.lucene.search BoostQuery getBoost

List of usage examples for org.apache.lucene.search BoostQuery getBoost

  1. HOME
  2. Java
  3. org.apache.lucene
  4. org.apache.lucene.search.*
  5. BoostQuery
  6. getBoost

Introduction

In this page you can find the example usage for org.apache.lucene.search BoostQuery getBoost.

Prototype

public float getBoost()

Source Link

Document

Return the applied boost.

Usage

From source file:org.codelibs.elasticsearch.index.query.SpanMultiTermQueryBuilder.java

License:Apache License

@Override
protected Query doToQuery(QueryShardContext context) throws IOException {
    Query subQuery = multiTermQueryBuilder.toQuery(context);
    float boost = AbstractQueryBuilder.DEFAULT_BOOST;
    if (subQuery instanceof BoostQuery) {
        BoostQuery boostQuery = (BoostQuery) subQuery;
        subQuery = boostQuery.getQuery();
        boost = boostQuery.getBoost();
    }/* w  w  w.  j a v a 2s. c o m*/
    //no MultiTermQuery extends SpanQuery, so SpanBoostQuery is not supported here
    assert subQuery instanceof SpanBoostQuery == false;
    if (subQuery instanceof MultiTermQuery == false) {
        throw new UnsupportedOperationException("unsupported inner query, should be "
                + MultiTermQuery.class.getName() + " but was " + subQuery.getClass().getName());
    }
    SpanQuery wrapper = new SpanMultiTermQueryWrapper<>((MultiTermQuery) subQuery);
    if (boost != AbstractQueryBuilder.DEFAULT_BOOST) {
        wrapper = new SpanBoostQuery(wrapper, boost);
    }
    return wrapper;
}

From source file:org.codelibs.elasticsearch.index.search.MultiMatchQuery.java

License:Apache License

static Query blendTerms(QueryShardContext context, BytesRef[] values, Float commonTermsCutoff, float tieBreaker,
        FieldAndFieldType... blendedFields) {
    List<Query> queries = new ArrayList<>();
    Term[] terms = new Term[blendedFields.length * values.length];
    float[] blendedBoost = new float[blendedFields.length * values.length];
    int i = 0;/*from   www .j a  va  2  s .  co  m*/
    for (FieldAndFieldType ft : blendedFields) {
        for (BytesRef term : values) {
            Query query;
            try {
                query = ft.fieldType.termQuery(term, context);
            } catch (IllegalArgumentException e) {
                // the query expects a certain class of values such as numbers
                // of ip addresses and the value can't be parsed, so ignore this
                // field
                continue;
            } catch (ElasticsearchParseException parseException) {
                // date fields throw an ElasticsearchParseException with the
                // underlying IAE as the cause, ignore this field if that is
                // the case
                if (parseException.getCause() instanceof IllegalArgumentException) {
                    continue;
                }
                throw parseException;
            }
            float boost = ft.boost;
            while (query instanceof BoostQuery) {
                BoostQuery bq = (BoostQuery) query;
                query = bq.getQuery();
                boost *= bq.getBoost();
            }
            if (query.getClass() == TermQuery.class) {
                terms[i] = ((TermQuery) query).getTerm();
                blendedBoost[i] = boost;
                i++;
            } else {
                if (boost != 1f) {
                    query = new BoostQuery(query, boost);
                }
                queries.add(query);
            }
        }
    }
    if (i > 0) {
        terms = Arrays.copyOf(terms, i);
        blendedBoost = Arrays.copyOf(blendedBoost, i);
        if (commonTermsCutoff != null) {
            throw new UnsupportedOperationException("QueryBuilders does not support this operation.");
            //                queries.add(BlendedTermQuery.commonTermsBlendedQuery(terms, blendedBoost, false, commonTermsCutoff));
        } else if (tieBreaker == 1.0f) {
            throw new UnsupportedOperationException("QueryBuilders does not support this operation.");
            //                queries.add(BlendedTermQuery.booleanBlendedQuery(terms, blendedBoost, false));
        } else {
            throw new UnsupportedOperationException("QueryBuilders does not support this operation.");
            //                queries.add(BlendedTermQuery.dismaxBlendedQuery(terms, blendedBoost, tieBreaker));
        }
    }
    if (queries.size() == 1) {
        return queries.get(0);
    } else {
        // best effort: add clauses that are not term queries so that they have an opportunity to match
        // however their score contribution will be different
        // TODO: can we improve this?
        BooleanQuery.Builder bq = new BooleanQuery.Builder();
        bq.setDisableCoord(true);
        for (Query query : queries) {
            bq.add(query, Occur.SHOULD);
        }
        return bq.build();
    }
}

From source file:org.codelibs.fess.helper.QueryHelper.java

License:Apache License

protected QueryBuilder convertQuery(final QueryContext context, final Query query, final float boost) {
    if (query instanceof TermQuery) {
        return convertTermQuery(context, (TermQuery) query, boost);
    } else if (query instanceof TermRangeQuery) {
        return convertTermRangeQuery(context, (TermRangeQuery) query, boost);
    } else if (query instanceof PhraseQuery) {
        return convertPhraseQuery(context, (PhraseQuery) query, boost);
    } else if (query instanceof FuzzyQuery) {
        return convertFuzzyQuery(context, (FuzzyQuery) query, boost);
    } else if (query instanceof PrefixQuery) {
        return convertPrefixQuery(context, (PrefixQuery) query, boost);
    } else if (query instanceof WildcardQuery) {
        return convertWildcardQuery(context, (WildcardQuery) query, boost);
    } else if (query instanceof BooleanQuery) {
        final BooleanQuery booleanQuery = (BooleanQuery) query;
        return convertBooleanQuery(context, booleanQuery, boost);
    } else if (query instanceof MatchAllDocsQuery) {
        return QueryBuilders.matchAllQuery();
    } else if (query instanceof BoostQuery) {
        final BoostQuery boostQuery = (BoostQuery) query;
        return convertQuery(context, boostQuery.getQuery(), boostQuery.getBoost());
    }//from   w  w  w . j av  a  2  s . c  o m
    throw new InvalidQueryException(
            messages -> messages.addErrorsInvalidQueryUnknown(UserMessages.GLOBAL_PROPERTY_KEY),
            "Unknown q: " + query.getClass() + " => " + query);
}

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

License:Apache License

/**
 * Checks the result of {@link QueryBuilder#toQuery(QueryShardContext)} given the original {@link QueryBuilder} and {@link QueryShardContext}.
 * Verifies that named queries and boost are properly handled and delegates to {@link #doAssertLuceneQuery(AbstractQueryBuilder, Query, QueryShardContext)}
 * for query specific checks./*from   w  w w .j  a v a 2  s .co m*/
 */
protected final void assertLuceneQuery(QB queryBuilder, Query query, QueryShardContext context)
        throws IOException {
    if (queryBuilder.queryName() != null) {
        Query namedQuery = context.copyNamedQueries().get(queryBuilder.queryName());
        assertThat(namedQuery, equalTo(query));
    }
    if (query != null) {
        if (queryBuilder.boost() != AbstractQueryBuilder.DEFAULT_BOOST) {
            assertThat(query, either(instanceOf(BoostQuery.class)).or(instanceOf(SpanBoostQuery.class)));
            if (query instanceof SpanBoostQuery) {
                SpanBoostQuery spanBoostQuery = (SpanBoostQuery) query;
                assertThat(spanBoostQuery.getBoost(), equalTo(queryBuilder.boost()));
                query = spanBoostQuery.getQuery();
            } else {
                BoostQuery boostQuery = (BoostQuery) query;
                assertThat(boostQuery.getBoost(), equalTo(queryBuilder.boost()));
                query = boostQuery.getQuery();
            }
        }
    }
    doAssertLuceneQuery(queryBuilder, query, context);
}

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

License:Apache License

protected static void assertTermOrBoostQuery(Query query, String field, String value, float fieldBoost) {
    if (fieldBoost != AbstractQueryBuilder.DEFAULT_BOOST) {
        assertThat(query, instanceOf(BoostQuery.class));
        BoostQuery boostQuery = (BoostQuery) query;
        assertThat(boostQuery.getBoost(), equalTo(fieldBoost));
        query = boostQuery.getQuery();//w  w  w  .  j av a  2s  . c  om
    }
    assertTermQuery(query, field, value);
}

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.FuzzyQueryBuilderTests.java

License:Apache License

public void testToQueryWithStringField() throws IOException {
    assumeTrue("test runs only when at least a type is registered", getCurrentTypes().length > 0);
    String query = "{\n" + "    \"fuzzy\":{\n" + "        \"" + STRING_FIELD_NAME + "\":{\n"
            + "            \"value\":\"sh\",\n" + "            \"fuzziness\": \"AUTO\",\n"
            + "            \"prefix_length\":1,\n" + "            \"boost\":2.0\n" + "        }\n" + "    }\n"
            + "}";
    Query parsedQuery = parseQuery(query).toQuery(createShardContext());
    assertThat(parsedQuery, instanceOf(BoostQuery.class));
    BoostQuery boostQuery = (BoostQuery) parsedQuery;
    assertThat(boostQuery.getBoost(), equalTo(2.0f));
    assertThat(boostQuery.getQuery(), instanceOf(FuzzyQuery.class));
    FuzzyQuery fuzzyQuery = (FuzzyQuery) boostQuery.getQuery();
    assertThat(fuzzyQuery.getTerm(), equalTo(new Term(STRING_FIELD_NAME, "sh")));
    assertThat(fuzzyQuery.getMaxEdits(), equalTo(Fuzziness.AUTO.asDistance("sh")));
    assertThat(fuzzyQuery.getPrefixLength(), equalTo(1));
}

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

License:Apache License

public void testToQueryBoost() throws IOException {
    assumeTrue("test runs only when at least a type is registered", getCurrentTypes().length > 0);
    QueryShardContext shardContext = createShardContext();
    MultiMatchQueryBuilder multiMatchQueryBuilder = new MultiMatchQueryBuilder("test");
    multiMatchQueryBuilder.field(STRING_FIELD_NAME, 5f);
    Query query = multiMatchQueryBuilder.toQuery(shardContext);
    assertTermOrBoostQuery(query, STRING_FIELD_NAME, "test", 5f);

    multiMatchQueryBuilder = new MultiMatchQueryBuilder("test");
    multiMatchQueryBuilder.field(STRING_FIELD_NAME, 5f);
    multiMatchQueryBuilder.boost(2f);// ww  w . j  av  a  2s.  c  om
    query = multiMatchQueryBuilder.toQuery(shardContext);
    assertThat(query, instanceOf(BoostQuery.class));
    BoostQuery boostQuery = (BoostQuery) query;
    assertThat(boostQuery.getBoost(), equalTo(2f));
    assertTermOrBoostQuery(boostQuery.getQuery(), STRING_FIELD_NAME, "test", 5f);
}

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

License:Apache License

@Override
protected Query doToQuery(QueryShardContext context) throws IOException {
    //TODO would be nice to have all the settings in one place: some change though at query execution time
    //e.g. field names get expanded to concrete names, defaults get resolved sometimes to settings values etc.
    QueryParserSettings qpSettings;/* ww w.  jav  a2  s.c o  m*/
    if (this.escape) {
        qpSettings = new QueryParserSettings(
                org.apache.lucene.queryparser.classic.QueryParser.escape(this.queryString));
    } else {
        qpSettings = new QueryParserSettings(this.queryString);
    }
    qpSettings.defaultField(this.defaultField == null ? context.defaultField() : this.defaultField);
    Map<String, Float> resolvedFields = new TreeMap<>();
    for (Map.Entry<String, Float> fieldsEntry : fieldsAndWeights.entrySet()) {
        String fieldName = fieldsEntry.getKey();
        Float weight = fieldsEntry.getValue();
        if (Regex.isSimpleMatchPattern(fieldName)) {
            for (String resolvedFieldName : context.getMapperService().simpleMatchToIndexNames(fieldName)) {
                resolvedFields.put(resolvedFieldName, weight);
            }
        } else {
            resolvedFields.put(fieldName, weight);
        }
    }
    qpSettings.fieldsAndWeights(resolvedFields);
    qpSettings.defaultOperator(defaultOperator.toQueryParserOperator());

    if (analyzer == null) {
        qpSettings.defaultAnalyzer(context.getMapperService().searchAnalyzer());
    } else {
        NamedAnalyzer namedAnalyzer = context.getAnalysisService().analyzer(analyzer);
        if (namedAnalyzer == null) {
            throw new QueryShardException(context, "[query_string] analyzer [" + analyzer + "] not found");
        }
        qpSettings.forceAnalyzer(namedAnalyzer);
    }
    if (quoteAnalyzer != null) {
        NamedAnalyzer namedAnalyzer = context.getAnalysisService().analyzer(quoteAnalyzer);
        if (namedAnalyzer == null) {
            throw new QueryShardException(context,
                    "[query_string] quote_analyzer [" + quoteAnalyzer + "] not found");
        }
        qpSettings.forceQuoteAnalyzer(namedAnalyzer);
    } else if (analyzer != null) {
        qpSettings.forceQuoteAnalyzer(qpSettings.analyzer());
    } else {
        qpSettings.defaultQuoteAnalyzer(context.getMapperService().searchQuoteAnalyzer());
    }

    qpSettings.quoteFieldSuffix(quoteFieldSuffix);
    qpSettings.autoGeneratePhraseQueries(autoGeneratePhraseQueries);
    qpSettings.allowLeadingWildcard(
            allowLeadingWildcard == null ? context.queryStringAllowLeadingWildcard() : allowLeadingWildcard);
    qpSettings
            .analyzeWildcard(analyzeWildcard == null ? context.queryStringAnalyzeWildcard() : analyzeWildcard);
    qpSettings.lowercaseExpandedTerms(lowercaseExpandedTerms);
    qpSettings.enablePositionIncrements(enablePositionIncrements);
    qpSettings.locale(locale);
    qpSettings.fuzziness(fuzziness);
    qpSettings.fuzzyPrefixLength(fuzzyPrefixLength);
    qpSettings.fuzzyMaxExpansions(fuzzyMaxExpansions);
    qpSettings.fuzzyRewriteMethod(
            QueryParsers.parseRewriteMethod(context.getParseFieldMatcher(), this.fuzzyRewrite));
    qpSettings.phraseSlop(phraseSlop);
    qpSettings.useDisMax(useDisMax);
    qpSettings.tieBreaker(tieBreaker);
    qpSettings.rewriteMethod(QueryParsers.parseRewriteMethod(context.getParseFieldMatcher(), this.rewrite));
    qpSettings.lenient(lenient == null ? context.queryStringLenient() : lenient);
    qpSettings.timeZone(timeZone);
    qpSettings.maxDeterminizedStates(maxDeterminizedStates);

    MapperQueryParser queryParser = context.queryParser(qpSettings);
    Query query;
    try {
        query = queryParser.parse(queryString);
    } catch (org.apache.lucene.queryparser.classic.ParseException e) {
        throw new QueryShardException(context, "Failed to parse query [" + this.queryString + "]", e);
    }

    if (query == null) {
        return null;
    }

    //save the BoostQuery wrapped structure if present
    List<Float> boosts = new ArrayList<>();
    while (query instanceof BoostQuery) {
        BoostQuery boostQuery = (BoostQuery) query;
        boosts.add(boostQuery.getBoost());
        query = boostQuery.getQuery();
    }

    query = Queries.fixNegativeQueryIfNeeded(query);
    // If the coordination factor is disabled on a boolean query we don't apply the minimum should match.
    // This is done to make sure that the minimum_should_match doesn't get applied when there is only one word
    // and multiple variations of the same word in the query (synonyms for instance).
    if (query instanceof BooleanQuery && !((BooleanQuery) query).isCoordDisabled()) {
        query = Queries.applyMinimumShouldMatch((BooleanQuery) query, this.minimumShouldMatch());
    }

    //restore the previous BoostQuery wrapping
    for (int i = boosts.size() - 1; i >= 0; i--) {
        query = new BoostQuery(query, boosts.get(i));
    }

    return query;
}

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

License:Apache License

public void testToQueryBoosts() throws Exception {
    assumeTrue("test runs only when at least a type is registered", getCurrentTypes().length > 0);
    QueryShardContext shardContext = createShardContext();
    QueryStringQueryBuilder queryStringQuery = queryStringQuery(STRING_FIELD_NAME + ":boosted^2");
    Query query = queryStringQuery.toQuery(shardContext);
    assertThat(query, instanceOf(BoostQuery.class));
    BoostQuery boostQuery = (BoostQuery) query;
    assertThat(boostQuery.getBoost(), equalTo(2.0f));
    assertThat(boostQuery.getQuery(), instanceOf(TermQuery.class));
    assertThat(((TermQuery) boostQuery.getQuery()).getTerm(), equalTo(new Term(STRING_FIELD_NAME, "boosted")));
    queryStringQuery.boost(2.0f);/*  w  ww.ja v a 2s. com*/
    query = queryStringQuery.toQuery(shardContext);
    assertThat(query, instanceOf(BoostQuery.class));
    boostQuery = (BoostQuery) query;
    assertThat(boostQuery.getBoost(), equalTo(2.0f));
    assertThat(boostQuery.getQuery(), instanceOf(BoostQuery.class));
    boostQuery = (BoostQuery) boostQuery.getQuery();
    assertThat(boostQuery.getBoost(), equalTo(2.0f));

    queryStringQuery = queryStringQuery(
            "((" + STRING_FIELD_NAME + ":boosted^2) AND (" + STRING_FIELD_NAME + ":foo^1.5))^3");
    query = queryStringQuery.toQuery(shardContext);
    assertThat(query, instanceOf(BoostQuery.class));
    boostQuery = (BoostQuery) query;
    assertThat(boostQuery.getBoost(), equalTo(3.0f));
    BoostQuery boostQuery1 = assertBooleanSubQuery(boostQuery.getQuery(), BoostQuery.class, 0);
    assertThat(boostQuery1.getBoost(), equalTo(2.0f));
    assertThat(boostQuery1.getQuery(), instanceOf(TermQuery.class));
    assertThat(((TermQuery) boostQuery1.getQuery()).getTerm(), equalTo(new Term(STRING_FIELD_NAME, "boosted")));
    BoostQuery boostQuery2 = assertBooleanSubQuery(boostQuery.getQuery(), BoostQuery.class, 1);
    assertThat(boostQuery2.getBoost(), equalTo(1.5f));
    assertThat(boostQuery2.getQuery(), instanceOf(TermQuery.class));
    assertThat(((TermQuery) boostQuery2.getQuery()).getTerm(), equalTo(new Term(STRING_FIELD_NAME, "foo")));
    queryStringQuery.boost(2.0f);
    query = queryStringQuery.toQuery(shardContext);
    assertThat(query, instanceOf(BoostQuery.class));
    boostQuery = (BoostQuery) query;
    assertThat(boostQuery.getBoost(), equalTo(2.0f));
}