QueryBuilder qb = em.getSearchFactory().buildQueryBuilder().forEntity(ResourceTable.class).get(); BooleanJunction<?> bool = qb.bool(); bool.must(qb.keyword().onField("myResourceLinksField").matching(theReferencingPid.toString()).createQuery()); bool.must(qb.keyword().onField("myResourceType").matching(theResourceName).createQuery());
.phrase() .withSlop(2) .onField(theFieldName).boostedTo(4.0f) } else { String joinedTerms = StringUtils.join(terms, ' '); theBoolean.must(theQueryBuilder.keyword().onField(theFieldName).matching(joinedTerms).createQuery());
Date startPublishDate, Date endPublishDate, String orderField, Integer pageIndex, Integer pageSize) { QueryBuilder queryBuilder = getFullTextQueryBuilder(); MustJunction termination = queryBuilder.bool() .must(queryBuilder.keyword().onFields(CommonUtils.empty(tagId) ? textFields : tagFields) .matching(CommonUtils.empty(tagId) ? text : tagId).createQuery()) .must(new TermQuery(new Term("siteId", siteId.toString()))); if (null != startPublishDate) { termination.must(queryBuilder.range().onField("publishDate").above(startPublishDate).createQuery()); termination.must(queryBuilder.range().onField("publishDate").below(endPublishDate).createQuery());
private FullTextQuery getSearchByNameQuery(String searchTerm) { FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(getEntityManager()); QueryBuilder projectQueryBuilder = fullTextEntityManager.getSearchFactory().buildQueryBuilder() .forEntity(Project.class).get(); BooleanJunction<?> booleanJunction = projectQueryBuilder.bool(); if (StringUtils.hasText(searchTerm)) { booleanJunction.must(projectQueryBuilder .keyword() .fuzzy().withPrefixLength(1).withThreshold(0.8F) .onField(Binding.project().name().getPath()) .matching(searchTerm) .createQuery()); } else { booleanJunction.must(projectQueryBuilder.all().createQuery()); } return fullTextEntityManager.createFullTextQuery(booleanJunction.createQuery(), Project.class); } }
@Override public Page<Role> searchByKeyword(String keywords, Pageable pageable) { // Must be retrieved inside a transaction to take part of final FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager); // Prepare a search query builder final QueryBuilder queryBuilder = fullTextEntityManager.getSearchFactory().buildQueryBuilder().forEntity(Role.class).get(); // This is a boolean junction... I'll add at least a keyword query final BooleanJunction<BooleanJunction> outer = queryBuilder.bool(); outer.must( queryBuilder .keyword() .wildcard() .onFields("name") .matching(keywords) .createQuery() ); FullTextQuery fullTextQuery = fullTextEntityManager.createFullTextQuery(outer.createQuery(), Role.class); fullTextQuery.setFirstResult(pageable.getOffset()); fullTextQuery.setMaxResults(pageable.getPageSize()); fullTextQuery.setSort(getSearchSort(pageable)); return new PageImpl<>(fullTextQuery.getResultList(), pageable, fullTextQuery.getResultSize()); }
private int countBretzelsViaIndex(FullTextEntityManager em) { QueryBuilder queryBuilder = em.getSearchFactory().buildQueryBuilder().forEntity( Bretzel.class ).get(); Query allQuery = queryBuilder.all().createQuery(); FullTextQuery fullTextQuery = em.createFullTextQuery( allQuery, Bretzel.class ); return fullTextQuery.getResultSize(); } }
.buildQueryBuilder().forEntity(User.class).get(); .keyword() .onFields("name", "city", "email") .matching(text) .createQuery();
@SuppressWarnings("unchecked") private List<ArrayBridgeTestEntity> findResultsWithRangeQuery(String fieldName, Object start) { QueryBuilder queryBuilder = fullTextSession.getSearchFactory().buildQueryBuilder() .forEntity( ArrayBridgeTestEntity.class ).get(); Query query = queryBuilder.range().onField( fieldName ).above( start ).createQuery(); return fullTextSession.createFullTextQuery( query, ArrayBridgeTestEntity.class ).list(); }
public void testAllExceptWithoutAnalyzer() { loadNumericTypes(); Query subQuery = Search.getSearchManager(cache).buildQueryBuilderForClass(NumericType.class).get().keyword() .wildcard().onField("name").matching("*string*").createQuery(); Query query = Search.getSearchManager(cache).buildQueryBuilderForClass(NumericType.class).get().all().except().createQuery(); CacheQuery<Person> cacheQuery = Search.getSearchManager(cache).getQuery(query); List<Person> found = cacheQuery.list(); assertEquals(3, found.size()); assert found.contains(type1); assert found.contains(type2); assert found.contains(type3); query = Search.getSearchManager(cache).buildQueryBuilderForClass(NumericType.class).get().all().except(subQuery).createQuery(); cacheQuery = Search.getSearchManager(cache).getQuery(query); found = cacheQuery.list(); assertEquals(0, found.size()); }
QueryBuilder buildQuery = searchFactory.buildQueryBuilder().forEntity(Compound.class).get(); TermContext keyword = buildQuery.keyword(); WildcardContext wildcard = keyword.wildcard(); String[] searchfields = Compound.getSearchfields(); TermMatchingContext onFields = wildcard.onField(searchfields[0]); for (int i = 1; i < searchfields.length; i++) onFields.andField(searchfields[i]); TermTermination matching = onFields.matching(input.toLowerCase()); Query query = matching.createQuery();
@Test public void should_mustNot() { QueryBuilder queryBuilder = helper.queryBuilder( IndexedEntity.class ); HSQuery query = helper.hsQuery( queryBuilder.bool() .should( queryBuilder.keyword().onField( "field1" ).matching( FIELD1_VALUE1 ).createQuery() ) .should( queryBuilder.keyword().onField( "field1" ).matching( FIELD1_VALUE3 ).createQuery() ) .must( queryBuilder.keyword().onField( "field1" ).matching( FIELD1_VALUE1 ).createQuery() ).not() .createQuery() ); helper.assertThat( query ) .matchesUnorderedIds( DOCUMENT_3 ); }
@Override @SuppressWarnings("unchecked") protected void execute(FullTextSession fts) { long bookCount = ctx.bookIdCounter.get(); String phrase = PHRASES[(int) ( bookCount % PHRASES.length )]; Query q = fts.getSearchFactory() .buildQueryBuilder() .forEntity( Book.class ) .get() .phrase() .withSlop( 3 ) .onField( "summary" ) .sentence( phrase ) .createQuery(); List<Book> result = fts.createFullTextQuery( q, Book.class ).list(); if ( ctx.testContext.assertQueryResults ) { assertResult( result, phrase ); assertResultSize( result, phrase, bookCount ); } }
private Query queryForRangeOnFieldSorted(int min, int max, String fieldName) { ExtendedSearchIntegrator integrator = factoryHolder.getSearchFactory(); QueryBuilder queryBuilder = integrator.buildQueryBuilder().forEntity( Person.class ).get(); return queryBuilder .range() .onField( fieldName ) .from( min ) .to( max ) .createQuery(); }
public void testPhraseSentence() { loadTestingData(); Query query = Search.getSearchManager(cache).buildQueryBuilderForClass(Person.class).get().phrase() .onField("blurb").sentence("Eats grass").createQuery(); CacheQuery<Person> cacheQuery = Search.getSearchManager(cache).getQuery(query); List<Person> found = cacheQuery.list(); assertEquals(1, found.size()); assert found.contains(person2); person4 = new Person(); person4.setName("Another goat"); person4.setBlurb("Eats grass and drinks water."); cache.put("anotherKey", person4); found = cacheQuery.list(); assertEquals(2, found.size()); assert found.contains(person2); assert found.contains(person4); }
//look for users whos id is 1 and createDate is more than lastMonth Date lastMonth = ...; QueryBuilder userQB = searchFactory.buildQueryBuilder().forEntity( User.class ).get(); Query luceneQuery = userQB .bool() .must( userQB.keyword().onField("id").matching("1").createQuery() ) .must( userQB.range().onField("creationDate").above(lastMonth) .createQuery() ) .createQuery();
// New DSL based query composition //org.hibernate.search.query.dsl SearchFactory searchFactory = fullTextSession.getSearchFactory(); QueryBuilder buildQuery = searchFactory.buildQueryBuilder().forEntity(MasterDiagnosis.class).get(); PhraseContext keyword = buildQuery.phrase(); keyword.withSlop(3); //WildcardContext wildcard = keyword.wildcard(); String[] searchfields = MasterDiagnosis.getSearchfields(); PhraseMatchingContext onFields = keyword.onField(searchfields[0]); for (int i = 1; i < searchfields.length; i++) onFields.andField(searchfields[i]); PhraseTermination matching = onFields.sentence(lowerCasedSearchTerm); Query query = matching.createQuery(); // Convert the Search Query into something that provides results: Specify Compound again to be future proof
@Override public Query getQuery() { return child == null ? builder.all().createQuery() : child.getQuery(); } }