Unmodifiable - Improved read only immutable entity beans / graphs

[rbygrave]

Unmodifiable entities are:

• immutable, will throw on attempts to mutate via setters
• disabled lazy loading [don't mutate via lazy loading]
• can be partially populated [with some properties unloaded]
• throw on attempts to read unloaded properties including unloaded collections
• collections "freeze" to unmodifiable collections
• mutable types (e.g. DbArray) also "freeze" to unmodifiable if supported
• Uses PersistenceContextScope.QUERY [must do so in order to avoid connecting to modifiable entities in PC]

Changes

• Adds new UnloadedPropertyException and UnmodifiableEntityException
• Changes from using IllegalStateException to UnloadedPropertyException, UnmodifiableEntityException, or UnsupportedOperationException
• A query that is read only + disabled lazy loading "upgrades" to unmodifiable

Ugh

"Read Only" and "Unmodifiable" should probably be exactly the same thing/concept but read only existed before and so it slightly different [it does not include/imply disabled lazy loading + PersistenceContextScope.QUERY ]. Ideally we change query.setReadOnly(true) to be exactly the same as query.setUnmodifiable(true).

[rbygrave]

FYI @nedge

[rPraml]

Hello Rob, I took a short look on this PR.
I'm looking forward to this change.

We've always used a cumbersome combination of persistence-scope-query + readonly + cache etc.

I have to say that we also use the BeanCache.

I haven't looked at your PR in detail about what happens if data is partially present in the BeanCache and a partial bean is created and the missing data then has to be reloaded using lazy load

[rPraml]

"Read Only" and "Unmodifiable" should probably be exactly the same thing/concept but read only existed before and so it slightly different [it does not include/imply disabled lazy loading + PersistenceContextScope.QUERY ]. Ideally we change query.setReadOnly(true) to be exactly the same as query.setUnmodifiable(true).

I would agree that. (if really necessary, we couldbadd a config flag for backward compatibility)

But I think it still needs to be specified what should happen when caches are involved, as they already check the readOnly flag.

QueryCache:

Beans/IdLists in the queryCache should be always unmodifiable by default. (we use setUseQuerCache=true always together with setReadonly=true)
I can imagine only very few use cases, where this is not necessary (we have exacly one)

It is also necessary to set the persistence-scope to QUERY when beans are put into the queryCache, otherwise we got memory leaks.

So I have to pay attention always to use all 3 properties together correctly in my code.

Therefore, I would appreciate it if setUseQuerCache(true) would set everything correctly (or maybe an other convenient method like withQueryCaching())

BeanCache

Imagine if I do the query DB.find(...).select("prop1").setId(42).setUseBeanCache(true).findOne()

This will put partial data to the bean cache.

Next I do a select("*").setImmutable(true) and will have a beanCache hit.

What will we expect?

• got a partial loaded bean that throws a LazyLoadException on access to an unloaded property (that would be bad)
• or can a bean from the cache do lazy loads anyway
• or has the cache to validate, if there are all properties present and treat this situation as cache miss

mutable types

There are mutable types like Calendar or @DbJson properties. The later we use a lot. (you may remember JsonMutationDetection)

How do we handle this and protect from modification?

I think there is not much we can do about this, which would be totally OK for me, if it is specified.
(But I could imagine that custom json objects also can implement the freeze method later)

Roland

[rbygrave]

query cache ... always to use all 3 properties together correctly ... appreciate it if setUseQuerCache(true) would set everything correctly

Yes that makes sense. Yes I think we should migrate to setUseQuerCache(true) using unmodifiable implicitly.

mutable types

Some we can freeze (and we do in this PR) and some we can't do anything about (like Calendar).

bean cache

We need to figure this out but maybe we can't use the existing bean cache with unmodifiable. I have some thoughts around a new/different "bean cache" made of immutable beans (actually immutable graphs). My intention is to look at that first.