@Test
  public void testSortableField() throws Exception {
    FullTextSession s = Search.getFullTextSession(openSession());
    Transaction tx = s.beginTransaction();

    Item item1 = new Item();
    item1.setId(3);
    item1.setPrice((short) 3454);
    s.persist(item1);

    Item item2 = new Item();
    item2.setId(2);
    item2.setPrice((short) 3354);
    s.persist(item2);

    Item item3 = new Item();
    item3.setId(1);
    item3.setPrice((short) 3554);
    s.persist(item3);

    tx.commit();
    s.clear();

    tx = s.beginTransaction();

    Query q =
        s.getSearchFactory().buildQueryBuilder().forEntity(Item.class).get().all().createQuery();
    FullTextQuery query = s.createFullTextQuery(q, Item.class);
    query.setSort(new Sort(new SortField("price", SortField.Type.INT)));

    List<?> results = query.list();
    assertThat(results)
        .onProperty("price")
        .describedAs("Sortable field via programmatic config")
        .containsExactly((short) 3354, (short) 3454, (short) 3554);

    query.setSort(new Sort(new SortField("id", SortField.Type.STRING)));

    results = query.list();
    assertThat(results)
        .onProperty("id")
        .describedAs("Sortable field via programmatic config")
        .containsExactly(1, 2, 3);

    s.delete(results.get(0));
    s.delete(results.get(1));
    s.delete(results.get(2));
    tx.commit();
    s.close();
  }
  @Test
  public void testAnalyzerDef() 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("street1_ngram:pea");

    final FullTextQuery query = s.createFullTextQuery(luceneQuery);
    assertEquals("Analyzer inoperant", 1, query.getResultSize());

    s.delete(query.list().get(0));
    tx.commit();
    s.close();
  }
  @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(groups = "ch07")
  public void testPrefixQuery() throws Exception {
    FullTextSession session = Search.getFullTextSession(openSession());
    Transaction tx = session.beginTransaction();
    buildIndex(session, tx);

    String userInput = "sea";

    tx = session.beginTransaction();
    PrefixQuery query = new PrefixQuery(new Term("title", userInput));
    System.out.println(query.toString());

    org.hibernate.search.FullTextQuery hibQuery = session.createFullTextQuery(query, Dvd.class);
    List<Dvd> results = hibQuery.list();

    assert results.size() == 4 : "incorrect hit count";
    for (Dvd dvd : results) {
      assert dvd.getTitle().indexOf("Sea") >= 0;
      System.out.println(dvd.getTitle());
    }

    for (Object element : session.createQuery("from " + Dvd.class.getName()).list())
      session.delete(element);
    tx.commit();
    session.close();
  }
  @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();
  }
  @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();
  }
  @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();
  }
  @Test(groups = "ch12")
  public void vectorTest() throws Exception {
    FullTextSession session = Search.getFullTextSession(openSession());
    Transaction tx = session.beginTransaction();
    buildIndex(session, tx);

    try {
      tx = session.beginTransaction();

      Query query = new TermQuery(new Term("content", "properties"));
      System.out.println(query.toString());

      FullTextQuery hibQuery = session.createFullTextQuery(query, ElectricalProperties.class);
      hibQuery.setProjection(
          FullTextQuery.DOCUMENT, FullTextQuery.DOCUMENT_ID, FullTextQuery.SCORE);

      reader = getReader(session);

      List<Object[]> results = hibQuery.list();

      assert results.size() > 0 : "no results returned";
      for (int x = 0; x < results.size(); x++) {

        Integer docId = (Integer) results.get(x)[1];
        TermPositionVector vector = (TermPositionVector) reader.getTermFreqVector(docId, "content");
        String[] terms = vector.getTerms();
        int[] f = vector.getTermFrequencies();

        System.out.println(results.get(x)[2]);
        for (int y = 0; y < vector.size(); y++) {
          System.out.print("docID# =>" + docId);
          System.out.print(" term => " + terms[y]);
          System.out.print(" freq => " + f[y]);

          int[] positions = vector.getTermPositions(y);
          TermVectorOffsetInfo[] offsets = vector.getOffsets(y);
          for (int z = 0; z < positions.length; z++) {
            System.out.print(" position => " + positions[z]);
            System.out.print(" starting offset => " + offsets[z].getStartOffset());
            System.out.println(" ending offset => " + offsets[z].getEndOffset());
          }
          System.out.println("---------------");
        }
      }
      for (Object element :
          session.createQuery("from " + ElectricalProperties.class.getName()).list())
        session.delete(element);

      tx.commit();
    } finally {
      session.close();
      if (provider != null) {
        provider.closeReader(reader);
      }
    }
  }
