@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; }
protected void executeSimpleQuery(Cache<String, Person> cache) throws ParseException { CacheQuery<?> cacheQuery = createCacheQuery(cache, "blurb", "playing"); List<?> found = cacheQuery.list(); int elems = found.size(); assertEquals(1, elems); Object val = found.get(0); Person expectedPerson = persons[0]; assertEquals(expectedPerson, val); }
@Test(expectedExceptions = SearchException.class, expectedExceptionsMessageRegExp = ".*cannot be converted to an indexed query") public void testPreventHybridQuery() { CacheQuery<Person> hybridQuery = Search.getSearchManager(cacheAMachine1) .getQuery(String.format("FROM %s p where p.nonIndexedField = 'nothing'", Person.class.getName()), IndexedQueryMode.BROADCAST, Person.class); hybridQuery.list(); }
public void testBroadcastIckleTermQuery() { String targetName = "name2"; CacheQuery<Person> singlePerson = Search.getSearchManager(cacheAMachine1) .getQuery(String.format("FROM %s p where p.name:'%s'", Person.class.getName(), targetName), IndexedQueryMode.BROADCAST, Person.class); assertEquals(1, singlePerson.list().size()); assertEquals(targetName, singlePerson.list().iterator().next().getName()); StaticTestingErrorHandler.assertAllGood(cacheAMachine1, cacheAMachine2); }
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(); }
private void testPaginationInternal(int pageSize, Sort sort) { CacheQuery<Person> paginationQuery = buildPaginationQuery(0, pageSize, sort); int idx = 0; Set<String> keys = new HashSet<>(); while (idx < NUM_ENTRIES) { List<Person> results = paginationQuery.list(); results.stream().map(Person::getName).forEach(keys::add); idx += pageSize; paginationQuery = buildPaginationQuery(idx, pageSize, sort); } assertEquals(NUM_ENTRIES, keys.size()); StaticTestingErrorHandler.assertAllGood(cacheAMachine1, cacheAMachine2); }
public void testFullTextFilterOnOff() throws ParseException { loadTestingData(); queryParser = createQueryParser("blurb"); Query luceneQuery = queryParser.parse("Eats"); CacheQuery<Person> query = Search.getSearchManager(cache).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("Mini Goat", person.getName()); assertEquals("Eats cheese", person.getBlurb()); //Disabling the fullTextFilter. query.disableFullTextFilter("personFilter"); assertEquals(3, query.getResultSize()); StaticTestingErrorHandler.assertAllGood(cache); }
public void testBroadcastProjectionIckleQuery() { SearchManager sm = Search.getSearchManager(cacheAMachine2); CacheQuery<Object[]> onlyNames = sm.getQuery( String.format("Select p.name FROM %s p", Person.class.getName()), IndexedQueryMode.BROADCAST, Person.class ); List<Object[]> results = onlyNames.list(); assertEquals(NUM_ENTRIES, results.size()); Set<String> names = new HashSet<>(); results.iterator().forEachRemaining(s -> names.add((String) s[0])); Set<String> allNames = IntStream.range(0, NUM_ENTRIES).boxed().map(i -> "name" + i).collect(Collectors.toSet()); assertEquals(allNames, names); StaticTestingErrorHandler.assertAllGood(cacheAMachine1, cacheAMachine2); }
@Test(enabled = false, description = "Disabled due to https://issues.jboss.org/browse/ISPN-8564") public void testSimpleProjection2() { IckleParsingResult<Class<?>> parsingResult = IckleParser.parse("select author.name from org.infinispan.query.dsl.embedded.testdomain.Book", qe.propertyHelper); CacheQuery q = qe.buildLuceneQuery(parsingResult, null, -1, -1); List<?> list = q.list(); assertEquals(3, list.size()); }
private int countIndexedDocuments(Class<?> clazz) { CacheQuery<?> query = Search.getSearchManager(cache).getQuery(new MatchAllDocsQuery(), clazz); return query.list().size(); }
public void testOverwriteNotIndexedValue() { final long id = 10; cache.put(id, new NotIndexedType("name1")); Map<Object, Object> map = new HashMap<>(); map.put(id, new TestEntity("name2", "surname2", id, "note")); cache.putAll(map); CacheQuery<?> q1 = queryByNameField("name2", AnotherTestEntity.class); assertEquals(1, q1.getResultSize()); assertEquals(TestEntity.class, q1.list().get(0).getClass()); 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); }
@Test(expectedExceptions = SearchException.class, expectedExceptionsMessageRegExp = ".*cannot be converted to an indexed query") public void testPreventAggregationQueries() { CacheQuery<Person> aggregationQuery = Search.getSearchManager(cacheAMachine1) .getQuery(String.format("FROM %s p where p.name:'name3' group by p.name", Person.class.getName()), IndexedQueryMode.BROADCAST, Person.class); aggregationQuery.list(); }
public void testBroadcastFuzzyIckle() { CacheQuery<Person> persons0to10 = Search.getSearchManager(cacheAMachine1) .getQuery(String.format("FROM %s p where p.name:'nome'~2", Person.class.getName()), IndexedQueryMode.BROADCAST, Person.class); assertEquals(10, persons0to10.list().size()); StaticTestingErrorHandler.assertAllGood(cacheAMachine1, cacheAMachine2); }
public void testSimpleProjection1() { IckleParsingResult<Class<?>> parsingResult = IckleParser.parse("select b.author.name from org.infinispan.query.dsl.embedded.testdomain.Book b", qe.propertyHelper); CacheQuery q = qe.buildLuceneQuery(parsingResult, null, -1, -1); List<?> list = q.list(); assertEquals(3, list.size()); }
private void assertAllIndexed(final Cache cache) { eventually(() -> { int size = Search.getSearchManager(cache).getQuery(new MatchAllDocsQuery(), Transaction.class).list().size(); return size == NUM_ENTRIES; }); }
public void testSimpleForNonField() throws ParseException { loadTestingData(); CacheQuery<?> cacheQuery = createCacheQuery(cache, "nonIndexedField", "test1" ); List<?> found = cacheQuery.list(); int elems = found.size(); assert elems == 0 : "Expected 0 but was " + elems; StaticTestingErrorHandler.assertAllGood(cache); }
public void testAsyncOverwriteNotIndexedValue() throws Exception { final long id = 10; cache.put(id, new NotIndexedType("name1")); Map<Object, Object> map = new HashMap<>(); map.put(id, new TestEntity("name2", "surname2", id, "note")); Future futureTask = cache.putAllAsync(map); futureTask.get(); assertTrue(futureTask.isDone()); CacheQuery<?> q1 = queryByNameField("name2", AnotherTestEntity.class); assertEquals(1, q1.getResultSize()); assertEquals(TestEntity.class, q1.list().get(0).getClass()); StaticTestingErrorHandler.assertAllGood(cache); }
@Override void warmup() { for (int i = 0; i < WARMUP_ITERATIONS; i++) { CacheQuery query = Search.getSearchManager(cache).getQuery(new MatchAllDocsQuery(), Entity.class); query.list(); } }