import org.apache.lucene.search.Query; import org.hibernate.search.query.dsl.QueryBuilder; import org.infinispan.Cache; import org.infinispan.query.CacheQuery; import org.infinispan.query.Search; import org.infinispan.query.SearchManager; [...] private Cache<String, MyObject> m_cache; @PostConstruct public void setup () { m_cache = MyObjectCacheFactory.getMyObjectCache(); } @NotNull public List<MyObject> getMyObjects ( int searchNumber ) { SearchManager searchManager = Search.getSearchManager( m_cache ); QueryBuilder queryBuilder = searchManager.buildQueryBuilderForClass( MyObject.class ).get(); Query luceneQuery = queryBuilder.keyword().onField( "searchNumber" ).matching( searchNumber ).createQuery(); CacheQuery cacheQuery = searchManager.getQuery( luceneQuery, MyObject.class ); //noinspection unchecked return (List)cacheQuery.list(); }
protected SearchManagerImplementor getSearchManager() { if (!isIndexed) { throw new IllegalStateException("Cache is not indexed"); } if (searchManager == null) { searchManager = SecurityActions.getCacheSearchManager(cache).unwrap(SearchManagerImplementor.class); } return searchManager; }
@Override protected ModelNode invokeCommand(Cache<?, ?> cache, ModelNode operation, OperationContext context) { SearchManager searchManager = SecurityActions.getSearchManager(cache.getAdvancedCache()); if (searchManager != null) { searchManager.getMassIndexer().start(); } return null; } }
@Test public void testIndexAndQuery() throws Exception { SearchManager searchManager = Search.getSearchManager(cache); cache.put(123405, new Bond(new Date(System.currentTimeMillis()), 450L)); assertEfficientIndexingUsed(searchManager.unwrap(SearchIntegrator.class), Bond.class); cache.put(123502, new Debenture("GB", 116d)); assertEfficientIndexingUsed(searchManager.unwrap(SearchIntegrator.class), Debenture.class); cache.put(223456, new Bond(new Date(System.currentTimeMillis()), 550L)); assertEfficientIndexingUsed(searchManager.unwrap(SearchIntegrator.class), Bond.class); CacheQuery<?> query = searchManager.getQuery(new MatchAllDocsQuery(), Bond.class, Debenture.class); assertEquals(query.list().size(), 3); CacheQuery<?> queryBond = searchManager.getQuery(new MatchAllDocsQuery(), Bond.class); assertEquals(queryBond.getResultSize(), 2); CacheQuery<?> queryDeb = searchManager.getQuery(new MatchAllDocsQuery(), Debenture.class); assertEquals(queryDeb.getResultSize(), 1); }
private static void assertFind(Cache cache, String keyword, int expectedCount) { SearchManager queryFactory = Search.getSearchManager(cache); Query luceneQuery = new TermQuery(new Term("blurb", keyword)); CacheQuery<?> cacheQuery = queryFactory.getQuery(luceneQuery); int resultSize = cacheQuery.getResultSize(); Assert.assertEquals(resultSize, expectedCount); }
SearchIntegrator searchFactory = sm.unwrap(SearchIntegrator.class); assertNotNull(searchFactory.getIndexManager(ProgrammaticSearchMappingProviderImpl.getIndexName(cache.getName()))); Query luceneQuery = sm.buildQueryBuilderForClass(ProtobufValueWrapper.class) .get() .keyword() .createQuery(); List<byte[]> list = sm.<byte[]>getQuery(luceneQuery).list(); assertEquals(1, list.size()); byte[] pvw = list.get(0);
public void testReindexing() throws Exception { Cache cache = cache(0).getAdvancedCache().withFlags(Flag.SKIP_INDEXING); SearchManager searchManager = Search.getSearchManager(cache); Query query = searchManager.buildQueryBuilderForClass(Car.class) .get() .keyword() .onField("make") .matching("ford") .createQuery(); cache.put("car1", new Car("ford", "white", 300)); cache.put("car2", new Car("ford", "blue", 300)); cache.put("car3", new Car("ford", "red", 300)); // ensure these were not indexed assertEquals(0, searchManager.getQuery(query, Car.class).getResultSize()); //reindex searchManager.getMassIndexer().start(); // check that the indexing is complete immediately assertEquals(3, searchManager.getQuery(query, Car.class).getResultSize()); } }
SearchIntegrator searchFactory = sm.getSearchFactory(); QueryParser qp = new QueryParser(); ? sm.getQuery(q,GenericData.Record.class) : sm.getClusteredQuery(q,GenericData.Record.class);
private QueryBuilder createQueryBuilder() { return searchManager.buildQueryBuilderForClass(Foo.class).get(); }
Analyzer analyzer = search.getAnalyzer("standard_analyzer"); String text = "This is just FOOBAR's"; assertEquals(asList("This", "is", "just", "FOOBAR's"), terms(analyzer, "name", text)); analyzer = search.getAnalyzer("html_standard_analyzer"); text = "This is <b>foo</b><i>bar's</i>"; assertEquals(asList("This", "is", "foobar's"), terms(analyzer, "name", text)); analyzer = search.getAnalyzer("html_whitespace_analyzer"); text = "This is <b>foo</b><i>bar's</i>"; assertEquals(asList("This", "is", "foobar's"), terms(analyzer, "name", text)); analyzer = search.getAnalyzer("length_analyzer"); text = "ab abc abcd abcde abcdef"; assertEquals(asList("abc", "abcd", "abcde"), terms(analyzer, "name", text)); analyzer = search.getAnalyzer("length_analyzer"); text = "ab abc abcd abcde abcdef"; assertEquals(asList("abc", "abcd", "abcde"), terms(analyzer, "name", text)); analyzer = search.getAnalyzer("porter_analyzer"); text = "bikes bikes biking"; assertEquals(asList("bike", "bike", "bike"), terms(analyzer, "name", text)); analyzer = search.getAnalyzer("word_analyzer"); text = "CamelCase"; assertEquals(asList("Camel", "Case"), terms(analyzer, "name", text)); analyzer = search.getAnalyzer("synonym_analyzer");
@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(); }
private QueryBuilder createQueryBuilder() { return searchManager.buildQueryBuilderForClass(Foo.class).get(); }
private <T> List<T> queryAll(SearchManager sm, Class<T> entityType) { return sm.<T>getQuery(sm.buildQueryBuilderForClass(entityType).get().all().createQuery(), entityType).list(); }
@Override protected void verifyFindsCar(Cache cache, int expectedCount, String carMake) { SearchManager searchManager = Search.getSearchManager(cache); CacheQuery<?> cacheQuery = searchManager.getQuery(new TermQuery(new Term("make", carMake)), IndexedQueryMode.BROADCAST); assertEquals(expectedCount, cacheQuery.getResultSize()); } }
protected SearchIntegrator getSearchFactory() { if (searchFactory == null) { searchFactory = getSearchManager().unwrap(SearchIntegrator.class); } return searchFactory; }
@Override protected void rebuildIndexes() throws Exception { Cache cache = caches.get(0); SearchManager searchManager = Search.getSearchManager(cache); CompletableFuture<Void> future = searchManager.getMassIndexer().startAsync(); future.get(); } }
protected Query createLuceneQuery() { if (queryType == QueryType.MATCH_ALL) { return new MatchAllDocsQuery(); } if (queryType == QueryType.TERM) { return Search.getSearchManager(cache) .buildQueryBuilderForClass(Entity.class).get() .keyword().onField("val").matching(getRandomTerm()) .createQuery(); } return null; }
private <T> List<T> queryAll(SearchManager sm, Class<T> entityType) { return sm.<T>getQuery(sm.buildQueryBuilderForClass(entityType).get().all().createQuery(), entityType).list(); }
private <T> CacheQuery<T> createCacheQuery(String query) throws ParseException { queryParser = createQueryParser(query.substring(0, query.indexOf(':'))); Query q = queryParser.parse(query); return Search.getSearchManager(cache1).getQuery(q); }
private boolean isMasterNode(Cache<?,?> cache) { //Implicitly verifies the components are setup as configured by casting: SearchManager searchManager = Search.getSearchManager(cache); SearchIntegrator searchFactory = searchManager.unwrap(SearchIntegrator.class); InfinispanIndexManager indexManager = (InfinispanIndexManager) searchFactory.getIndexManager("person"); return indexManager.isMasterLocal(); }