Example #9
0
  public void testBatchSize() throws Exception {
    FullTextSession s = Search.getFullTextSession(openSession());
    Transaction tx = s.beginTransaction();
    final int loop = 14;
    s.doWork(
        new Work() {
          @Override
          public void execute(Connection connection) throws SQLException {
            for (int i = 0; i < loop; i++) {
              Statement statmt = connection.createStatement();
              statmt.executeUpdate(
                  "insert into Domain(id, name) values( + " + (i + 1) + ", 'sponge" + i + "')");
              statmt.executeUpdate(
                  "insert into Email(id, title, body, header, domain_id) values( + "
                      + (i + 1)
                      + ", 'Bob Sponge', 'Meet the guys who create the software', 'nope', "
                      + (i + 1)
                      + ")");
              statmt.close();
            }
          }
        });
    tx.commit();
    s.close();

    // check non created object does get found!!1
    s = Search.getFullTextSession(openSession());
    tx = s.beginTransaction();
    ScrollableResults results = s.createCriteria(Email.class).scroll(ScrollMode.FORWARD_ONLY);
    int index = 0;
    while (results.next()) {
      index++;
      s.index(results.get(0));
      if (index % 5 == 0) {
        s.clear();
      }
    }
    tx
        .commit(); // if you get a LazyInitializationException, that's because we clear() the
                   // session in the loop.. it only works with a batch size of 5 (the point of the
                   // test)
    s.clear();
    tx = s.beginTransaction();
    QueryParser parser =
        new QueryParser(TestConstants.getTargetLuceneVersion(), "id", TestConstants.stopAnalyzer);
    List result = s.createFullTextQuery(parser.parse("body:create")).list();
    assertEquals(14, result.size());
    for (Object object : result) {
      s.delete(object);
    }
    tx.commit();
    s.close();
  }
  @After
  public void deleteTestData() {
    Session s = openSession();
    FullTextSession session = Search.getFullTextSession(s);
    Transaction tx = s.beginTransaction();

    QueryDescriptor query = ElasticsearchQueries.fromJson("{ 'query': { 'match_all' : {} } }");
    List<?> result = session.createFullTextQuery(query).list();

    for (Object entity : result) {
      session.delete(entity);
    }

    tx.commit();
    s.close();
  }
  @Test
  public void testFullTextFilterDefAtMappingLevel() throws Exception {
    FullTextSession s = Search.getFullTextSession(openSession());
    Transaction tx = s.beginTransaction();

    Address address = new Address();
    address.setStreet1("Peachtree Rd NE");
    address.setStreet2("Peachtnot Rd NE");
    address.setOwner("test");
    Calendar c =
        GregorianCalendar.getInstance(
            TimeZone.getTimeZone("GMT"), Locale.ROOT); // for the sake of tests
    c.set(2009, Calendar.NOVEMBER, 15);

    address.setLastUpdated(c);
    s.persist(address);

    address = new Address();

    address.setStreet1("Peachtnot Rd NE");
    address.setStreet2("Peachtree Rd NE");
    address.setLastUpdated(c);
    address.setOwner("testowner");
    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:Peachtnot");
    FullTextQuery query =
        s.createFullTextQuery(luceneQuery).setProjection(FullTextQuery.THIS, FullTextQuery.SCORE);
    query.enableFullTextFilter("security").setParameter("ownerName", "testowner");
    assertEquals("expecting 1 results", 1, query.getResultSize());

    @SuppressWarnings("unchecked")
    List<Object[]> results = query.list();

    for (Object[] result : results) {
      s.delete(result[0]);
    }
    tx.commit();
    s.close();
  }
  @Test
  public void testCalendarBridgeMapping() throws Exception {
    FullTextSession s = Search.getFullTextSession(openSession());
    Transaction tx = s.beginTransaction();

    Address address = new Address();
    address.setStreet1("Peachtree Rd NE");
    address.setStreet2("Peachtnot Rd NE");
    Calendar calendar =
        GregorianCalendar.getInstance(
            TimeZone.getTimeZone("GMT"), Locale.ROOT); // for the sake of tests
    calendar.set(2009, Calendar.NOVEMBER, 15);

    address.setLastUpdated(calendar);
    s.persist(address);

    address = new Address();
    address.setStreet1("Peachtnot Rd NE");
    address.setStreet2("Peachtree Rd NE");
    address.setLastUpdated(calendar);
    s.persist(address);

    tx.commit();

    s.clear();

    tx = s.beginTransaction();

    long searchTimeStamp = DateTools.round(calendar.getTime().getTime(), DateTools.Resolution.DAY);
    org.apache.lucene.search.Query luceneQuery =
        NumericRangeQuery.newLongRange(
            "last-updated", searchTimeStamp, searchTimeStamp, true, true);

    FullTextQuery query =
        s.createFullTextQuery(luceneQuery).setProjection(FullTextQuery.THIS, FullTextQuery.SCORE);
    assertEquals("expecting 2 results", 2, query.getResultSize());

    @SuppressWarnings("unchecked")
    List<Object[]> results = query.list();

    for (Object[] result : results) {
      s.delete(result[0]);
    }
    tx.commit();
    s.close();
  }
  @After
  public void deleteTestData() {
    Session s = openSession();
    FullTextSession session = Search.getFullTextSession(s);
    Transaction tx = s.beginTransaction();

    // TODO verify this is no longer needed after we implement the delete operations
    QueryDescriptor query = ElasticSearchQueries.fromJson("{ 'query': { 'match_all' : {} } }");
    List<?> result = session.createFullTextQuery(query).list();

    for (Object entity : result) {
      session.delete(entity);
    }

    tx.commit();
    s.close();
  }
  @Test(groups = "ch04")
  public void testEntityAssociations() throws Exception {
    Session session = factory.openSession();
    Transaction tx = session.beginTransaction();

    Item item = new Item();
    item.setDescription("Great DVD");
    item.setEan("123456789012");
    item.setTitle("Great DVD");
    Director director = new Director();
    director.setName("Emmanuel");
    director.getItems().add(item);
    item.setDirector(director);
    Actor actor = new Actor();
    actor.setName("John");
    session.save(actor);
    item.getActors().add(actor);
    actor.getItems().add(item);
    session.save(item);
    session.save(director);
    tx.commit();

    session.clear();

    tx = session.beginTransaction();
    actor = (Actor) session.get(Actor.class, actor.getId());
    actor.setName("John Griffin");
    director = (Director) session.get(Director.class, director.getId());
    director.setName("emmanuel Bernard");
    tx.commit();

    session.clear();

    tx = session.beginTransaction();
    FullTextSession fts = Search.getFullTextSession(session);
    BooleanQuery query = new BooleanQuery();
    query.add(new TermQuery(new Term("actors.name", "griffin")), BooleanClause.Occur.MUST);
    query.add(new TermQuery(new Term("director.name", "bernard")), BooleanClause.Occur.MUST);
    List results = fts.createFullTextQuery(query, Item.class).list();
    assert results.size() == 1;
    fts.delete(results.get(0));
    tx.commit();
    fts.close();
  }
  public void testBoostedFieldDesc() throws Exception {
    FullTextSession fullTextSession = Search.getFullTextSession(openSession());
    buildBoostedFieldIndex(fullTextSession);

    fullTextSession.clear();
    Transaction tx = fullTextSession.beginTransaction();

    QueryParser authorParser =
        new QueryParser(
            TestConstants.getTargetLuceneVersion(), "author", TestConstants.standardAnalyzer);
    QueryParser descParser =
        new QueryParser(
            TestConstants.getTargetLuceneVersion(), "description", TestConstants.standardAnalyzer);
    Query author = authorParser.parse("Wells");
    Query desc = descParser.parse("martians");

    BooleanQuery query = new BooleanQuery();
    query.add(author, BooleanClause.Occur.SHOULD);
    query.add(desc, BooleanClause.Occur.SHOULD);
    log.debug(query.toString());

    org.hibernate.search.FullTextQuery hibQuery =
        fullTextSession.createFullTextQuery(query, BoostedFieldDescriptionLibrary.class);
    List results = hibQuery.list();

    assertTrue(
        "incorrect document boost",
        ((BoostedFieldDescriptionLibrary) results.get(0)).getDescription().startsWith("Martians"));

    log.debug(hibQuery.explain(0).toString());
    log.debug(hibQuery.explain(1).toString());

    // cleanup
    for (Object element :
        fullTextSession
            .createQuery("from " + BoostedFieldDescriptionLibrary.class.getName())
            .list()) {
      fullTextSession.delete(element);
    }
    tx.commit();
    fullTextSession.close();
  }
  @Test
  public void testBoost() throws Exception {
    FullTextSession s = Search.getFullTextSession(openSession());
    Transaction tx = s.beginTransaction();

    Address address = new Address();
    address.setStreet1("Peachtree Rd NE");
    address.setStreet2("Peachtnot Rd NE");
    s.persist(address);

    address = new Address();
    address.setStreet1("Peachtnot Rd NE");
    address.setStreet2("Peachtree Rd NE");
    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:peachtree OR idx_street2:peachtree");
    FullTextQuery query =
        s.createFullTextQuery(luceneQuery).setProjection(FullTextQuery.THIS, FullTextQuery.SCORE);
    assertEquals("expecting two results", 2, query.getResultSize());

    @SuppressWarnings("unchecked")
    List<Object[]> results = query.list();

    assertTrue(
        "first result should be strictly higher",
        (Float) results.get(0)[1] > (Float) results.get(1)[1] * 1.9f);
    assertEquals(
        "Wrong result ordered", address.getStreet1(), ((Address) results.get(0)[0]).getStreet1());
    for (Object[] result : results) {
      s.delete(result[0]);
    }
    tx.commit();
    s.close();
  }
  /**
   * Tests that the token filters applied to <code>Team</code> are successfully created and used.
   * Refer to <code>Team</code> to see the exact definitions.
   *
   * @throws Exception in case the test fails
   */
  @Test
  public void testAnalyzerDef() throws Exception {
    // create the test instance
    Team team = new Team();
    team.setDescription(
        "This is a D\u00E0scription"); // \u00E0 == � - ISOLatin1AccentFilterFactory should strip of
                                       // diacritic
    team.setLocation("Atlanta");
    team.setName("ATL team");

    // persist and index the test object
    FullTextSession fts = Search.getFullTextSession(openSession());
    Transaction tx = fts.beginTransaction();
    fts.persist(team);
    tx.commit();
    fts.clear();

    // execute several search to show that the right tokenizers were applies
    tx = fts.beginTransaction();
    TermQuery query = new TermQuery(new Term("description", "D\u00E0scription"));
    assertEquals(
        "iso latin filter should work. � should be a now",
        0,
        fts.createFullTextQuery(query).list().size());

    query = new TermQuery(new Term("description", "is"));
    assertEquals(
        "stop word filter should work. is should be removed",
        0,
        fts.createFullTextQuery(query).list().size());

    query = new TermQuery(new Term("description", "dascript"));
    assertEquals(
        "snowball stemmer should work. 'dascription' should be stemmed to 'dascript'",
        1,
        fts.createFullTextQuery(query).list().size());

    // cleanup
    fts.delete(fts.createFullTextQuery(query).list().get(0));
    tx.commit();
    fts.close();
  }
  @Test
  @Category(
      ElasticsearchSupportInProgress
          .class) // HSEARCH-2428 Provide an alternative to
                  // org.hibernate.search.analyzer.Discriminator for Elasticsearch?
  public void testAnalyzerDiscriminator() throws Exception {
    FullTextSession s = Search.getFullTextSession(openSession());
    Transaction tx = s.beginTransaction();

    BlogEntry deEntry = new BlogEntry();
    deEntry.setTitle("aufeinanderschl\u00FCgen");
    deEntry.setDescription("aufeinanderschl\u00FCgen");
    deEntry.setLanguage("de");
    s.persist(deEntry);

    BlogEntry enEntry = new BlogEntry();
    enEntry.setTitle("acknowledgment");
    enEntry.setDescription("acknowledgment");
    enEntry.setLanguage("en");
    s.persist(enEntry);

    tx.commit();

    s.clear();

    tx = s.beginTransaction();

    // at query time we use a standard analyzer. We explicitly search for tokens which can only be
    // found if the
    // right language specific stemmer was used at index time
    assertEquals(1, nbrOfMatchingResults("description", "aufeinanderschlug", s));
    assertEquals(1, nbrOfMatchingResults("description", "acknowledg", s));
    assertEquals(0, nbrOfMatchingResults("title", "aufeinanderschlug", s));
    assertEquals(1, nbrOfMatchingResults("title", "acknowledgment", s));

    for (Object result : s.createQuery("from " + BlogEntry.class.getName()).list()) {
      s.delete(result);
    }
    tx.commit();
    s.close();
  }
