Example usage for org.apache.lucene.search MultiTermQuery CONSTANT_SCORE

Introduction

In this page you can find the example usage for org.apache.lucene.search MultiTermQuery CONSTANT_SCORE_REWRITE.

Prototype

RewriteMethod CONSTANT_SCORE_REWRITE

To view the source code for org.apache.lucene.search MultiTermQuery CONSTANT_SCORE_REWRITE.

Click Source Link

Document

A rewrite method that first creates a private Filter, by visiting each term in sequence and marking all docs for that term.

Usage

From source file:org.alfresco.solr.query.Solr4QueryParser.java

License:Open Source License

protected Query newRangeQuery(String field, String part1, String part2, boolean startInclusive,
        boolean endInclusive) {
    final BytesRef start;
    final BytesRef end;

    if (part1 == null) {
        start = null;//w w w .ja  va2 s .c o m
    } else {
        start = analyzeRangeTerms ? analyzeMultitermTerm(field, part1) : new BytesRef(part1);
    }

    if (part2 == null) {
        end = null;
    } else {
        end = analyzeRangeTerms ? analyzeMultitermTerm(field, part2) : new BytesRef(part2);
    }

    final TermRangeQuery query = new TermRangeQuery(field, start, end, startInclusive, endInclusive);

    query.setRewriteMethod(MultiTermQuery.CONSTANT_SCORE_REWRITE);
    return query;
}

From source file:org.apache.solr.legacy.TestNumericRangeQuery32.java

License:Apache License

/** test for both constant score and boolean query, the other tests only use the constant score mode */
private void testRange(int precisionStep) throws Exception {
    String field = "field" + precisionStep;
    int count = 3000;
    int lower = (distance * 3 / 2) + startOffset, upper = lower + count * distance + (distance / 3);
    LegacyNumericRangeQuery<Integer> q = LegacyNumericRangeQuery.newIntRange(field, precisionStep, lower, upper,
            true, true);/*  w ww .j  ava  2  s .c  om*/
    for (byte i = 0; i < 2; i++) {
        TopDocs topDocs;
        String type;
        switch (i) {
        case 0:
            type = " (constant score filter rewrite)";
            q.setRewriteMethod(MultiTermQuery.CONSTANT_SCORE_REWRITE);
            topDocs = searcher.search(q, noDocs, Sort.INDEXORDER);
            break;
        case 1:
            type = " (constant score boolean rewrite)";
            q.setRewriteMethod(MultiTermQuery.CONSTANT_SCORE_BOOLEAN_REWRITE);
            topDocs = searcher.search(q, noDocs, Sort.INDEXORDER);
            break;
        default:
            return;
        }
        ScoreDoc[] sd = topDocs.scoreDocs;
        assertNotNull(sd);
        assertEquals("Score doc count" + type, count, sd.length);
        Document doc = searcher.doc(sd[0].doc);
        assertEquals("First doc" + type, 2 * distance + startOffset,
                doc.getField(field).numericValue().intValue());
        doc = searcher.doc(sd[sd.length - 1].doc);
        assertEquals("Last doc" + type, (1 + count) * distance + startOffset,
                doc.getField(field).numericValue().intValue());
    }
}

From source file:org.apache.solr.legacy.TestNumericRangeQuery64.java

License:Apache License

