@Test void numericIndexVerificationNoDuplicates() throws Exception { List<Object> data = asList( Integer.MAX_VALUE - 2, Integer.MAX_VALUE - 1, Integer.MAX_VALUE ); NodePropertyAccessor nodePropertyAccessor = newPropertyAccessor( data ); insert( data ); IndexSearcher indexSearcher = spy( searcherManager.acquire() ); runUniquenessVerification( nodePropertyAccessor, indexSearcher ); verify( indexSearcher, never() ).search( any( Query.class ), any( Collector.class ) ); }
@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); } }
@Test void numericIndexVerificationSomePossibleDuplicates() throws Exception { List<Object> data = asList( 42, Long.MAX_VALUE - 1, Long.MAX_VALUE ); NodePropertyAccessor nodePropertyAccessor = newPropertyAccessor( data ); insert( data ); IndexSearcher indexSearcher = spy( searcherManager.acquire() ); runUniquenessVerification( nodePropertyAccessor, indexSearcher ); verify( indexSearcher ).search( any( Query.class ), any( Collector.class ) ); }
/** * 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); } }
@Test void numericIndexVerificationSomeWithDuplicates() throws Exception { List<Object> data = asList( Integer.MAX_VALUE, Long.MAX_VALUE, 42, Long.MAX_VALUE ); NodePropertyAccessor nodePropertyAccessor = newPropertyAccessor( data ); insert( data ); IndexSearcher indexSearcher = spy( searcherManager.acquire() ); assertThrows( IndexEntryConflictException.class, () -> runUniquenessVerification( nodePropertyAccessor, indexSearcher ) ); verify( indexSearcher ).search( any( Query.class ), any( Collector.class ) ); }
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 ); } }
try searcher = searcherManager.acquire();
public static List<Long> getAllNodes( Directory directory, Value propertyValue ) throws IOException { try ( SearcherManager manager = new SearcherManager( directory, new SearcherFactory() ) ) { IndexSearcher searcher = manager.acquire(); Query query = LuceneDocumentStructure.newSeekQuery( propertyValue ); AllNodesCollector collector = new AllNodesCollector(); searcher.search( query, collector ); return collector.nodeIds; } }
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); } }
private Searcher acquireSearcher() { try { IndexSearcher searcher = searcherManager.acquire(); return new Searcher(searcher); } catch(IOException ex){ throw Throwables.propagate(ex); } }
public IndexSearcher acquireIndexSearcher() throws IOException { // TODO: move this to separate thread to not penalty next incoming searcher searcherManager.maybeRefresh(); return searcherManager.acquire(); }
public void close() { try { mgr.acquire().getIndexReader().close(); } catch (IOException e) { LOGGER.error(e.getMessage(), e); } }
public IndexSearcher acquireIndexSearcher() throws IOException { // TODO: move this to separate thread to not penalty next incoming searcher searcherManager.maybeRefresh(); return searcherManager.acquire(); }
public IndexSearcher acquireIndexSearcher() throws IOException { // TODO: move this to separate thread to not penalty next incoming searcher searcherManager.maybeRefresh(); return searcherManager.acquire(); }
@Override public void afterRefresh(boolean didRefresh) throws IOException { if (didRefresh) { IndexSearcher indexSearcher = newSearchManager.acquire(); try { record(indexSearcher); } finally { newSearchManager.release(indexSearcher); } } } });
public IndexSearcher bookSearcher() { if (isState(State.CLOSING)) return null; try { if (isState(State.CLOSED)) open(); return this._searcher.acquire(); } catch (IOException ex) { LOGGER.error("Failed to book searcher", ex); return null; } }
public IndexSearcher getSearcher() throws IOException { try { nrt.waitForGeneration(reopenToken); } catch (InterruptedException e) { OLogManager.instance().error(this, "Error on get searcher from Lucene index", e); } return searcherManager.acquire(); }
@Override public IndexSearcher searcher() { try { updateLastAccess(); openIfClosed(); nrt.waitForGeneration(reopenToken); return searcherManager.acquire(); } catch (Exception e) { OLogManager.instance().error(this, "Error on get searcher from Lucene index", e); throw OException.wrapException(new OLuceneIndexException("Error on get searcher from Lucene index"), e); } }