Example usage for org.apache.lucene.search FuzzyQuery getTranspositions

Introduction

In this page you can find the example usage for org.apache.lucene.search FuzzyQuery getTranspositions.

Prototype

public boolean getTranspositions() 

Source Link

Document

Returns true if transpositions should be treated as a primitive edit operation.

Usage

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

License:Apache License

@Override
public Map visit(FuzzyQuery query) throws Exception {
    final Map map = newQuery(query);
    final Term term = query.getTerm();
    final String field = getTermField(term);
    final String termStr = term.bytes().utf8ToString();
    final String rewriteMethod = query.getRewriteMethod().getClass().getSimpleName();
    map.put(field, termStr);/*  w ww . j ava 2 s.  c om*/
    map.put("max_edits", query.getMaxEdits());
    map.put("prefix_length", query.getPrefixLength());
    map.put("transpositions", query.getTranspositions());
    map.put("rewrite_method", rewriteMethod);
    return map;
}

---

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

License:Apache License

@Override
protected void doAssertLuceneQuery(MatchQueryBuilder queryBuilder, Query query, QueryShardContext context)
        throws IOException {
    assertThat(query, notNullValue());/*from  www. ja v a2 s.  co m*/

    if (query instanceof MatchAllDocsQuery) {
        assertThat(queryBuilder.zeroTermsQuery(), equalTo(ZeroTermsQuery.ALL));
        return;
    }

    switch (queryBuilder.type()) {
    case BOOLEAN:
        assertThat(query,
                either(instanceOf(BooleanQuery.class)).or(instanceOf(ExtendedCommonTermsQuery.class))
                        .or(instanceOf(TermQuery.class)).or(instanceOf(FuzzyQuery.class))
                        .or(instanceOf(MatchNoDocsQuery.class)).or(instanceOf(PointRangeQuery.class)));
        break;
    case PHRASE:
        assertThat(query,
                either(instanceOf(BooleanQuery.class)).or(instanceOf(PhraseQuery.class))
                        .or(instanceOf(TermQuery.class)).or(instanceOf(FuzzyQuery.class))
                        .or(instanceOf(PointRangeQuery.class)));
        break;
    case PHRASE_PREFIX:
        assertThat(query,
                either(instanceOf(BooleanQuery.class)).or(instanceOf(MultiPhrasePrefixQuery.class))
                        .or(instanceOf(TermQuery.class)).or(instanceOf(FuzzyQuery.class))
                        .or(instanceOf(PointRangeQuery.class)));
        break;
    }

    MappedFieldType fieldType = context.fieldMapper(queryBuilder.fieldName());
    if (query instanceof TermQuery && fieldType != null) {
        String queryValue = queryBuilder.value().toString();
        if (queryBuilder.analyzer() == null || queryBuilder.analyzer().equals("simple")) {
            queryValue = queryValue.toLowerCase(Locale.ROOT);
        }
        Query expectedTermQuery = fieldType.termQuery(queryValue, context);
        assertEquals(expectedTermQuery, query);
    }

    if (query instanceof BooleanQuery) {
        BooleanQuery bq = (BooleanQuery) query;
        if (queryBuilder.minimumShouldMatch() != null) {
            // calculate expected minimumShouldMatch value
            int optionalClauses = 0;
            for (BooleanClause c : bq.clauses()) {
                if (c.getOccur() == BooleanClause.Occur.SHOULD) {
                    optionalClauses++;
                }
            }
            int msm = Queries.calculateMinShouldMatch(optionalClauses, queryBuilder.minimumShouldMatch());
            assertThat(bq.getMinimumNumberShouldMatch(), equalTo(msm));
        }
        if (queryBuilder.analyzer() == null && queryBuilder.value().toString().length() > 0) {
            assertEquals(bq.clauses().size(), queryBuilder.value().toString().split(" ").length);
        }
    }

    if (query instanceof ExtendedCommonTermsQuery) {
        assertTrue(queryBuilder.cutoffFrequency() != null);
        ExtendedCommonTermsQuery ectq = (ExtendedCommonTermsQuery) query;
        assertEquals(queryBuilder.cutoffFrequency(), ectq.getMaxTermFrequency(), Float.MIN_VALUE);
    }

    if (query instanceof FuzzyQuery) {
        assertTrue(queryBuilder.fuzziness() != null);
        FuzzyQuery fuzzyQuery = (FuzzyQuery) query;
        // depending on analyzer being set or not we can have term lowercased along the way, so to simplify test we just
        // compare lowercased terms here
        String originalTermLc = queryBuilder.value().toString().toLowerCase(Locale.ROOT);
        String actualTermLc = fuzzyQuery.getTerm().text().toLowerCase(Locale.ROOT);
        Matcher<String> termLcMatcher = equalTo(originalTermLc);
        if ("false".equals(originalTermLc) || "true".equals(originalTermLc)) {
            // Booleans become t/f when querying a boolean field
            termLcMatcher = either(termLcMatcher).or(equalTo(originalTermLc.substring(0, 1)));
        }
        assertThat(actualTermLc, termLcMatcher);
        assertThat(queryBuilder.prefixLength(), equalTo(fuzzyQuery.getPrefixLength()));
        assertThat(queryBuilder.fuzzyTranspositions(), equalTo(fuzzyQuery.getTranspositions()));
    }

    if (query instanceof PointRangeQuery) {
        // TODO
    }
}

---