import org.infinispan.query.dsl.QueryFactory; //导入依赖的package包/类
public static void main(String[] args) {
   ConfigurationBuilder builder = new ConfigurationBuilder();
   builder.indexing().index(Index.ALL)
      .addProperty("default.directory_provider", "ram")
      .addProperty("lucene_version", "LUCENE_CURRENT");
   // Construct a simple local cache manager with default configuration
   DefaultCacheManager cacheManager = new DefaultCacheManager(builder.build());
   // Obtain the default cache
   Cache<String, Person> cache = cacheManager.getCache();
   // Store some entries
   cache.put("person1", new Person("William", "Shakespeare"));
   cache.put("person2", new Person("William", "Wordsworth"));
   cache.put("person3", new Person("John", "Milton"));
   // Obtain a query factory for the cache
   QueryFactory queryFactory = Search.getQueryFactory(cache);
   // Construct a query
   Query query = queryFactory.from(Person.class).having("name").eq("William").toBuilder().build();
   // Execute the query
   List<Person> matches = query.list();
   // List the results
   matches.forEach(person -> System.out.printf("Match: %s", person));
   // Stop the cache manager and release all resources
   cacheManager.stop();
}
 

import org.infinispan.query.dsl.QueryFactory; //导入依赖的package包/类
@Test
public void testAttributeQuery() throws Exception {

   remoteCache0.put(1, createEmployee1());
   remoteCache0.put(2, createEmployee2());

   QueryFactory qf = Search.getQueryFactory(remoteCache1);

   Query query = qf.from(Employee.class)
         .having("ssn").eq("12357").toBuilder()
         .build();
   List<Employee> list = query.list();
   assertNotNull(list);
   assertEquals(1, list.size());

}
 

import org.infinispan.query.dsl.QueryFactory; //导入依赖的package包/类
@Override
public List<?> getRules(final String clientIPAddress) {
    try {
        final RemoteCache<String, Rule> ruleCache = cacheManagerForIndexableCaches.getCache(SinkitCacheName.infinispan_rules.toString());
        final ImmutablePair<String, String> startEndAddresses = CIDRUtils.getStartEndAddresses(clientIPAddress);
        final String clientIPAddressPaddedBigInt = startEndAddresses.getLeft();
        log.log(Level.FINE, "Getting key [" + clientIPAddress + "] which actually translates to BigInteger zero padded representation " + "[" + clientIPAddressPaddedBigInt + "]");
        // Let's try to hit it
        Rule rule = ruleCache.withFlags(Flag.SKIP_CACHE_LOAD).get(clientIPAddressPaddedBigInt);
        if (rule != null) {
            return Collections.singletonList(rule);
        }
        QueryFactory qf = Search.getQueryFactory(ruleCache);
        Query query = qf.from(Rule.class)
                .having("startAddress").lte(clientIPAddressPaddedBigInt)
                .and()
                .having("endAddress").gte(clientIPAddressPaddedBigInt)
                .toBuilder().build();
        return query.list();
    } catch (Exception e) {
        log.log(Level.SEVERE, "getRules client address troubles", e);
        // TODO: Proper Error codes.
        return null;
    }
}
 

import org.infinispan.query.dsl.QueryFactory; //导入依赖的package包/类
@Override
public List<?> getAllRules() {
    try {
        final RemoteCache<String, Rule> ruleCache = cacheManagerForIndexableCaches.getCache(SinkitCacheName.infinispan_rules.toString());
        log.log(Level.SEVERE, "getAllRules: This is a very expensive operation.");
        final QueryFactory qf = Search.getQueryFactory(ruleCache);
        final Query query = qf.from(Rule.class).build();
        // Hundreds of records...
        List<Rule> results = query.list();
        return results;
    } catch (Exception e) {
        log.log(Level.SEVERE, "getRules client address troubles", e);
        // TODO: Proper Error codes.
        return null;
    }
}
 

