## org.apache.lucene.search
Class FuzzyQuery

    java.lang.Object
      org.apache.lucene.search.Query
          org.apache.lucene.search.MultiTermQuery
              org.apache.lucene.search.FuzzyQuery

All Implemented Interfaces:
  java.io.Serializable, java.lang.Cloneable

    public class FuzzyQuery

extends MultiTermQuery

Implements the fuzzy search query. The similarity measurement is based on the Levenshtein (edit distance) algorithm. Warning: this query is not very scalable with its default prefix length of 0 - in this case, *every* term will be enumerated and cause an edit score calculation.

See Also:
  Serialized Form

Nested Class Summary
`protected static class` `FuzzyQuery.ScoreTerm`
`protected static class` `FuzzyQuery.ScoreTermQueue`

Nested classes/interfaces inherited from class org.apache.lucene.search.MultiTermQuery
`MultiTermQuery.ConstantScoreAutoRewrite, MultiTermQuery.RewriteMethod`

Field Summary
`static float` `defaultMinSimilarity`
`static int` `defaultPrefixLength`
`protected Term` `term`

Fields inherited from class org.apache.lucene.search.MultiTermQuery
`CONSTANT_SCORE_AUTO_REWRITE_DEFAULT, CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE, CONSTANT_SCORE_FILTER_REWRITE, rewriteMethod, SCORING_BOOLEAN_QUERY_REWRITE`

Constructor Summary
`FuzzyQuery(Term term)` Calls `FuzzyQuery(term, 0.5f, 0)`.
`FuzzyQuery(Term term, float minimumSimilarity)` Calls `FuzzyQuery(term, minimumSimilarity, 0)`.
`FuzzyQuery(Term term, float minimumSimilarity, int prefixLength)` Create a new FuzzyQuery that will match terms with a similarity of at least `minimumSimilarity` to `term`.

Method Summary
`boolean` `equals(java.lang.Object obj)`
`protected FilteredTermEnum` `getEnum(IndexReader reader)` Construct the enumeration to be used, expanding the pattern term.
`float` `getMinSimilarity()` Returns the minimum similarity that is required for this query to match.
`int` `getPrefixLength()` Returns the non-fuzzy prefix length.
`Term` `getTerm()` Returns the pattern term.
`int` `hashCode()`
`Query` `rewrite(IndexReader reader)` Expert: called to re-write queries into primitive queries.
`void` `setRewriteMethod(MultiTermQuery.RewriteMethod method)` Sets the rewrite method to be used when executing the query.
`java.lang.String` `toString(java.lang.String field)` Prints a query to a string, with `field` assumed to be the default field and omitted.

Methods inherited from class org.apache.lucene.search.MultiTermQuery
`clearTotalNumberOfTerms, getRewriteMethod, getTotalNumberOfTerms, incTotalNumberOfTerms`

Methods inherited from class org.apache.lucene.search.Query
`clone, combine, createWeight, extractTerms, getBoost, getSimilarity, mergeBooleanQueries, setBoost, toString, weight`

Methods inherited from class java.lang.Object
`finalize, getClass, notify, notifyAll, wait, wait, wait`

Field Detail

### defaultMinSimilarity

    public static final float defaultMinSimilarity

See Also:
  Constant Field Values

### defaultPrefixLength

    public static final int defaultPrefixLength

See Also:
  Constant Field Values

### term

    protected Term term

Constructor Detail

### FuzzyQuery

    public FuzzyQuery(Term term,
                      float minimumSimilarity,
                      int prefixLength)
               throws java.lang.IllegalArgumentException

  Create a new FuzzyQuery that will match terms with a similarity of at least `minimumSimilarity` to `term`. If a `prefixLength` > 0 is specified, a common prefix of that length is also required.

  Parameters:
    `term` - the term to search for
    `minimumSimilarity` - a value between 0 and 1 to set the required similarity between the query term and the matching terms. For example, for a `minimumSimilarity` of `0.5` a term of the same length as the query term is considered similar to the query term if the edit distance between both terms is less than `length(term)*0.5`
    `prefixLength` - length of common (non-fuzzy) prefix
  Throws:
    `java.lang.IllegalArgumentException` - if minimumSimilarity is >= 1 or < 0 or if prefixLength < 0

### FuzzyQuery

    public FuzzyQuery(Term term,
                      float minimumSimilarity)
               throws java.lang.IllegalArgumentException

  Calls `FuzzyQuery(term, minimumSimilarity, 0)`.

  Throws:
    `java.lang.IllegalArgumentException`

### FuzzyQuery

    public FuzzyQuery(Term term)

  Calls `FuzzyQuery(term, 0.5f, 0)`.

Method Detail

### getMinSimilarity

    public float getMinSimilarity()

  Returns the minimum similarity that is required for this query to match.

  Returns:
    float value between 0.0 and 1.0

### getPrefixLength

    public int getPrefixLength()

  Returns the non-fuzzy prefix length. This is the number of characters at the start of a term that must be identical (not fuzzy) to the query term if the query is to match that term.

### getEnum

    protected FilteredTermEnum getEnum(IndexReader reader)
                                throws java.io.IOException

  Description copied from class: `MultiTermQuery`
  Construct the enumeration to be used, expanding the pattern term.

  Specified by:
    `getEnum` in class `MultiTermQuery`
  Throws:
    `java.io.IOException`

### getTerm

    public Term getTerm()

  Returns the pattern term.

  Overrides:
    `getTerm` in class `MultiTermQuery`

### setRewriteMethod

    public void setRewriteMethod(MultiTermQuery.RewriteMethod method)

  Description copied from class: `MultiTermQuery`
  Sets the rewrite method to be used when executing the query. You can use one of the four core methods, or implement your own subclass of `MultiTermQuery.RewriteMethod`.

  Overrides:
    `setRewriteMethod` in class `MultiTermQuery`

### rewrite

    public Query rewrite(IndexReader reader)
                  throws java.io.IOException

  Description copied from class: `Query`
  Expert: called to re-write queries into primitive queries. For example, a PrefixQuery will be rewritten into a BooleanQuery that consists of TermQuerys.

  Overrides:
    `rewrite` in class `MultiTermQuery`
  Throws:
    `java.io.IOException`

### toString

    public java.lang.String toString(java.lang.String field)

  Description copied from class: `Query`
  Prints a query to a string, with `field` assumed to be the default field and omitted.

  The representation used is one that is supposed to be readable by `QueryParser`. However, there are the following limitations:

  - If the query was created by the parser, the printed representation may not be exactly what was parsed. For example, characters that need to be escaped will be represented without the required backslash.
  - Some of the more complicated queries (e.g. span queries) don't have a representation that can be parsed by QueryParser.

  Overrides:
    `toString` in class `MultiTermQuery`

### hashCode

    public int hashCode()

  Overrides:
    `hashCode` in class `MultiTermQuery`

### equals

    public boolean equals(java.lang.Object obj)

  Overrides:
    `equals` in class `MultiTermQuery`

Copyright © 2000-2011 Apache Software Foundation. All Rights Reserved.