protected QueryFactory getQueryFactory(String index) { return Search .getQueryFactory(this.infinispanContext.getCache(index.toLowerCase())); }
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 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]); }
@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(); }
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)); }
/** * Sorting on a field that does not contain DocValues so Hibernate Search is forced to uninvert it. * @see <a href="https://issues.jboss.org/browse/ISPN-5729">https://issues.jboss.org/browse/ISPN-5729</a> */ @Test public void testUninverting() { remoteCache.put(1, createUser1()); remoteCache.put(2, createUser2()); QueryFactory qf = Search.getQueryFactory(remoteCache); Query query = qf.from(User.class) .having("name").eq("John") .orderBy("id") .build(); assertEquals(0, query.list().size()); }
@Test @WithRunningServer(@RunningServer(name = "query-programmatic-search-mapping-provider")) public void testFullTextTermRightOperandAnalyzed() throws Exception { ConfigurationBuilder clientBuilder = new ConfigurationBuilder(); clientBuilder.addServer() .host(server.getHotrodEndpoint().getInetAddress().getHostName()) .port(server.getHotrodEndpoint().getPort()) .marshaller(new ProtoStreamMarshaller()); remoteCacheManager = new RemoteCacheManager(clientBuilder.build()); //initialize server-side serialization context RemoteCache<String, String> metadataCache = remoteCacheManager.getCache(ProtobufMetadataManagerConstants.PROTOBUF_METADATA_CACHE_NAME); metadataCache.put("sample_bank_account/bank.proto", Util.getResourceAsString("/sample_bank_account/bank.proto", getClass().getClassLoader())); assertFalse(metadataCache.containsKey(ProtobufMetadataManagerConstants.ERRORS_KEY_SUFFIX)); //initialize client-side serialization context MarshallerRegistration.registerMarshallers(ProtoStreamMarshaller.getSerializationContext(remoteCacheManager)); RemoteCache<Integer, Transaction> remoteCache = remoteCacheManager.getCache(); remoteCache.clear(); remoteCache.put(1, createTransaction1()); QueryFactory qf = Search.getQueryFactory(remoteCache); Query q = qf.create("from sample_bank_account.Transaction where longDescription:'RENT'"); List<Transaction> list = q.list(); assertNotNull(list); assertEquals(1, list.size()); assertEquals(Transaction.class, list.get(0).getClass()); assertTransaction1(list.get(0)); }
@Test public void testManualIndexing() throws Exception { QueryBuilder qb = Search.getQueryFactory(remoteCache).from(User.class) .having("name").eq("Tom"); User user = new User(); user.setId(1); user.setName("Tom"); user.setSurname("Cat"); user.setGender(User.Gender.MALE); remoteCache.put(1, user); assertEquals(0, qb.build().list().size()); //manual indexing ObjectName massIndexerName = new ObjectName("jboss." + InfinispanSubsystem.SUBSYSTEM_NAME + ":type=Query,manager=" + ObjectName.quote(cacheContainerName) + ",cache=" + ObjectName.quote(cacheName) + ",component=MassIndexer"); jmxConnectionProvider.getConnection().invoke(massIndexerName, "start", null, null); List<User> list = qb.build().list(); assertEquals(1, list.size()); User foundUser = list.get(0); assertEquals(1, foundUser.getId()); assertEquals("Tom", foundUser.getName()); assertEquals("Cat", foundUser.getSurname()); assertEquals(User.Gender.MALE, foundUser.getGender()); } }