@Override @SuppressWarnings("unchecked") public <T> List<T> list() { if (results == null) { List<?> list = createCacheQuery().list(); results = rowProcessor == null ? list : ((List<Object[]>) list).stream().map(rowProcessor) .collect(Collectors.toCollection(() -> new ArrayList<>(list.size()))); } return (List<T>) results; }
public void testPagination() { cacheQuery.firstResult(2); cacheQuery.maxResults(1); // applying sort SortField sortField = new SortField("age", Type.INT); Sort sort = new Sort(sortField); cacheQuery.sort(sort); List<Person> results = cacheQuery.list(); assertEquals(1, results.size()); assertEquals(10, cacheQuery.getResultSize()); Person result = results.get(0); assertEquals(12, result.getAge()); StaticTestingErrorHandler.assertAllGood(cacheAMachine1, cacheAMachine2); }
protected void assertDocsIndexed(long millis) { int numEntries = getNumEntries(); this.eventually(() -> { CacheQuery<Object[]> query = Search.getSearchManager(pickCache()).getQuery(new MatchAllDocsQuery()).projection("val"); Set<Integer> indexedDocsIds = query.list().stream().map(projections -> (Integer) projections[0]).collect(Collectors.toSet()); int resultSize = indexedDocsIds.size(); return resultSize == numEntries; }, millis); }
private CacheQuery<Person> buildPaginationQuery(int offset, int pageSize, Sort sort) { CacheQuery<Person> clusteredQuery = Search.getSearchManager(cacheAMachine1) .getQuery(new MatchAllDocsQuery(), IndexedQueryMode.BROADCAST); clusteredQuery.firstResult(offset); clusteredQuery.maxResults(pageSize); if (sort != null) { clusteredQuery.sort(sort); } return clusteredQuery; }
private List searchByName(String name, Cache c) { SearchManager sm = Search.getSearchManager(c); CacheQuery<?> q = sm.getQuery(SEntity.searchByName(name), SEntity.class); int resultSize = q.getResultSize(); List<?> l = q.list(); assert l.size() == resultSize; return q.list(); }
public void testLazyNonOrdered() { try (ResultIterator<Person> ignored = cacheQuery.iterator(new FetchOptions().fetchMode(FetchOptions.FetchMode.LAZY))) { assert cacheQuery.getResultSize() == 10 : cacheQuery.getResultSize(); } StaticTestingErrorHandler.assertAllGood(cacheAMachine1, cacheAMachine2); }
/** * Build a Lucene index query. */ protected <E> CacheQuery<E> buildLuceneQuery(IckleParsingResult<TypeMetadata> ickleParsingResult, Map<String, Object> namedParameters, long startOffset, int maxResults) { if (log.isDebugEnabled()) { log.debugf("Building Lucene query for : %s", ickleParsingResult.getQueryString()); } if (!isIndexed) { throw log.cannotRunLuceneQueriesIfNotIndexed(cache.getName()); } LuceneQueryParsingResult luceneParsingResult = transformParsingResult(ickleParsingResult, namedParameters); org.apache.lucene.search.Query luceneQuery = makeTypeQuery(luceneParsingResult.getQuery(), luceneParsingResult.getTargetEntityName()); if (log.isDebugEnabled()) { log.debugf("The resulting Lucene query is : %s", luceneQuery.toString()); } CacheQuery<?> cacheQuery = makeCacheQuery(ickleParsingResult, luceneQuery); if (luceneParsingResult.getSort() != null) { cacheQuery = cacheQuery.sort(luceneParsingResult.getSort()); } if (luceneParsingResult.getProjections() != null) { cacheQuery = cacheQuery.projection(luceneParsingResult.getProjections()); } if (startOffset >= 0) { cacheQuery = cacheQuery.firstResult((int) startOffset); } if (maxResults > 0) { cacheQuery = cacheQuery.maxResults(maxResults); } return (CacheQuery<E>) cacheQuery; }
@Override public int getResultSize() { //todo [anistor] optimize this by running a slightly modified query that performs just COUNT only, ignoring projections or sorting return createCacheQuery().getResultSize(); }
public void testPaginatedIckleQuery() { SearchManager sm = Search.getSearchManager(cacheAMachine1); CacheQuery<Person> q = sm.getQuery(String.format("FROM %s p order by p.age", Person.class.getName()), IndexedQueryMode.BROADCAST, Person.class); q.firstResult(5); q.maxResults(10); List<Person> results = q.list(); assertEquals(10, results.size()); assertEquals("name5", results.iterator().next().getName()); assertEquals("name14", results.get(9).getName()); }
public void testList() { // applying sort SortField sortField = new SortField("age", Type.INT); Sort sort = new Sort(sortField); cacheQuery.sort(sort); List<Person> results = cacheQuery.list(); assertEquals(10, cacheQuery.getResultSize()); int previousAge = 0; for (Person person : results) { assert person.getAge() > previousAge; previousAge = person.getAge(); } StaticTestingErrorHandler.assertAllGood(cacheAMachine1, cacheAMachine2); }
public void testMaxResults() throws ParseException { loadTestingData(); queryParser = createQueryParser("blurb"); Query luceneQuery = queryParser.parse("eats"); CacheQuery<?> cacheQuery = Search.getSearchManager(cache).getQuery(luceneQuery) .maxResults(1); assertEquals(3, cacheQuery.getResultSize()); // NOTE: getResultSize() ignores pagination (maxResults, firstResult) assertEquals(1, cacheQuery.list().size()); ResultIterator<?> eagerIterator = cacheQuery.iterator(new FetchOptions().fetchMode(FetchOptions.FetchMode.EAGER)); try { assertEquals(1, countElements(eagerIterator)); } finally { eagerIterator.close(); } ResultIterator<?> lazyIterator = cacheQuery.iterator(new FetchOptions().fetchMode(FetchOptions.FetchMode.LAZY)); try { assertEquals(1, countElements(lazyIterator)); } finally { lazyIterator.close(); } ResultIterator<?> defaultIterator = cacheQuery.iterator(); try { assertEquals(1, countElements(defaultIterator)); } finally { defaultIterator.close(); } StaticTestingErrorHandler.assertAllGood(cache); }
public void testFullTextFilterOnOff() throws Exception { prepareTestData(); queryParser = createQueryParser("blurb"); Query luceneQuery = queryParser.parse("eats"); CacheQuery<Person> query = Search.getSearchManager(cache1).getQuery(luceneQuery); FullTextFilter filter = query.enableFullTextFilter("personFilter"); filter.setParameter("blurbText", "cheese"); assertEquals(1, query.getResultSize()); List<Person> result = query.list(); Person person = result.get(0); assertEquals("MiniGoat", person.getName()); assertEquals("Eats cheese", person.getBlurb()); //Disabling the fullTextFilter. query.disableFullTextFilter("personFilter"); assertEquals(2, query.getResultSize()); StaticTestingErrorHandler.assertAllGood(cache1, cache2); }
public void testLazyOrdered() { // applying sort SortField sortField = new SortField("age", Type.INT); Sort sort = new Sort(sortField); cacheQuery.sort(sort); for (int i = 0; i < 2; i++) { try (ResultIterator<Person> iterator = cacheQuery.iterator(new FetchOptions().fetchMode(FetchOptions.FetchMode.LAZY))) { assert cacheQuery.getResultSize() == 10 : cacheQuery.getResultSize(); int previousAge = 0; while (iterator.hasNext()) { Person person = iterator.next(); assert person.getAge() > previousAge; previousAge = person.getAge(); } } } StaticTestingErrorHandler.assertAllGood(cacheAMachine1, cacheAMachine2); }
@Test(expectedExceptions = IllegalArgumentException.class) public void testLazyIteratorWithInvalidFetchSize() throws ParseException { loadTestingData(); queryParser = createQueryParser("blurb"); Query luceneQuery = queryParser.parse("Eats"); CacheQuery<?> cacheQuery = Search.getSearchManager(cache).<Person>getQuery(luceneQuery).firstResult(1); cacheQuery.iterator(new FetchOptions().fetchMode(FetchOptions.FetchMode.LAZY).fetchSize(0)); }
private void assertQueryReturns(CacheQuery<?> cacheQuery, Object[] expected) { assertQueryListContains(cacheQuery.list(), expected); try (ResultIterator<?> eagerIterator = cacheQuery.iterator(new FetchOptions().fetchMode(FetchOptions.FetchMode.EAGER))) { assertQueryIteratorContains(eagerIterator, expected); } try (ResultIterator<?> lazyIterator = cacheQuery.iterator(new FetchOptions().fetchMode(FetchOptions.FetchMode.LAZY))) { assertQueryIteratorContains(lazyIterator, expected); } }
cacheQuery = cacheQuery.sort(luceneParsingResult.getSort()); cacheQuery = cacheQuery.projection(luceneParsingResult.getProjections());
@Test(expectedExceptions = UnsupportedOperationException.class) public void testIteratorRemove() { cacheQuery.maxResults(1); try (ResultIterator<Person> iterator = cacheQuery.iterator(new FetchOptions().fetchMode(FetchOptions.FetchMode.EAGER))) { assert iterator.hasNext(); iterator.remove(); } StaticTestingErrorHandler.assertAllGood(cacheAMachine1, cacheAMachine2); }
@Test public void testQueryReturnsNullWhenProjectingCacheValue() throws Exception { withTx(tm(), (Callable<Void>) () -> { cache.remove("1"); // cache will now be out of sync with the index Query query = createQueryBuilder().keyword().onField("bar").matching("1").createQuery(); ResultIterator<Object[]> iterator = searchManager.getQuery(query).projection(ProjectionConstants.VALUE, "bar").iterator(new FetchOptions().fetchMode(LAZY)); assertTrue(iterator.hasNext()); Object[] projection = iterator.next(); assertNull(projection[0]); assertEquals("1", projection[1]); return null; }); }
private CacheQuery<?> createProjectionQuery(String... projection) { QueryBuilder queryBuilder = searchManager.buildQueryBuilderForClass(Foo.class).get(); Query query = queryBuilder.keyword().onField("bar").matching("bar1").createQuery(); return searchManager.getQuery(query).projection(projection); }