org.infinispan.client.hotrod.Search 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 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) 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();
}