import org.infinispan.query.dsl.QueryFactory; //导入依赖的package包/类
@Override
public String deleteRulesByCustomer(Integer customerId) {
    int counter = 0;
    //TODO: Shouldn't this be done by a one Infinispan DSL removal call?
    try {
        final RemoteCache<String, Rule> ruleCache = cacheManagerForIndexableCaches.getCache(SinkitCacheName.infinispan_rules.toString());
        final QueryFactory qf = Search.getQueryFactory(ruleCache);
        Query query = qf.from(Rule.class)
                .having("customerId").eq(customerId)
                .toBuilder().build();
        // TODO: Use CloseableIterator
        Iterator iterator = query.list().iterator();
        while (iterator.hasNext()) {
            ruleCache.remove(((Rule) iterator.next()).getStartAddress());
            counter++;
        }
        return counter + " RULES DELETED FOR CUSTOMER ID: " + customerId;
    } catch (Exception e) {
        log.log(Level.SEVERE, "deleteRulesByCustomer", e);
        // TODO: Proper Error codes.
        return null;
    }
}
 

import org.infinispan.query.dsl.QueryFactory; //导入依赖的package包/类
public List<Beer> getBeerByIbuBetweenIQ(double low, double high){
    QueryFactory queryFactory = Search.getQueryFactory(cache);
    org.infinispan.query.dsl.Query infinispanQuery =
            queryFactory.from(Beer.class)
                    .orderBy("ibu", SortOrder.ASC)
                    .having("ibu")
                    .between(low,high)
                    .build();
    return infinispanQuery.list();
}
 

import org.infinispan.query.dsl.QueryFactory; //导入依赖的package包/类
public List<Beer> getAllBeers(boolean desc) {
    QueryFactory queryFactory = Search.getQueryFactory(cache);
    org.infinispan.query.dsl.QueryBuilder infinispanQueryBuilder =
            queryFactory.from(Beer.class);

    if(desc){
        infinispanQueryBuilder.orderBy("id", SortOrder.DESC);
    }
    org.infinispan.query.dsl.Query infinispanQuery = infinispanQueryBuilder.build();
    return infinispanQuery.list();
}
 

import org.infinispan.query.dsl.QueryFactory; //导入依赖的package包/类
public List<Beer> getBeerByWildcardDescription(String description){
    QueryFactory queryFactory = Search.getQueryFactory(cache);
    org.infinispan.query.dsl.Query infinispanQuery =
            queryFactory.from(Beer.class)
                    .having("description")
                    .like("%" + description + "%")
                    .build();
    return infinispanQuery.list();
}
 

import org.infinispan.query.dsl.QueryFactory; //导入依赖的package包/类
/**
 * There are 3 ways to find the result, in ascending order by their cost:
 * 1. local cache of already found results based on clientIPAddressPaddedBigInt
 * 2. getting key clientIPAddressPaddedBigInt from the cache of Rules
 * 3. lookup in the cache of Rules based on subnets
 * <p>
 * TODO: List? Array? Map with additional data? Let's think this over.
 * TODO: Replace/factor out duplicated code in .getRules out of webApiEJB
 *
 * @param clientIPAddressPaddedBigInt
 * @return list of rules
 */
private List<Rule> rulesLookup(final String clientIPAddressPaddedBigInt, final RemoteCache<String, Rule> ruleCache) {
    try {
        log.log(Level.FINE, "Getting key BigInteger zero padded representation " + clientIPAddressPaddedBigInt);
        // Let's search subnets
        final String keyInCache = DigestUtils.md5Hex(clientIPAddressPaddedBigInt + clientIPAddressPaddedBigInt);
        log.log(Level.FINE, "keyInCache: " + keyInCache + ", from: " + (clientIPAddressPaddedBigInt + clientIPAddressPaddedBigInt));

        final List<Rule> cached = ruleLocalCache.get(keyInCache);
        if (cached != null) {
            return cached;
        } else {
            // Let's try to hit it
            final Rule rule = ruleCache.withFlags(Flag.SKIP_CACHE_LOAD).get(clientIPAddressPaddedBigInt);
            if (rule != null) {
                return Collections.singletonList(rule);
            }
            final QueryFactory qf = Search.getQueryFactory(ruleCache);
            final Query query = qf.from(Rule.class)
                    .having("startAddress").lte(clientIPAddressPaddedBigInt)
                    .and()
                    .having("endAddress").gte(clientIPAddressPaddedBigInt)
                    .toBuilder().build();
            if (query != null) {
                final List<Rule> result = query.list();
                ruleLocalCache.put(keyInCache, result);
                return result;

            }
            return Collections.emptyList();
        }
    } catch (Exception e) {
        log.log(Level.SEVERE, "getRules client address troubles", e);
        return null;
    }
}
 

