/** Attempts to seek to the exact term, returning * true if the term is found. If this returns false, the * enum is unpositioned. For some codecs, seekExact may * be substantially faster than {@link #seekCeil}. */ public boolean seekExact(BytesRef text) throws IOException { return seekCeil(text) == SeekStatus.FOUND; }
@Override public SeekStatus seekCeil(BytesRef text) throws IOException { return in.seekCeil(text); }
@Override public SeekStatus seekCeil(BytesRef text) throws IOException { return actualEnum.seekCeil(text); }
@Override public int lookupTerm(BytesRef key) throws IOException { SeekStatus status = termsEnum.seekCeil(key); switch (status) { case FOUND: return Math.toIntExact(termsEnum.ord()); default: return Math.toIntExact(-1L - termsEnum.ord()); } }
@Override public long lookupTerm(BytesRef key) throws IOException { SeekStatus status = termsEnum.seekCeil(key); switch (status) { case FOUND: return termsEnum.ord(); default: return -1L - termsEnum.ord(); } }
/** Test Terms.intersect on this range, and validates that it returns the same doc ids as using non-intersect TermsEnum. Returns true if * any fake terms were seen. */ private static boolean checkSingleTermRange(String field, int maxDoc, Terms terms, BytesRef minTerm, BytesRef maxTerm, FixedBitSet normalDocs, FixedBitSet intersectDocs) throws IOException { //System.out.println(" check minTerm=" + minTerm.utf8ToString() + " maxTerm=" + maxTerm.utf8ToString()); assert minTerm.compareTo(maxTerm) <= 0; TermsEnum termsEnum = terms.iterator(); TermsEnum.SeekStatus status = termsEnum.seekCeil(minTerm); if (status != TermsEnum.SeekStatus.FOUND) { throw new RuntimeException("failed to seek to existing term field=" + field + " term=" + minTerm); } // Do "dumb" iteration to visit all terms in the range: long normalTermCount = getDocsFromTermRange(field, maxDoc, termsEnum, normalDocs, minTerm, maxTerm, false); // Now do the same operation using intersect: long intersectTermCount = getDocsFromTermRange(field, maxDoc, terms.intersect(new CompiledAutomaton(Automata.makeBinaryInterval(minTerm, true, maxTerm, false), true, false, Integer.MAX_VALUE, true), null), intersectDocs, minTerm, maxTerm, true); if (intersectTermCount > normalTermCount) { throw new RuntimeException("intersect returned too many terms: field=" + field + " intersectTermCount=" + intersectTermCount + " normalTermCount=" + normalTermCount); } if (normalDocs.equals(intersectDocs) == false) { throw new RuntimeException("intersect visited different docs than straight terms enum: " + normalDocs.cardinality() + " for straight enum, vs " + intersectDocs.cardinality() + " for intersect, minTerm=" + minTerm + " maxTerm=" + maxTerm); } //System.out.println(" docs=" + normalTermCount); //System.out.println(" " + intersectTermCount + " vs " + normalTermCount); return intersectTermCount != normalTermCount; }
if (t == null || tenum.seekCeil(t) == SeekStatus.END) {
if (terms != null) { uidIter = terms.iterator(); TermsEnum.SeekStatus stat = uidIter.seekCeil(new BytesRef(startuid)); //init uid if (stat == TermsEnum.SeekStatus.END) { uidIter = null;
if (termsEnum.seekCeil(lastTerm.get()) != TermsEnum.SeekStatus.FOUND) { throw new RuntimeException("seek to last term " + lastTerm.get() + " failed"); if (termsEnum.seekCeil(seekTerms[i]) != TermsEnum.SeekStatus.FOUND) { throw new RuntimeException("seek to existing term " + seekTerms[i] + " failed");
TermsEnum.SeekStatus status = termsEnum.seekCeil(delTerm); if (status == TermsEnum.SeekStatus.FOUND) {
int mid = (low+high) >>> 1; scratch.setByteAt(scratch.length()-1, (byte) mid); if (iterator.seekCeil(scratch.get()) == TermsEnum.SeekStatus.END) {
/** Attempts to seek to the exact term, returning * true if the term is found. If this returns false, the * enum is unpositioned. For some codecs, seekExact may * be substantially faster than {@link #seekCeil}. */ public boolean seekExact(BytesRef text) throws IOException { return seekCeil(text) == SeekStatus.FOUND; }
/** Attempts to seek to the exact term, returning * true if the term is found. If this returns false, the * enum is unpositioned. For some codecs, seekExact may * be substantially faster than {@link #seekCeil}. */ public boolean seekExact(BytesRef text) throws IOException { return seekCeil(text) == SeekStatus.FOUND; }
@Override public SeekStatus seekCeil(BytesRef text) throws IOException { return in.seekCeil(text); }
private void getPrefixTerms(ObjectHashSet<Term> terms, final Term prefix, final IndexReader reader) throws IOException { // SlowCompositeReaderWrapper could be used... but this would merge all terms from each segment into one terms // instance, which is very expensive. Therefore I think it is better to iterate over each leaf individually. List<LeafReaderContext> leaves = reader.leaves(); for (LeafReaderContext leaf : leaves) { Terms _terms = leaf.reader().terms(field); if (_terms == null) { continue; } TermsEnum termsEnum = _terms.iterator(); TermsEnum.SeekStatus seekStatus = termsEnum.seekCeil(prefix.bytes()); if (TermsEnum.SeekStatus.END == seekStatus) { continue; } for (BytesRef term = termsEnum.term(); term != null; term = termsEnum.next()) { if (!StringHelper.startsWith(term, prefix.bytes())) { break; } terms.add(new Term(field, BytesRef.deepCopyOf(term))); if (terms.size() >= maxExpansions) { return; } } } }
@Override public SeekStatus seekCeil(BytesRef text) throws IOException { return delegate().seekCeil(text); }
@Override public int lookupTerm(BytesRef key) throws IOException { SeekStatus status = termsEnum.seekCeil(key); switch (status) { case FOUND: return Math.toIntExact(termsEnum.ord()); default: return Math.toIntExact(-1L - termsEnum.ord()); } }
final TermsEnum te = terms.iterator(); if (lowerValue != null) { if (te.seekCeil(lowerValue) == TermsEnum.SeekStatus.END) { return DocIdSet.EMPTY ;
@Override public long lookupTerm(BytesRef key) throws IOException { SeekStatus status = termsEnum.seekCeil(key); switch (status) { case FOUND: return termsEnum.ord(); default: return -1L - termsEnum.ord(); } }