Hi,

I'm trying to make a small thing based on Hibernate-Lucene integration.

Mainly I would like to extend org.hibernate.lucene.event.LuceneEventListener class or reuse it by means of composition but:

* its remove() and add() methods are private (I would have liked to override them)
* its documentBuilders field is private and there are not getters (in a delegating method I would have liked to access that property)

So basically I now have to copy and paste its whole implementation and simply modify what I need..

Am I missing something?

--------------------------
Regards,
Alessio Pace.
http://www.jroller.com/page/alessiopace

Nope.
Simply do that - and write your custom listener.

I did just that - needed some extra annotation handling.

Ok, thanks, the same thing that I need :-)

------------------
Regards,
Alessio Pace.
http://www.jroller.com/page/alessiopace
-------------------

I'm open for discussion regarding the ability to extend the lucene event listeners.
What do you want to do exactly?

Hi Emmanuel,
thanks for the reply.

Basically I would like to reuse the LuceneListener. The simplest thing that I would like to do is to have an hook in the add() method of LuceneEventListener, placed after the creation of a Document by the DocumentBuilder, so that it is possible to add custom Field(s) to the Document which is created.

In this way it would be possible to just reuse the LuceneEvent listener (actually, I had to copy & paste it), in order to add Fields to the mapped Entity->Document. The purpose of that later addition of Fields is to add something meant to be put only in the Lucene Index, without polluting the domain model with @Unstored getters returning constants like the name of the entity class..

So, something like:


What do you think?

---------------
Regards,
Alessio Pace.

What is the reason for adding constants to the index. Seems like a pollution to me.
When we manage to find the use case, I'll try and think of a proper solution, but subclassing an event seems the worse case senario to me so far, esp becasue I expect to add more behavior to it, like async batching

Hi Emmanuel,

Hibernate provides transparent support for mapping Entities to Lucene Index(es), but not the way back (correct me if i'm wrong..).

In a project I'm working which relies on Hibernate, I had to find a simple way to make the Lucene Index(es) to Entities mapping back. I provide you the example which led me to 2 implementation alternatives.

Imagine you have class Foo and class Bar, both are @Indexed, but on two different directories (so, 2 different Lucene indexes).

Now you want to make a ranked search over both of the indexes, through a Lucene MultiIndexSearcher. The search result are Lucene Documents, but you don't know if a Document originated from a Foo or a Bar instance (you would have to check the field names in the Document and the field names on the two classes).

One possibility is to extend the LuceneEventListener so that it is possibile to add a Field named "type" whose value is the canonical name of the domain entity ("x.y.Foo" or "x.y.Bar" in the example).

In this way it would be possible to map back the Lucene Document to a domain entity instance (you know the Class, and the id, you just have to make a findById for the given class and id).

The alternative to rewriting/extending the LuceneEventListener would be otherwise to add to each domain entity a getter stating the type of the class, and make that value go into the Lucene index but *not* going into the relational mapping:



Maybe there is another solution, but so far I can only see those 2 alternatives that I talked about, which summarizing again are:

1) extending/rewriting the LuceneEventListener, adding that "type" Field there after the DocumetBuilder created the Document (see my previous message).
2) adding the "@Text(..) String getType(){ .. }" to the domain entities (but this method has no business value)

If you can suggest me a better approach (different from "use the Compass Framework" :) I would appreciate a lot :-)

Thanks in advance,
-------------------------------
Alessio Pace.
http://jroller.com/page/alessiopace

Yes I have a better approach.
I already prototyped a query facility on top of Lucene but returning entities :-)

I plan to work on it again soon and push it back to the main branch, but I think it's already working fine.

http://anonsvn.jboss.org/repos/hibernate/branches/Lucene_Integration/HibernateExt/metadata/

Ah, I didn't know of that branch...

After giving a look at it, it seems cool! :-D And it seems like we adopted the same "trick" of the class name Field into the Lucene Documents. Unfortunately, I coded my solution "externally" from Hibernate code base.

Do you have any idea when it will be merged? I would like to use it in production... :-)

Regards,
Alessio Pace.

no firm date, I think it will be part of HAN 3.3
I don't know if I will backport that to 3.2

thanks for the all the infos and the support.

Regards,
-------------------
Alessio Pace.
http://www.jroller.com/page/alessiopace