import org.infinispan.query.dsl.QueryFactory; //导入依赖的package包/类
public InfinispanRemoteQueryAdapter(QueryFactory queryFactory) {
    this.queryFactory = queryFactory;
}
 

import org.infinispan.query.dsl.QueryFactory; //导入依赖的package包/类
public <T> QueryAdapter<T> createQueryAdapter(Class<T> entityClass) {
    RemoteCache<?, T> cache = getCache(entityClass);
    QueryFactory qf = org.infinispan.client.hotrod.Search.getQueryFactory(cache);
    return new InfinispanRemoteQueryAdapter<>(qf);
}
 

import org.infinispan.query.dsl.QueryFactory; //导入依赖的package包/类
public InfinispanCriteriaConverter(QueryFactory queryFactory, QueryBuilder queryBuilder) {
    this.queryFactory = queryFactory;
    this.queryBuilder = queryBuilder;
}
 

import org.infinispan.query.dsl.QueryFactory; //导入依赖的package包/类
@Override
public Query build(QueryFactory<Query> queryFactory) {
    return queryFactory.from(User.class)
        .having("name").like("%abc%")
        .toBuilder().build();
}
 

import org.infinispan.query.dsl.QueryFactory; //导入依赖的package包/类
@Override
public Query build(QueryFactory<Query> queryFactory) {
    return queryFactory.from(User.class)
        .having("name").like("CQ%")
        .toBuilder().build();
}
 

import org.infinispan.query.dsl.QueryFactory; //导入依赖的package包/类
public QueryBuilder(RemoteCacheImpl cache, QueryFactory qf, Schema schema) {
   super(qf,GenericData.Record.class.getName());
   this.cache = cache;
   this.schema = schema;
}
 

import org.infinispan.query.dsl.QueryFactory; //导入依赖的package包/类
@Produces
@InventoryResource
public QueryFactory getResourceQueryFactory() {
    return queryResource;
}
 

import org.infinispan.query.dsl.QueryFactory; //导入依赖的package包/类
@Produces
@InventoryResourceType
public QueryFactory getResourceTypeQueryFactory() {
    return queryResourceType;
}
 

import org.infinispan.query.dsl.QueryFactory; //导入依赖的package包/类
@SuppressWarnings("rawtypes")
	private static QueryBuilder getQueryBuilder(String cacheName, ObjectConnection conn) throws TranslatorException {
		
		Cache c = (Cache) conn.getCacheContainer().getCache(cacheName);
		
		// changed from 8.7.x (Infin. 6.1) to
		// upstream where only Infin  6.0 is available
		QueryFactory qf = Search.getSearchManager(c).getQueryFactory();
//		QueryFactory qf = Search.getQueryFactory(c);  
			
		Class<?> type = conn.getType(cacheName);
	    		  
	    QueryBuilder qb = qf.from(type);

	    return qb;
	}
 

import org.infinispan.query.dsl.QueryFactory; //导入依赖的package包/类
@SuppressWarnings({ "unused", "rawtypes" })
@Override
public QueryFactory getQueryFactory(String cacheName) throws TranslatorException {
	
	return Search.getQueryFactory(getCache(cacheName));
}
 

import org.infinispan.query.dsl.QueryFactory; //导入依赖的package包/类
@SuppressWarnings("rawtypes")
private static QueryBuilder getQueryBuilder(String cacheName, InfinispanConnection conn) throws TranslatorException {
	
	Class<?> type = conn.getType(cacheName);
	
	QueryFactory qf = conn.getQueryFactory(cacheName);
    		  
    QueryBuilder qb = qf.from(type);

    return qb;
}