/** test for constant score + boolean query + filter, the other tests only use the constant score mode */
private void testRange(int precisionStep) throws Exception {
    String field = "field" + precisionStep;
    int count = 3000;
    long lower = (distance * 3 / 2) + startOffset, upper = lower + count * distance + (distance / 3);
    LegacyNumericRangeQuery<Long> q = LegacyNumericRangeQuery.newLongRange(field, precisionStep, lower, upper,
            true, true);//  w w  w.j a v  a2  s.c  o  m
    for (byte i = 0; i < 2; i++) {
        TopDocs topDocs;
        String type;
        switch (i) {
        case 0:
            type = " (constant score filter rewrite)";
            q.setRewriteMethod(MultiTermQuery.CONSTANT_SCORE_REWRITE);
            topDocs = searcher.search(q, noDocs, Sort.INDEXORDER);
            break;
        case 1:
            type = " (constant score boolean rewrite)";
            q.setRewriteMethod(MultiTermQuery.CONSTANT_SCORE_BOOLEAN_REWRITE);
            topDocs = searcher.search(q, noDocs, Sort.INDEXORDER);
            break;
        default:
            return;
        }
        ScoreDoc[] sd = topDocs.scoreDocs;
        assertNotNull(sd);
        assertEquals("Score doc count" + type, count, sd.length);
        Document doc = searcher.doc(sd[0].doc);
        assertEquals("First doc" + type, 2 * distance + startOffset,
                doc.getField(field).numericValue().longValue());
        doc = searcher.doc(sd[sd.length - 1].doc);
        assertEquals("Last doc" + type, (1 + count) * distance + startOffset,
                doc.getField(field).numericValue().longValue());
    }
}

From source file:org.codelibs.elasticsearch.index.query.support.QueryParsers.java

License:Apache License

public static MultiTermQuery.RewriteMethod parseRewriteMethod(@Nullable String rewriteMethod) {
    return parseRewriteMethod(rewriteMethod, MultiTermQuery.CONSTANT_SCORE_REWRITE);
}

From source file:org.codelibs.elasticsearch.index.query.support.QueryParsers.java

License:Apache License

public static MultiTermQuery.RewriteMethod parseRewriteMethod(@Nullable String rewriteMethod,
        @Nullable MultiTermQuery.RewriteMethod defaultRewriteMethod) {
    if (rewriteMethod == null) {
        return defaultRewriteMethod;
    }// w w w .jav a2s .  c om
    if (CONSTANT_SCORE.match(rewriteMethod)) {
        return MultiTermQuery.CONSTANT_SCORE_REWRITE;
    }
    if (SCORING_BOOLEAN.match(rewriteMethod)) {
        return MultiTermQuery.SCORING_BOOLEAN_REWRITE;
    }
    if (CONSTANT_SCORE_BOOLEAN.match(rewriteMethod)) {
        return MultiTermQuery.CONSTANT_SCORE_BOOLEAN_REWRITE;
    }

    int firstDigit = -1;
    for (int i = 0; i < rewriteMethod.length(); ++i) {
        if (Character.isDigit(rewriteMethod.charAt(i))) {
            firstDigit = i;
            break;
        }
    }

    if (firstDigit >= 0) {
        final int size = Integer.parseInt(rewriteMethod.substring(firstDigit));
        String rewriteMethodName = rewriteMethod.substring(0, firstDigit);

        if (TOP_TERMS.match(rewriteMethodName)) {
            return new MultiTermQuery.TopTermsScoringBooleanQueryRewrite(size);
        }
        if (TOP_TERMS_BOOST.match(rewriteMethodName)) {
            return new MultiTermQuery.TopTermsBoostOnlyBooleanQueryRewrite(size);
        }
        if (TOP_TERMS_BLENDED_FREQS.match(rewriteMethodName)) {
            return new MultiTermQuery.TopTermsBlendedFreqScoringRewrite(size);
        }
    }

    throw new IllegalArgumentException("Failed to parse rewrite_method [" + rewriteMethod + "]");
}

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

License:Apache License

