@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 testBroadcastIckleMatchAllQuery() { CacheQuery<Person> everybody = Search.getSearchManager(cacheAMachine1) .getQuery(String.format("FROM %s", Person.class.getName()), IndexedQueryMode.BROADCAST, Person.class); assertEquals(NUM_ENTRIES, everybody.list().size()); StaticTestingErrorHandler.assertAllGood(cacheAMachine1, cacheAMachine2); }
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); }
protected void checkIndex(int expectedNumber, Class<?> entity) { for (Cache<?, ?> c : caches) { SearchManager searchManager = Search.getSearchManager(c); assertEquals(searchManager.getQuery(new MatchAllDocsQuery(), entity).getResultSize(), expectedNumber); } }
@Test public void searchOnEmptyIndex() throws ParseException { QueryParser queryParser = TestQueryHelperFactory.createQueryParser("countryName"); Query query = queryParser.parse("Italy"); List<Object> list = qf.getQuery(query, Country.class, City.class).list(); assertEquals(0, list.size()); }
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); }
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()); }
@Test(expectedExceptions = UnsupportedOperationException.class, expectedExceptionsMessageRegExp = "Clustered queries do not support timeouts yet.") public void testClusteredQueryCacheTimeout() throws Exception { SearchManager searchManager = Search.getSearchManager(cache1); QueryParser queryParser = createQueryParser("bar"); org.apache.lucene.search.Query luceneQuery = queryParser.parse("fakebar"); CacheQuery<?> query = searchManager.getQuery(luceneQuery, IndexedQueryMode.BROADCAST, Foo.class); query.timeout(1, TimeUnit.NANOSECONDS); }
protected void checkIndex(int expectedNumber, Class<?> entity) { Cache<Integer, Transaction> c = caches.get(0); SearchManager searchManager = Search.getSearchManager(c); CacheQuery<?> q = searchManager.getQuery(new MatchAllDocsQuery(), entity); int resultSize = q.getResultSize(); assertEquals(expectedNumber, resultSize); }
@Override void warmup() { for (int i = 0; i < WARMUP_ITERATIONS; i++) { CacheQuery query = Search.getSearchManager(cache).getQuery(new MatchAllDocsQuery(), Entity.class); query.list(); } }
@Test public void searchOnSimpleField() throws ParseException { QueryParser queryParser = TestQueryHelperFactory.createQueryParser("countryName"); Query query = queryParser.parse("Italy"); Country italy = new Country(); italy.countryName = "Italy"; cache.put("IT", italy); List<Object> list = qf.getQuery(query, Country.class, City.class).list(); assertEquals(1, list.size()); }
protected void assertIndexSize(int expectedIndexSize) { SearchManager searchManager = Search.getSearchManager(cache); CacheQuery<Person> query = searchManager.getQuery(new MatchAllDocsQuery(), Person.class); assertEquals(expectedIndexSize, query.list().size()); StaticTestingErrorHandler.assertAllGood(cache); }
public void testMultipleResults() throws ParseException { loadTestingData(); queryParser = createQueryParser("name"); Query luceneQuery = queryParser.parse("goat"); CacheQuery<Person> cacheQuery = Search.getSearchManager(cache).getQuery(luceneQuery); List<Person> found = cacheQuery.list(); assert found.size() == 2; assertTrue(found.contains(person2)); assertTrue(found.contains(person3)); StaticTestingErrorHandler.assertAllGood(cache); }
protected void populateCache() throws ParseException { prepareTestData(); cacheQuery = Search.getSearchManager(cacheAMachine1).getQuery(createLuceneQuery(), IndexedQueryMode.BROADCAST); StaticTestingErrorHandler.assertAllGood(cacheAMachine1, cacheAMachine2); }
public void testFuzzyQuery() throws ParseException { populateCache(); org.apache.lucene.search.Query query = queryParser.parse("name:name1~2"); CacheQuery<Person> clusteredQuery = Search.getSearchManager(cacheAMachine1) .getQuery(query, IndexedQueryMode.BROADCAST, Person.class); assertEquals(NUM_ENTRIES, clusteredQuery.list().size()); StaticTestingErrorHandler.assertAllGood(cacheAMachine1, cacheAMachine2); }
public void testGetResultSize() throws Exception { prepareTestData(); queryParser = createQueryParser("blurb"); luceneQuery = queryParser.parse("playing"); cacheQuery = Search.getSearchManager(cache2).getQuery(luceneQuery); List<Person> found = cacheQuery.list(); assertEquals(1, found.size()); StaticTestingErrorHandler.assertAllGood(cache1, cache2); }
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; }
public void testCustomKeys() { CustomKey key1 = new CustomKey(1, 2, 3); CustomKey key2 = new CustomKey(900, 800, 700); CustomKey key3 = new CustomKey(1024, 2048, 4096); cache.put(key1, person1); cache.put(key2, person1); cache.put(key3, person1); Term term = new Term("blurb", "owns"); CacheQuery<?> cacheQuery = Search.getSearchManager(cache).getQuery(new TermQuery(term)); assertEquals(3, cacheQuery.getResultSize()); } }
private <T> CacheQuery<T> queryByNameField(String name, Class<T> entity) { SearchManager sm = Search.getSearchManager(cache); Query query = sm.buildQueryBuilderForClass(entity) .get().keyword().onField("name").matching(name).createQuery(); return sm.getQuery(query); } }
private void assertNumberOfCars(int expectedCount, String carMake) { for (Cache cache : caches) { SearchManager sm = Search.getSearchManager(cache); Query query = sm.buildQueryBuilderForClass(Car.class).get().keyword().onField("make").matching(carMake).createQuery(); CacheQuery<Car> cacheQuery = sm.getQuery(query, Car.class); assertEquals("Expected count not met on cache " + cache, expectedCount, cacheQuery.getResultSize()); assertEquals("Expected count not met on cache " + cache, expectedCount, cacheQuery.list().size()); } } }