CODEWITHSUNDEEP
javahibernatelazy-loading
DD.
DD.

Reputation: 22001

Hibernate count collection size without initializing

Is there a way I can count the size of an associated collection without initializing?

e.g.

Select count(p.children) from Parent p

(there is a good reason why I cant do this any other way as my where clause is more complicated and my from clause is a polymorphic query)

Thanks.

Upvotes: 43

Views: 27460

Answers (3)

neel4soft
neel4soft

Reputation: 537

You can do the same like this:

@Override
public FaqQuestions getFaqQuestionById(Long questionId) {
    session = sessionFactory.openSession();
    tx = session.beginTransaction();
    FaqQuestions faqQuestions = null;
    try {
        faqQuestions = (FaqQuestions) session.get(FaqQuestions.class,
                questionId);
        Hibernate.initialize(faqQuestions.getFaqAnswers());

        tx.commit();
        faqQuestions.getFaqAnswers().size();
    } finally {
        session.close();
    }
    return faqQuestions;
}

Just use faqQuestions.getFaqAnswers().size()nin your controller and you will get the size if lazily intialised list, without fetching the list itself.

Upvotes: -2

Steve Ebersole
Steve Ebersole

Reputation: 9443

You can use Session#createFilter which is a form of HQL which explicitly operates on collections. For example, you mention Parent and Children so if you have a Person p the most basic form would be:

session.createFilter( p.getChildren(), "" ).list()

This simply returns you a list of the children. It is important to note that the returned collection is not "live", it is not in any way associated with p.

The interesting part comes from the second argument. This is an HQL fragment. Here for example, you might want:

session.createFilter( p.getChildren(), "select count(*)" ).uniqueResult();

You mentioned you have a where clause, so you also might want:

session.createFilter( p.getChildren(), "select count(*) where this.age > 18" ).uniqueResult();

Notice there is no from clause. That is to say that the from clause is implied from the association. The elements of the collection are given the alias 'this' so you can refer to it from other parts of the HQL fragment.

Upvotes: 2

Péter Török
Péter Török

Reputation: 116286

A possible solution other than queries might be mapping children with lazy="extra" (in XML notation). This way, you can fetch the Parent with whatever query you need, then call parent.getChildren().size() without loading the whole collection (only a SELECT COUNT type query is executed).

With annotations, it would be

@OneToMany
@org.hibernate.annotations.LazyCollection(
org.hibernate.annotations.LazyCollectionOption.EXTRA
)
private Set<Child> children = new HashSet<Child>();

Update: Quote from Java Persistence with Hibernate, ch. 13.1.3:

A proxy is initialized if you call any method that is not the identifier getter method, a collection is initialized if you start iterating through its elements or if you call any of the collection-management operations, such as size() and contains(). Hibernate provides an additional setting that is mostly useful for large collections; they can be mapped as extra lazy. [...]

[Mapped as above,] the collection is no longer initialized if you call size(), contains(), or isEmpty() — the database is queried to retrieve the necessary information. If it’s a Map or a List, the operations containsKey() and get() also query the database directly.

So with an entity mapped as above, you can then do

Parent p = // execute query to load desired parent
// due to lazy loading, at this point p.children is a proxy object
int count = p.getChildren().size(); // the collection is not loaded, only its size

Upvotes: 73

Related Questions