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

List of usage examples for org.apache.lucene.search FuzzyQuery getPrefixLength

  1. HOME
  2. Java
  3. org.apache.lucene
  4. org.apache.lucene.search.*
  5. FuzzyQuery
  6. getPrefixLength

Introduction

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

Prototype

public int getPrefixLength()

Source Link

Document

Returns the non-fuzzy prefix length.

Usage

From source file:com.github.rnewson.couchdb.lucene.QueryPlan.java

License:Apache License

private static void planFuzzyQuery(final StringBuilder builder, final FuzzyQuery query) {
    builder.append(query.getTerm());/* w  w w.  j a  v  a 2 s  . co  m*/
    builder.append(",prefixLength=");
    builder.append(query.getPrefixLength());
    builder.append(",maxEdits=");
    builder.append(query.getMaxEdits());
}

From source file:com.stratio.cassandra.index.query.FuzzyConditionTest.java

License:Apache License

@Test
public void testFuzzyQuery() {

    Map<String, ColumnMapper<?>> map = new HashMap<>();
    map.put("name", new ColumnMapperBoolean());
    Schema mappers = new Schema(EnglishAnalyzer.class.getName(), map);

    FuzzyCondition fuzzyCondition = new FuzzyCondition(0.5f, "name", "tr", 1, 2, 49, true);
    Query query = fuzzyCondition.query(mappers);

    Assert.assertNotNull(query);/* w w w. j  a v a2s.  c o m*/
    Assert.assertEquals(org.apache.lucene.search.FuzzyQuery.class, query.getClass());
    org.apache.lucene.search.FuzzyQuery luceneQuery = (org.apache.lucene.search.FuzzyQuery) query;
    Assert.assertEquals("name", luceneQuery.getField());
    Assert.assertEquals("tr", luceneQuery.getTerm().text());
    Assert.assertEquals(1, luceneQuery.getMaxEdits());
    Assert.assertEquals(2, luceneQuery.getPrefixLength());
    Assert.assertEquals(0.5f, query.getBoost(), 0);
}

From source file:com.stratio.cassandra.lucene.search.condition.FuzzyConditionTest.java

License:Apache License

@Test
public void testQuery() {

    Schema schema = mock(Schema.class);
    when(schema.getAnalyzer()).thenReturn(PreBuiltAnalyzers.STANDARD.get());
    when(schema.getMapper("name")).thenReturn(new StringMapper("name", null, null, null));

    FuzzyCondition condition = new FuzzyCondition(0.5f, "name", "tr", 1, 2, 49, true);
    Query query = condition.query(schema);

    assertNotNull(query);/*from ww w .  j  a  v a2  s  .  c o m*/
    assertEquals(FuzzyQuery.class, query.getClass());
    FuzzyQuery luceneQuery = (FuzzyQuery) query;
    assertEquals("name", luceneQuery.getField());
    assertEquals("tr", luceneQuery.getTerm().text());
    assertEquals(1, luceneQuery.getMaxEdits());
    assertEquals(2, luceneQuery.getPrefixLength());
    assertEquals(0.5f, query.getBoost(), 0);
}

From source file:org.easynet.resource.queryparser.QueryParserTestBase.java

License:Apache License

