SearchFactory searchFactory = fullTextSession.getSearchFactory(); QueryBuilder buildQuery = searchFactory.buildQueryBuilder().forEntity(Compound.class).get(); TermContext keyword = buildQuery.keyword(); WildcardContext wildcard = keyword.wildcard(); String[] searchfields = Compound.getSearchfields(); FullTextQuery fullTextQuery = fullTextSession.createFullTextQuery(query, Compound.class); fullTextQuery.setMaxResults(20); List<Object[]> results = fullTextQuery.setProjection(projectedFields.toArray(new String[projectedFields.size()])).list();
/** * @see ContextDAO#updateSearchIndexAsync() */ @Override public Future<?> updateSearchIndexAsync() { try { log.info("Started asynchronously updating the search index..."); return Search.getFullTextSession(sessionFactory.getCurrentSession()).createIndexer().start(); } catch (Exception e) { throw new RuntimeException("Failed to start asynchronous search index update", e); } }
session.purgeAll(type); session.flush(); session.clear(); FlushMode flushMode = session.getFlushMode(); CacheMode cacheMode = session.getCacheMode(); try { session.setFlushMode(FlushMode.MANUAL); session.setCacheMode(CacheMode.IGNORE); ScrollableResults results = session.createCriteria(type).setFetchSize(1000).scroll(ScrollMode.FORWARD_ONLY); int index = 0; while (results.next()) { index++; session.index(results.get(0)); if (index % 1000 == 0) { session.flushToIndexes(); session.clear(); session.flushToIndexes(); session.clear(); session.setFlushMode(flushMode); session.setCacheMode(cacheMode);
/** * @see org.openmrs.api.db.ContextDAO#updateSearchIndexForObject(java.lang.Object) */ @Override @Transactional public void updateSearchIndexForObject(Object object) { FullTextSession session = Search.getFullTextSession(sessionFactory.getCurrentSession()); session.index(object); session.flushToIndexes(); }
@SuppressWarnings("unchecked") private void searchSong(Session session) throws Exception { FullTextSession fullTextSession = Search.getFullTextSession( session ); Transaction tx = session.beginTransaction(); QueryParser parser = new QueryParser( XMPDM.ARTIST.getName(), TestConstants.standardAnalyzer ); Query query = parser.parse( "Emmanuel" ); List<Song> result = fullTextSession.createFullTextQuery( query ).list(); assertEquals( "Emmanuel is not an artist", 0, result.size() ); query = parser.parse( "Hardy" ); result = fullTextSession.createFullTextQuery( query ).list(); assertEquals( "Hardy is the artist", 1, result.size() ); tx.commit(); }
@Test public void testDateResolution() { Session s = openSession(); FullTextSession fullTextSession = Search.getFullTextSession( s ); Transaction tx = s.beginTransaction(); Calendar dob = Calendar.getInstance( TimeZone.getTimeZone( "UTC" ), Locale.ENGLISH ); dob.set( 1958, 3, 7, 7, 7, 7 ); final QueryBuilder monthQb = fullTextSession.getSearchFactory() .buildQueryBuilder().forEntity( GolfPlayer.class ).get(); Query query = monthQb.keyword().onField( "dateOfBirth" ).matching( dob.getTime() ).createQuery(); assertEquals( 1, fullTextSession.createFullTextQuery( query, GolfPlayer.class ).getResultSize() ); tx.commit(); s.close(); }
@SuppressWarnings("unchecked") @Test public void testResultOrderedByDocId() throws Exception { Transaction tx = fullTextSession.beginTransaction(); Query query = queryParser.parse( "summary:lucene" ); FullTextQuery hibQuery = fullTextSession.createFullTextQuery( query, Book.class ); Sort sort = new Sort( new SortField( null, SortField.Type.DOC, false ) ); hibQuery.setSort( sort ); List<Book> result = hibQuery.list(); assertNotNull( result ); assertThat( result ).extracting( "id" ).containsExactlyInAnyOrder( 1, 2, 3, 10 ); tx.commit(); }
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(); }
@Test public void testObjectTypeFilteringTwoClasses() throws Exception { Session session = openSession(); Transaction tx = session.beginTransaction(); FullTextSession fullTextSession = Search.getFullTextSession( session ); FullTextQuery fullTextQuery = fullTextSession.createFullTextQuery( luceneQuery, Author.class, Music.class ); List result = fullTextQuery.list(); assertEquals( "Should match the author and music only", 2, result.size() ); tx.commit(); fullTextSession.close(); }
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 public void testIterateEmptyHits() throws Exception { FullTextSession fullTextSession = Search.getFullTextSession( openSession() ); Transaction tx = fullTextSession.beginTransaction(); QueryParser parser = new QueryParser( "dept", TestConstants.standardAnalyzer ); Query query = parser.parse( "dept:XXX" ); org.hibernate.search.FullTextQuery hibQuery = fullTextSession.createFullTextQuery( query, Employee.class ); Iterator iter = hibQuery.iterate(); assertFalse( iter.hasNext() ); hibQuery = fullTextSession.createFullTextQuery( query, Employee.class ).setFirstResult( 10 ).setMaxResults( 20 ); iter = hibQuery.iterate(); assertFalse( iter.hasNext() ); tx.commit(); fullTextSession.close(); }
@Test public void testLuceneDocumentIdProjection() throws Exception { FullTextSession s = Search.getFullTextSession( getSession() ); Transaction tx = s.beginTransaction(); QueryParser parser = new QueryParser( "dept", TestConstants.standardAnalyzer ); Query query = parser.parse( "dept:ITech" ); org.hibernate.search.FullTextQuery hibQuery = s.createFullTextQuery( query, Employee.class ); hibQuery.setProjection( FullTextQuery.DOCUMENT_ID ); List<?> result = hibQuery.list(); assertNotNull( result ); Object[] projection = (Object[]) result.get( 0 ); assertTrue( "DOCUMENT_ID incorrect", projection[0] instanceof Integer ); tx.commit(); }
@SuppressWarnings("unchecked") private List<EntityExtendingMappedSuperclassWithCollectionField> searchEntityByCollectionValue(String value) { Transaction transaction = fullTextSession.beginTransaction(); FullTextQuery query = fullTextSession.createFullTextQuery( new TermQuery( new Term( "collection", value ) ), EntityExtendingMappedSuperclassWithCollectionField.class ); List<EntityExtendingMappedSuperclassWithCollectionField> result = query.list(); transaction.commit(); fullTextSession.clear(); return result; }
@Test public void testNumericFieldQuery() throws Exception { Session s = openSession(); FullTextSession session = Search.getFullTextSession( s ); Transaction tx = s.beginTransaction(); QueryDescriptor query = ElasticsearchQueries.fromJson( "{ 'query': { 'range' : { 'wordCount' : { 'gte' : 8, 'lt' : 10 } } } }" ); List<?> result = session.createFullTextQuery( query ).list(); assertThat( result ).extracting( "title" ).containsExactlyInAnyOrder( "Latest in ORM", "ORM for beginners" ); tx.commit(); s.close(); }
@Test public void testGetResultSize() throws Exception { Session s = openSession(); FullTextSession session = Search.getFullTextSession( s ); Transaction tx = s.beginTransaction(); QueryDescriptor query = ElasticsearchQueries.fromJson( "{ 'query': { 'match' : { 'abstract' : 'Hibernate' } } }" ); FullTextQuery fullTextQuery = session.createFullTextQuery( query, ScientificArticle.class ); assertThat( fullTextQuery.getResultSize() ).isEqualTo( 4 ); tx.commit(); s.close(); }
private List<?> doQuery(Session slaveSession) throws ParseException { FullTextSession ftSession = Search.getFullTextSession( slaveSession ); Query luceneQuery = parser.parse( "logo:Boston or logo:Mapple leaves" ); slaveSession.getTransaction().begin(); FullTextQuery query = ftSession.createFullTextQuery( luceneQuery ); List<?> result = query.list(); slaveSession.getTransaction().commit(); return result; }
private void purgeAll() { FullTextSession fullTextSession = builder.openFullTextSession(); try { Transaction tx = fullTextSession.beginTransaction(); fullTextSession.purgeAll( Object.class ); tx.commit(); } finally { fullTextSession.close(); } }
private List<EntityA> search(Session s, String field, String value) { FullTextSession session = Search.getFullTextSession( s ); QueryBuilder queryBuilder = session.getSearchFactory().buildQueryBuilder().forEntity( EntityA.class ).get(); Query query = queryBuilder.keyword().onField( field ).matching( value ).createQuery(); @SuppressWarnings("unchecked") List<EntityA> result = session.createFullTextQuery( query ).list(); return result; }
private HelpItem doQuery(String tagName) { Transaction tx = getSession().beginTransaction(); FullTextSession fullTextSession = Search.getFullTextSession( getSession() ); Query termQuery = new TermQuery( new Term( "tags.tag.name", tagName ) ); FullTextQuery fullTextQuery = fullTextSession.createFullTextQuery( termQuery, HelpItem.class ); HelpItem check = (HelpItem) fullTextQuery.uniqueResult(); assertNotNull( "No HelpItem with Tag '" + tagName + "' found in Lucene index.", check ); assertTrue( check.getTags().get( 0 ).getTag().getName().equals( tagName ) ); tx.commit(); return check; }
@Test public void testEntityCanSortOnId() { try ( Session session = openSession() ) { FullTextSession fullTextSession = Search.getFullTextSession( session ); Transaction transaction = fullTextSession.beginTransaction(); Sort sort = new Sort( new SortField( "id", SortField.Type.STRING ) ); QueryBuilder queryBuilder = fullTextSession.getSearchFactory().buildQueryBuilder().forEntity( Villain.class ).get(); Query q = queryBuilder.keyword().onField( "name" ).matching( LEX ).createQuery(); FullTextQuery fullTextQuery = fullTextSession.createFullTextQuery( q, Villain.class ); fullTextQuery.setSort( sort ); List list = fullTextQuery.list(); assertThat( list ).hasSize( 1 ); Villain actual = (Villain) list.get( 0 ); assertThat( actual.getName() ).isEqualTo( LEX ); transaction.commit(); } }