fullTextEntityManager.getSearchFactory() .buildQueryBuilder().forEntity(User.class).get(); .keyword() .onFields("name", "city", "email") .matching(text) .createQuery(); fullTextEntityManager.createFullTextQuery(query, User.class);
/** * Create an initial Lucene index for the data already present in the * database. * This method is called when Spring's startup. */ @Override public void onApplicationEvent(final ApplicationReadyEvent event) { try { FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager); fullTextEntityManager.createIndexer().startAndWait(); } catch (InterruptedException e) { System.out.println( "An error occurred trying to build the serach index: " + e.toString()); } return; }
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); } }
public void testQueryTimeoutException() throws Exception { FullTextEntityManager em = Search.getFullTextEntityManager( factory.createEntityManager() ); em.getTransaction().begin(); for ( long i = 0; i < 1000; i++ ) { Clock clock = new Clock( Long.valueOf( i ), "Model cat A" + i, ( i % 2 == 0 ) ? "Seiko" : "Swatch", Long.valueOf( 2000 + i ) ); em.persist( clock ); em.getTransaction().commit(); em.clear(); em.getTransaction().begin(); final QueryBuilder builder = em.getSearchFactory().buildQueryBuilder().forEntity( Clock.class ).get(); Query query = builder.keyword().onField( "brand" ).matching( "Seiko" ).createQuery(); FullTextQuery hibernateQuery = em.createFullTextQuery( query, Clock.class ); fail( "Expected a QueryTimeoutException" ); em.getTransaction().commit(); em.clear(); em.getTransaction().begin(); assertEquals( 1000, em.createQuery( "delete from " + Clock.class.getName() ).executeUpdate() ); em.getTransaction().commit(); em.close();
em.persist( poi ); em.persist( poi2 ); em.persist( poi3 ); } ); em.clear(); em.persist( poi4 ); em.persist( poi5 ); em.persist( poi6 ); } ); em.clear(); withinTransaction( em, () -> { double centerLatitude = 24.0d; double centerLongitude = 32.0d; final QueryBuilder builder = em.getSearchFactory().buildQueryBuilder().forEntity( POI.class ).get(); org.apache.lucene.search.Query luceneQuery = builder.spatial().onField( "location" ) .within( 100, Unit.KM ).ofLatitude( centerLatitude ).andLongitude( centerLongitude ).createQuery(); FullTextQuery hibQuery = em.createFullTextQuery( luceneQuery, POI.class ); hibQuery.setProjection( FullTextQuery.THIS, FullTextQuery.SPATIAL_DISTANCE ); hibQuery.setSpatialParameters( centerLatitude, centerLongitude, "location" ); hibQuery.setSort( builder.sort().byField( "idSort" ).createSort() ); List results = hibQuery.getResultList(); Assert.assertEquals( 6, results.size() );
@SuppressWarnings("unchecked") private void assertAssociatedElementsHaveBeenIndexed() throws Exception { FullTextEntityManager fullTextEm = Search.getFullTextEntityManager( createEntityManager() ); fullTextEm.getTransaction().begin(); QueryBuilder b = fullTextEm.getSearchFactory().buildQueryBuilder().forEntity( IndexedLabel.class ).get(); { Query luceneQuery = b.keyword().wildcard().onField( "name" ).matching( "tes*" ).createQuery(); List<IndexedLabel> labels = fullTextEm.createFullTextQuery( luceneQuery ).getResultList(); assertThat( labels ).hasSize( 1 ); assertThat( contains( labels, "test" ) ).isTrue(); } { Query luceneQuery = b.keyword().wildcard().onField( "name" ).matching( "mas*" ).createQuery(); List<IndexedLabel> labels = fullTextEm.createFullTextQuery( luceneQuery ).getResultList(); assertThat( labels ).hasSize( 1 ); assertThat( contains( labels, "massindex" ) ).isTrue(); } fullTextEm.getTransaction().commit(); fullTextEm.close(); }
private void fullTextSearch(String query) { FullTextEntityManager fullTextEntityManager = org.hibernate.search.jpa.Search.getFullTextEntityManager( entityManager); QueryBuilder qb = fullTextEntityManager.getSearchFactory().buildQueryBuilder() .forEntity(ArtificerArtifact.class).get(); BooleanJunction<BooleanJunction> junction = qb.bool(); junction.must(qb.keyword().onField("trashed").matching(false).createQuery()); junction.must(qb.keyword() .onFields("description", "name", "comments.text", "properties.key", "properties.value") .andField("content").ignoreFieldBridge() .andField("contentPath").ignoreFieldBridge() .matching(query) .createQuery()); qb.keyword().onField("model").matching(artifactModel).createQuery()); FullTextQuery fullTextQuery = fullTextEntityManager.createFullTextQuery( junction.createQuery(), ArtificerArtifact.class); fullTextQuery.setProjection("id");
@Override @SuppressWarnings("unchecked") public SearchResult<Page> search(String term, int offset, int limit) { FullTextEntityManager fullTextEm = Search.getFullTextEntityManager( getEm() ); QueryBuilder queryBuilder = fullTextEm.getSearchFactory().buildQueryBuilder() .forEntity( Page.class ).get(); Query luceneQuery; if ( term == null || term.isEmpty() ) { luceneQuery = queryBuilder.all().createQuery(); } else { luceneQuery = queryBuilder.keyword() .onField( "title" ).boostedTo( 2.0f ) .andField( "content" ) .matching( term ) .createQuery(); } Sort scoreSort = queryBuilder.sort().byScore().createSort(); FullTextQuery query = fullTextEm.createFullTextQuery( luceneQuery, Page.class ) .setFirstResult( offset ) .setMaxResults( limit ) .setSort( scoreSort ); return new SearchResult<>( query.getResultSize(), query.getResultList() ); }
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(); } }
@Test @SuppressWarnings("unchecked") public void testResultOrderedByDateDescending() throws Exception { EntityTransaction tx = em.getTransaction(); tx.begin(); QueryBuilder builder = em.getSearchFactory().buildQueryBuilder().forEntity( ProductArticle.class ).get(); org.apache.lucene.search.Query query = builder.keyword().wildcard().onField( "header" ).matching( "hib*" ).createQuery(); Sort dateDescending = builder.sort().byField( "creationDate" ).desc().createSort(); List<ProductArticle> result = em.createFullTextQuery( query, ProductArticle.class ) .setSort( dateDescending ).setFirstResult( 3 ).getResultList(); assertThat( result ).as( "query result" ).hasSize( 3 ); assertThat( result.get( 0 ).getArticleId() ).as( "article id" ).isEqualTo( 3 ); assertThat( result.get( 1 ).getArticleId() ).as( "article id" ).isEqualTo( 2 ); assertThat( result.get( 2 ).getArticleId() ).as( "article id" ).isEqualTo( 1 ); tx.commit(); em.clear(); }
@Override public boolean isDisabled() { Boolean retVal = ourDisabled; if (retVal == null) { retVal = new TransactionTemplate(myTxManager).execute(t -> { try { FullTextEntityManager em = org.hibernate.search.jpa.Search.getFullTextEntityManager(myEntityManager); em.getSearchFactory().buildQueryBuilder().forEntity(ResourceTable.class).get(); return Boolean.FALSE; } catch (Exception e) { ourLog.trace("FullText test failed", e); ourLog.debug("Hibernate Search (Lucene) appears to be disabled on this server, fulltext will be disabled"); return Boolean.TRUE; } }); ourDisabled = retVal; } assert retVal != null; return retVal; }
Search.getFullTextEntityManager(manager); final QueryBuilder titleQB = fullTextEntityManager.getSearchFactory().buildQueryBuilder() .forEntity(clazz).get(); titleQB.phrase().withSlop(2).onField(TITLE_NGRAM_INDEX) .andField(TITLE_EDGE_NGRAM_INDEX).boostedTo(5) .andField("atoms.name").boostedTo(5) fullTextEntityManager.createFullTextQuery(booleanQuery, clazz);
FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(em); QueryBuilder qb = fullTextEntityManager.getSearchFactory().buildQueryBuilder().forEntity(Customer.class).get(); TermMatchingContext onFields = qb.keyword().onFields("customer.shortDescription", "customer.longDescription"); BooleanJunction<BooleanJunction> bool = qb.bool(); org.apache.lucene.search.Query query = null; String[] searchTerms = searchQuery.split("\\s+"); for (int j = 0; j < searchTerms.length; j++) { String currentTerm = searchTerms[j]; bool.must(onFields.matching(currentTerm).createQuery()); } query = bool.createQuery(); FullTextQuery persistenceQuery = fullTextEntityManager.createFullTextQuery(query, Customer.class); resultList = persistenceQuery.getResultList();
@Override public Page<DataSource> searchByQuery(String query, Pageable pageable) { final FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager); LOGGER.info("Query : {}, Pageable: {}", query, pageable); FullTextQuery fullTextQuery; try { final QueryParser queryParser = new QueryParser("content", fullTextEntityManager.getSearchFactory().getAnalyzer(DataSource.class)); fullTextQuery = fullTextEntityManager.createFullTextQuery(queryParser.parse(query), DataSource.class); } catch (ParseException e) { LOGGER.error("Fail to search query : {}", e.getMessage()); throw new RuntimeException("Fail to search query : " + e.getMessage()); } fullTextQuery.setFirstResult(pageable.getOffset()); fullTextQuery.setMaxResults(pageable.getPageSize()); fullTextQuery.setSort(getSearchSort(pageable)); LOGGER.debug("FullTextQuery : {}", fullTextQuery); return new PageImpl<>(fullTextQuery.getResultList(), pageable, fullTextQuery.getResultSize()); }
FullTextEntityManager fullTextEm = Search.getFullTextEntityManager(this.entityManager); QueryBuilder qb = fullTextEm.getSearchFactory().buildQueryBuilder().forEntity(Person.class).get(); FullTextQuery fullTextQuery = fullTextEm.createFullTextQuery(qb.all().createQuery()); // I added this line to use projections fullTextQuery.setProjection("id", "name", "email", "user", "phone"); Sort sortField = new Sort(new SortField("name", SortField.STRING)); fullTextQuery.setSort(sortField); return fullTextQuery.getResultList();
public List<T> search(String searchTerm) throws SearchException { FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager); org.apache.lucene.search.Query qry; try { qry = HibernateSearchJpaTools.generateQuery(searchTerm, this.persistentClass, entityManager, defaultAnalyzer); } catch (ParseException ex) { throw new SearchException(ex); } org.hibernate.search.jpa.FullTextQuery hibQuery = fullTextEntityManager.createFullTextQuery(qry, this.persistentClass); // filter search results by owner.id value: // hibQuery.enableFullTextFilter("owned").setParameter("ownerId", owner.getId().toString()); return hibQuery.getResultList(); }
List<BeitragVO> results; List<String> fields= new ArrayList<String>(); FullTextEntityManager fullTextEntityManager = org.hibernate.search.jpa.Search .getFullTextEntityManager(em); // em = entitymanager QueryBuilder qb = fullTextEntityManager.getSearchFactory() .buildQueryBuilder().forEntity(BeitragVO.class).get(); if (student) { fields.add("user.surname"); fields.add("user.givenname"); } if (company) { fields.add("company.name"); } org.apache.lucene.search.Query luceneQuery = qb.keyword() .onFields(fields.toArray(new String[fields.size()])) .matching(searchterm).createQuery();
@Test public void testGetResultList() throws Exception { em.getTransaction().begin(); Query query = NumericRangeQuery.newIntRange( "saltQty", 23, 23, true, true ); assertEquals( "getResultList should return a result", 1, em.createFullTextQuery( query ).getResultList().size() ); em.getTransaction().commit(); }
private void purgeAll(Class<?>... entityTypes) throws Exception { FullTextEntityManager fullTextEm = Search.getFullTextEntityManager( createEntityManager() ); for ( Class<?> entityType : entityTypes ) { fullTextEm.purgeAll( entityType ); fullTextEm.flushToIndexes(); } int numDocs = fullTextEm.getSearchFactory().getIndexReaderAccessor().open( entityTypes ).numDocs(); fullTextEm.close(); assertThat( numDocs ).isEqualTo( 0 ); }
private void startAndWaitMassIndexing(Class<?>... entityTypes) throws InterruptedException { FullTextEntityManager fullTextEm = Search.getFullTextEntityManager( createEntityManager() ); fullTextEm.createIndexer( entityTypes ).purgeAllOnStart( true ).startAndWait(); int numDocs = fullTextEm.getSearchFactory().getIndexReaderAccessor().open( entityTypes ).numDocs(); fullTextEm.close(); assertThat( numDocs ).isGreaterThan( 0 ); }