protected QueryFactory getQueryFactory(String index) { return Search .getQueryFactory(this.infinispanContext.getCache(index.toLowerCase())); }
assertEquals(3, remoteCache.size()); QueryFactory qf = Search.getQueryFactory(remoteCache); Query query = qf.from(User.class).having("name").eq("user1").and().having("age").gt(20).build(); ContinuousQuery<Integer, User> continuousQuery = Search.getContinuousQuery(remoteCache); continuousQuery.addContinuousQueryListener(query, listener);
@Override protected void doStart() throws Exception { super.doStart(); manager.start(); cache = manager.getCache(cacheName); if (configuration.hasQueryBuilder()) { if (InfinispanUtil.isRemote(cache)) { RemoteCache<Object, Object> remoteCache = InfinispanUtil.asRemote(cache); Query query = InfinispanRemoteOperation.buildQuery(configuration.getQueryBuilder(), remoteCache); continuousQuery = Search.getContinuousQuery(remoteCache); continuousQuery.addContinuousQueryListener(query, new ContinuousQueryEventListener(cache.getName())); } else { throw new IllegalArgumentException( "Can't run continuous queries against embedded cache (" + cache.getName() + ")"); } } else { if (manager.isCacheContainerEmbedded()) { consumerHandler = InfinispanConsumerEmbeddedHandler.INSTANCE; } else if (manager.isCacheContainerRemote()) { consumerHandler = InfinispanConsumerRemoteHandler.INSTANCE; } else { throw new UnsupportedOperationException( "Unsupported CacheContainer type " + manager.getCacheContainer().getClass().getName()); } listener = consumerHandler.start(this); } }
public static Query buildQuery(InfinispanQueryBuilder queryBuilder, RemoteCache<Object, Object> cache) { return queryBuilder != null ? queryBuilder.build(Search.getQueryFactory(cache)) : null; } }
protected QueryFactory getQueryFactory(String index) { return Search .getQueryFactory(this.infinispanContext.getCache(index.toLowerCase())); }
private void assertIndexSize(RemoteCache<Integer, Transaction> remoteCache) { Query query = Search.getQueryFactory(remoteCache).create("From Transaction"); assertEquals("Entries should be indexed", 100, query.getResultSize()); } }
private void execQuery(String userLogin, String cacheName) { RemoteCache<Object, Object> cache = remoteCacheManagers.get(userLogin).getCache(cacheName); QueryFactory qf = Search.getQueryFactory(cache); Query query = qf.from(User.class) .having("name").eq("Tom") .build(); List<User> list = query.list(); assertNotNull(list); assertEquals(1, list.size()); assertEquals(User.class, list.get(0).getClass()); } }
@Test public void testWayTooManyInClauses() { expectedException.expect(HotRodClientException.class); expectedException.expectMessage("org.apache.lucene.search.BooleanQuery$TooManyClauses: maxClauseCount is set to 1025"); Set<String> values = new HashSet<>(); for (int i = 0; i < 1026; i++) { values.add("test" + i); } QueryFactory qf = Search.getQueryFactory(remoteCache); QueryBuilder qb = qf.from(User.class).having("name").in(values); // this Ickle query translates to a BooleanQuery with 1026 clauses, 1 more than the configured // -Dinfinispan.query.lucene.max-boolean-clauses=1025, so executing the query is expected to fail qb.build().list(); }
@Test public void testIteratorWithQuery() { remoteCache.put(1, createUser1()); remoteCache.put(2, createUser2()); QueryFactory qf = Search.getQueryFactory(remoteCache); Query simpleQuery = qf.from(User.class).having("name").eq("Tom").build(); List<Map.Entry<Object, Object>> entries = new ArrayList<>(1); try (CloseableIterator<Map.Entry<Object, Object>> iter = remoteCache.retrieveEntriesByQuery(simpleQuery, null, 3)) { while (iter.hasNext()) { entries.add(iter.next()); } } assertEquals(1, entries.size()); assertEquals("Cat", ((User) entries.get(0).getValue()).getSurname()); }
@Test public void testManyInClauses() { remoteCache.put(1, createUser1()); remoteCache.put(2, createUser2()); // get user back from remote cache and check its attributes User fromCache = remoteCache.get(1); assertUser1(fromCache); QueryFactory qf = Search.getQueryFactory(remoteCache); Set<String> values = new HashSet<>(); values.add("Tom"); for (int i = 0; i < 1024; i++) { values.add("test" + i); } QueryBuilder qb = qf.from(User.class).having("name").in(values); // this Ickle query translates to a BooleanQuery with 1025 clauses, 1 more than the max default (1024) so // executing it will fail unless the server jvm arg -Dinfinispan.query.lucene.max-boolean-clauses=1025 takes effect List<User> list = qb.build().list(); assertNotNull(list); assertEquals(1, list.size()); assertEquals(User.class, list.get(0).getClass()); assertUser1(list.get(0)); }
@Test public void testHotRodInteroperability() throws Exception { remoteCache.clear(); // Put object via Hot Rod remoteCache.put("BTC", new CryptoCurrency("Bitcoin", 1)); remoteCache.put("ETH", new CryptoCurrency("Ethereum", 2)); remoteCache.put("XRP", new CryptoCurrency("Ripple", 3)); remoteCache.put("CAT", new CryptoCurrency("Catcoin", 618)); assertEquals(remoteCache.get("CAT").getDescription(), "Catcoin"); assertEquals(remoteCache.size(), 4); Query query = Search.getQueryFactory(remoteCache).create("FROM " + getEntityName() + " c where c.rank < 10"); List<CryptoCurrency> highRankCoins = query.list(); assertEquals(highRankCoins.size(), 3); // Read as Json CryptoCurrency btc = readCurrencyViaJson("BTC"); assertEquals("Bitcoin", btc.getDescription()); assertEquals(Integer.valueOf(1), btc.getRank()); // Write as Json writeCurrencyViaJson("LTC", "Litecoin", 4); // Assert inserted entity is searchable query = Search.getQueryFactory(remoteCache).create("FROM " + getEntityName() + " c where c.description = 'Litecoin'"); CryptoCurrency litecoin = (CryptoCurrency) query.list().iterator().next(); assertEquals(litecoin.getDescription(), "Litecoin"); assertTrue(litecoin.getRank() == 4); // Read as JSON from the Hot Rod client Object jsonResult = remoteCache.withDataFormat(DataFormat.builder().valueType(MediaType.APPLICATION_JSON).build()).get("LTC"); JsonNode jsonNode = new ObjectMapper().readTree((byte[]) jsonResult); assertEquals("Litecoin", jsonNode.get("description").asText()); }
@Test public void testEmbeddedAttributeQuery() { remoteCache.put(1, createUser1()); remoteCache.put(2, createUser2()); // get user back from remote cache via query and check its attributes QueryFactory qf = Search.getQueryFactory(remoteCache); Query query = qf.from(User.class) .having("addresses.postCode").eq("1234") .build(); List<User> list = query.list(); assertNotNull(list); assertEquals(1, list.size()); assertEquals(User.class, list.get(0).getClass()); assertUser1(list.get(0)); }
private int queryResultsIn(RemoteInfinispanServer server) throws IOException { ConfigurationBuilder configurationBuilder = configurationBuilder(server); RemoteCacheManager remoteCacheManager = new RemoteCacheManagerFactory().createManager(configurationBuilder); MarshallerRegistration.registerMarshallers(ProtoStreamMarshaller.getSerializationContext(remoteCacheManager)); RemoteCache<Integer, User> remoteCache = remoteCacheManager.getCache("repl_descriptor"); Query query = Search.getQueryFactory(remoteCache).from(User.class).build(); return query.list().size(); }
@Test public void testIteratorWithQueryAndProjections() { remoteCache.put(1, createUser1()); remoteCache.put(2, createUser2()); QueryFactory qf = Search.getQueryFactory(remoteCache); Query simpleQuery = qf.from(User.class).select("surname", "name").having("name").eq("Tom").build(); List<Map.Entry<Object, Object>> entries = new ArrayList<>(1); try (CloseableIterator<Map.Entry<Object, Object>> iter = remoteCache.retrieveEntriesByQuery(simpleQuery, null, 3)) { while (iter.hasNext()) { entries.add(iter.next()); } } assertEquals(1, entries.size()); Object[] projections = (Object[]) entries.get(0).getValue(); assertEquals("Cat", projections[0]); assertEquals("Tom", projections[1]); }
ProtostreamAssociationMappingAdapter mapper = provider.getCollectionsDataMapper( cacheName ); return mapper.withinCacheEncodingContext( c -> { QueryBuilder qb = Search.getQueryFactory( c ).from( provider.getEntityType( c ) );
public ClosableIterator<Tuple> executeBackendQuery(BackendQuery<InfinispanRemoteQueryDescriptor> backendQuery, QueryParameters queryParameters) { EntityKeyMetadata entityKeyMetadata = backendQuery.getSingleEntityMetadataInformationOrNull() == null ? null : backendQuery.getSingleEntityMetadataInformationOrNull().getEntityKeyMetadata(); InfinispanRemoteQueryDescriptor queryDescriptor = backendQuery.getQuery(); RemoteCache<ProtostreamId, ProtostreamPayload> cache = provider.getCache( queryDescriptor.getCache() ); QueryFactory queryFactory = Search.getQueryFactory( cache ); Query query = queryFactory.create( queryDescriptor.getQuery() ); applyNamedParameters( queryParameters, query ); applyRowSelection( queryParameters, query ); boolean hasProjection = hasProjection( queryDescriptor ); if ( entityKeyMetadata != null && hasProjection ) { throw log.addEntityNotAllowedInNativeQueriesUsingProjection( entityKeyMetadata.getTable(), backendQuery.toString() ); } return hasProjection ? new RawTypeClosableIterator( query, queryDescriptor.getProjections() ) : new ProtostreamPayloadClosableIterator( query.list() ); }
@Test public void testAttributeQuery() { remoteCache.put(1, createUser1()); remoteCache.put(2, createUser2()); // get user back from remote cache and check its attributes User fromCache = remoteCache.get(1); assertUser1(fromCache); // get user back from remote cache via query and check its attributes QueryFactory qf = Search.getQueryFactory(remoteCache); Query query = qf.from(User.class) .having("name").eq("Tom") .build(); List<User> list = query.list(); assertNotNull(list); assertEquals(1, list.size()); assertEquals(User.class, list.get(0).getClass()); assertUser1(list.get(0)); }
@Test public void testProjections() { remoteCache.put(1, createUser1()); remoteCache.put(2, createUser2()); // get user back from remote cache and check its attributes User fromCache = remoteCache.get(1); assertUser1(fromCache); // get user back from remote cache via query and check its attributes QueryFactory qf = Search.getQueryFactory(remoteCache); Query query = qf.from(User.class) .select("name", "surname") .having("name").eq("Tom") .build(); List<Object[]> list = query.list(); assertNotNull(list); assertEquals(1, list.size()); assertEquals(Object[].class, list.get(0).getClass()); assertEquals("Tom", list.get(0)[0]); assertEquals("Cat", list.get(0)[1]); }
@Test @WithRunningServer(@RunningServer(name = "custom-compat-marshaller")) public void testCompatQuery() { remoteCacheManager = ITestUtils.createCacheManager(server1); RemoteCache<Integer, TestEntity> remoteCache = remoteCacheManager.getCache(); remoteCache.clear(); for (int i = 0; i < 10; i++) { TestEntity user = new TestEntity("name" + i); remoteCache.put(i, user); } QueryFactory queryFactory = Search.getQueryFactory(remoteCache); Query query = queryFactory.from(TestEntity.class).build(); List<?> list = query.list(); assertEquals(10, list.size()); assertTrue(list.get(0) instanceof TestEntity); }
@Test public void testAttributeQuery() { remoteCache.put(1, createUser1()); remoteCache.put(2, createUser2()); // get user1 back from remote cache and check its attributes AnnotatedUser fromCache = remoteCache.get(1); assertUser1(fromCache); // get user1 back from remote cache via query and check its attributes QueryFactory qf = Search.getQueryFactory(remoteCache); Query query = qf.from(AnnotatedUser.class) .having("name").eq("Tom") .build(); List<AnnotatedUser> list = query.list(); assertNotNull(list); assertEquals(1, list.size()); assertEquals(AnnotatedUser.class, list.get(0).getClass()); assertUser1(list.get(0)); // get user2 back from remote cache via query and check its attributes query = qf.from(AnnotatedUser.class) .having("address.postCode").eq("Xyz") .build(); list = query.list(); assertNotNull(list); assertEquals(1, list.size()); assertEquals(AnnotatedUser.class, list.get(0).getClass()); assertUser2(list.get(0)); }