public void testToQueryWildcarQuery() throws Exception {
    assumeTrue("test runs only when at least a type is registered", getCurrentTypes().length > 0);
    for (Operator op : Operator.values()) {
        BooleanClause.Occur defaultOp = op.toBooleanClauseOccur();
        MapperQueryParser queryParser = new MapperQueryParser(createShardContext());
        QueryParserSettings settings = new QueryParserSettings("first foo-bar-foobar* last");
        settings.defaultField(STRING_FIELD_NAME);
        settings.fieldsAndWeights(Collections.emptyMap());
        settings.analyzeWildcard(true);/*from  w  w  w. ja va  2  s . c  om*/
        settings.fuzziness(Fuzziness.AUTO);
        settings.rewriteMethod(MultiTermQuery.CONSTANT_SCORE_REWRITE);
        settings.defaultOperator(op.toQueryParserOperator());
        queryParser.reset(settings);
        Query query = queryParser.parse("first foo-bar-foobar* last");
        Query expectedQuery = new BooleanQuery.Builder()
                .add(new BooleanClause(new TermQuery(new Term(STRING_FIELD_NAME, "first")), defaultOp))
                .add(new BooleanQuery.Builder()
                        .add(new BooleanClause(new TermQuery(new Term(STRING_FIELD_NAME, "foo")), defaultOp))
                        .add(new BooleanClause(new TermQuery(new Term(STRING_FIELD_NAME, "bar")), defaultOp))
                        .add(new BooleanClause(new PrefixQuery(new Term(STRING_FIELD_NAME, "foobar")),
                                defaultOp))
                        .build(), defaultOp)
                .add(new BooleanClause(new TermQuery(new Term(STRING_FIELD_NAME, "last")), defaultOp)).build();
        assertThat(query, Matchers.equalTo(expectedQuery));
    }
}

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

License:Apache License

public void testToQueryWilcardQueryWithSynonyms() throws Exception {
    assumeTrue("test runs only when at least a type is registered", getCurrentTypes().length > 0);
    for (Operator op : Operator.values()) {
        BooleanClause.Occur defaultOp = op.toBooleanClauseOccur();
        MapperQueryParser queryParser = new MapperQueryParser(createShardContext());
        QueryParserSettings settings = new QueryParserSettings("first foo-bar-foobar* last");
        settings.defaultField(STRING_FIELD_NAME);
        settings.fieldsAndWeights(Collections.emptyMap());
        settings.analyzeWildcard(true);/* ww  w  .  j a  v a  2  s .co m*/
        settings.fuzziness(Fuzziness.AUTO);
        settings.rewriteMethod(MultiTermQuery.CONSTANT_SCORE_REWRITE);
        settings.defaultOperator(op.toQueryParserOperator());
        settings.forceAnalyzer(new MockRepeatAnalyzer());
        queryParser.reset(settings);
        Query query = queryParser.parse("first foo-bar-foobar* last");

        Query expectedQuery = new BooleanQuery.Builder()
                .add(new BooleanClause(
                        new SynonymQuery(new Term(STRING_FIELD_NAME, "first"),
                                new Term(STRING_FIELD_NAME, "first")),
                        defaultOp))
                .add(new BooleanQuery.Builder()
                        .add(new BooleanClause(
                                new SynonymQuery(new Term(STRING_FIELD_NAME, "foo"),
                                        new Term(STRING_FIELD_NAME, "foo")),
                                defaultOp))
                        .add(new BooleanClause(new SynonymQuery(new Term(STRING_FIELD_NAME, "bar"),
                                new Term(STRING_FIELD_NAME, "bar")), defaultOp))
                        .add(new BooleanQuery.Builder()
                                .add(new BooleanClause(new PrefixQuery(new Term(STRING_FIELD_NAME, "foobar")),
                                        BooleanClause.Occur.SHOULD))
                                .add(new BooleanClause(new PrefixQuery(new Term(STRING_FIELD_NAME, "foobar")),
                                        BooleanClause.Occur.SHOULD))
                                .setDisableCoord(true).build(), defaultOp)
                        .build(), defaultOp)
                .add(new BooleanClause(new SynonymQuery(new Term(STRING_FIELD_NAME, "last"),
                        new Term(STRING_FIELD_NAME, "last")), defaultOp))
                .build();
        assertThat(query, Matchers.equalTo(expectedQuery));
    }
}

Example usage for org.apache.lucene.search MultiTermQuery CONSTANT_SCORE_REWRITE

Introduction

Prototype

Document

Usage