public void destroy() { for (SuperIndexSearcher is : searcherList) { try { is.getSearcherManager().release(is); } catch (IOException ex) { LOGGER.log(Level.WARNING, "cannot release indexSearcher", ex); } } }
/** * Free any resources associated with this helper (that includes closing the * used {@link #searcher} in case of no-project setup). */ public void destroy() { if (searcher != null && closeOnDestroy) { IOUtils.close(searcher.getIndexReader()); } for (SuperIndexSearcher is : searcherList) { try { is.getSearcherManager().release(is); } catch (IOException ex) { LOGGER.log(Level.WARNING, "cannot release indexSearcher", ex); } } }
@Override public void query(Query query, int limit, IndexResultCollector collector) throws IOException { long start = stats.startRepositoryQuery(); int totalHits = 0; IndexSearcher searcher = searcherManager.acquire(); try { TopDocs docs = searcher.search(query, limit); totalHits = docs.totalHits; for (ScoreDoc scoreDoc : docs.scoreDocs) { Document doc = searcher.doc(scoreDoc.doc); Object key = SerializerUtil.getKey(doc); if (logger.isDebugEnabled()) { logger.debug("query found doc:" + doc + ":" + scoreDoc); } collector.collect(key, scoreDoc.score); } } finally { searcherManager.release(searcher); stats.endRepositoryQuery(start, totalHits); } }
/** * Returns <code>true</code> if no changes have occured since this searcher * ie. reader was opened, otherwise <code>false</code>. * @see DirectoryReader#isCurrent() */ public boolean isSearcherCurrent() throws IOException { final IndexSearcher searcher = acquire(); try { final IndexReader r = searcher.getIndexReader(); assert r instanceof DirectoryReader: "searcher's IndexReader should be a DirectoryReader, but got " + r; return ((DirectoryReader) r).isCurrent(); } finally { release(searcher); } }
private void removeFromCache( long entityId ) throws IOException { IndexSearcher searcher = searcherManager.acquire(); try { Query query = type.idTermQuery( entityId ); TopDocs docs = searcher.search( query, 1 ); if ( docs.totalHits > 0 ) { Document document = searcher.doc( docs.scoreDocs[0].doc ); for ( IndexableField field : document.getFields() ) { String key = field.name(); Object value = field.stringValue(); removeFromCache( entityId, key, value ); } } } finally { searcherManager.release( searcher ); } }
private void runUniquenessVerification( NodePropertyAccessor nodePropertyAccessor, IndexSearcher indexSearcher ) throws IOException, IndexEntryConflictException { try { PartitionSearcher partitionSearcher = mock( PartitionSearcher.class ); when( partitionSearcher.getIndexSearcher() ).thenReturn( indexSearcher ); try ( UniquenessVerifier verifier = new SimpleUniquenessVerifier( partitionSearcher ) ) { verifier.verify( nodePropertyAccessor, PROPERTY_KEY_IDS ); } } finally { searcherManager.release( indexSearcher ); } }
searcherManager.release( searcher );
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); } }
public void releaseIndexSearcher( final IndexSearcher is ) throws IOException { if ( is == null ) { return; } searcherManager.release( is ); }
public void releaseIndexSearcher( final IndexSearcher is ) throws IOException { if ( is == null ) { return; } searcherManager.release( is ); }
public void releaseIndexSearcher( final IndexSearcher is ) throws IOException { if ( is == null ) { return; } searcherManager.release( is ); }
@Override public void close() { try { searcherManager.release(searcher); } catch(IOException ex) { throw Throwables.propagate(ex); } } }
@Override public void release(IndexSearcher searcher) { try { searcherManager.release(searcher); } catch (IOException e) { throw new RuntimeException(e); } }
public void releaseIndexSearcher(IndexSearcher indexSearcher) { SearcherManager searcherManager = getSearcherManager(); try { searcherManager.release(indexSearcher); } catch (IOException e) { throw new RuntimeException("Error on releasing an IndexSearcher", e); } }
@Override public void afterRefresh(boolean didRefresh) throws IOException { if (didRefresh) { IndexSearcher indexSearcher = newSearchManager.acquire(); try { record(indexSearcher); } finally { newSearchManager.release(indexSearcher); } } } });
public Document retrieve(final int docID) throws IOException { IndexSearcher searcher = mgr.acquire(); try { return searcher.doc(docID); } finally { mgr.release(searcher); } }
public Document retrieve(final int docID) throws IOException { IndexSearcher searcher = mgr.acquire(); try { return searcher.doc(docID); } finally { mgr.release(searcher); searcher = null; } }
public void releaseSearcher(IndexSearcher searcher) { if (isState(State.CLOSED)|| isState(State.CLOSING)) return; try { this._searcher.release(searcher); } catch (IOException ex) { LOGGER.error("Failed to release searcher", ex); } }
@Override public void release(IndexSearcher searcher) { updateLastAccess(); openIfClosed(); try { searcherManager.release(searcher); } catch (IOException e) { OLogManager.instance().error(this, "Error on releasing index searcher of Lucene index", e); } }