public void testWildcard() throws Exception {
    assertQueryEquals("term*", null, "term*");
    assertQueryEquals("term*^2", null, "term*^2.0");
    assertQueryEquals("term~", null, "term~2");
    assertQueryEquals("term~1", null, "term~1");
    assertQueryEquals("term~0.7", null, "term~1");
    assertQueryEquals("term~^3", null, "term~2^3.0");
    assertQueryEquals("term^3~", null, "term~2^3.0");
    assertQueryEquals("term*germ", null, "term*germ");
    assertQueryEquals("term*germ^3", null, "term*germ^3.0");

    assertTrue(getQuery("term*") instanceof PrefixQuery);
    assertTrue(getQuery("term*^2") instanceof PrefixQuery);
    assertTrue(getQuery("term~") instanceof FuzzyQuery);
    assertTrue(getQuery("term~0.7") instanceof FuzzyQuery);
    FuzzyQuery fq = (FuzzyQuery) getQuery("term~0.7");
    assertEquals(1, fq.getMaxEdits());//from ww  w  .ja va 2s .  c om
    assertEquals(FuzzyQuery.defaultPrefixLength, fq.getPrefixLength());
    fq = (FuzzyQuery) getQuery("term~");
    assertEquals(2, fq.getMaxEdits());
    assertEquals(FuzzyQuery.defaultPrefixLength, fq.getPrefixLength());

    assertParseException("term~1.1"); // value > 1, throws exception

    assertTrue(getQuery("term*germ") instanceof WildcardQuery);

    /*
     * Tests to see that wild card terms are (or are not) properly
     * lower-cased with propery parser configuration
     */
    // First prefix queries:
    // by default, convert to lowercase:
    assertWildcardQueryEquals("Term*", true, "term*");
    // explicitly set lowercase:
    assertWildcardQueryEquals("term*", true, "term*");
    assertWildcardQueryEquals("Term*", true, "term*");
    assertWildcardQueryEquals("TERM*", true, "term*");
    // explicitly disable lowercase conversion:
    assertWildcardQueryEquals("term*", false, "term*");
    assertWildcardQueryEquals("Term*", false, "Term*");
    assertWildcardQueryEquals("TERM*", false, "TERM*");
    // Then 'full' wildcard queries:
    // by default, convert to lowercase:
    assertWildcardQueryEquals("Te?m", "te?m");
    // explicitly set lowercase:
    assertWildcardQueryEquals("te?m", true, "te?m");
    assertWildcardQueryEquals("Te?m", true, "te?m");
    assertWildcardQueryEquals("TE?M", true, "te?m");
    assertWildcardQueryEquals("Te?m*gerM", true, "te?m*germ");
    // explicitly disable lowercase conversion:
    assertWildcardQueryEquals("te?m", false, "te?m");
    assertWildcardQueryEquals("Te?m", false, "Te?m");
    assertWildcardQueryEquals("TE?M", false, "TE?M");
    assertWildcardQueryEquals("Te?m*gerM", false, "Te?m*gerM");
    // Fuzzy queries:
    assertWildcardQueryEquals("Term~", "term~2");
    assertWildcardQueryEquals("Term~", true, "term~2");
    assertWildcardQueryEquals("Term~", false, "Term~2");
    // Range queries:
    assertWildcardQueryEquals("[A TO C]", "[a TO c]");
    assertWildcardQueryEquals("[A TO C]", true, "[a TO c]");
    assertWildcardQueryEquals("[A TO C]", false, "[A TO C]");
    // Test suffix queries: first disallow
    try {
        assertWildcardQueryEquals("*Term", true, "*term");
    } catch (Exception pe) {
        // expected exception
        if (!isQueryParserException(pe)) {
            fail();
        }
    }
    try {
        assertWildcardQueryEquals("?Term", true, "?term");
        fail();
    } catch (Exception pe) {
        // expected exception
        if (!isQueryParserException(pe)) {
            fail();
        }
    }
    // Test suffix queries: then allow
    assertWildcardQueryEquals("*Term", true, "*term", true);
    assertWildcardQueryEquals("?Term", true, "?term", true);
}

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);//from   www  .j  a  v  a 2s. co m
    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.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.MatchQueryBuilderTests.java

License:Apache License

@Override
protected void doAssertLuceneQuery(MatchQueryBuilder queryBuilder, Query query, QueryShardContext context)
        throws IOException {
    assertThat(query, notNullValue());//from  ww  w . ja va  2 s . c om

    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
    }
}

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

License:Apache License

@Test
public void testFuzzyQueryWithFieldsBuilder() throws IOException {
    IndexQueryParserService queryParser = queryParser();
    Query parsedQuery = queryParser.parse(fuzzyQuery("name.first", "sh")
            .fuzziness(Fuzziness.fromSimilarity(0.1f)).prefixLength(1).boost(2.0f).buildAsBytes()).query();
    assertThat(parsedQuery, instanceOf(FuzzyQuery.class));
    FuzzyQuery fuzzyQuery = (FuzzyQuery) parsedQuery;
    assertThat(fuzzyQuery.getTerm(), equalTo(new Term("name.first", "sh")));
    assertThat(fuzzyQuery.getMaxEdits(), equalTo(FuzzyQuery.floatToEdits(0.1f, "sh".length())));
    assertThat(fuzzyQuery.getPrefixLength(), equalTo(1));
    assertThat(fuzzyQuery.getBoost(), equalTo(2.0f));
}

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

License:Apache License

@Test
public void testFuzzyQueryWithFields() throws IOException {
    IndexQueryParserService queryParser = queryParser();
    String query = copyToStringFromClasspath("/org/elasticsearch/index/query/fuzzy-with-fields.json");
    Query parsedQuery = queryParser.parse(query).query();
    assertThat(parsedQuery, instanceOf(FuzzyQuery.class));
    FuzzyQuery fuzzyQuery = (FuzzyQuery) parsedQuery;
    assertThat(fuzzyQuery.getTerm(), equalTo(new Term("name.first", "sh")));
    assertThat(fuzzyQuery.getMaxEdits(), equalTo(FuzzyQuery.floatToEdits(0.1f, "sh".length())));
    assertThat(fuzzyQuery.getPrefixLength(), equalTo(1));
    assertThat(fuzzyQuery.getBoost(), equalTo(2.0f));
}

From source file:org.elasticsearch.index.query.xcontent.SimpleIndexQueryParserTests.java

License:Apache License

@Test
public void testFuzzyQueryWithFieldsBuilder() throws IOException {
    IndexQueryParser queryParser = queryParser();
    Query parsedQuery = queryParser.parse(
            fuzzyQuery("name.first", "sh").minSimilarity(0.1f).prefixLength(1).boost(2.0f).buildAsBytes())
            .query();//w w  w .  j a v  a2s  .  c o  m
    assertThat(parsedQuery, instanceOf(FuzzyQuery.class));
    FuzzyQuery fuzzyQuery = (FuzzyQuery) parsedQuery;
    assertThat(fuzzyQuery.getTerm(), equalTo(new Term("name.first", "sh")));
    assertThat(fuzzyQuery.getMinSimilarity(), equalTo(0.1f));
    assertThat(fuzzyQuery.getPrefixLength(), equalTo(1));
    assertThat(fuzzyQuery.getBoost(), equalTo(2.0f));
}