Hibernate Search (Lucene) filter on collections

Question

I have a problem to implement a boolean logic with Hibernate Search Filter. There are persons that can be part of groups. Every group has a status from status catalog.

I need to filter all the users that are in group 1 and have status 2. For that I'm using a boolean query with Occur.MUST for both clauses, but in the filtered result are included persons that has list of grops and one of them is 1 and one of the statuses of the group is 2, for example:

person | group | status
105      (1)       3
105       2        3
105       3       (2)

188      (1)       3
188       7       (2)

197      (1)       4
197       8        5
197       9       (2)

The users 105, 188 and 197 has not to be included in the filtered result. What is the correct way to accomplsh that?

Filter:

BooleanQuery bq = new BooleanQuery();
TermQuery tqGroup = new TermQuery(new Term("groupPersons.id.groupId", "1"));
TermQuery tqStatus = new TermQuery(new Term("groupPersons.status.id", "2"));
bq.add(tqGroup, BooleanClause.Occur.MUST);
bq.add(tqStatus, BooleanClause.Occur.MUST);
filter = new QueryWrapperFilter(bq);

Person entity:

...
private List<GroupPerson> groupPersons = new ArrayList<GroupPerson>(0);

@IndexedEmbedded
@OneToMany(fetch = FetchType.LAZY, mappedBy = "person")
public List<GroupPerson> getGroupPersons() {
    return this.groupPersons;
}

GroupPerson entity:

...

@EmbeddedId
@AttributeOverrides({
        @AttributeOverride(name = "groupId", column = @Column(name = "group_id", nullable = false)),
        @AttributeOverride(name = "personId", column = @Column(name = "person_id", nullable = false)) })
@NotNull
@DocumentId
@FieldBridge(impl = GroupPersonIdBridge.class) 
public GroupPersonId getId() {
    return this.id;
}

...

@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "status_id",nullable = false)
@IndexedEmbedded
@NotNull
public Status getStatus() {
     return this.Status;
}

OrganizationPersonIdBridge:

public Object get(String name, Document document) {
    GroupPersonId id = new GroupPersonId();
    Field field = document.getField( name + ".groupId" );
    id.setGroupId(Long.parseLong(field.stringValue()));
    field = document.getField( name + ".personId" );
    id.setPersonId(Long.parseLong(field.stringValue()));
    return id;
  }

  public String objectToString(Object object) {
     GroupPersonId id = (GroupPersonId) object;
    StringBuilder sb = new StringBuilder();
    sb.append( id.getGroupId() )
    .append(" ")
    .append(id.getPersonId());
    return sb.toString();
  }


  public void set(String name,Object value,Document document,LuceneOptions luceneOptions) {
    GroupPersonId id = (GroupPersonId)value;
    Store store = luceneOptions.getStore();
    Index index = luceneOptions.getIndex();
    TermVector termVector = luceneOptions.getTermVector();
    Float boost = luceneOptions.getBoost();
    //store each property in a unique field
    Field field = new Field(name + ".groupId", id.getGroupId() + "", store, index, termVector);
    field.setBoost( boost );
    document.add( field );

    field = new Field(name + ".personId", id.getPersonId() + "", store, index, termVector);
    field.setBoost( boost );
    document.add( field );
    //store the unique string representation in the named field
    field = new Field( name,
    objectToString( id ),
    store, index, termVector );
    field.setBoost( boost );
    document.add( field );
  } 

The version of Hibernate search is 4.5.1.Final

Answer 1

For someone who haves the same uses case, here is the solution using classBridge:

public class CustomClassBridge implements FieldBridge, Serializable {
public final static String SEPARATOR = "-";

@Override
public void set(String name, Object value, Document document, LuceneOptions luceneOptions) {
    GroupPerson gp = (GroupPerson)value;
    String fieldValue = gp.getId().getGroupId() + SEPARATOR + gp.getStatus().getId();
    Field field = new Field(name, fieldValue, luceneOptions.getStore(), luceneOptions.getIndex(), luceneOptions.getTermVector());
    field.setBoost(luceneOptions.getBoost());
    document.add(field);
}
}

Add annotation to GroupPerson entity on class level:

@ClassBridge(name="groupStatus",index=Index.YES, analyze=Analyze.NO, store=Store.YES, impl = CustomClassBridge.class)

And finally in the filter:

TermQuery tq = new TermQuery(new Term("groupPersons.groupStatus", 1 + CustomClassBridge.SEPARATOR + 2));

Answer 2

The problem is that a Lucene Document does not have associations. When you are using @IndexedEmbedded you are effectively flattening all associations into a single Lucene Document (which is what's get added to a Lucene index and retrieved at search time). A Document can have the a field with the same name added multiple times. Taking your example, the Document for the Person with the id 105 will contain the following field name to field value pairs:

+-------------------------+-------------+
|       field name        | field value |
+-------------------------+-------------+
| groupPersons.id.groupId |           1 |
| groupPersons.id.groupId |           2 |
| groupPersons.id.groupId |           3 |
| groupPersons.status.id  |           3 |
| groupPersons.status.id  |           3 |
| groupPersons.status.id  |           2 |
+-------------------------+-------------+

If you now look at your query, you understand why person 105 is a match. Both boolean queries match.

How can you solve the problem? You need to make sure to have something unique to search on. One way of doing this, is to index group and status into a single field - using a custom bridge. Then you can write a query which just targets that field.