Index: lucene/contrib/instantiated/src/java/org/apache/lucene/store/instantiated/InstantiatedTermsEnum.java --- lucene/contrib/instantiated/src/java/org/apache/lucene/store/instantiated/InstantiatedTermsEnum.java Tue Jun 21 04:53:16 2011 -0400 +++ lucene/contrib/instantiated/src/java/org/apache/lucene/store/instantiated/InstantiatedTermsEnum.java Tue Jun 21 18:12:47 2011 -0400 @@ -44,7 +44,7 @@ } @Override - public SeekStatus seek(BytesRef text, boolean useCache) { + public SeekStatus seek(BytesRef text, boolean useCache, boolean onlyExact) { final Term t = new Term(field, text); int loc = Arrays.binarySearch(terms, t, InstantiatedTerm.termComparator); if (loc < 0) { @@ -52,7 +52,9 @@ if (upto >= terms.length) { return SeekStatus.END; } else { - br.copy(terms[upto].getTerm().bytes()); + if (!onlyExact) { + br.copy(terms[upto].getTerm().bytes()); + } return SeekStatus.NOT_FOUND; } } else { Index: lucene/contrib/memory/src/java/org/apache/lucene/index/memory/MemoryIndex.java --- lucene/contrib/memory/src/java/org/apache/lucene/index/memory/MemoryIndex.java Tue Jun 21 04:53:16 2011 -0400 +++ lucene/contrib/memory/src/java/org/apache/lucene/index/memory/MemoryIndex.java Tue Jun 21 18:12:47 2011 -0400 @@ -860,14 +860,16 @@ } @Override - public SeekStatus seek(BytesRef text, boolean useCache) { + public SeekStatus seek(BytesRef text, boolean useCache, boolean onlyExact) { termUpto = Arrays.binarySearch(info.sortedTerms, text, termComparator); if (termUpto < 0) { // not found; choose successor termUpto = -termUpto -1; if (termUpto >= info.sortedTerms.length) { return SeekStatus.END; } else { - br.copy(info.sortedTerms[termUpto].getKey()); + if (!onlyExact) { + br.copy(info.sortedTerms[termUpto].getKey()); + } return SeekStatus.NOT_FOUND; } } else { Index: lucene/src/java/org/apache/lucene/index/BufferedDeletesStream.java --- lucene/src/java/org/apache/lucene/index/BufferedDeletesStream.java Tue Jun 21 04:53:16 2011 -0400 +++ lucene/src/java/org/apache/lucene/index/BufferedDeletesStream.java Tue Jun 21 18:12:47 2011 -0400 @@ -398,7 +398,7 @@ // System.out.println(" term=" + term); - if (termsEnum.seek(term.bytes(), false) == TermsEnum.SeekStatus.FOUND) { + if (termsEnum.seek(term.bytes(), false, true) == TermsEnum.SeekStatus.FOUND) { DocsEnum docsEnum = termsEnum.docs(reader.getDeletedDocs(), docs); if (docsEnum != null) { Index: lucene/src/java/org/apache/lucene/index/DocTermOrds.java --- lucene/src/java/org/apache/lucene/index/DocTermOrds.java Tue Jun 21 04:53:16 2011 -0400 +++ lucene/src/java/org/apache/lucene/index/DocTermOrds.java Tue Jun 21 18:12:47 2011 -0400 @@ -693,7 +693,7 @@ } @Override - public SeekStatus seek(BytesRef target, boolean useCache) throws IOException { + public SeekStatus seek(BytesRef target, boolean useCache, boolean onlyExact) throws IOException { // already here if (term != null && term.equals(target)) { @@ -712,6 +712,10 @@ return SeekStatus.FOUND; } + if (onlyExact) { + return SeekStatus.NOT_FOUND; + } + // we didn't hit the term exactly startIdx = -startIdx-1; @@ -756,14 +760,14 @@ @Override public SeekStatus seek(long targetOrd) throws IOException { int delta = (int) (targetOrd - ordBase - ord); - //System.out.println(" seek(ord) targetOrd=" + targetOrd + " delta=" + delta + " ord=" + ord); + //System.out.println(" seek(ord) targetOrd=" + targetOrd + " delta=" + delta + " ord=" + ord + " ii=" + indexInterval); if (delta < 0 || delta > indexInterval) { final int idx = (int) (targetOrd >>> indexIntervalBits); final BytesRef base = indexedTermsArray[idx]; //System.out.println(" do seek term=" + base.utf8ToString()); ord = idx << indexIntervalBits; delta = (int) (targetOrd - ord); - final TermsEnum.SeekStatus seekStatus = termsEnum.seek(base, true); + final TermsEnum.SeekStatus seekStatus = termsEnum.seek(base, true, false); assert seekStatus == TermsEnum.SeekStatus.FOUND; } else { //System.out.println("seek w/in block"); @@ -779,8 +783,8 @@ } setTerm(); + //System.out.println(" return term=" + term.utf8ToString()); return term == null ? SeekStatus.END : SeekStatus.FOUND; - //System.out.println(" return term=" + term.utf8ToString()); } private BytesRef setTerm() throws IOException { Index: lucene/src/java/org/apache/lucene/index/FilterIndexReader.java --- lucene/src/java/org/apache/lucene/index/FilterIndexReader.java Tue Jun 21 04:53:16 2011 -0400 +++ lucene/src/java/org/apache/lucene/index/FilterIndexReader.java Tue Jun 21 18:12:47 2011 -0400 @@ -132,8 +132,8 @@ public FilterTermsEnum(TermsEnum in) { this.in = in; } @Override - public SeekStatus seek(BytesRef text, boolean useCache) throws IOException { - return in.seek(text, useCache); + public SeekStatus seek(BytesRef text, boolean useCache, boolean onlyExact) throws IOException { + return in.seek(text, useCache, onlyExact); } @Override Index: lucene/src/java/org/apache/lucene/index/MultiTermsEnum.java --- lucene/src/java/org/apache/lucene/index/MultiTermsEnum.java Tue Jun 21 04:53:16 2011 -0400 +++ lucene/src/java/org/apache/lucene/index/MultiTermsEnum.java Tue Jun 21 18:12:47 2011 -0400 @@ -139,7 +139,7 @@ } @Override - public SeekStatus seek(BytesRef term, boolean useCache) throws IOException { + public SeekStatus seek(BytesRef term, boolean useCache, boolean onlyExact) throws IOException { queue.clear(); numTop = 0; @@ -147,8 +147,13 @@ if (lastSeek != null && termComp.compare(lastSeek, term) <= 0) { seekOpt = true; } - lastSeekScratch.copy(term); - lastSeek = lastSeekScratch; + + if (!onlyExact) { + lastSeekScratch.copy(term); + lastSeek = lastSeekScratch; + } else { + lastSeek = null; + } for(int i=0;i>> result = fstEnum.seekExact(text); + if (result == null) { + return SeekStatus.NOT_FOUND; + } else { + PairOutputs.Pair> pair1 = result.output; + PairOutputs.Pair pair2 = pair1.output2; + docsStart = pair1.output1; + docFreq = pair2.output1.intValue(); + totalTermFreq = pair2.output2; + return SeekStatus.FOUND; + } } else { - //System.out.println(" got text=" + term.utf8ToString()); - PairOutputs.Pair> pair1 = result.output; - PairOutputs.Pair pair2 = pair1.output2; - docsStart = pair1.output1; - docFreq = pair2.output1.intValue(); - totalTermFreq = pair2.output2; + //System.out.println("seek to text=" + text.utf8ToString()); + final BytesRefFSTEnum.InputOutput>> result = fstEnum.seekCeil(text); + if (result == null) { + //System.out.println(" end"); + return SeekStatus.END; + } else { + //System.out.println(" got text=" + term.utf8ToString()); + PairOutputs.Pair> pair1 = result.output; + PairOutputs.Pair pair2 = pair1.output2; + docsStart = pair1.output1; + docFreq = pair2.output1.intValue(); + totalTermFreq = pair2.output2; - if (result.input.equals(text)) { - //System.out.println(" match docsStart=" + docsStart); - return SeekStatus.FOUND; - } else { - //System.out.println(" not match docsStart=" + docsStart); - return SeekStatus.NOT_FOUND; + if (result.input.equals(text)) { + //System.out.println(" match docsStart=" + docsStart); + return SeekStatus.FOUND; + } else { + //System.out.println(" not match docsStart=" + docsStart); + return SeekStatus.NOT_FOUND; + } } } } Index: lucene/src/java/org/apache/lucene/search/FilteredTermsEnum.java --- lucene/src/java/org/apache/lucene/search/FilteredTermsEnum.java Tue Jun 21 04:53:16 2011 -0400 +++ lucene/src/java/org/apache/lucene/search/FilteredTermsEnum.java Tue Jun 21 18:12:47 2011 -0400 @@ -135,7 +135,7 @@ * @throws UnsupportedOperationException */ @Override - public SeekStatus seek(BytesRef term, boolean useCache) throws IOException { + public SeekStatus seek(BytesRef term, boolean useCache, boolean onlyExact /* ignored */) throws IOException { throw new UnsupportedOperationException(getClass().getName()+" does not support seeking"); } @@ -189,7 +189,7 @@ final BytesRef t = nextSeekTerm(actualTerm); // Make sure we always seek forward: assert actualTerm == null || t == null || getComparator().compare(t, actualTerm) > 0: "curTerm=" + actualTerm + " seekTerm=" + t; - if (t == null || tenum.seek(t, false) == SeekStatus.END) { + if (t == null || tenum.seek(t, false, false) == SeekStatus.END) { // no more terms to seek to or enum exhausted return null; } Index: lucene/src/java/org/apache/lucene/search/FuzzyTermsEnum.java --- lucene/src/java/org/apache/lucene/search/FuzzyTermsEnum.java Tue Jun 21 04:53:16 2011 -0400 +++ lucene/src/java/org/apache/lucene/search/FuzzyTermsEnum.java Tue Jun 21 18:12:47 2011 -0400 @@ -283,8 +283,8 @@ } @Override - public SeekStatus seek(BytesRef text, boolean useCache) throws IOException { - return actualEnum.seek(text, useCache); + public SeekStatus seek(BytesRef text, boolean useCache, boolean onlyExact) throws IOException { + return actualEnum.seek(text, useCache, onlyExact); } @Override Index: lucene/src/java/org/apache/lucene/search/cache/DocTermsIndexCreator.java --- lucene/src/java/org/apache/lucene/search/cache/DocTermsIndexCreator.java Tue Jun 21 04:53:16 2011 -0400 +++ lucene/src/java/org/apache/lucene/search/cache/DocTermsIndexCreator.java Tue Jun 21 18:12:47 2011 -0400 @@ -241,7 +241,7 @@ } @Override - public SeekStatus seek(BytesRef text, boolean useCache) throws IOException { + public SeekStatus seek(BytesRef text, boolean useCache /* ignored */, boolean onlyExact /* ignored */) throws IOException { int low = 1; int high = numOrd-1; Index: lucene/src/java/org/apache/lucene/util/PerReaderTermState.java --- lucene/src/java/org/apache/lucene/util/PerReaderTermState.java Tue Jun 21 04:53:16 2011 -0400 +++ lucene/src/java/org/apache/lucene/util/PerReaderTermState.java Tue Jun 21 18:12:47 2011 -0400 @@ -90,7 +90,7 @@ final Terms terms = fields.terms(field); if (terms != null) { final TermsEnum termsEnum = terms.getThreadTermsEnum(); // thread-private don't share! - if (SeekStatus.FOUND == termsEnum.seek(bytes, cache)) { + if (SeekStatus.FOUND == termsEnum.seek(bytes, cache, true)) { final TermState termState = termsEnum.termState(); perReaderTermState.register(termState, leaves[i].ord, termsEnum.docFreq()); } Index: lucene/src/java/org/apache/lucene/util/fst/BytesRefFSTEnum.java --- lucene/src/java/org/apache/lucene/util/fst/BytesRefFSTEnum.java Tue Jun 21 04:53:16 2011 -0400 +++ lucene/src/java/org/apache/lucene/util/fst/BytesRefFSTEnum.java Tue Jun 21 18:12:47 2011 -0400 @@ -71,6 +71,21 @@ return setResult(); } + /** Seeks to exactly this term, returning null if the term + * doesn't exist. This is faster than using {@link + * #seekFloor} or {@link #seekCeil} because it + * short-circuits as soon the match is not found. */ + public InputOutput seekExact(BytesRef target) throws IOException { + this.target = target; + targetLength = target.length; + if (super.doSeekExact()) { + assert upto == 1+target.length; + return setResult(); + } else { + return null; + } + } + @Override protected int getTargetLabel() { if (upto-1 == target.length) { Index: lucene/src/java/org/apache/lucene/util/fst/FST.java --- lucene/src/java/org/apache/lucene/util/fst/FST.java Tue Jun 21 04:53:16 2011 -0400 +++ lucene/src/java/org/apache/lucene/util/fst/FST.java Tue Jun 21 18:12:47 2011 -0400 @@ -704,6 +704,12 @@ if (labelToMatch == END_LABEL) { if (follow.isFinal()) { + if (follow.target <= 0) { + arc.flags = BIT_LAST_ARC; + } else { + arc.flags = 0; + arc.nextArc = follow.target; + } arc.output = follow.nextFinalOutput; arc.label = END_LABEL; return arc; Index: lucene/src/java/org/apache/lucene/util/fst/FSTEnum.java --- lucene/src/java/org/apache/lucene/util/fst/FSTEnum.java Tue Jun 21 04:53:16 2011 -0400 +++ lucene/src/java/org/apache/lucene/util/fst/FSTEnum.java Tue Jun 21 18:12:47 2011 -0400 @@ -73,6 +73,7 @@ final int cmp = getCurrentLabel() - getTargetLabel(); if (cmp < 0) { // seek forward + //System.out.println(" seek fwd"); break; } else if (cmp > 0) { // seek backwards -- reset this arc to the first arc @@ -83,6 +84,7 @@ } upto++; } + //System.out.println(" fall through upto=" + upto); } protected void doNext() throws IOException { @@ -352,7 +354,7 @@ //System.out.println(" hasFloor arcIdx=" + (arc.arcIdx+1)); fst.readNextRealArc(arc); assert arc.isLast() || fst.readNextArcLabel(arc) > targetLabel; - assert arc.label < targetLabel; + assert arc.label < targetLabel: "arc.label=" + arc.label + " vs targetLabel=" + targetLabel; pushLast(); return; } @@ -410,6 +412,48 @@ } } + /** Seeks to exactly target term. */ + protected boolean doSeekExact() throws IOException { + + // TODO: possibly caller could/should provide common + // prefix length? ie this work may be redundant if + // caller is in fact intersecting against its own + // automaton + + //System.out.println("FE: seek exact upto=" + upto); + + // Save time by starting at the end of the shared prefix + // b/w our current term & the target: + rewindPrefix(); + + //System.out.println("FE: after rewind upto=" + upto); + FST.Arc arc = getArc(upto-1); + int targetLabel = getTargetLabel(); + + while(true) { + //System.out.println(" cycle target=" + (targetLabel == -1 ? "-1" : (char) targetLabel)); + final FST.Arc nextArc = fst.findTargetArc(targetLabel, arc, getArc(upto)); + if (nextArc == null) { + // short circuit + //upto--; + //upto = 0; + fst.readFirstTargetArc(arc, getArc(upto)); + //System.out.println(" no match upto=" + upto); + return false; + } + // Match -- recurse: + output[upto] = fst.outputs.add(output[upto-1], nextArc.output); + if (targetLabel == FST.END_LABEL) { + //System.out.println(" return found; upto=" + upto + " output=" + output[upto] + " nextArc=" + nextArc.isLast()); + return true; + } + setCurrentLabel(targetLabel); + incr(); + targetLabel = getTargetLabel(); + arc = nextArc; + } + } + private void incr() { upto++; grow(); Index: lucene/src/java/org/apache/lucene/util/fst/IntsRefFSTEnum.java --- lucene/src/java/org/apache/lucene/util/fst/IntsRefFSTEnum.java Tue Jun 21 04:53:16 2011 -0400 +++ lucene/src/java/org/apache/lucene/util/fst/IntsRefFSTEnum.java Tue Jun 21 18:12:47 2011 -0400 @@ -71,6 +71,21 @@ return setResult(); } + /** Seeks to exactly this term, returning null if the term + * doesn't exist. This is faster than using {@link + * #seekFloor} or {@link #seekCeil} because it + * short-circuits as soon the match is not found. */ + public InputOutput seekExact(IntsRef target) throws IOException { + this.target = target; + targetLength = target.length; + if (super.doSeekExact()) { + assert upto == 1+target.length; + return setResult(); + } else { + return null; + } + } + @Override protected int getTargetLabel() { if (upto-1 == target.length) { Index: lucene/src/test/org/apache/lucene/TestExternalCodecs.java --- lucene/src/test/org/apache/lucene/TestExternalCodecs.java Tue Jun 21 04:53:16 2011 -0400 +++ lucene/src/test/org/apache/lucene/TestExternalCodecs.java Tue Jun 21 18:12:47 2011 -0400 @@ -305,7 +305,7 @@ } @Override - public SeekStatus seek(BytesRef term, boolean useCache) { + public SeekStatus seek(BytesRef term, boolean useCache, boolean onlyExact) { current = term.utf8ToString(); it = null; if (ramField.termToDocs.containsKey(current)) { Index: lucene/src/test/org/apache/lucene/index/TestDocTermOrds.java --- lucene/src/test/org/apache/lucene/index/TestDocTermOrds.java Tue Jun 21 04:53:16 2011 -0400 +++ lucene/src/test/org/apache/lucene/index/TestDocTermOrds.java Tue Jun 21 18:12:47 2011 -0400 @@ -479,7 +479,7 @@ Terms terms = MultiFields.getTerms(r, "field"); if (terms != null) { TermsEnum termsEnum = terms.iterator(); - TermsEnum.SeekStatus result = termsEnum.seek(prefixRef, false); + TermsEnum.SeekStatus result = termsEnum.seek(prefixRef, false, false); if (result != TermsEnum.SeekStatus.END) { assertFalse("term=" + termsEnum.term().utf8ToString() + " matches prefix=" + prefixRef.utf8ToString(), termsEnum.term().startsWith(prefixRef)); } else { Index: lucene/src/test/org/apache/lucene/index/TestPerSegmentDeletes.java --- lucene/src/test/org/apache/lucene/index/TestPerSegmentDeletes.java Tue Jun 21 04:53:16 2011 -0400 +++ lucene/src/test/org/apache/lucene/index/TestPerSegmentDeletes.java Tue Jun 21 18:12:47 2011 -0400 @@ -225,7 +225,7 @@ Fields fields = MultiFields.getFields(reader); Terms cterms = fields.terms(term.field); TermsEnum ctermsEnum = cterms.iterator(); - SeekStatus ss = ctermsEnum.seek(new BytesRef(term.text()), false); + SeekStatus ss = ctermsEnum.seek(new BytesRef(term.text()), false, true); if (ss.equals(SeekStatus.FOUND)) { DocsEnum docsEnum = ctermsEnum.docs(bits, null); return toArray(docsEnum); Index: lucene/src/test/org/apache/lucene/util/fst/TestFSTs.java --- lucene/src/test/org/apache/lucene/util/fst/TestFSTs.java Tue Jun 21 04:53:16 2011 -0400 +++ lucene/src/test/org/apache/lucene/util/fst/TestFSTs.java Tue Jun 21 18:12:47 2011 -0400 @@ -588,7 +588,13 @@ // ok doesn't exist //System.out.println(" seek " + inputToString(inputMode, term)); final IntsRefFSTEnum.InputOutput seekResult; - if (random.nextBoolean()) { + if (random.nextInt(3) == 0) { + if (VERBOSE) { + System.out.println(" do non-exist seekExact term=" + inputToString(inputMode, term)); + } + seekResult = fstEnum.seekExact(term); + pos = -1; + } else if (random.nextBoolean()) { if (VERBOSE) { System.out.println(" do non-exist seekFloor term=" + inputToString(inputMode, term)); } @@ -625,7 +631,12 @@ // seek to term that does exist: InputOutput pair = pairs.get(random.nextInt(pairs.size())); final IntsRefFSTEnum.InputOutput seekResult; - if (random.nextBoolean()) { + if (random.nextInt(3) == 2) { + if (VERBOSE) { + System.out.println(" do exists seekExact term=" + inputToString(inputMode, pair.input)); + } + seekResult = fstEnum.seekExact(pair.input); + } else if (random.nextBoolean()) { if (VERBOSE) { System.out.println(" do exists seekFloor " + inputToString(inputMode, pair.input)); } Index: modules/suggest/src/java/org/apache/lucene/search/spell/SpellChecker.java --- modules/suggest/src/java/org/apache/lucene/search/spell/SpellChecker.java Tue Jun 21 04:53:16 2011 -0400 +++ modules/suggest/src/java/org/apache/lucene/search/spell/SpellChecker.java Tue Jun 21 18:12:47 2011 -0400 @@ -539,7 +539,7 @@ // we have a non-empty index, check if the term exists currentTerm.copy(word); for (TermsEnum te : termsEnums) { - if (te.seek(currentTerm, false) == TermsEnum.SeekStatus.FOUND) { + if (te.seek(currentTerm, false, true) == TermsEnum.SeekStatus.FOUND) { continue terms; } } Index: solr/src/java/org/apache/solr/handler/component/TermsComponent.java --- solr/src/java/org/apache/solr/handler/component/TermsComponent.java Tue Jun 21 04:53:16 2011 -0400 +++ solr/src/java/org/apache/solr/handler/component/TermsComponent.java Tue Jun 21 18:12:47 2011 -0400 @@ -162,7 +162,7 @@ BytesRef term = null; if (lowerBytes != null) { - if (termsEnum.seek(lowerBytes, true) == TermsEnum.SeekStatus.END) { + if (termsEnum.seek(lowerBytes, true, false) == TermsEnum.SeekStatus.END) { termsEnum = null; } else { term = termsEnum.term(); Index: solr/src/java/org/apache/solr/request/SimpleFacets.java --- solr/src/java/org/apache/solr/request/SimpleFacets.java Tue Jun 21 04:53:16 2011 -0400 +++ solr/src/java/org/apache/solr/request/SimpleFacets.java Tue Jun 21 18:12:47 2011 -0400 @@ -641,7 +641,7 @@ // facet.offset when sorting by index order. if (startTermBytes != null) { - if (termsEnum.seek(startTermBytes, true) == TermsEnum.SeekStatus.END) { + if (termsEnum.seek(startTermBytes, true, false) == TermsEnum.SeekStatus.END) { termsEnum = null; } else { term = termsEnum.term(); Index: solr/src/java/org/apache/solr/request/UnInvertedField.java --- solr/src/java/org/apache/solr/request/UnInvertedField.java Tue Jun 21 04:53:16 2011 -0400 +++ solr/src/java/org/apache/solr/request/UnInvertedField.java Tue Jun 21 18:12:47 2011 -0400 @@ -228,13 +228,13 @@ TermsEnum te = getOrdTermsEnum(searcher.getIndexReader()); if (prefix != null && prefix.length() > 0) { final BytesRef prefixBr = new BytesRef(prefix); - if (te.seek(prefixBr, true) == TermsEnum.SeekStatus.END) { + if (te.seek(prefixBr, true, false) == TermsEnum.SeekStatus.END) { startTerm = numTermsInField; } else { startTerm = (int) te.ord(); } prefixBr.append(UnicodeUtil.BIG_TERM); - if (te.seek(prefixBr, true) == TermsEnum.SeekStatus.END) { + if (te.seek(prefixBr, true, false) == TermsEnum.SeekStatus.END) { endTerm = numTermsInField; } else { endTerm = (int) te.ord(); Index: solr/src/java/org/apache/solr/search/JoinQParserPlugin.java --- solr/src/java/org/apache/solr/search/JoinQParserPlugin.java Tue Jun 21 04:53:16 2011 -0400 +++ solr/src/java/org/apache/solr/search/JoinQParserPlugin.java Tue Jun 21 18:12:47 2011 -0400 @@ -281,7 +281,7 @@ if (prefix == null) { term = termsEnum.next(); } else { - if (termsEnum.seek(prefix, true) != TermsEnum.SeekStatus.END) { + if (termsEnum.seek(prefix, true, false) != TermsEnum.SeekStatus.END) { term = termsEnum.term(); } } Index: solr/src/java/org/apache/solr/search/function/FileFloatSource.java --- solr/src/java/org/apache/solr/search/function/FileFloatSource.java Tue Jun 21 04:53:16 2011 -0400 +++ solr/src/java/org/apache/solr/search/function/FileFloatSource.java Tue Jun 21 18:12:47 2011 -0400 @@ -268,7 +268,7 @@ continue; // go to next line in file.. leave values as default. } - if (termsEnum.seek(internalKey, false) != TermsEnum.SeekStatus.FOUND) { + if (termsEnum.seek(internalKey, false, true) != TermsEnum.SeekStatus.FOUND) { if (notFoundCount<10) { // collect first 10 not found for logging notFound.add(key); } Index: solr/src/test/org/apache/solr/request/TestFaceting.java --- solr/src/test/org/apache/solr/request/TestFaceting.java Tue Jun 21 04:53:16 2011 -0400 +++ solr/src/test/org/apache/solr/request/TestFaceting.java Tue Jun 21 18:12:47 2011 -0400 @@ -103,7 +103,7 @@ // test seeking before term if (size>0) { - assertEquals(size>0, te.seek(new BytesRef("000"), true) != TermsEnum.SeekStatus.END); + assertEquals(size>0, te.seek(new BytesRef("000"), true, false) != TermsEnum.SeekStatus.END); assertEquals(0, te.ord()); assertEquals(t(0), te.term().utf8ToString()); }