.buildQueryBuilder().forEntity(User.class).get(); .keyword() .onFields("name", "city", "email") .matching(text)
/** * @return analyzer */ public Analyzer getAnalyzer() { return super.getFullTextSession().getSearchFactory().getAnalyzer("cms"); }
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; }
@Override protected void execute(FullTextSession fts) { Query q = fts.getSearchFactory() .buildQueryBuilder() .forEntity( Book.class ) .get() .all() .createQuery(); fts.createFullTextQuery( q, Book.class ) .setSort( new Sort( new SortField( "rating", SortField.Type.FLOAT, true ) ) ) .setMaxResults( 100 ) .list(); }
@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(); }
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; }
@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(); }
private void assertExists(FullTextSession s, String keyword, String expectedProjection) { QueryBuilder queryBuilder = s.getSearchFactory().buildQueryBuilder().forEntity( CheeseRollingCompetitor.class ).get(); Query q = queryBuilder.keyword().onField( "Nickname" ).matching( keyword ).createQuery(); FullTextQuery fullTextQuery = s.createFullTextQuery( q, CheeseRollingCompetitor.class ).setProjection( "Nickname" ); List list = fullTextQuery.list(); Assert.assertEquals( 1, list.size() ); Assert.assertEquals( expectedProjection, ( (Object[]) list.get( 0 ) )[0] ); s.clear(); }
private static <T> List<T> find(Session session, Class<T> clazz, String key, String value) { FullTextSession fts = Search.getFullTextSession( session ); Query luceneQuery = fts.getSearchFactory().buildQueryBuilder() .forEntity( clazz ).get() .keyword().onField( key ).matching( value ) .createQuery(); @SuppressWarnings("unchecked") List<T> result = fts.createFullTextQuery( luceneQuery ).getResultList(); return result; }
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();
@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; }
.build(); FullTextSession fts = sessionBuilder.openFullTextSession(); fts.beginTransaction(); ASubOfRoot a = new ASubOfRoot(); a.id = "1"; a.name = "Foo"; fts.persist( a ); Unrelated b = new Unrelated(); b.id = "2"; b.name = "Bar"; fts.persist( b ); fts.getTransaction().commit(); DirectoryBasedIndexManager indexManager = (DirectoryBasedIndexManager) fts.getSearchFactory().unwrap( SearchIntegrator.class ).getIndexManager( "index1" ); WorkspaceHolder backendProcessor = (WorkspaceHolder) indexManager.getWorkspaceHolder(); IndexWriter writer = backendProcessor.getIndexResources().getWorkspace().getIndexWriter(); IndexReader indexReader = fts.getSearchFactory().getIndexReaderAccessor().open( "index1" ); try { assertThat( indexReader.numDocs() ).isEqualTo( 1 );
@Test public void canDeleteByQuery() throws Exception { Session s = openSession(); FullTextSession session = Search.getFullTextSession( s ); ExtendedSearchIntegrator integrator = session.getSearchFactory() .unwrap( ExtendedSearchIntegrator.class ); DeleteByQueryWork queryWork = new DeleteByQueryWork( new PojoIndexedTypeIdentifier( HockeyPlayer.class ), new SingularTermDeletionQuery( "active", "false" ) ); TransactionContext tc = new TransactionContextForTest(); integrator.getWorker().performWork( queryWork, tc ); integrator.getWorker().flushWorks( tc ); QueryDescriptor query = ElasticsearchQueries.fromJson( "{ 'query': { 'match_all' : {} } }" ); Transaction tx = s.beginTransaction(); @SuppressWarnings("unchecked") List<HockeyPlayer> result = session.createFullTextQuery( query, HockeyPlayer.class ).list(); assertThat( result ).extracting( "name" ).containsExactlyInAnyOrder( "Hergesheimer", "Brand" ); tx.commit(); s.close(); }
@Test public void testNoTermVector() throws Exception { FullTextSession s = Search.getFullTextSession( openSession() ); Transaction tx = s.beginTransaction(); Employee e1 = new Employee( 1000, "Griffin", "ITech" ); s.save( e1 ); tx.commit(); s.clear(); tx = s.beginTransaction(); // Here's how to get a reader from a FullTextSession SearchFactory searchFactory = s.getSearchFactory(); IndexReader reader = searchFactory.getIndexReaderAccessor().open( Employee.class ); Terms termVector = reader.getTermVector( 0, "dept" ); assertNull( "should not find a term position vector", termVector ); // cleanup for ( Object element : s.createQuery( "from " + ElectricalProperties.class.getName() ).list() ) { s.delete( element ); } searchFactory.getIndexReaderAccessor().close( reader ); tx.commit(); s.close(); }
private void verifyBackendUsage(String name, Class<? extends BackendQueueProcessor> backendType) { FullTextSessionBuilder builder = new FullTextSessionBuilder(); FullTextSession ftSession = builder .setProperty( "hibernate.search.default.worker.backend", name ) .addAnnotatedClass( BlogEntry.class ) .openFullTextSession(); ExtendedSearchIntegrator integrator = ftSession.getSearchFactory().unwrap( ExtendedSearchIntegrator.class ); ftSession.close(); IndexManagerHolder allIndexesManager = integrator.getIndexManagerHolder(); DirectoryBasedIndexManager indexManager = (DirectoryBasedIndexManager) allIndexesManager.getIndexManager( "org.hibernate.search.test.configuration.BlogEntry" ); BackendQueueProcessor backendQueueProcessor = allIndexesManager.getBackendQueueProcessor( indexManager.getIndexName() ); assertEquals( backendType, backendQueueProcessor.getClass() ); builder.close(); }
private void purgeAll(Class<?> entityType) throws IOException { FullTextSession session = Search.getFullTextSession( openSession() ); session.purgeAll( entityType ); session.flushToIndexes(); final int numDocs; try ( IndexReader indexReader = session.getSearchFactory().getIndexReaderAccessor().open( entityType ) ) { numDocs = indexReader.numDocs(); } session.close(); assertThat( numDocs ).isEqualTo( 0 ); }
private LuceneProcessingChain createProcessingChain(Map<String, Object> namedParameters, FullTextSession fullTextSession) { SearchIntegrator searchFactory = fullTextSession.getSearchFactory().unwrap( SearchIntegrator.class ); return new LuceneProcessingChain.Builder( searchFactory, entityNamesResolver ) .namedParameters( namedParameters ) .buildProcessingChainForClassBasedEntities(); }
private void startAndWaitMassIndexing(Class<?> entityType) throws InterruptedException, IOException { FullTextSession session = Search.getFullTextSession( openSession() ); session.createIndexer( entityType ).purgeAllOnStart( true ).startAndWait(); final int numDocs; try ( IndexReader indexReader = session.getSearchFactory().getIndexReaderAccessor().open( entityType ) ) { numDocs = indexReader.numDocs(); } assertThat( numDocs ).isGreaterThan( 0 ); }
analyzer = defaultAnalyzer; } else { analyzer = txtSession.getSearchFactory().getAnalyzer(searchedEntity); SearchFactory searchFactory = txtSession.getSearchFactory(); readerAccessor = searchFactory.getIndexReaderAccessor(); reader = readerAccessor.open(searchedEntity); Collection<String> fieldNames = new HashSet<>();
@Test public void testProvidedIdMapping() throws Exception { FullTextSession fullTextSession = Search.getFullTextSession( openSession() ); SearchIntegrator sf = fullTextSession.getSearchFactory().unwrap( SearchIntegrator.class ); ProvidedIdEntry person1 = new ProvidedIdEntry(); person1.setName( "Big Goat" ); person1.setBlurb( "Eats grass" ); ProvidedIdEntry person2 = new ProvidedIdEntry(); person2.setName( "Mini Goat" ); person2.setBlurb( "Eats cheese" ); ProvidedIdEntry person3 = new ProvidedIdEntry(); person3.setName( "Regular goat" ); person3.setBlurb( "Is anorexic" ); SearchITHelper helper = new SearchITHelper( () -> sf ); helper.index() .push( person1, 1 ) .push( person2, 2 ) .push( person3, 3 ) .execute(); Transaction transaction = fullTextSession.beginTransaction(); //we cannot use FTQuery because @ProvidedId does not provide the getter id and Hibernate Hsearch Query extension //needs it. So we use plain HSQuery helper.assertThat( "providedidentry.name", "goat" ) .from( ProvidedIdEntry.class ) .hasResultSize( 3 ); transaction.commit(); getSession().close(); }