org.infinispan.query.dsl.Query Java Examples

@Path("query/{id}")
@GET
@Produces(MediaType.TEXT_PLAIN)
public String queryAuthorSurname(@PathParam("id") String name) {
    ensureStart();
    QueryFactory queryFactory = Search.getQueryFactory(cache);
    Query query = queryFactory.from(Book.class)
            .having("authors.name").like("%" + name + "%")
            .build();
    List<Book> list = query.list();
    if (list.isEmpty()) {
        return "No one found for " + name;
    }

    return list.stream()
            .map(Book::getAuthors)
            .flatMap(Set::stream)
            .map(author -> author.getName() + " " + author.getSurname())
            .sorted()
            .collect(Collectors.joining(",", "[", "]"));
}
 

@Path("icklequery/{id}")
@GET
@Produces(MediaType.TEXT_PLAIN)
public String ickleQueryAuthorSurname(@PathParam("id") String name) {
    ensureStart();
    QueryFactory queryFactory = Search.getQueryFactory(cache);
    Query query = queryFactory.create("from book_sample.Book b where b.authors.name like '%" + name + "%'");
    List<Book> list = query.list();
    if (list.isEmpty()) {
        return "No one found for " + name;
    }
    return list.stream()
            .map(Book::getAuthors)
            .flatMap(Set::stream)
            .map(author -> author.getName() + " " + author.getSurname())
            .sorted()
            .collect(Collectors.joining(",", "[", "]"));
}
 

/**
 * Search for all credentials sets, which match tenant, authId, type.
 *
 * @param key The search key.
 * @return The result of the search.
 */
private CompletableFuture<LinkedList<JsonObject>> searchCredentials(final io.enmasse.iot.infinispan.device.CredentialKey key) {

    final QueryFactory queryFactory = Search.getQueryFactory(this.managementCache);

    final Query query = queryFactory
            .create(String.format("from %s d where d.tenantId=:tenantId and d.credentials.authId=:authId and d.credentials.type=:type", DeviceInformation.class.getName()),
                    IndexedQueryMode.BROADCAST)
            .setParameter("tenantId", key.getTenantId())
            .setParameter("authId", key.getAuthId())
            .setParameter("type", key.getType());

    return CompletableFuture
            .supplyAsync(query::<DeviceInformation>list, this.executor)
            .thenApply(result -> mapCredentials(key, result));

}
 

@Path("magazinequery/{id}")
@GET
public String magazineQuery(@PathParam("id") String name) {
    ensureStart();
    QueryFactory queryFactory = Search.getQueryFactory(magazineCache);
    Query query = queryFactory.create("from magazine_sample.Magazine m where m.name like '%" + name + "%'");
    List<Magazine> list = query.list();
    if (list.isEmpty()) {
        return "No one found for " + name;
    }
    return list.stream()
            .map(m -> m.getName() + ":" + m.getPublicationYearMonth())
            .collect(Collectors.joining(",", "[", "]"));
}
 

private void performCleanup(
        final CleanerConfig config,
        final RemoteCache<DeviceKey, DeviceInformation> devicesCache) {

    final String tenantId = config.getTenantId();

    // Query and delete entries in devicesCache
    final Query query = createQuery(config, devicesCache, tenantId);

    log.info("Start deleting tenant data: {}", config);

    long count = 0;
    int len;
    long remaining;
    do {
        final List<DeviceInformation> result = measure("List", () -> query.list());
        log.debug("List: {}", result);
        measure("Delete", () -> {
            result.forEach(entry -> {
                log.debug("result: {}", entry);
                deleteDevice(devicesCache, tenantId, entry.getDeviceId());
            });
            return null;
        });

        len = result.size();
        count += len;

        // get the total remaining entries
        remaining = query.getResultSize();
        // reset query
        query.startOffset(0);

        log.info("Deleted {} entries in this iteration. Total remaining: {}.", len, remaining);

    } while (remaining > 0);

    log.info("Removed tenant ({}) from system (total: {}).", tenantId, count);
}
 

private Query createQuery(final CleanerConfig config, final RemoteCache<DeviceKey, DeviceInformation> devicesCache, final String tenantId) {

        final QueryFactory queryFactory = Search.getQueryFactory(devicesCache);

        return queryFactory
                .create(
                        String.format("from %s d where d.tenantId=:tenantId", DeviceInformation.class.getName()),
                        config.isIndexBroadcastQuery() ? IndexedQueryMode.BROADCAST : IndexedQueryMode.FETCH)
                .maxResults(Math.max(config.getInfinispan().getDeletionChunkSize(), CleanerConfig.DEFAULT_DELETION_CHUNK_SIZE))
                .setParameter("tenantId", tenantId);

    }
 

