Refine search
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 ); } }
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; } }
private void closeSearcher() { try { if ( searcherManager != null ) { this.searcherManager.close(); } } catch ( IOException e ) { throw new RuntimeException( e ); } finally { this.searcherManager = null; } }
/** * 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); } }
mgr = new SearcherManager(dir, new ThreadpoolSearcherFactory()); searcherManagerMap.put(proj, mgr); searcher = (SuperIndexSearcher) mgr.acquire(); searcher.setSearcherManager(mgr); } catch (IOException ex) { searcher = (SuperIndexSearcher) mgr.acquire(); searcher.setSearcherManager(mgr);
@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 ) ); }
/** * update the documents in the lucene index and share it on HDFS * * @param documents the document to update */ public void insertOrUpdateDocument(List<DQDocument> documents) { List<DQDocument> documentsToCreate = new ArrayList<>(); try { LOGGER.debug("update " + documents.size() + " documents"); for (DQDocument document : documents) { final Term term = new Term(DictionarySearcher.F_DOCID, document.getId()); mgr.maybeRefreshBlocking(); IndexSearcher searcher = mgr.acquire(); if (searcher.search(new TermQuery(term), 1).totalHits == 1) { getWriter().updateDocument(term, DictionaryUtils.dqDocumentToLuceneDocument(document).getFields()); } else { documentsToCreate.add(document); } mgr.release(searcher); } createDocument(documentsToCreate); } catch (IOException e) { LOGGER.error(e.getMessage(), e); } }
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; }
private TopDocs sendListDocumentsQuery(String categoryId, int offset, int n, boolean searchInCustom) throws IOException { SearcherManager searcherManager = getSearcherManager(searchInCustom); if (searchInCustom) { searcherManager.maybeRefresh(); } IndexSearcher searcher = searcherManager.acquire(); TopDocs result; if (offset <= 0) { result = searcher.search(getListDocumentsQuery(categoryId), n); } else { TopDocs topDocs = searcher.search(getListDocumentsQuery(categoryId), offset + n); Query q = new TermQuery(new Term(DictionarySearcher.F_CATID, categoryId)); result = searcher.searchAfter(topDocs.scoreDocs[Math.min(topDocs.totalHits, offset) - 1], q, n); } searcherManager.release(searcher); return result; }
@Override protected IndexSearcher refreshIfNeeded(IndexSearcher referenceToRefresh) throws IOException { final IndexReader r = referenceToRefresh.getIndexReader(); assert r instanceof DirectoryReader: "searcher's IndexReader should be a DirectoryReader, but got " + r; final IndexReader newReader = DirectoryReader.openIfChanged((DirectoryReader) r); if (newReader == null) { return null; } else { return getSearcher(searcherFactory, newReader, r); } }
private List<DQDocument> dqDocListFromTopDocs(String catId, String catName, TopDocs docs, boolean searchInCustom) throws IOException { SearcherManager searcherManager = getSearcherManager(searchInCustom); if (searchInCustom) { searcherManager.maybeRefresh(); } IndexSearcher searcher = searcherManager.acquire(); IndexReader reader = searcher.getIndexReader(); List<DQDocument> dqDocList = new ArrayList<>(); for (ScoreDoc scoreDoc : docs.scoreDocs) { Document luceneDoc = reader.document(scoreDoc.doc); DQDocument dqDoc = DictionaryUtils.dictionaryEntryFromDocument(luceneDoc, catId, catName); dqDocList.add(dqDoc); } searcherManager.release(searcher); return dqDocList; }
/** * 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); } } }
public void close() { try { mgr.acquire().getIndexReader().close(); } catch (IOException e) { LOGGER.error(e.getMessage(), e); } }
protected SearcherManager createSearchManager() throws IOException { return new SearcherManager(writer, APPLY_ALL_DELETES, true, null); }
import org.apache.lucene.search.SearcherManager; // ... public class SearchLayer1 { // ... private final SearcherManager searcherManager; public SearchLayer1() throws IOException { // ... this.searcherManager = new SearcherManager(indexWriter, false, null); } // ... public void experiment() throws IOException { searcherManager.maybeRefresh(); IndexSearcher isearcher = searcherManager.acquire(); try { // ... } finally { searcherManager.release(isearcher); } } public void close() throws IOException { searcherManager.close(); // ... } }
public void destroy() { for (SuperIndexSearcher is : searcherList) { try { is.getSearcherManager().release(is); } catch (IOException ex) { LOGGER.log(Level.WARNING, "cannot release indexSearcher", ex); } } }
public IndexSearcher acquireIndexSearcher() throws IOException { // TODO: move this to separate thread to not penalty next incoming searcher searcherManager.maybeRefresh(); return searcherManager.acquire(); }
private void updateSearcherManager() { Log.d(TAG, "updateSearcherManager"); try { if (mSearcherManager != null) { mSearcherManager.close(); } File indexDirFile = new File(mLucenePath); Directory dir = FSDirectory.open(indexDirFile); mSearcherManager = new SearcherManager(dir, new SearcherFactory()); } catch (IOException e) { Log.e(TAG, "updateSearcherManager - " + e.getClass() + ": " + e.getLocalizedMessage()); } }