@Override protected EntityInfo loadEntityInfo(int index) { try { return extractor.extract(index); } catch (IOException e) { throw new CacheException("Cannot load result at index " + index, e); } } }
@Override public void close() { extractor.close(); }
public LazyIterator(DocumentExtractor extractor, QueryResultLoader resultLoader, int fetchSize) { super(resultLoader, extractor.getFirstIndex(), extractor.getMaxIndex(), fetchSize); this.extractor = extractor; }
@BeforeMethod public void setUp() throws Exception { super.setUp(); extractor = mock(DocumentExtractor.class); when(extractor.getMaxIndex()).thenReturn(entityInfos.size() - 1); when(extractor.extract(anyInt())).thenAnswer((Answer<EntityInfo>) invocation -> { int index = (Integer) invocation.getArguments()[0]; return entityInfos.get(index); }); iterator = new LazyIterator<>(extractor, new EntityLoader(cache, new KeyTransformationHandler(null)), getFetchSize()); }
private NodeTopDocs collectKeys(DocumentExtractor extractor, HSQuery query) { TopDocs topDocs = extractor.getTopDocs(); int topDocsLength = topDocs.scoreDocs.length; Object[] keys = null; Object[] projections = null; if (query.getProjectedFields() == null) { keys = new Object[topDocsLength]; // collecting keys (it's a eager query!) for (int i = 0; i < topDocsLength; i++) { keys[i] = extractKey(extractor, i); } } else { projections = new Object[topDocsLength]; try { for (int docIndex = 0; docIndex < topDocsLength; docIndex++) { projections[docIndex] = extractor.extract(docIndex).getProjection(); } } catch (IOException e) { throw new SearchException("Error while extracting projection", e); } } return new NodeTopDocs(cache.getRpcManager().getAddress(), topDocs, keys, projections); } }
private NodeTopDocs collectKeys(DocumentExtractor extractor) { TopDocs topDocs = extractor.getTopDocs(); Object[] keys = new Object[topDocs.scoreDocs.length]; KeyTransformationHandler keyTransformationHandler = KeyTransformationHandler .getInstance(cache.getAdvancedCache()); // collecting keys (it's a eager query!) for (int i = 0; i < topDocs.scoreDocs.length; i++) { keys[i] = QueryExtractorUtil.extractKey(extractor, cache, keyTransformationHandler, i); } return new NodeTopDocs(topDocs, keys); }
@Override QueryResponse perform() { HSQuery query = queryDefinition.getHsQuery(); query.afterDeserialise(getSearchFactory()); DocumentExtractor extractor = query.queryDocumentExtractor(); // registering... getQueryBox().put(queryId, extractor); // returning the QueryResponse TopDocs topDocs = extractor.getTopDocs(); return new QueryResponse(new NodeTopDocs(cache.getRpcManager().getAddress(), topDocs)); } }
@Override protected EntityInfo loadEntityInfo(int index) { try { return extractor.extract(index); } catch (IOException e) { throw new CacheException("Cannot load result at index " + index, e); } } }
@Override public void close() { extractor.close(); }
LazyIterator(DocumentExtractor extractor, QueryResultLoader resultLoader, int fetchSize) { super(resultLoader, extractor.getFirstIndex(), extractor.getMaxIndex(), fetchSize); this.extractor = extractor; }
@Override public QueryResponse perform() { query.afterDeserialise(getSearchFactory()); DocumentExtractor extractor = query.queryDocumentExtractor(); int resultSize = query.queryResultSize(); QueryBox box = getQueryBox(); // registering... box.put(lazyQueryId, extractor); // returning the QueryResponse TopDocs topDocs = extractor.getTopDocs(); QueryResponse queryResponse = new QueryResponse(new NodeTopDocs(topDocs), box.getMyId(), resultSize); queryResponse.setAddress(cache.getAdvancedCache().getRpcManager().getAddress()); return queryResponse; }
/** * Extract an entityInfo, either from cache or from the index. * @param x the position in the index. * @return */ private EntityInfo getEntityInfo(int x) { EntityInfo entityInfo = einfo == null ? null : einfo.get(); if ( entityInfo == null ) { try { entityInfo = documentExtractor.extract( x ); } catch (IOException e) { throw new SearchException( "Unable to read Lucene topDocs[" + x + "]", e ); } einfo = new SoftReference<EntityInfo>( entityInfo ); } return entityInfo; }
/** * Kill the query (DocumentExtractor). * * @param queryId The id of the query */ void kill(UUID queryId) { DocumentExtractor extractor = queries.remove(queryId); if (extractor != null) { extractor.close(); } }
public ScrollableResultsImpl(int fetchSize, DocumentExtractor extractor, Loader loader, SessionImplementor sessionImplementor, boolean hasThisProjection ) { this.loader = loader; this.documentExtractor = extractor; this.fetchSize = fetchSize; this.session = sessionImplementor; this.hasThisProjection = hasThisProjection; this.first = extractor.getFirstIndex(); this.max = extractor.getMaxIndex(); int size = Math.max( max - first + 1, 0 ); this.resultsContext = new LoadedObject[size]; beforeFirst(); }
/** * Utility to extract the cache key of a DocumentExtractor and use the KeyTransformationHandler to turn the string * into the actual key object. * * @param extractor * @param docIndex * @return */ Object extractKey(DocumentExtractor extractor, int docIndex) { String strKey; try { strKey = (String) extractor.extract(docIndex).getId(); } catch (IOException e) { throw new SearchException("Error while extracting key", e); } return keyTransformationHandler.stringToKey(strKey); } }
/** * Kill the query (DocumentExtractor) * * @param id * The id of the query */ public void kill(UUID id) { DocumentExtractor extractor = queries.remove(id); ageOrderedQueries.remove(id); if (extractor != null) extractor.close(); }
@Test(expectedExceptions = IllegalArgumentException.class) public void testLazyIteratorInitWithInvalidFetchSize() throws IOException { DocumentExtractor extractor = mock(DocumentExtractor.class); when(extractor.extract(anyInt())).thenAnswer((Answer<EntityInfo>) invocation -> { int index = (Integer) invocation.getArguments()[0]; return entityInfos.get(index); }); cache = mock(AdvancedCache.class); new LazyIterator<>(extractor, new EntityLoader(cache, new KeyTransformationHandler(null)), getFetchSize()); }
@Override public void close() { closed = true; try { documentExtractor.close(); } catch (SearchException e) { log.unableToCloseSearcherInScrollableResult( e ); } }
public static Object extractKey(DocumentExtractor extractor, Cache<?, ?> cache, KeyTransformationHandler keyTransformationHandler, int docIndex) { String bufferDocumentId; try { bufferDocumentId = (String) extractor.extract(docIndex).getId(); } catch (IOException e) { log.error("Error while extracting key...", e); return null; } Object key = keyTransformationHandler.stringToKey(bufferDocumentId, cache .getAdvancedCache().getClassLoader()); return key; }
@Override protected void extractFacetResults() { DocumentExtractor queryDocumentExtractor = queryDocumentExtractor(); queryDocumentExtractor.close(); }