I agree with you - but you should then wait for Gavin to reply and possibly tell you why it is not working this way in Hibernate...

I faced the same problem as you and had a look at Hibernate's collection management code... Unfortunately, I couldn't find an easy way to add this kind of behavior :(

So I revert to the lazy elements (with proxies)

Specifically I need to convert
so that it uses lazy elements.

If you are using a list, set or bag, all you have to do is enable lazy by having lazy="true"

Surely that just sets the list as a whole to lazy? Ie: if nothing touches the list it's not loaded; if anything touches it, it's loaded all at once. That loading-all-at-once is what i'm trying to avoid.

Not exactly. This would make the collection lazy - meaning it is not loaded when its owning entity is loaded. It will be the first time you access it.
What you need is to make the elements of the list lazy... But unfortunately, it appears your list content is not persistent entities, but primitive types (strings) :(
If they were persistent entities (with an id) - the could have declared them lazy by adding the 'lazy=true' tag in its mapping definition:

So I should wrap the lines in a <class>?

Small remark to clarify what we said so far:
If I understand the Hibernate code correctly, adding to a collection will not trigger its initialization if:
- the collection is not already loaded;
- the collection is connected to a session;
- and the collection is an inverse collection.

Therefore, it does not apply to indexed collections like lists and maps (which cannot be inverse).

So when you expect a huge collection, and you often append to it - a possible approach would be to make it an inverse collection ?

I think so...

But before going any further, maybe you should wait a bit for other people to join the thread. Would be nice if we could have opinions of some Hibernate members...

Maybe there is another approach, maybe we are completly wrong... ;)

Lines have sequence, so an inverse <bag> isn't up to the job. I could add <property name="lineNumber" type="long"/> but then I'd have to implement list semantics myself with locking, session.filter(), and so forth.

A list of lazy <class> might work better.

In fact, if I combine my earlier unique-key hackish manual list with an inverse set, I get list semantics for free! (Well nearly. Technically I get sparse list semantics, and I have to futz with locking to avoid a race on indexes.)

A recap, my current state-of-the-art:

Hibernate's schema generator seems actually smart enough to not even need to generate the "line_ids" table.

I'm a bit tired (1AM here) but it looks ok.
The "line_ids" is not needed since the foreign key will be stored in the "lines" table...

Yeah, the mapping to fields is arcane... I never try to second-guess it, I just have an ant script call the schema export.

Well, listen - I'm sorry but I made a test and Hibernate is still loading the entire collection and all its elements. Apparently, the lazy class tag doesn't seem to apply to entities when they are in collection...

Very strange, and I can't believe it... It is probably too late and I should better go in my bed... things will become obvious tomorrow :(

OK, just a note, there is a lot of incorrect stuff written in this thread. :(

The actual functionality is this:

(1) For bags and lists with inverse="true", add() does not initialize the collection
(2) For all other collection mappings add() does immediately initailize the collection

As noted, this behavior is required in order to comply with the contracts defined by the Java Collections API.