@Test
public void testElementCollectionOfBasicTypeMapping() throws Exception {
Session s = openSession();
FullTextSession session = Search.getFullTextSession(s);
Transaction tx = s.beginTransaction();
QueryDescriptor query =
ElasticsearchQueries.fromJson("{ 'query': { 'match' : { 'lastName' : 'Hergesheimer' } } }");
List<?> result =
session
.createFullTextQuery(query, GolfPlayer.class)
.setProjection(ProjectionConstants.SOURCE)
.list();
String source = (String) ((Object[]) result.iterator().next())[0];
JsonHelper.assertJsonEqualsIgnoringUnknownFields(
"{"
+ "\"lastName\": \"Hergesheimer\","
+ "\"strengths\": ["
+ "\"willingness\", \"precision\", \"stamina\""
+ "]"
+ "}",
source);
tx.commit();
s.close();
}
@Test
public void testQueryOnNullToken() {
Session s = openSession();
FullTextSession session = Search.getFullTextSession(s);
Transaction tx = s.beginTransaction();
QueryDescriptor query = ElasticSearchQueries.fromQueryString("firstName:<NULL>");
List<?> result = session.createFullTextQuery(query, GolfPlayer.class).list();
assertThat(result)
.onProperty("id")
.describedAs("Querying null-encoded String")
.containsOnly(2L);
query = ElasticSearchQueries.fromQueryString("dateOfBirth:1970-01-01");
result = session.createFullTextQuery(query, GolfPlayer.class).list();
assertThat(result).onProperty("id").describedAs("Querying null-encoded Date").containsOnly(2L);
query = ElasticSearchQueries.fromQueryString("active:false");
result = session.createFullTextQuery(query, GolfPlayer.class).list();
assertThat(result)
.onProperty("id")
.describedAs("Querying null-encoded Boolean")
.containsOnly(2L);
query = ElasticSearchQueries.fromQueryString("driveWidth:\\-1");
result = session.createFullTextQuery(query, GolfPlayer.class).list();
assertThat(result)
.onProperty("id")
.describedAs("Querying null-encoded Integer")
.containsOnly(2L);
tx.commit();
s.close();
}
@SuppressWarnings("unchecked")
@GET
@Produces(MediaType.APPLICATION_JSON)
public Response volumes(
@QueryParam("categoryId") Long categoryId,
@QueryParam("page") Integer page,
@QueryParam("q") String q) {
Volumes volumes = new Volumes();
VolumeDAO volumeDAO = DAOFactory.getInstance().getVolumeDAO();
FullTextSession fts = org.hibernate.search.Search.getFullTextSession(volumeDAO.getSession());
try {
Query query = buildLuceneQuery(categoryId, page, q);
FullTextQuery createFullTextQuery =
fts.createFullTextQuery(query, com.book.identification.model.Volume.class);
addPaginationToQuery(createFullTextQuery, page);
List<Volume> list = createFullTextQuery.list();
for (Volume volume : list) {
volume.setPage(page);
volume.setQ(q);
}
volumes.setVolumes(createFullTextQuery.list());
} catch (ParseException e1) {
e1.printStackTrace();
}
if (volumes.getVolumes().isEmpty()) {
return Response.ok("volumes : {}").build();
}
return Response.ok(volumes).build();
}
private void rebuildIndexWithMassIndexer(Class<?> entityType, String tenantId) throws Exception {
FullTextSession session = Search.getFullTextSession(openSessionWithTenantId(tenantId));
session.createIndexer(entityType).purgeAllOnStart(true).startAndWait();
int numDocs = session.getSearchFactory().getIndexReaderAccessor().open(entityType).numDocs();
session.close();
assertThat(numDocs).isGreaterThan(0);
}
@SuppressWarnings("unchecked")
public List<Dap> getDaps() {
if (dapExample != null) {
Example example =
Example.create(dapExample).excludeFalse().ignoreCase().enableLike(MatchMode.ANYWHERE);
return session.createCriteria(Dap.class).add(example).list();
} else if (searchText != null && searchText.trim().length() > 0) {
FullTextSession fullTextSession = Search.getFullTextSession(sessionManager.getSession());
try {
fullTextSession.createIndexer().startAndWait();
} catch (java.lang.InterruptedException e) {
logger.warn("Lucene Indexing was interrupted by something " + e);
}
QueryBuilder qb =
fullTextSession.getSearchFactory().buildQueryBuilder().forEntity(Dap.class).get();
org.apache.lucene.search.Query luceneQuery =
qb.keyword().onFields("name").matching(searchText).createQuery();
return fullTextSession.createFullTextQuery(luceneQuery, Dap.class).list();
} else {
// default - unfiltered - all entitites list
return session.createCriteria(Dap.class).list();
}
}
@Test
public void testMapping() throws Exception {
Address address = new Address();
address.setStreet1("3340 Peachtree Rd NE");
address.setStreet2("JBoss");
FullTextSession s = Search.getFullTextSession(openSession());
Transaction tx = s.beginTransaction();
s.persist(address);
tx.commit();
s.clear();
tx = s.beginTransaction();
QueryParser parser = new QueryParser("id", TestConstants.standardAnalyzer);
org.apache.lucene.search.Query luceneQuery = parser.parse("" + address.getAddressId());
FullTextQuery query = s.createFullTextQuery(luceneQuery);
assertEquals("documentId does not work properly", 1, query.getResultSize());
luceneQuery = parser.parse("street1:peachtree");
query = s.createFullTextQuery(luceneQuery).setProjection("idx_street2", FullTextQuery.THIS);
assertEquals("Not properly indexed", 1, query.getResultSize());
Object[] firstResult = (Object[]) query.list().get(0);
assertEquals("@Field.store not respected", "JBoss", firstResult[0]);
// Verify that AddressClassBridge was applied as well:
luceneQuery = parser.parse("AddressClassBridge:Applied\\!");
assertEquals(1, s.createFullTextQuery(luceneQuery).getResultSize());
s.delete(firstResult[1]);
tx.commit();
s.close();
}
@Test
public void testMapping() throws Exception {
Session s = openSession();
FullTextSession session = Search.getFullTextSession(s);
Transaction tx = s.beginTransaction();
QueryDescriptor query =
ElasticsearchQueries.fromJson("{ 'query': { 'match' : { 'lastName' : 'Hergesheimer' } } }");
List<?> result =
session
.createFullTextQuery(query, GolfPlayer.class)
.setProjection(ProjectionConstants.SOURCE)
.list();
String source = (String) ((Object[]) result.iterator().next())[0];
JsonHelper.assertJsonEqualsIgnoringUnknownFields(
"{"
+ "\"active\": true,"
+ "\"dateOfBirth\": \"1958-04-07T00:00:00Z\","
+ "\"driveWidth\": 285,"
+ "\"firstName\": \"Klaus\","
+ "\"handicap\": 3.4,"
+ "\"lastName\": \"Hergesheimer\","
+ "\"fullName\": \"Klaus Hergesheimer\","
+ "\"age\": 34,"
+ "\"puttingStrength\": \"2.5\""
+ "}",
source);
tx.commit();
s.close();
}
private float getScore(Query query) {
Session session = openSession();
Object[] queryResult;
float score;
try {
FullTextSession fullTextSession = Search.getFullTextSession(session);
List<?> resultList =
fullTextSession
.createFullTextQuery(query, DynamicBoostedDescLibrary.class)
.setProjection(ProjectionConstants.SCORE, ProjectionConstants.EXPLANATION)
.setMaxResults(1)
.list();
if (resultList.size() == 0) {
score = 0.0f;
} else {
queryResult = (Object[]) resultList.get(0);
score = (Float) queryResult[0];
String explanation = queryResult[1].toString();
log.debugf("score: %f explanation: %s", score, explanation);
}
} finally {
session.close();
}
return score;
}
@Test
public void testProjectionOfNullValues() {
Session s = openSession();
FullTextSession session = Search.getFullTextSession(s);
Transaction tx = s.beginTransaction();
QueryDescriptor query = ElasticSearchQueries.fromQueryString("lastName:Kidd");
List<?> result =
session
.createFullTextQuery(query, GolfPlayer.class)
.setProjection(
"firstName",
"lastName",
"active",
"dateOfBirth",
"handicap",
"driveWidth",
"ranking.value")
.list();
assertThat(result).hasSize(1);
Object[] projection = (Object[]) result.iterator().next();
assertThat(projection[0]).describedAs("firstName").isNull();
assertThat(projection[1]).describedAs("lastName").isEqualTo("Kidd");
assertThat(projection[2]).describedAs("active").isNull();
assertThat(projection[3]).describedAs("dateOfBirth").isNull();
assertThat(projection[4]).describedAs("handicap").isEqualTo(0.0D);
assertThat(projection[5]).describedAs("driveWidth").isNull();
assertThat(projection[6]).describedAs("ranking value").isNull();
tx.commit();
s.close();
}
@Test
public void verifyIndexExclusivity() {
FullTextSessionBuilder builder = new FullTextSessionBuilder();
FullTextSession ftSession =
builder
.setProperty("hibernate.search.Book.indexmanager", "near-real-time")
.setProperty(
"hibernate.search." + Foo.class.getName() + ".indexmanager",
"org.hibernate.search.testsupport.indexmanager.RamIndexManager")
.addAnnotatedClass(BlogEntry.class)
.addAnnotatedClass(Foo.class)
.addAnnotatedClass(org.hibernate.search.test.query.Book.class)
.addAnnotatedClass(org.hibernate.search.test.query.Author.class)
.openFullTextSession();
SearchFactoryImplementor searchFactory =
(SearchFactoryImplementor) ftSession.getSearchFactory();
ftSession.close();
IndexManagerHolder allIndexesManager = searchFactory.getIndexManagerHolder();
// checks for the default implementation
checkIndexManagerType(
allIndexesManager,
"org.hibernate.search.test.configuration.BlogEntry",
org.hibernate.search.indexes.impl.DirectoryBasedIndexManager.class);
// Uses "NRT" taken from shortcut names
checkIndexManagerType(
allIndexesManager, "Book", org.hibernate.search.indexes.impl.NRTIndexManager.class);
// Uses a fully qualified name to load an implementation
checkIndexManagerType(allIndexesManager, Foo.class.getName(), RamIndexManager.class);
builder.close();
}
@Override
public void setUp() throws Exception {
super.setUp();
FullTextSession fullTextSession = Search.getFullTextSession(openSession());
searchFactory = (SearchFactoryImplementor) fullTextSession.getSearchFactory();
fullTextSession.close();
}
@Test
public void testUseOfMultipleCustomFieldBridgeInstances() throws Exception {
Transaction transaction = fullTextSession.beginTransaction();
final QueryBuilder monthQb =
fullTextSession.getSearchFactory().buildQueryBuilder().forEntity(Month.class).get();
// Rather complex code here as we're not exposing the #withFieldBridge methods on the public
// interface
final ConnectedTermMatchingContext field1Context =
(ConnectedTermMatchingContext) monthQb.keyword().onField(MonthClassBridge.FIELD_NAME_1);
final ConnectedTermMatchingContext field2Context =
(ConnectedTermMatchingContext)
field1Context
.withFieldBridge(new String2FieldBridgeAdaptor(new RomanNumberFieldBridge()))
.andField(MonthClassBridge.FIELD_NAME_2);
Query query =
field2Context
.withFieldBridge(new String2FieldBridgeAdaptor(new RomanNumberFieldBridge()))
.matching(2)
.createQuery();
assertEquals(1, fullTextSession.createFullTextQuery(query, Month.class).getResultSize());
transaction.commit();
}
@Test
public void testClassBridgeInstanceMapping() throws Exception {
OrderLine orderLine = new OrderLine();
orderLine.setName("Sequoia");
FullTextSession s = Search.getFullTextSession(openSession());
Transaction tx = s.beginTransaction();
s.persist(orderLine);
tx.commit();
s.clear();
tx = s.beginTransaction();
QueryParser parser = new QueryParser("id", TestConstants.standardAnalyzer);
org.apache.lucene.search.Query luceneQuery = parser.parse("orderLineName:Sequoia");
FullTextQuery query = s.createFullTextQuery(luceneQuery);
assertEquals("Bridge not used", 1, query.getResultSize());
luceneQuery = parser.parse("orderLineName_ngram:quo");
query = s.createFullTextQuery(luceneQuery);
assertEquals("Analyzer configuration not applied", 1, query.getResultSize());
luceneQuery = parser.parse("orderLineNameViaParam:Sequoia");
query = s.createFullTextQuery(luceneQuery);
assertEquals("Parameter configuration not applied", 1, query.getResultSize());
s.delete(query.list().get(0));
tx.commit();
s.close();
}
@Override
public final void run() {
try {
ctx.startSignal.await();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
counter.incrementAndGet();
long startTime = 0;
if (MEASURE_TASK_TIME) {
startTime = System.nanoTime();
}
FullTextSession s = Search.getFullTextSession(ctx.sf.openSession());
Transaction tx = s.beginTransaction();
try {
execute(s);
tx.commit();
} catch (RuntimeException e) {
tx.rollback();
throw e;
} finally {
s.close();
}
if (MEASURE_TASK_TIME) {
long stopTime = System.nanoTime();
timer.addAndGet(stopTime - startTime);
}
}
@Test
@SkipForDialect(
value = {SybaseASE15Dialect.class, Sybase11Dialect.class},
comment = "Sybase does not support @Lob")
public void testCreateIndexSearchEntityWithLobField() {
// create and index
Session session = openSession();
Transaction tx = session.beginTransaction();
LobHolder lobHolder = new LobHolder();
lobHolder.setVeryLongText("this text is very long ...");
session.persist(lobHolder);
tx.commit();
session.close();
// search
session = openSession();
tx = session.beginTransaction();
FullTextSession fullTextSession = Search.getFullTextSession(session);
QueryBuilder qb =
fullTextSession.getSearchFactory().buildQueryBuilder().forEntity(LobHolder.class).get();
Query query = qb.keyword().onField("veryLongText").matching("text").createQuery();
FullTextQuery hibernateQuery = fullTextSession.createFullTextQuery(query);
List<LobHolder> result = hibernateQuery.list();
assertEquals("We should have a match for the single LobHolder", 1, result.size());
tx.commit();
session.close();
}
@Test(groups = "ch04")
public void testEmbedded() throws Exception {
Session session = factory.openSession();
Item item = new Item();
item.setDescription("Great DVD");
item.setEan("123456789012");
item.setTitle("Great DVD");
item.setRating(new Rating());
item.getRating().setOverall(5);
item.getRating().setPicture(4);
item.getRating().setScenario(5);
item.getRating().setSoundtrack(3);
Transaction tx = session.beginTransaction();
session.save(item);
tx.commit();
session.clear();
tx = session.beginTransaction();
FullTextSession fts = Search.getFullTextSession(session);
List results =
fts.createFullTextQuery(new TermQuery(new Term("rating.overall", "5")), Item.class).list();
assert results.size() == 1;
fts.delete(results.get(0));
tx.commit();
fts.close();
}
private void assertExecutionTimeoutHasNoPartialResult() {
FullTextQuery hibernateQuery = fts.createFullTextQuery(allSeikoClocksQuery, Clock.class);
hibernateQuery.limitExecutionTimeTo(30, TimeUnit.SECONDS);
List results = hibernateQuery.list();
assertEquals("Test below limit termination", 500, results.size());
assertFalse(hibernateQuery.hasPartialResults());
fts.clear();
}
public int countBusLineByDatabaseCount() {
FullTextSession fullTextSession = Search.getFullTextSession(sessions.openSession());
Transaction tx = fullTextSession.beginTransaction();
int count = fullTextSession.createCriteria(BusLine.class).list().size();
tx.commit();
fullTextSession.close();
return count;
}
private void purgeAll(Class<?> entityType, String tenantId) {
FullTextSession session = Search.getFullTextSession(openSessionWithTenantId(tenantId));
session.purgeAll(entityType);
session.flushToIndexes();
int numDocs = session.getSearchFactory().getIndexReaderAccessor().open(entityType).numDocs();
session.close();
assertThat(numDocs).isEqualTo(0);
}
/** Changes the parent LocationGroup's name to "Airport" */
private void updateLocationGroupName(FullTextSession fullTextSession) {
final Transaction transaction = fullTextSession.beginTransaction();
LocationGroup group = (LocationGroup) fullTextSession.get(LocationGroup.class, 1L);
LocationGroup locationGroup = (LocationGroup) fullTextSession.merge(group);
locationGroup.setName("Airport");
transaction.commit();
}
private void buildIndex(FullTextSession session, Transaction tx) {
for (int x = 0; x < titles.length; x++) {
Dvd dvd = new Dvd();
dvd.setTitle(titles[x]);
dvd.setId(x);
session.save(dvd);
}
tx.commit();
session.clear();
}
public int countBusLinesByFullText() {
FullTextSession fullTextSession = Search.getFullTextSession(sessions.openSession());
Transaction tx = fullTextSession.beginTransaction();
org.apache.lucene.search.Query ftQuery = new MatchAllDocsQuery();
FullTextQuery query = fullTextSession.createFullTextQuery(ftQuery, BusLine.class);
int count = query.list().size();
tx.commit();
fullTextSession.close();
return count;
}
/**
* Creates a full-text query on Locations entities and checks the term is found exactly the
* expected number of times (or fails the test)
*/
private void assertFoundLocations(
FullTextSession fullTextSession, String locationGroupName, int expectedFoundLocations) {
final Transaction transaction = fullTextSession.beginTransaction();
TermQuery luceneQuery = new TermQuery(new Term("locationGroup.name", locationGroupName));
FullTextQuery fullTextQuery = fullTextSession.createFullTextQuery(luceneQuery, Location.class);
int resultSize = fullTextQuery.getResultSize();
transaction.commit();
Assert.assertEquals(expectedFoundLocations, resultSize);
}
@Test
public void testBridgeMapping() throws Exception {
Address address = new Address();
address.setStreet1("Peachtree Rd NE");
address.setStreet2("JBoss");
FullTextSession s = Search.getFullTextSession(openSession());
Transaction tx = s.beginTransaction();
s.persist(address);
tx.commit();
s.clear();
tx = s.beginTransaction();
QueryParser parser = new QueryParser("id", TestConstants.standardAnalyzer);
org.apache.lucene.search.Query luceneQuery = parser.parse("street1:peac");
FullTextQuery query = s.createFullTextQuery(luceneQuery);
assertEquals("PrefixQuery should not be on", 0, query.getResultSize());
luceneQuery = parser.parse("street1_abridged:peac");
query = s.createFullTextQuery(luceneQuery);
assertEquals("Bridge not used", 1, query.getResultSize());
s.delete(query.list().get(0));
tx.commit();
s.close();
}
@SuppressWarnings("unchecked")
@Override
public List<Page> fetch(Query query, Criteria crit) {
assertCriteriaEntity(crit);
FullTextSession fullTextSession = getFullTextSession();
FullTextQuery fq = fullTextSession.createFullTextQuery(query, Page.class);
fq.setCriteriaQuery(crit != null ? crit : pageDao.criteria());
return fq.list();
}
@Test
public void testUseOfFieldBridge() throws Exception {
Transaction transaction = fullTextSession.beginTransaction();
final QueryBuilder monthQb =
fullTextSession.getSearchFactory().buildQueryBuilder().forEntity(Month.class).get();
Query query = monthQb.keyword().onField("monthValue").matching(2).createQuery();
assertEquals(1, fullTextSession.createFullTextQuery(query, Month.class).getResultSize());
transaction.commit();
}
/** Adds a single Location to the LocationGroup#1 */
private void addLocationToGroupCollection(FullTextSession fullTextSession) {
final Transaction transaction = fullTextSession.beginTransaction();
LocationGroup group = (LocationGroup) fullTextSession.get(LocationGroup.class, 1L);
Location location = new Location("New Room");
fullTextSession.persist(location);
group.getLocations().add(location);
location.setLocationGroup(group);
transaction.commit();
}
@Override
@After
public void tearDown() throws Exception {
// check for ongoing transaction which is an indicator that something went wrong
// don't call the cleanup methods in this case. Otherwise the original error get swallowed
if (fullTextSession.getTransaction().getStatus() != TransactionStatus.ACTIVE) {
deleteTestBooks();
deleteTestNumbers();
fullTextSession.close();
}
super.tearDown();
}
@Test
public void testFieldBridge() {
Transaction transaction = fullTextSession.beginTransaction();
final QueryBuilder monthQb =
fullTextSession.getSearchFactory().buildQueryBuilder().forEntity(Month.class).get();
Query query = monthQb.keyword().onField("monthRomanNumber").matching(2).createQuery();
FullTextQuery fullTextQuery = fullTextSession.createFullTextQuery(query, Month.class);
List<?> results = fullTextQuery.list();
assertEquals(1, results.size());
Month february = (Month) results.get(0);
assertEquals(2, february.getMonthValue());
transaction.commit();
}
private void assertExecutionTimeoutOccursOnList() {
FullTextQuery hibernateQuery = fts.createFullTextQuery(allSwatchClocksQuery, Clock.class);
hibernateQuery.limitExecutionTimeTo(1, TimeUnit.NANOSECONDS);
List result = hibernateQuery.list();
System.out.println("Result size early: " + result.size());
assertEquals(
"Test early failure, before the number of results are even fetched", 0, result.size());
if (result.size() == 0) {
// sometimes, this
assertTrue(hibernateQuery.hasPartialResults());
}
fts.clear();
}