/** * <p>Construct a MultiReader aggregating the named set of (sub)readers. * @param subReaders set of (sub)readers; this array will be cloned. * @param closeSubReaders indicates whether the subreaders should be closed * when this MultiReader is closed */ public MultiReader(IndexReader[] subReaders, boolean closeSubReaders) throws IOException { super(subReaders.clone()); this.closeSubReaders = closeSubReaders; if (!closeSubReaders) { for (int i = 0; i < subReaders.length; i++) { subReaders[i].incRef(); } } }
public SearcherTracker(IndexSearcher searcher) { this.searcher = searcher; version = ((DirectoryReader) searcher.getIndexReader()).getVersion(); searcher.getIndexReader().incRef(); // Use nanoTime not currentTimeMillis since it [in // theory] reduces risk from clock shift recordTimeSec = System.nanoTime() / NANOS_PER_SEC; }
/** Expert: create a ParallelCompositeReader based on the provided * readers and storedFieldReaders; when a document is * loaded, only storedFieldsReaders will be used. */ public ParallelCompositeReader(boolean closeSubReaders, CompositeReader[] readers, CompositeReader[] storedFieldReaders) throws IOException { super(prepareLeafReaders(readers, storedFieldReaders)); this.closeSubReaders = closeSubReaders; Collections.addAll(completeReaderSet, readers); Collections.addAll(completeReaderSet, storedFieldReaders); // update ref-counts (like MultiReader): if (!closeSubReaders) { for (final IndexReader reader : completeReaderSet) { reader.incRef(); } } // finally add our own synthetic readers, so we close or decRef them, too (it does not matter what we do) completeReaderSet.addAll(getSequentialSubReaders()); // ParallelReader instances can be short-lived, which would make caching trappy // so we do not cache on them, unless they wrap a single reader in which // case we delegate if (readers.length == 1 && storedFieldReaders.length == 1 && readers[0] == storedFieldReaders[0]) { cacheHelper = readers[0].getReaderCacheHelper(); } else { cacheHelper = null; } }
ExternalSearcherManager(SearcherManager internalSearcherManager, SearcherFactory searcherFactory) throws IOException { IndexSearcher acquire = internalSearcherManager.acquire(); try { IndexReader indexReader = acquire.getIndexReader(); assert indexReader instanceof ElasticsearchDirectoryReader: "searcher's IndexReader should be an ElasticsearchDirectoryReader, but got " + indexReader; indexReader.incRef(); // steal the reader - getSearcher will decrement if it fails current = SearcherManager.getSearcher(searcherFactory, indexReader, null); } finally { internalSearcherManager.release(acquire); } this.searcherFactory = searcherFactory; this.internalSearcherManager = internalSearcherManager; }
@Override protected IndexSearcher refreshIfNeeded(IndexSearcher referenceToRefresh) throws IOException { // we simply run a blocking refresh on the internal reference manager and then steal it's reader // it's a save operation since we acquire the reader which incs it's reference but then down the road // steal it by calling incRef on the "stolen" reader internalSearcherManager.maybeRefreshBlocking(); IndexSearcher acquire = internalSearcherManager.acquire(); try { final IndexReader previousReader = referenceToRefresh.getIndexReader(); assert previousReader instanceof ElasticsearchDirectoryReader: "searcher's IndexReader should be an ElasticsearchDirectoryReader, but got " + previousReader; final IndexReader newReader = acquire.getIndexReader(); if (newReader == previousReader) { // nothing has changed - both ref managers share the same instance so we can use reference equality return null; } else { newReader.incRef(); // steal the reader - getSearcher will decrement if it fails return SearcherManager.getSearcher(searcherFactory, newReader, previousReader); } } finally { internalSearcherManager.release(acquire); } }
@Override public void incRef() { in.incRef(); }
@Override public void incRef() { this.delegate.incRef(); }
/** * Apply the filter * * @param id String * @param reader IndexReader * @param deleteNodesOnly boolean */ public FilterIndexReaderByStringId(String id, IndexReader reader, Set<String> deletions, Set<String> containerDeletions, boolean deleteNodesOnly) { super(reader); reader.incRef(); this.id = id; this.deletions = deletions; this.containerDeletions = containerDeletions; this.deleteNodesOnly = deleteNodesOnly; if (s_logger.isDebugEnabled()) { s_logger.debug("Applying deletions FOR "+id +" (the index ito which these are applied is the previous one ...)"); } }
private void setManagedReader(IndexReader r) { r.incRef(); reader = r; lastManaged = true; watch.reset().start(); }
/** * <p>Construct a MultiReader aggregating the named set of (sub)readers. * @param subReaders set of (sub)readers; this array will be cloned. * @param closeSubReaders indicates whether the subreaders should be closed * when this MultiReader is closed */ public MultiReader(IndexReader[] subReaders, boolean closeSubReaders) throws IOException { super(subReaders.clone()); this.closeSubReaders = closeSubReaders; if (!closeSubReaders) { for (int i = 0; i < subReaders.length; i++) { subReaders[i].incRef(); } } }
/** * <p>Construct a MultiReader aggregating the named set of (sub)readers. * @param subReaders set of (sub)readers; this array will be cloned. * @param closeSubReaders indicates whether the subreaders should be closed * when this MultiReader is closed */ public MultiReader(IndexReader[] subReaders, boolean closeSubReaders) throws IOException { super(subReaders.clone()); this.closeSubReaders = closeSubReaders; if (!closeSubReaders) { for (int i = 0; i < subReaders.length; i++) { subReaders[i].incRef(); } } }
/** * <p>Construct a MultiReader aggregating the named set of (sub)readers. * @param subReaders set of (sub)readers; this array will be cloned. * @param closeSubReaders indicates whether the subreaders should be closed * when this MultiReader is closed */ public MultiReader(IndexReader[] subReaders, boolean closeSubReaders) throws IOException { super(subReaders.clone()); this.closeSubReaders = closeSubReaders; if (!closeSubReaders) { for (int i = 0; i < subReaders.length; i++) { subReaders[i].incRef(); } } }
private IndexReader createReader(List<LuceneIndexReader> nrtReaders) { //Increment count by 1. MultiReader does it for all readers //So no need for an explicit increment for MultiReader if (readers.size() == 1 && nrtReaders.isEmpty()){ IndexReader reader = readers.get(0).getReader(); reader.incRef(); return reader; } if (nrtReaders.size() == 1 && readers.isEmpty()){ IndexReader reader = nrtReaders.get(0).getReader(); reader.incRef(); return reader; } IndexReader[] readerArr = new IndexReader[readers.size() + nrtReaders.size()]; int i = 0; for (LuceneIndexReader r : Iterables.concat(readers, nrtReaders)){ readerArr[i++] = r.getReader(); } return new MultiReader(readerArr, false); }
private IndexSearcher obtainSearcher() { synchronized (searcherLock) { ensureOpen(); searcher.getIndexReader().incRef(); return searcher; } }
private IndexSearcher obtainSearcher() { synchronized (searcherLock) { ensureOpen(); searcher.getIndexReader().incRef(); return searcher; } }
public SearcherTracker(IndexSearcher searcher) { this.searcher = searcher; version = ((DirectoryReader) searcher.getIndexReader()).getVersion(); searcher.getIndexReader().incRef(); // Use nanoTime not currentTimeMillis since it [in // theory] reduces risk from clock shift recordTimeSec = System.nanoTime() / NANOS_PER_SEC; }
public SearcherTracker(IndexSearcher searcher) { this.searcher = searcher; version = ((DirectoryReader) searcher.getIndexReader()).getVersion(); searcher.getIndexReader().incRef(); // Use nanoTime not currentTimeMillis since it [in // theory] reduces risk from clock shift recordTimeSec = System.nanoTime() / NANOS_PER_SEC; }
public SearcherTracker(IndexSearcher searcher) { this.searcher = searcher; version = ((DirectoryReader) searcher.getIndexReader()).getVersion(); searcher.getIndexReader().incRef(); // Use nanoTime not currentTimeMillis since it [in // theory] reduces risk from clock shift recordTimeSec = System.nanoTime() / NANOS_PER_SEC; }
private void incReaderRef() { searcher.getIndexReader().incRef(); Counter searcherLuceneOpenInstrument = Instrumentation.pullCounter(InstrumentationName.SEARCHER_LUCENE_OPEN); searcherLuceneOpenInstrument.incrementAndGet(); }
ExternalSearcherManager(SearcherManager internalSearcherManager, SearcherFactory searcherFactory) throws IOException { IndexSearcher acquire = internalSearcherManager.acquire(); try { IndexReader indexReader = acquire.getIndexReader(); assert indexReader instanceof ElasticsearchDirectoryReader: "searcher's IndexReader should be an ElasticsearchDirectoryReader, but got " + indexReader; indexReader.incRef(); // steal the reader - getSearcher will decrement if it fails current = SearcherManager.getSearcher(searcherFactory, indexReader, null); } finally { internalSearcherManager.release(acquire); } this.searcherFactory = searcherFactory; this.internalSearcherManager = internalSearcherManager; }