public static void main(String[] args) {
   // Create cache manager
   DefaultCacheManager cacheManager = new DefaultCacheManager();

   // Create cache config
   ConfigurationBuilder builder = new ConfigurationBuilder();
   builder.indexing().index(Index.ALL)
           .addProperty("default.directory_provider", "ram")
           .addProperty("lucene_version", "LUCENE_CURRENT");

   // Obtain the cache
   Cache<String, Person> cache = cacheManager.administration()
           .withFlags(CacheContainerAdmin.AdminFlag.VOLATILE)
           .getOrCreateCache("cache", builder.build());

   // 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();
}
 

public static void main(String[] args) throws Exception {
   // Create a configuration for a locally-running server
   ConfigurationBuilder builder = new ConfigurationBuilder();
   builder.addServer()
            .host("127.0.0.1")
            .port(ConfigurationProperties.DEFAULT_HOTROD_PORT)
          .security().authentication()
            //Add user credentials.
            .username("username")
            .password("password")
            .realm("default")
            .saslMechanism("DIGEST-MD5");

   // Connect to the server
   RemoteCacheManager client = new RemoteCacheManager(builder.build());

   // Get the people cache, create it if needed with the default configuration
   RemoteCache<String, Person> peopleCache = client.administration()
           .withFlags(CacheContainerAdmin.AdminFlag.VOLATILE)
           .getOrCreateCache("people-remote-query", DefaultTemplate.DIST_SYNC);

   // Create the persons dataset to be stored in the cache
   Map<String, Person> people = new HashMap<>();
   people.put("1", new Person("Oihana", "Rossignol", 2016, "Paris"));
   people.put("2", new Person("Elaia", "Rossignol", 2018, "Paris"));
   people.put("3", new Person("Yago", "Steiner", 2013, "Saint-Mandé"));
   people.put("4", new Person("Alberto", "Steiner", 2016, "Paris"));

   // Create and add the Protobuf schema for Person class. Note Person is an annotated POJO
   addPersonSchema(client);

   // Put all the values in the cache
   peopleCache.putAll(people);

   // Get a query factory from the cache
   QueryFactory queryFactory = Search.getQueryFactory(peopleCache);

   // Create a query with lastName parameter
   Query query = queryFactory.create("FROM tutorial.Person p where p.lastName = :lastName");

   // Set the parameter value
   query.setParameter("lastName", "Rossignol");

   // Execute the query
   List<Person> rossignols = query.list();

   // Print the results
   System.out.println(rossignols);

   // Stop the client and release all resources
   client.stop();
}
 

public static void main(String[] args) throws Exception {
   // Create a configuration for a locally-running server
   ConfigurationBuilder builder = new ConfigurationBuilder();
   builder.addServer()
            .host("127.0.0.1")
            .port(ConfigurationProperties.DEFAULT_HOTROD_PORT)
          .security().authentication()
            //Add user credentials.
            .username("username")
            .password("password")
            .realm("default")
            .saslMechanism("DIGEST-MD5");

   // Connect to the server
   RemoteCacheManager client = new RemoteCacheManager(builder.build());

   // Get the cache, create it if needed with an existing template name
   RemoteCache<String, InstaPost> instaPostsCache = client.administration().withFlags(CacheContainerAdmin.AdminFlag.VOLATILE).getOrCreateCache(CACHE_NAME, DefaultTemplate.DIST_SYNC);

   // Create and add the Protobuf schema for InstaPost class. Note InstaPost is an annotated POJO
   addInstapostsSchema(client);

   // Get a query factory from the cache
   QueryFactory queryFactory = Search.getQueryFactory(instaPostsCache);

   // Create a query with lastName parameter
   Query query = queryFactory.create("FROM tutorial.InstaPost p where p.user = :userName");

   // Set the parameter value
   query.setParameter("userName", "belen_esteban");

   // Create the continuous query
   ContinuousQuery<String, InstaPost> continuousQuery = Search.getContinuousQuery(instaPostsCache);

   // Create the continuous query listener.
   List<InstaPost> queryPosts = new ArrayList<>();
   ContinuousQueryListener<String, InstaPost> listener =
         new ContinuousQueryListener<String, InstaPost>() {
            // This method will be executed every time new items that correspond with the query arrive
            @Override
            public void resultJoining(String key, InstaPost post) {
               System.out.println(String.format("@%s has posted again! Hashtag: #%s", post.user, post.hashtag));
               queryPosts.add(post);
            }
         };

   // And the listener corresponding the query to the continuous query
   continuousQuery.addContinuousQueryListener(query, listener);

   // Add 1000 random posts
   for (int i = 0; i < 1000; i++) {
      // Add a post
      addRandomPost(instaPostsCache);

      // Await a little to see results
      Thread.sleep(10);
   }

   System.out.println("Total posts " + instaPostsCache.size());
   System.out.println("Total posts by @belen_esteban " + queryPosts.size());

   // Remove the listener. Listeners should be removed when they are no longer needed to avoid memory leaks
   continuousQuery.removeContinuousQueryListener(listener);

   // Remove the cache
   client.administration().removeCache(CACHE_NAME);

   // Stop the client and release all resources
   client.stop();
}