public ReaderCache(String indexName) throws IOException { this.indexName = indexName; documents = new MapMaker().makeMap(); termCache = new TermCache(indexName); fieldNorms = new MapMaker().makeMap(); docHits = new OpenBitSet(CassandraIndexManager.maxDocsPerShard); readerFinishedListeners = new ArrayList<ReaderFinishedListener>(); fieldCacheKey = UUID.randomUUID(); }
public DocIdSet getDocIdSet(IndexReader reader) throws IOException { OpenBitSet result = new OpenBitSet(reader.maxDoc());
@Override protected Object createValue(IndexReader reader, Entry entryKey) throws IOException { Entry entry = entryKey; String field = entry.field; if (reader.maxDoc() == reader.docFreq(new Term(field))) { return DocIdSet.EMPTY_DOCIDSET; } OpenBitSet res = new OpenBitSet(reader.maxDoc()); TermDocs termDocs = reader.termDocs(); TermEnum termEnum = reader.terms (new Term (field)); try { do { Term term = termEnum.term(); if (term==null || term.field() != field) break; termDocs.seek (termEnum); while (termDocs.next()) { res.fastSet(termDocs.doc()); } } while (termEnum.next()); } finally { termDocs.close(); termEnum.close(); } res.flip(0, reader.maxDoc()); return res; } }
/** * Constructs a DocSetHitCollector with the specified parameter. * * @param maxDoc The maximum size of all the documents in the index */ public DocSetScoreCollector(int maxDoc) { scores = new float[maxDoc]; bits = new OpenBitSet(maxDoc); }
public IdentifierSet() { bitSet = new OpenBitSet(); }
public DocIdSet getDocIdSet(IndexReader reader) throws IOException { final OpenBitSet bits = new OpenBitSet(reader.maxDoc()); new IndexSearcher(reader).search(query, new HitCollector() { public final void collect(int doc, float score) { bits.set(doc); // set bit for hit } }); return bits; }
/** Resets the collector. */ public void reset() { super.reset(); bits = new OpenBitSet(); }
public DocIdSet getDocIdSet(IndexReader reader) throws IOException { final OpenBitSet bits = new OpenBitSet(reader.maxDoc()); new IndexSearcher(reader).search(query, new HitCollector() { public final void collect(int doc, float score) { bits.set(doc); // set bit for hit } }); return bits; }
public IssueIdCollector(final IndexReader indexReader) { this.indexReader = indexReader; this.maxDocs = indexReader.maxDoc(); this.docIds = new OpenBitSet(maxDocs); }
private OpenBitSet initBitSet(IndexReader indexReader, int maxDoc) { OpenBitSet bitSet = (OpenBitSet) deletedBitSets.get(indexReader); if (bitSet == null) { // TODO we can implement our own DocIdSet for marked deleted ones bitSet = new OpenBitSet(maxDoc); bitSet.set(0, maxDoc); deletedBitSets.put(indexReader, bitSet); allBitSets.remove(indexReader); } return bitSet; }
public void documentCollapsed(int docId, CollapseGroup collapseGroup, CollapseContext collapseContext) { OpenBitSet bitSet = collapsedDocumentsByFieldValue.get(collapseGroup); if (bitSet == null) { collapsedDocumentsByFieldValue.put(collapseGroup, bitSet = new OpenBitSet()); } // We cannot use fastset because we do not know the size upfront. // The set method is more expensive than fastset, but that is the best for now. // Setting bitSet to maxDoc may increase the memory footprint dramatically, because for each distinct fieldvalue // there is a bitset bitSet.set(docId); }
private OpenBitSet createDocIdSet(IndexReader reader) throws IOException { final OpenBitSet bits = new OpenBitSet(reader.maxDoc()); long start = System.currentTimeMillis(); new IndexSearcher(reader).search(query, new AbstractHitCollector() { @Override public final void collect(int doc, float score) { bits.set(doc); // set bit for hit } }); log.info("For userId '{}', creating CachingMultiReaderQueryFilter doc id set took {} ms.", userId, String.valueOf(System.currentTimeMillis() - start)); return bits; }
/** * Converts a filter into a DocSet. * This method is not cache-aware and no caches are checked. */ public DocSet convertFilter(Filter lfilter) throws IOException { BitSet bs = lfilter.bits(this.reader); OpenBitSet obs = new OpenBitSet(bs.size()); for(int i=bs.nextSetBit(0); i>=0; i=bs.nextSetBit(i+1)) { obs.fastSet(i); } return new BitDocSet(obs); }
public DocIdSet getDocIdSet(IndexReader reader) throws IOException { final OpenBitSet bitSet = new OpenBitSet(reader.maxDoc()); new PrefixGenerator(prefix) { public void handleDoc(int doc) { bitSet.set(doc); } }.generate(reader); return bitSet; }
@Override public DocIdSet getDocIdSet(IndexReader reader) throws IOException { final OpenBitSet bitSet = new OpenBitSet(reader.maxDoc()); new PrefixGenerator(prefix) { public void handleDoc(int doc) { bitSet.set(doc); } }.generate(reader); return bitSet; }
@Override public DocIdSet getDocIdSet(IndexReader reader) throws IOException { final OpenBitSet bitSet = new OpenBitSet(reader.maxDoc()); new WildcardGenerator(term) { public void handleDoc(int doc) { bitSet.set(doc); } }.generate(reader); return bitSet; }
public DocIdSet getDocIdSet(IndexReader reader) throws IOException { final OpenBitSet bitSet = new OpenBitSet(reader.maxDoc()); new PrefixGenerator(prefix) { public void handleDoc(int doc) { bitSet.set(doc); } }.generate(reader); return bitSet; }
@Override public OpenBitSet getBits() { int maxDoc = size() > 0 ? docs[size()-1] : 0; OpenBitSet bs = new OpenBitSet(maxDoc+1); for (int doc : docs) { bs.fastSet(doc); } return bs; }
@Override public DocIdSet getDocIdSet(AtomicReaderContext context, Bits acceptDocs) throws IOException { AtomicReader reader = context.reader(); OpenBitSet result = new OpenBitSet(reader.maxDoc()); result.set(0, reader.maxDoc()); return result; } }
/** * Inefficient base implementation. * * @see BitDocSet#getBits */ public OpenBitSet getBits() { OpenBitSet bits = new OpenBitSet(); for (DocIterator iter = iterator(); iter.hasNext();) { bits.set(iter.nextDoc()); } return bits; };