private List<org.infinispan.query.dsl.Query> findByQueryRaw(List<String> indices, Query query, Sort sort) { String whereClause = this.ickleConverter.where(query); String sortClause = this.ickleConverter.sort(sort); List<String> ind = indices; if (indices == null || indices.isEmpty()) { ind = this.getIndices(); } return ind.stream().map(index -> { QueryFactory qf = this.getQueryFactory(index); return this.infinispanContext.getTypes(index) .stream() .map(type -> this.buildQuery(type, whereClause, sortClause)) .map(q -> { if (logger.isDebugEnabled()) { logger.debug("Ickle Query: " + q); } return qf.create(q); }) .collect(toList()); }) .flatMap(x -> x.stream()) .collect(toList()); }
private List<org.infinispan.query.dsl.Query> findByQueryRaw(List<String> indices, Query query, Sort sort) { String whereClause = this.ickleConverter.where(query); String sortClause = this.ickleConverter.sort(sort); List<String> ind = indices; if (indices == null || indices.isEmpty()) { ind = this.getIndices(); } return ind.stream().map(index -> { QueryFactory qf = this.getQueryFactory(index); return this.infinispanContext.getTypes(index) .stream() .map(type -> this.buildQuery(type, whereClause, sortClause)) .map(q -> { if (logger.isDebugEnabled()) { logger.debug("Ickle Query: " + q); } return qf.create(q); }) .collect(toList()); }) .flatMap(x -> x.stream()) .collect(toList()); }
protected Query createQueryFromString(String q) { return getQueryFactory().create(q); } }
@Test public void testBroadcastNativeInfinispanFuzzyQuery() { String q = String.format("FROM %s p where p.name:'nome'~2", Person.class.getName()); Query query = Search.getQueryFactory(cacheAMachine1).create(q, IndexedQueryMode.BROADCAST); assertEquals(10, query.list().size()); }
@Test public void testBroadcastNativeInfinispanHybridQuery() { String q = "FROM " + Person.class.getName() + " where age >= 40 and nonIndexedField = 'na'"; Query query = Search.getQueryFactory(cacheAMachine1).create(q, IndexedQueryMode.BROADCAST); assertEquals(10, query.list().size()); }
@Test public void testBroadcastAggregatedInfinispanQuery() { QueryFactory queryFactory = Search.getQueryFactory(cacheAMachine2); Query hybridQuery = queryFactory.create("select name FROM " + Person.class.getName() + " WHERE name : 'na*' group by name", IndexedQueryMode.BROADCAST); assertEquals(NUM_ENTRIES, hybridQuery.list().size()); }
@Test public void testNonIndexedBroadcastInfinispanQuery() { QueryFactory queryFactory = Search.getQueryFactory(cacheAMachine2); Query slowQuery = queryFactory.create("FROM " + Person.class.getName() + " WHERE nonIndexedField LIKE 'na%'", IndexedQueryMode.BROADCAST); assertEquals(NUM_ENTRIES, slowQuery.list().size()); }
@Test public void testBroadcastNativeInfinispanMatchAllQuery() { String q = String.format("FROM %s", Person.class.getName()); Query partialResultQuery = Search.getQueryFactory(cacheAMachine1).create(q); Query fullResultQuery = Search.getQueryFactory(cacheAMachine2).create(q, IndexedQueryMode.BROADCAST); int docsInMachine1 = countLocalIndex(cacheAMachine1); assertEquals(docsInMachine1, partialResultQuery.list().size()); assertEquals(NUM_ENTRIES, fullResultQuery.list().size()); }
@Test public void testBroadcastSortedInfinispanQuery() { QueryFactory queryFactory = Search.getQueryFactory(cacheAMachine1); Query sortedQuery = queryFactory.create("FROM " + Person.class.getName() + " p order by p.age desc", IndexedQueryMode.BROADCAST); List<Person> results = sortedQuery.list(); assertEquals(NUM_ENTRIES, results.size()); assertEquals(NUM_ENTRIES - 1, results.iterator().next().getAge()); StaticTestingErrorHandler.assertAllGood(cacheAMachine1, cacheAMachine2); }
@Test public void testQuery() throws Exception { cache.put("1", new Person("Donald", "MAGA", 78)); assertEquals(getIndexDocs(), 1); CacheQuery<Object> queryFromLucene = createCacheQuery(cache, "name", "Donald"); assertEquals(1, queryFromLucene.list().size()); Query queryFromIckle = Search.getQueryFactory(cache) .create("From org.infinispan.query.test.Person p where p.name:'Donald'"); assertEquals(1, queryFromIckle.list().size()); }
private void assertIndexSize(RemoteCache<Integer, Transaction> remoteCache) { Query query = Search.getQueryFactory(remoteCache).create("From Transaction"); assertEquals("Entries should be indexed", 100, query.getResultSize()); } }
public void testFullTextTerm() { QueryFactory qf = getQueryFactory(); Query q = qf.create("from " + getModelFactory().getTransactionTypeName() + " where longDescription:'rent'"); List<Transaction> list = q.list(); assertEquals(1, list.size()); }
private void executeQueries() { String q = getQuery(); caches().forEach(c -> { Query allNodesQuery = Search.getQueryFactory(c).create(q, getIndexedQueryMode()); assertAllNodesQueryResults(allNodesQuery.getResultSize()); }); Query singleNodeQuery = Search.getQueryFactory(cache(0)).create(q); assertSingleNodeQueryResults(singleNodeQuery.list().size()); }
public void testFullTextPhrase() { QueryFactory qf = getQueryFactory(); Query q = qf.create("from " + getModelFactory().getTransactionTypeName() + " where longDescription:'expensive shoes'"); List<Transaction> list = q.list(); assertEquals(50, list.size()); }
@Test(expectedExceptions = ParsingException.class, expectedExceptionsMessageRegExp = "ISPN028523: Filters cannot use full-text searches") public void testDisallowFullTextQuery() { Query query = Search.getQueryFactory(cache()).create("from org.infinispan.query.test.Person where name : 'john'"); cache().addListener(new EntryListener(), Search.makeFilter(query), null); }
/** * Fulltext continuous queries are not allowed. */ @Test(expectedExceptions = ParsingException.class, expectedExceptionsMessageRegExp = ".*ISPN028521:.*") public void testDisallowFullTextQuery() { Query query = Search.getQueryFactory(cache()).create("from org.infinispan.query.test.Person where name : 'john'"); ContinuousQuery<Object, Object> cq = Search.getContinuousQuery(cache()); cq.addContinuousQueryListener(query, new CallCountingCQResultListener<>()); }
@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()); }
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 @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)); }
Query query = Search.getQueryFactory(cache).create(queryString); query.list();