@Test @SuppressWarnings("unchecked") public void testBoolean() throws Exception { Transaction transaction = fullTextSession.beginTransaction(); final QueryBuilder monthQb = fullTextSession.getSearchFactory().buildQueryBuilder().forEntity(Month.class).get(); // must Query query = monthQb .bool() .must(monthQb.keyword().onField("mythology").matching("colder").createQuery()) .createQuery(); List<Month> results = fullTextSession.createFullTextQuery(query, Month.class).list(); assertEquals(1, results.size()); assertEquals("January", results.get(0).getName()); // must not + all query = monthQb .bool() .should(monthQb.all().createQuery()) .must(monthQb.keyword().onField("mythology").matching("colder").createQuery()) .not() .createQuery(); results = fullTextSession.createFullTextQuery(query, Month.class).list(); assertEquals(2, results.size()); assertEquals("February", results.get(0).getName()); assertEquals("March", results.get(1).getName()); // implicit must not + all (not recommended) query = monthQb .bool() .must(monthQb.keyword().onField("mythology").matching("colder").createQuery()) .not() .createQuery(); results = fullTextSession.createFullTextQuery(query, Month.class).list(); assertEquals(2, results.size()); assertEquals("February", results.get(0).getName()); assertEquals("March", results.get(1).getName()); // all except (recommended) query = monthQb .all() .except(monthQb.keyword().onField("mythology").matching("colder").createQuery()) .createQuery(); results = fullTextSession.createFullTextQuery(query, Month.class).list(); assertEquals(2, results.size()); assertEquals("February", results.get(0).getName()); assertEquals("March", results.get(1).getName()); transaction.commit(); }
public void testFaceting() throws Exception { QueryBuilder queryBuilder = qf.buildQueryBuilderForClass(Car.class).get(); FacetingRequest request = queryBuilder .facet() .name(facetName) .onField(indexFieldName) .discrete() .createFacetingRequest(); Query luceneQuery = queryBuilder.all().createQuery(); CacheQuery query = qf.getQuery(luceneQuery); query.getFacetManager().enableFaceting(request); List<Facet> facetList = query.getFacetManager().getFacets(facetName); assertEquals("Wrong number of facets", 2, facetList.size()); assertEquals("4000", facetList.get(0).getValue()); assertEquals(2, facetList.get(0).getCount()); assertEquals(indexFieldName, facetList.get(0).getFieldName()); assertEquals("2341", facetList.get(1).getValue()); assertEquals(1, facetList.get(1).getCount()); assertEquals(indexFieldName, facetList.get(1).getFieldName()); }
public static List<Object> performSearch( Select command, Class<?> type, String cacheName, CacheContainerWrapper cache) throws TranslatorException { LogManager.logTrace(LogConstants.CTX_CONNECTOR, "Using Lucene Searching."); // $NON-NLS-1$ // Map<?, ?> cache, SearchManager searchManager = Search.getSearchManager((Cache<?, ?>) cache.getCache(cacheName)); QueryBuilder queryBuilder = searchManager.buildQueryBuilderForClass(type).get(); BooleanJunction<BooleanJunction> junction = queryBuilder.bool(); boolean createdQueries = buildQueryFromWhereClause(command.getWhere(), junction, queryBuilder); Query query = null; if (createdQueries) { query = junction.createQuery(); } else { query = queryBuilder.all().createQuery(); } CacheQuery cacheQuery = searchManager.getQuery(query, type); // rootNodeType List<Object> results = cacheQuery.list(); if (results == null || results.isEmpty()) { return Collections.emptyList(); } return results; }
// loading categories ids and names public List<String> extractCategories() { FullTextEntityManager fullTextEntityManager = org.hibernate.search.jpa.Search.getFullTextEntityManager(em); QueryBuilder queryBuilder = fullTextEntityManager .getSearchFactory() .buildQueryBuilder() .forEntity(Categories.class) .get(); org.apache.lucene.search.Query query = queryBuilder.all().createQuery(); FullTextQuery fullTextQuery = fullTextEntityManager.createFullTextQuery(query, Categories.class); fullTextQuery.setProjection(FullTextQuery.ID, "category"); Sort sort = new Sort(new SortField("category", SortField.STRING)); fullTextQuery.setSort(sort); fullTextQuery.initializeObjectsWith( ObjectLookupMethod.SKIP, DatabaseRetrievalMethod.FIND_BY_ID); List<String> results = fullTextQuery.getResultList(); return results; }
@Override public void setUp() throws Exception { super.setUp(); fts = Search.getFullTextSession(openSession()); QueryBuilder builder = fts.getSearchFactory().buildQueryBuilder().forEntity(Clock.class).get(); allSeikoClocksQuery = builder.keyword().onField("brand").matching("Seiko").createQuery(); allSwatchClocksQuery = builder.keyword().onField("brand").matching("Swatch").createQuery(); noMatchQuery = builder.keyword().onField("brand").matching("Blah").createQuery(); matchAllQuery = builder.all().createQuery(); storeClocks(fts); }
private Query getQuery(QueryBuilder queryBuilder, List<Query> queries) { if (queries.isEmpty()) { return queryBuilder.all().createQuery(); } else { BooleanJunction<BooleanJunction> bool = queryBuilder.bool(); for (Query query : queries) { bool.must(query); } return bool.createQuery(); } }
private FullTextQuery buildFullTextQuery( UserSearchRequest request, Pageable pageable, Criteria criteria) { FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager); QueryBuilder qb = fullTextEntityManager.getSearchFactory().buildQueryBuilder().forEntity(User.class).get(); @SuppressWarnings("rawtypes") BooleanJunction<BooleanJunction> junction = qb.bool(); junction.must(qb.all().createQuery()); if (StringUtils.hasText(request.getKeyword())) { Analyzer analyzer = fullTextEntityManager.getSearchFactory().getAnalyzer("synonyms"); String[] fields = new String[] { "loginId", "name.firstName", "name.lastName", }; MultiFieldQueryParser parser = new MultiFieldQueryParser(fields, analyzer); parser.setDefaultOperator(QueryParser.Operator.AND); Query query = null; try { query = parser.parse(request.getKeyword()); } catch (ParseException e1) { try { query = parser.parse(QueryParser.escape(request.getKeyword())); } catch (ParseException e2) { throw new RuntimeException(e2); } } junction.must(query); } if (!CollectionUtils.isEmpty(request.getRoles())) { for (User.Role role : request.getRoles()) { junction.must(qb.keyword().onField("roles").matching(role).createQuery()); } } Query searchQuery = junction.createQuery(); Sort sort = new Sort(new SortField("id", SortField.Type.STRING, false)); FullTextQuery persistenceQuery = fullTextEntityManager .createFullTextQuery(searchQuery, User.class) .setCriteriaQuery(criteria) // .setProjection("id") .setSort(sort); if (pageable != null) { persistenceQuery.setFirstResult(pageable.getOffset()); persistenceQuery.setMaxResults(pageable.getPageSize()); } return persistenceQuery; }
private List<Clock> searchAll(String tenantId) { FullTextSession session = Search.getFullTextSession(openSessionWithTenantId(tenantId)); QueryBuilder queryBuilder = session.getSearchFactory().buildQueryBuilder().forEntity(Clock.class).get(); Query luceneQuery = queryBuilder.all().createQuery(); Transaction transaction = session.beginTransaction(); @SuppressWarnings("unchecked") List<Clock> list = session.createFullTextQuery(luceneQuery).list(); transaction.commit(); session.clear(); session.close(); return list; }
@Test @TestForIssue(jiraKey = "HSEARCH-703") public void testPolymorphicQueryForUnindexedSuperTypeReturnsIndexedSubType() { Transaction transaction = fullTextSession.beginTransaction(); final QueryBuilder builder = fullTextSession.getSearchFactory().buildQueryBuilder().forEntity(Object.class).get(); Query query = builder.all().createQuery(); List<?> results = fullTextSession.createFullTextQuery(query, Object.class).list(); assertEquals("expected all instances of all indexed types", 7, results.size()); transaction.commit(); }
public void testPutMap() throws Exception { prepareTestData(); SearchManager searchManager = Search.getSearchManager(cache2); QueryBuilder queryBuilder = searchManager.buildQueryBuilderForClass(Person.class).get(); Query allQuery = queryBuilder.all().createQuery(); assert searchManager.getQuery(allQuery, Person.class).list().size() == 3; Map<String, Person> allWrites = new HashMap<String, Person>(); allWrites.put(key1, person1); allWrites.put(key2, person2); allWrites.put(key3, person3); cache2.putAll(allWrites); List found = searchManager.getQuery(allQuery, Person.class).list(); AssertJUnit.assertEquals(3, found.size()); cache2.putAll(allWrites); found = searchManager.getQuery(allQuery, Person.class).list(); AssertJUnit.assertEquals(3, found.size()); }
@Override public Page<Comment> search(CommentSearchRequest request, Pageable pageable) { FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager); QueryBuilder qb = fullTextEntityManager.getSearchFactory().buildQueryBuilder().forEntity(Comment.class).get(); @SuppressWarnings("rawtypes") BooleanJunction<BooleanJunction> junction = qb.bool(); junction.must(qb.all().createQuery()); if (StringUtils.hasText(request.getKeyword())) { Analyzer analyzer = fullTextEntityManager.getSearchFactory().getAnalyzer("synonyms"); String[] fields = new String[] {"authorName", "content"}; MultiFieldQueryParser parser = new MultiFieldQueryParser(fields, analyzer); parser.setDefaultOperator(QueryParser.Operator.AND); Query query = null; try { query = parser.parse(request.getKeyword()); } catch (ParseException e1) { try { query = parser.parse(QueryParser.escape(request.getKeyword())); } catch (ParseException e2) { throw new RuntimeException(e2); } } junction.must(query); } if (StringUtils.hasText(request.getLanguage())) { junction.must( qb.keyword().onField("post.language").matching(request.getLanguage()).createQuery()); } if (request.getPostId() != null) { junction.must(qb.keyword().onField("post.id").matching(request.getPostId()).createQuery()); } if (request.getApproved() != null) { junction.must(qb.keyword().onField("approved").matching(request.getApproved()).createQuery()); } Query searchQuery = junction.createQuery(); Session session = (Session) entityManager.getDelegate(); Criteria criteria = session .createCriteria(Comment.class) .setFetchMode("post", FetchMode.JOIN) .setFetchMode("author", FetchMode.JOIN); Sort sort = null; if (pageable.getSort() != null) { if (pageable.getSort().getOrderFor("date") != null) { Order order = pageable.getSort().getOrderFor("date"); sort = new Sort( new SortField( "date", SortField.Type.STRING, order.getDirection().equals(Direction.DESC)), new SortField( "id", SortField.Type.LONG, order.getDirection().equals(Direction.DESC))); } } if (sort == null) { sort = new Sort( new SortField("date", SortField.Type.STRING), new SortField("id", SortField.Type.LONG)); } FullTextQuery persistenceQuery = fullTextEntityManager .createFullTextQuery(searchQuery, Comment.class) .setCriteriaQuery(criteria) .setSort(sort); persistenceQuery.setFirstResult(pageable.getOffset()); persistenceQuery.setMaxResults(pageable.getPageSize()); int resultSize = persistenceQuery.getResultSize(); @SuppressWarnings("unchecked") List<Comment> results = persistenceQuery.getResultList(); return new PageImpl<>(results, pageable, resultSize); }
private FullTextQuery buildFullTextQuery( ArticleSearchRequest request, Pageable pageable, Criteria criteria) { FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager); QueryBuilder qb = fullTextEntityManager.getSearchFactory().buildQueryBuilder().forEntity(Article.class).get(); @SuppressWarnings("rawtypes") BooleanJunction<BooleanJunction> junction = qb.bool(); junction.must(qb.all().createQuery()); junction.must( qb.keyword().onField("drafted").ignoreAnalyzer().matching("_null_").createQuery()); if (StringUtils.hasText(request.getKeyword())) { Analyzer analyzer = fullTextEntityManager.getSearchFactory().getAnalyzer("synonyms"); String[] fields = new String[] { "title", "body", "categories.name", "tags.name", }; MultiFieldQueryParser parser = new MultiFieldQueryParser(fields, analyzer); parser.setDefaultOperator(QueryParser.Operator.AND); Query query = null; try { query = parser.parse(request.getKeyword()); } catch (ParseException e1) { try { query = parser.parse(QueryParser.escape(request.getKeyword())); } catch (ParseException e2) { throw new RuntimeException(e2); } } junction.must(query); } if (request.getStatus() != null) { junction.must(qb.keyword().onField("status").matching(request.getStatus()).createQuery()); } if (StringUtils.hasText(request.getLanguage())) { junction.must(qb.keyword().onField("language").matching(request.getLanguage()).createQuery()); } if (request.getDateFrom() != null) { junction.must(qb.range().onField("date").above(request.getDateFrom()).createQuery()); } if (request.getDateTo() != null) { junction.must(qb.range().onField("date").below(request.getDateTo()).createQuery()); } if (!CollectionUtils.isEmpty(request.getCategoryIds())) { BooleanJunction<BooleanJunction> subJunction = qb.bool(); for (long categoryId : request.getCategoryIds()) { subJunction.should( qb.keyword().onField("categories.id").matching(categoryId).createQuery()); } junction.must(subJunction.createQuery()); } if (!CollectionUtils.isEmpty(request.getCategoryCodes())) { BooleanJunction<BooleanJunction> subJunction = qb.bool(); for (String categoryCode : request.getCategoryCodes()) { subJunction.should( qb.keyword().onField("categories.code").matching(categoryCode).createQuery()); } junction.must(subJunction.createQuery()); } if (!CollectionUtils.isEmpty(request.getTagIds())) { BooleanJunction<BooleanJunction> subJunction = qb.bool(); for (long tagId : request.getTagIds()) { subJunction.should(qb.keyword().onField("tags.id").matching(tagId).createQuery()); } junction.must(subJunction.createQuery()); } if (!CollectionUtils.isEmpty(request.getTagNames())) { BooleanJunction<BooleanJunction> subJunction = qb.bool(); for (String tagName : request.getTagNames()) { subJunction.should(qb.phrase().onField("tags.name").sentence(tagName).createQuery()); } junction.must(subJunction.createQuery()); } if (request.getAuthorId() != null) { junction.must( qb.keyword().onField("author.id").matching(request.getAuthorId()).createQuery()); } Query searchQuery = junction.createQuery(); Sort sort = new Sort( new SortField("date", SortField.Type.STRING, true), new SortField("id", SortField.Type.LONG, true)); FullTextQuery persistenceQuery = fullTextEntityManager .createFullTextQuery(searchQuery, Article.class) .setCriteriaQuery(criteria) .setSort(sort); if (pageable != null) { persistenceQuery.setFirstResult(pageable.getOffset()); persistenceQuery.setMaxResults(pageable.getPageSize()); } return persistenceQuery; }