Index: src/test/org/apache/lucene/search/TestFuzzyQuery.java
===================================================================
--- src/test/org/apache/lucene/search/TestFuzzyQuery.java	(revision 910225)
+++ src/test/org/apache/lucene/search/TestFuzzyQuery.java	(working copy)
@@ -317,6 +317,30 @@
     assertEquals(0, hits.length);
   }
   
+  /** Test the TOP_TERMS_CONSTANT_BOOLEAN_REWRITE rewrite method. */
+  public void testConstantRewrite() throws Exception {
+    RAMDirectory directory = new RAMDirectory();
+    IndexWriter writer = new IndexWriter(directory, new WhitespaceAnalyzer(TEST_VERSION_CURRENT),
+        true, IndexWriter.MaxFieldLength.LIMITED);
+    addDoc("Lucene", writer);
+    addDoc("Lucene", writer);
+    addDoc("Lucenne", writer);
+    writer.optimize();
+    writer.close();
+    IndexSearcher searcher = new IndexSearcher(directory, true);
+    IndexReader reader = searcher.getIndexReader();
+    FuzzyQuery query = new FuzzyQuery(new Term("field", "Lucene"));
+    query.setRewriteMethod(MultiTermQuery.TOP_TERMS_CONSTANT_BOOLEAN_REWRITE);
+    ScoreDoc[] hits = searcher.search(query, null, 1000).scoreDocs;
+    assertEquals(3, hits.length);
+    // normally, Lucenne would be the first result as IDF will skew the score.
+    assertEquals("Lucene", reader.document(hits[0].doc).get("field"));
+    assertEquals("Lucene", reader.document(hits[1].doc).get("field"));
+    assertEquals("Lucenne", reader.document(hits[2].doc).get("field"));
+    searcher.close();
+    reader.close();
+  }
+  
   public void testGiga() throws Exception {
 
     StandardAnalyzer analyzer = new StandardAnalyzer(TEST_VERSION_CURRENT);
Index: src/java/org/apache/lucene/search/MultiTermQuery.java
===================================================================
--- src/java/org/apache/lucene/search/MultiTermQuery.java	(revision 910225)
+++ src/java/org/apache/lucene/search/MultiTermQuery.java	(working copy)
@@ -163,7 +163,7 @@
    *  @see #setRewriteMethod */
   public final static RewriteMethod SCORING_BOOLEAN_QUERY_REWRITE = new ScoringBooleanQueryRewrite();
 
-  private static final class TopTermsScoringBooleanQueryRewrite extends BooleanQueryRewrite {
+  private static abstract class TopTermsBooleanQueryRewrite extends BooleanQueryRewrite {
     @Override
     public Query rewrite(IndexReader reader, MultiTermQuery query) throws IOException {
       final int maxSize = BooleanQuery.getMaxClauseCount();
@@ -188,18 +188,15 @@
       
       final BooleanQuery bq = new BooleanQuery(true);
       for (final ScoreTerm st : stQueue) {
-        TermQuery tq = new TermQuery(st.term);    // found a match
+        Query tq = getQuery(st.term);    // found a match
         tq.setBoost(query.getBoost() * st.boost); // set the boost
         bq.add(tq, BooleanClause.Occur.SHOULD);   // add to query
       }
       query.incTotalNumberOfTerms(bq.clauses().size());
       return bq;
     }
-
-    // Make sure we are still a singleton even after deserializing
-    protected Object readResolve() {
-      return TOP_TERMS_SCORING_BOOLEAN_REWRITE;
-    }
+    
+    protected abstract Query getQuery(Term term);
   
     private static class ScoreTerm implements Comparable<ScoreTerm> {
       public Term term;
@@ -214,6 +211,30 @@
     }
   }
   
+  private static final class TopTermsScoringBooleanQueryRewrite extends TopTermsBooleanQueryRewrite {
+    @Override
+    protected Query getQuery(Term term) {
+      return new TermQuery(term);
+    }
+    
+    // Make sure we are still a singleton even after deserializing
+    protected Object readResolve() {
+      return TOP_TERMS_SCORING_BOOLEAN_REWRITE;
+    }
+  }
+  
+  private static final class TopTermsConstantBooleanQueryRewrite extends TopTermsBooleanQueryRewrite {
+    @Override
+    protected Query getQuery(Term term) {
+      return new ConstantScoreQuery(new QueryWrapperFilter(new TermQuery(term)));
+    }
+    
+    // Make sure we are still a singleton even after deserializing
+    protected Object readResolve() {
+      return TOP_TERMS_CONSTANT_BOOLEAN_REWRITE;
+    }
+  }
+  
   /** A rewrite method that first translates each term into
    *  {@link BooleanClause.Occur#SHOULD} clause in a
    *  BooleanQuery, and keeps the scores as computed by the
@@ -225,6 +246,17 @@
    *
    *  @see #setRewriteMethod */
   public final static RewriteMethod TOP_TERMS_SCORING_BOOLEAN_REWRITE = new TopTermsScoringBooleanQueryRewrite();
+  
+  /** A rewrite method that first translates each term into
+   *  {@link BooleanClause.Occur#SHOULD} clause in a
+   *  BooleanQuery, but the scores are only computed as
+   *  the boost.
+   *
+   * <p>This rewrite mode only uses the top scoring terms
+   * so it will not overflow the boolean max clause count.
+   *
+   *  @see #setRewriteMethod */
+  public final static RewriteMethod TOP_TERMS_CONSTANT_BOOLEAN_REWRITE = new TopTermsConstantBooleanQueryRewrite();
 
   private static class ConstantScoreBooleanQueryRewrite extends ScoringBooleanQueryRewrite implements Serializable {
     @Override