} else { String joinedTerms = StringUtils.join(terms, ' '); theBoolean.must(theQueryBuilder.keyword().onField(theFieldName).matching(joinedTerms).createQuery());
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());
QueryBuilder qb = em.getSearchFactory().buildQueryBuilder().forEntity(ResourceTable.class).get(); .must(qb.keyword().onField("myResourceLinksField").matching(pid.toString()).createQuery()) .must(textQuery) .createQuery();
TermCodeSystemVersion csv = cs.getCurrentVersion(); FullTextEntityManager em = org.hibernate.search.jpa.Search.getFullTextEntityManager(myEntityManager); QueryBuilder qb = em.getSearchFactory().buildQueryBuilder().forEntity(TermConcept.class).get(); BooleanJunction<?> bool = qb.bool(); bool.must(qb.keyword().onField("myCodeSystemVersionPid").matching(csv.getPid()).createQuery()); bool.must(qb.keyword().onField("myParentPids").matching("" + code.getId()).createQuery()); } else { throw new InvalidRequestException("Don't know how to handle op=" + nextFilter.getOp() + " on property " + nextFilter.getProperty());
@Override public Query visit(IsNullExpr isNullExpr) { PropertyValueExpr propertyValueExpr = (PropertyValueExpr) isNullExpr.getChild(); return applyFieldBridge(false, propertyValueExpr.getPropertyPath(), queryBuilder.keyword().onField(propertyValueExpr.getPropertyPath().asStringPath())).matching(null).createQuery(); }
private Query createQuery(QueryBuilder queryBuilder, String fieldName, String term) { return queryBuilder .keyword() .onField( fieldName ) .ignoreFieldBridge() .matching( term ) .createQuery(); }
private Query searchQueryForValue(String field, String value, FullTextSession session) { QueryBuilder queryBuilder = session.getSearchFactory().buildQueryBuilder() .forEntity( WorkingPerson.class ).get(); return queryBuilder.keyword().onField( field ).matching( value ).createQuery(); }
private <T> CacheQuery<T> queryByNameField(String name, Class<T> entity) { SearchManager sm = Search.getSearchManager(cache); Query query = sm.buildQueryBuilderForClass(entity) .get().keyword().onField("name").matching(name).createQuery(); return sm.getQuery(query); } }
private CacheQuery<?> createProjectionQuery(String... projection) { QueryBuilder queryBuilder = searchManager.buildQueryBuilderForClass(Foo.class).get(); Query query = queryBuilder.keyword().onField("bar").matching("bar1").createQuery(); return searchManager.getQuery(query).projection(projection); }
@Override @Before 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 ); }
protected Query createLuceneQuery() { if (queryType == QueryType.MATCH_ALL) { return new MatchAllDocsQuery(); } if (queryType == QueryType.TERM) { return Search.getSearchManager(cache) .buildQueryBuilderForClass(Entity.class).get() .keyword().onField("val").matching(getRandomTerm()) .createQuery(); } return null; }
private static void assertFindBook(Cache<?, ?> cache) { SearchManager searchManager = Search.getSearchManager(cache); QueryBuilder queryBuilder = searchManager.buildQueryBuilderForClass(Book.class).get(); Query luceneQuery = queryBuilder.keyword().onField("title").matching("infinispan").createQuery(); CacheQuery<Book> cacheQuery = searchManager.getQuery(luceneQuery); List<Book> list = cacheQuery.list(); assertEquals(1, list.size()); }
@Test @TestForIssue(jiraKey = "HSEARCH-1791") public void testUsingMatchQueryOnNumericDocumentIdGeneratesTermQuery() throws Exception { // making sure a string based TermQuery is used final QueryBuilder monthQb = helper.queryBuilder( Month.class ); Query query = monthQb.keyword() .onField( "id" ) .matching( 1 ) .createQuery(); assertTrue( "A string based TermQuery is expected, but got a " + query.getClass(), query instanceof TermQuery ); }
public List<String> searchName(String name) { FullTextEntityManager fullTextEm = Search.getFullTextEntityManager( em ); Query luceneQuery = fullTextEm.getSearchFactory().buildQueryBuilder() .forEntity( RegisteredMember.class ).get() .keyword().onField( "name" ).matching( name ).createQuery(); List<?> resultList = fullTextEm.createFullTextQuery( luceneQuery ).setProjection( "name" ).getResultList(); List<String> names = new ArrayList<>( resultList.size() ); for ( Object projection : resultList ) { names.add( (String) ( ( (Object[]) projection )[0] ) ); } return names; }
@Test(expected = SearchException.class) public void testNullIndexingWithDSLQueryIgnoringFieldBridge() throws Exception { QueryBuilder queryBuilder = getSearchFactory().buildQueryBuilder().forEntity( Value.class ).get(); queryBuilder.keyword().onField( "value" ).ignoreFieldBridge().matching( null ).createQuery(); }
private void searchSongDsl(Session session) throws Exception { FullTextSession fullTextSession = Search.getFullTextSession( session ); Transaction tx = session.beginTransaction(); QueryBuilder queryBuilder = fullTextSession.getSearchFactory().buildQueryBuilder().forEntity( Song.class ).get(); Query queryEmmanuel = queryBuilder.keyword().onField( "mp3FileName" ).ignoreFieldBridge().matching( "Emmanuel" ).createQuery(); List<Song> result = fullTextSession.createFullTextQuery( queryEmmanuel ).list(); assertEquals( "Emmanuel is not an artist", 0, result.size() ); Query queryHardy = queryBuilder.keyword().onField( "mp3FileName" ).ignoreFieldBridge().matching( "Hardy" ).createQuery(); result = fullTextSession.createFullTextQuery( queryHardy ).list(); assertEquals( "Hardy is the artist", 1, result.size() ); tx.commit(); }
@Override public List<Artifact> searchAutocomplete(String searchPattern, Integer limit, Integer offset) throws ServiceException { String[] searchFields = new String[] { Binding.artifact().artifactId().getPath(), Binding.artifact().group().groupId().getPath() }; QueryBuilder queryBuilder = Search.getFullTextEntityManager(getEntityManager()).getSearchFactory().buildQueryBuilder() .forEntity(Artifact.class).get(); Query luceneQuery = queryBuilder.keyword().onField(Binding.artifact().deprecationStatus().getPath()).matching(ArtifactDeprecationStatus.NORMAL).createQuery(); List<SortField> sortFields = ImmutableList.<SortField>builder() .add(new SortField(Binding.artifact().group().getPath() + '.' + ArtifactGroup.GROUP_ID_SORT_FIELD_NAME, SortField.Type.STRING)) .add(new SortField(Artifact.ARTIFACT_ID_SORT_FIELD_NAME, SortField.Type.STRING)) .build(); Sort sort = new Sort(sortFields.toArray(new SortField[sortFields.size()])); return hibernateSearchService.searchAutocomplete(getObjectClass(), searchFields, searchPattern, luceneQuery, limit, offset, sort); }
@SuppressWarnings("unchecked") public List<Member> search(String name) { Query luceneQuery = em.getSearchFactory().buildQueryBuilder() .forEntity( Member.class ).get().keyword() .onField( "name" ).matching( name ) .createQuery(); return em.createFullTextQuery( luceneQuery ).getResultList(); }
protected void verifyFindsPerson(int expectedCount, String name) throws Exception { SearchManager searchManager = Search.getSearchManager(cache); QueryBuilder carQueryBuilder = searchManager.buildQueryBuilderForClass(Person.class).get(); Query fullTextQuery = carQueryBuilder.keyword().onField("name").matching(name).createQuery(); CacheQuery<Car> cacheQuery = searchManager.getQuery(fullTextQuery, Person.class); assertEquals(expectedCount, cacheQuery.getResultSize()); } }
private void verifyFindsCar(Cache cache, int expectedCount, String carMake) { SearchManager searchManager = Search.getSearchManager(cache); QueryBuilder carQueryBuilder = searchManager.buildQueryBuilderForClass(Car.class).get(); Query fullTextQuery = carQueryBuilder.keyword().onField("make").matching(carMake).createQuery(); CacheQuery<?> cacheQuery = searchManager.getQuery(fullTextQuery, Car.class); assertEquals(expectedCount, cacheQuery.getResultSize()); }