Example #19
0
  @Test
  public void testMessageSending() throws Exception {

    TShirt shirt = createObjectWithSQL();
    List<LuceneWork> queue = createDocumentAndWorkQueue(shirt);

    registerMessageListener();
    sendMessage(queue);

    // need to sleep to give JMS processing and indexing time
    Thread.sleep(1000);

    FullTextSession ftSess = Search.getFullTextSession(openSession());
    ftSess.getTransaction().begin();
    QueryParser parser =
        new QueryParser(TestConstants.getTargetLuceneVersion(), "id", TestConstants.stopAnalyzer);
    Query luceneQuery = parser.parse("logo:jboss");
    org.hibernate.Query query = ftSess.createFullTextQuery(luceneQuery);
    List result = query.list();
    assertEquals(1, result.size());
    ftSess.delete(result.get(0));
    ftSess.getTransaction().commit();
    ftSess.close();
  }
  @Test
  public void testIndexEmbedded() throws Exception {
    FullTextSession s = Search.getFullTextSession(openSession());
    Transaction tx = s.beginTransaction();

    ProductCatalog productCatalog = new ProductCatalog();
    productCatalog.setName("Cars");
    Item item = new Item();
    item.setId(1);
    item.setDescription("Ferrari");
    item.setProductCatalog(productCatalog);
    productCatalog.addItem(item);

    s.persist(item);
    s.persist(productCatalog);
    tx.commit();

    s.clear();

    tx = s.beginTransaction();

    QueryParser parser = new QueryParser("id", TestConstants.standardAnalyzer);
    org.apache.lucene.search.Query luceneQuery = parser.parse("items.description:Ferrari");
    FullTextQuery query =
        s.createFullTextQuery(luceneQuery).setProjection(FullTextQuery.THIS, FullTextQuery.SCORE);
    assertEquals("expecting 1 results", 1, query.getResultSize());

    @SuppressWarnings("unchecked")
    List<Object[]> results = query.list();

    for (Object[] result : results) {
      s.delete(result[0]);
    }
    tx.commit();
    s.close();
  }
  @Test
  public void testDateBridgeMapping() throws Exception {
    FullTextSession s = Search.getFullTextSession(openSession());
    Transaction tx = s.beginTransaction();

    Address address = new Address();
    address.setStreet1("Peachtree Rd NE");
    address.setStreet2("Peachtnot Rd NE");
    Calendar c =
        GregorianCalendar.getInstance(
            TimeZone.getTimeZone("GMT"), Locale.ROOT); // for the sake of tests
    c.set(2009, Calendar.NOVEMBER, 15);

    Date date = new Date(c.getTimeInMillis());
    address.setDateCreated(date);
    s.persist(address);

    address = new Address();
    address.setStreet1("Peachtnot Rd NE");
    address.setStreet2("Peachtree Rd NE");
    address.setDateCreated(date);
    s.persist(address);

    BlogEntry enEntry = new BlogEntry();
    enEntry.setTitle("acknowledgment");
    enEntry.setDescription("acknowledgment");
    enEntry.setLanguage("en");
    enEntry.setDateCreated(date);
    s.persist(enEntry);

    tx.commit();

    s.clear();

    tx = s.beginTransaction();

    long searchTimeStamp = DateTools.round(date.getTime(), DateTools.Resolution.DAY);
    BooleanQuery.Builder booleanQueryBuilder = new BooleanQuery.Builder();
    booleanQueryBuilder.add(
        NumericRangeQuery.newLongRange(
            "date-created", searchTimeStamp, searchTimeStamp, true, true),
        BooleanClause.Occur.SHOULD);
    booleanQueryBuilder.add(
        NumericRangeQuery.newLongRange(
            "blog-entry-created", searchTimeStamp, searchTimeStamp, true, true),
        BooleanClause.Occur.SHOULD);

    FullTextQuery query =
        s.createFullTextQuery(booleanQueryBuilder.build())
            .setProjection(FullTextQuery.THIS, FullTextQuery.SCORE);
    assertEquals("expecting 3 results", 3, query.getResultSize());

    @SuppressWarnings("unchecked")
    List<Object[]> results = query.list();

    for (Object[] result : results) {
      s.delete(result[0]);
    }
    tx.commit();
    s.close();
  }
  @Test
  public void testSpatial() {
    org.hibernate.Session s = openSession();
    Transaction tx = s.beginTransaction();
    MemberLevelTestPoI memberLevelTestPoI = new MemberLevelTestPoI("test", 24.0, 32.0d);
    s.persist(memberLevelTestPoI);
    s.flush();
    tx.commit();

    tx = s.beginTransaction();
    FullTextSession session = Search.getFullTextSession(s);

    QueryBuilder builder =
        session.getSearchFactory().buildQueryBuilder().forEntity(MemberLevelTestPoI.class).get();

    double centerLatitude = 24;
    double centerLongitude = 31.5;

    org.apache.lucene.search.Query luceneQuery =
        builder
            .spatial()
            .onField("location")
            .within(50, Unit.KM)
            .ofLatitude(centerLatitude)
            .andLongitude(centerLongitude)
            .createQuery();

    org.hibernate.Query hibQuery =
        session.createFullTextQuery(luceneQuery, MemberLevelTestPoI.class);
    List<?> results = hibQuery.list();
    assertEquals(0, results.size());

    org.apache.lucene.search.Query luceneQuery2 =
        builder
            .spatial()
            .onField("location")
            .within(51, Unit.KM)
            .ofLatitude(centerLatitude)
            .andLongitude(centerLongitude)
            .createQuery();

    org.hibernate.Query hibQuery2 =
        session.createFullTextQuery(luceneQuery2, MemberLevelTestPoI.class);
    List<?> results2 = hibQuery2.list();
    assertEquals(1, results2.size());

    List<?> testPoIs = session.createQuery("from " + MemberLevelTestPoI.class.getName()).list();
    for (Object entity : testPoIs) {
      session.delete(entity);
    }
    tx.commit();
    session.close();

    s = openSession();
    tx = s.beginTransaction();
    ClassLevelTestPoI classLevelTestPoI = new ClassLevelTestPoI("test", 24.0, 32.0d);
    s.persist(classLevelTestPoI);
    s.flush();
    tx.commit();

    tx = s.beginTransaction();
    session = Search.getFullTextSession(s);

    builder =
        session.getSearchFactory().buildQueryBuilder().forEntity(ClassLevelTestPoI.class).get();

    centerLatitude = 24;
    centerLongitude = 31.5;

    luceneQuery =
        SpatialQueryBuilder.buildSpatialQueryByHash(
            centerLatitude, centerLongitude, 50, "location");
    hibQuery = session.createFullTextQuery(luceneQuery, ClassLevelTestPoI.class);
    results = hibQuery.list();
    assertEquals(0, results.size());

    luceneQuery2 =
        SpatialQueryBuilder.buildSpatialQueryByHash(
            centerLatitude, centerLongitude, 51, "location");
    hibQuery2 = session.createFullTextQuery(luceneQuery2, ClassLevelTestPoI.class);
    results2 = hibQuery2.list();
    assertEquals(1, results2.size());

    testPoIs = session.createQuery("from " + ClassLevelTestPoI.class.getName()).list();
    for (Object entity : testPoIs) {
      session.delete(entity);
    }
    tx.commit();
    session.close();

    s = openSession();
    tx = s.beginTransaction();
    LatLongAnnTestPoi latLongAnnTestPoi = new LatLongAnnTestPoi("test", 24.0, 32.0d);
    s.persist(latLongAnnTestPoi);
    s.flush();
    tx.commit();
    tx = s.beginTransaction();
    session = Search.getFullTextSession(s);

    builder =
        session.getSearchFactory().buildQueryBuilder().forEntity(LatLongAnnTestPoi.class).get();

    centerLatitude = 24;
    centerLongitude = 31.5;

    luceneQuery =
        builder
            .spatial()
            .onField("location")
            .within(50, Unit.KM)
            .ofLatitude(centerLatitude)
            .andLongitude(centerLongitude)
            .createQuery();

    hibQuery = session.createFullTextQuery(luceneQuery, LatLongAnnTestPoi.class);
    results = hibQuery.list();
    assertEquals(0, results.size());

    luceneQuery2 =
        builder
            .spatial()
            .onField("location")
            .within(51, Unit.KM)
            .ofLatitude(centerLatitude)
            .andLongitude(centerLongitude)
            .createQuery();

    hibQuery2 = session.createFullTextQuery(luceneQuery2, LatLongAnnTestPoi.class);
    results2 = hibQuery2.list();
    assertEquals(1, results2.size());

    testPoIs = session.createQuery("from " + LatLongAnnTestPoi.class.getName()).list();
    for (Object entity : testPoIs) {
      session.delete(entity);
    }
    tx.commit();

    session.close();
  }