[Hibernate-JIRA] Created: (HHH-2501) Read-only state of an entity in a session to propagate into subsequently lazy-loaded entities.
5:22 p.m.
Read-only state of an entity in a session to propagate into subsequently lazy-loaded
entities.
----------------------------------------------------------------------------------------------
Key: HHH-2501
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2501
Project: Hibernate3
Type: Improvement
Components: core
Environment: any
Reporter: Gunther Schadow
ISSUE:
Given an Entity entity and after Session.setReadOnly(entity), if the entity has lazy
collections, lazy properties etc., other Entities are loaded into the Session upon
navigating the object graph in the default read-writable state. However, it seems more
reasonable to maintain the read-only state of the owning object.
REQUEST:
Ability to propagate read-only state of an entity in a session into other lazy-loaded
entities.
BACKGROUND:
We have a system which permits users to make concurrent transactions which involve many of
the same objects. Usually no changes happen on these shared objects, but instead
connections (links) are made between these objects and new objects. For example, say you
have an online meeting system, and every Meeting held has a link to a number of User
object. The User objects are never changed in a Meeting, but there is a Relation called
Participation (of User in Meeting) to which new relationships are added. When a new
meeting is saved, it wants to save the User objects simply because a new Participation
link entry was added to the collection.
To an extent we can prevent this from happening by setting the Users explicitly to
read-only. However, now suppose we added a function "Invite your Friends" to a
Meeting, in which we would simply go:
for(User friend : currentUser.getFriends())
meeting.addInvitation(friend);
Now an Invitation is like a Participation, and would be added into the User but now it
wants to save these users just for a version upgrade only because they have received an
Invitation.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see:
http://www.atlassian.com/software/jira
5:29 p.m.
New subject: [Hibernate-JIRA] Updated: (HHH-2501) Read-only state of an entity in a session to propagate into subsequently lazy-loaded entities.
[ http://opensource.atlassian.com/projects/hibernate/browse/HHH-2501?page=all ]
Christian Bauer updated HHH-2501:
---------------------------------
Priority: Minor (was: Major)
type: New Feature (was: Improvement)
This was actually a question I got last week in training and we concluded that a
cascade="readonly" (or similar) might be quite useful. The request was to allow
read-onl entity instances in persistent state within the identity scope, avoiding data
aliasing problems with StatelessSession, but still being able to initialize proxies and
collections without the memory overhead of snapshots. I guess most people are hit by this
when they try to use the same mapping metadata for OLTP and reporting.
Read-only state of an entity in a session to propagate into
subsequently lazy-loaded entities.
----------------------------------------------------------------------------------------------
Key: HHH-2501
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2501
Project: Hibernate3
Type: New Feature
Components: core
Environment: any
Reporter: Gunther Schadow
Priority: Minor
ISSUE:
Given an Entity entity and after Session.setReadOnly(entity), if the entity has lazy
collections, lazy properties etc., other Entities are loaded into the Session upon
navigating the object graph in the default read-writable state. However, it seems more
reasonable to maintain the read-only state of the owning object.
REQUEST:
Ability to propagate read-only state of an entity in a session into other lazy-loaded
entities.
BACKGROUND:
We have a system which permits users to make concurrent transactions which involve many
of the same objects. Usually no changes happen on these shared objects, but instead
connections (links) are made between these objects and new objects. For example, say you
have an online meeting system, and every Meeting held has a link to a number of User
object. The User objects are never changed in a Meeting, but there is a Relation called
Participation (of User in Meeting) to which new relationships are added. When a new
meeting is saved, it wants to save the User objects simply because a new Participation
link entry was added to the collection.
To an extent we can prevent this from happening by setting the Users explicitly to
read-only. However, now suppose we added a function "Invite your Friends" to a
Meeting, in which we would simply go:
for(User friend : currentUser.getFriends())
meeting.addInvitation(friend);
Now an Invitation is like a Participation, and would be added into the User but now it
wants to save these users just for a version upgrade only because they have received an
Invitation.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see:
http://www.atlassian.com/software/jira
3:22 a.m.
New subject: [Hibernate-JIRA] Commented: (HHH-2501) Read-only state of an entity in a session to propagate into subsequently lazy-loaded entities.
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2501?page=c...
]
Christian Bauer commented on HHH-2501:
--------------------------------------
Another good addition would be a session.setReadOnly() method (no parameters) that would
disable creation of snapshots for the whole session.
Read-only state of an entity in a session to propagate into
subsequently lazy-loaded entities.
----------------------------------------------------------------------------------------------
Key: HHH-2501
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2501
Project: Hibernate3
Type: New Feature
Components: core
Environment: any
Reporter: Gunther Schadow
Priority: Minor
ISSUE:
Given an Entity entity and after Session.setReadOnly(entity), if the entity has lazy
collections, lazy properties etc., other Entities are loaded into the Session upon
navigating the object graph in the default read-writable state. However, it seems more
reasonable to maintain the read-only state of the owning object.
REQUEST:
Ability to propagate read-only state of an entity in a session into other lazy-loaded
entities.
BACKGROUND:
We have a system which permits users to make concurrent transactions which involve many
of the same objects. Usually no changes happen on these shared objects, but instead
connections (links) are made between these objects and new objects. For example, say you
have an online meeting system, and every Meeting held has a link to a number of User
object. The User objects are never changed in a Meeting, but there is a Relation called
Participation (of User in Meeting) to which new relationships are added. When a new
meeting is saved, it wants to save the User objects simply because a new Participation
link entry was added to the collection.
To an extent we can prevent this from happening by setting the Users explicitly to
read-only. However, now suppose we added a function "Invite your Friends" to a
Meeting, in which we would simply go:
for(User friend : currentUser.getFriends())
meeting.addInvitation(friend);
Now an Invitation is like a Participation, and would be added into the User but now it
wants to save these users just for a version upgrade only because they have received an
Invitation.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see:
http://www.atlassian.com/software/jira
1:45 p.m.
New subject: [Hibernate-JIRA] Commented: (HHH-2501) Read-only state of an entity in a session to propagate into subsequently lazy-loaded entities.
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2501?page=c...
]
Gunther Schadow commented on HHH-2501:
--------------------------------------
Yes, absolutely, being able to put an entire session into read-only mode would be very
useful. It is useful for our rich client application but it is even more useful for a
reporting or OLAP use of the data base where you never need snapshots but you need to
churn through tons of data.
I am concerned that no response exists till date from the developers. For us it could be
important enough to just do the session.setReadOnly() by ourselves. What are the chances
of our changes to stick in future versions of Hibernate?
Read-only state of an entity in a session to propagate into
subsequently lazy-loaded entities.
----------------------------------------------------------------------------------------------
Key: HHH-2501
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2501
Project: Hibernate3
Issue Type: New Feature
Components: core
Environment: any
Reporter: Gunther Schadow
Priority: Minor
ISSUE:
Given an Entity entity and after Session.setReadOnly(entity), if the entity has lazy
collections, lazy properties etc., other Entities are loaded into the Session upon
navigating the object graph in the default read-writable state. However, it seems more
reasonable to maintain the read-only state of the owning object.
REQUEST:
Ability to propagate read-only state of an entity in a session into other lazy-loaded
entities.
BACKGROUND:
We have a system which permits users to make concurrent transactions which involve many
of the same objects. Usually no changes happen on these shared objects, but instead
connections (links) are made between these objects and new objects. For example, say you
have an online meeting system, and every Meeting held has a link to a number of User
object. The User objects are never changed in a Meeting, but there is a Relation called
Participation (of User in Meeting) to which new relationships are added. When a new
meeting is saved, it wants to save the User objects simply because a new Participation
link entry was added to the collection.
To an extent we can prevent this from happening by setting the Users explicitly to
read-only. However, now suppose we added a function "Invite your Friends" to a
Meeting, in which we would simply go:
for(User friend : currentUser.getFriends())
meeting.addInvitation(friend);
Now an Invitation is like a Participation, and would be added into the User but now it
wants to save these users just for a version upgrade only because they have received an
Invitation.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
11:10 p.m.
New subject: [Hibernate-JIRA] Commented: (HHH-2501) Read-only state of an entity in a session to propagate into subsequently lazy-loaded entities.
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2501?page=c...
]
Christian Bauer commented on HHH-2501:
--------------------------------------
Just attach your patch here.
Read-only state of an entity in a session to propagate into
subsequently lazy-loaded entities.
----------------------------------------------------------------------------------------------
Key: HHH-2501
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2501
Project: Hibernate3
Issue Type: New Feature
Components: core
Environment: any
Reporter: Gunther Schadow
Priority: Minor
ISSUE:
Given an Entity entity and after Session.setReadOnly(entity), if the entity has lazy
collections, lazy properties etc., other Entities are loaded into the Session upon
navigating the object graph in the default read-writable state. However, it seems more
reasonable to maintain the read-only state of the owning object.
REQUEST:
Ability to propagate read-only state of an entity in a session into other lazy-loaded
entities.
BACKGROUND:
We have a system which permits users to make concurrent transactions which involve many
of the same objects. Usually no changes happen on these shared objects, but instead
connections (links) are made between these objects and new objects. For example, say you
have an online meeting system, and every Meeting held has a link to a number of User
object. The User objects are never changed in a Meeting, but there is a Relation called
Participation (of User in Meeting) to which new relationships are added. When a new
meeting is saved, it wants to save the User objects simply because a new Participation
link entry was added to the collection.
To an extent we can prevent this from happening by setting the Users explicitly to
read-only. However, now suppose we added a function "Invite your Friends" to a
Meeting, in which we would simply go:
for(User friend : currentUser.getFriends())
meeting.addInvitation(friend);
Now an Invitation is like a Participation, and would be added into the User but now it
wants to save these users just for a version upgrade only because they have received an
Invitation.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
5:26 p.m.
New subject: [Hibernate-JIRA] Updated: (HHH-2501) Read-only state of an entity in a session to propagate into subsequently lazy-loaded entities.
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2501?page=c...
]
Shawn Clowater updated HHH-2501:
--------------------------------
Attachment: HHH-2501.patch
First pass at a patch to allow a readOnly attribute on a session.
Read-only state of an entity in a session to propagate into
subsequently lazy-loaded entities.
----------------------------------------------------------------------------------------------
Key: HHH-2501
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2501
Project: Hibernate3
Issue Type: New Feature
Components: core
Environment: any
Reporter: Gunther Schadow
Priority: Minor
Attachments: HHH-2501.patch
ISSUE:
Given an Entity entity and after Session.setReadOnly(entity), if the entity has lazy
collections, lazy properties etc., other Entities are loaded into the Session upon
navigating the object graph in the default read-writable state. However, it seems more
reasonable to maintain the read-only state of the owning object.
REQUEST:
Ability to propagate read-only state of an entity in a session into other lazy-loaded
entities.
BACKGROUND:
We have a system which permits users to make concurrent transactions which involve many
of the same objects. Usually no changes happen on these shared objects, but instead
connections (links) are made between these objects and new objects. For example, say you
have an online meeting system, and every Meeting held has a link to a number of User
object. The User objects are never changed in a Meeting, but there is a Relation called
Participation (of User in Meeting) to which new relationships are added. When a new
meeting is saved, it wants to save the User objects simply because a new Participation
link entry was added to the collection.
To an extent we can prevent this from happening by setting the Users explicitly to
read-only. However, now suppose we added a function "Invite your Friends" to a
Meeting, in which we would simply go:
for(User friend : currentUser.getFriends())
meeting.addInvitation(friend);
Now an Invitation is like a Participation, and would be added into the User but now it
wants to save these users just for a version upgrade only because they have received an
Invitation.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
5:58 p.m.
New subject: [Hibernate-JIRA] Commented: (HHH-2501) Read-only state of an entity in a session to propagate into subsequently lazy-loaded entities.
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2501?page=c...
]
Shawn Clowater commented on HHH-2501:
-------------------------------------
Added a rough pass at a patch based on the 3.2.6 code base as it's what I'm
currently running. If the feedback is positive (or negative with suggested improvements)
I can look at tweaking it for 3.3.
I only found 2 places where I think I had to check for the attribute, in the TwoPhaseLoad
and the DefaultLoadEventListener. In looking at the DefaultLoadEventListener I think the
deep copy could probably be skipped if the session was in a read-only mode.
The one thing I struggled with was how to get explicit updates to entities that were
existed in the session as Read-Only. In my testing I resorted to a manual evict/update
process and that seemed to work. Alternatively I found that you could call
setReadOnly(Object, boolean) on the session to return it to a MANAGED status but you had
to do that before you changed the property on your entity otherwise it was overwriting the
changed value.
I still think it would be handy to have the read only cascade since I had originally been
playing with a read only attribute on the Criteria API but it had the effect of loading
the root entity as read only and then anything loaded off a many to one ended up being
managed.
Read-only state of an entity in a session to propagate into
subsequently lazy-loaded entities.
----------------------------------------------------------------------------------------------
Key: HHH-2501
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2501
Project: Hibernate3
Issue Type: New Feature
Components: core
Environment: any
Reporter: Gunther Schadow
Priority: Minor
Attachments: HHH-2501.patch
ISSUE:
Given an Entity entity and after Session.setReadOnly(entity), if the entity has lazy
collections, lazy properties etc., other Entities are loaded into the Session upon
navigating the object graph in the default read-writable state. However, it seems more
reasonable to maintain the read-only state of the owning object.
REQUEST:
Ability to propagate read-only state of an entity in a session into other lazy-loaded
entities.
BACKGROUND:
We have a system which permits users to make concurrent transactions which involve many
of the same objects. Usually no changes happen on these shared objects, but instead
connections (links) are made between these objects and new objects. For example, say you
have an online meeting system, and every Meeting held has a link to a number of User
object. The User objects are never changed in a Meeting, but there is a Relation called
Participation (of User in Meeting) to which new relationships are added. When a new
meeting is saved, it wants to save the User objects simply because a new Participation
link entry was added to the collection.
To an extent we can prevent this from happening by setting the Users explicitly to
read-only. However, now suppose we added a function "Invite your Friends" to a
Meeting, in which we would simply go:
for(User friend : currentUser.getFriends())
meeting.addInvitation(friend);
Now an Invitation is like a Participation, and would be added into the User but now it
wants to save these users just for a version upgrade only because they have received an
Invitation.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
12:22 p.m.
New subject: [Hibernate-JIRA] Commented: (HHH-2501) Read-only state of an entity in a session to propagate into subsequently lazy-loaded entities.
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2501?page=c...
]
Steve Ebersole commented on HHH-2501:
-------------------------------------
There are internal details, but the basic difficulty here is that "read only" is
tracked on the o.h.engine.EntityEntry class. EntityEntry is only created and tracked for
*initialized* entities. Proxies currently have no way to track there "read
only" state. Your patch is making the assumption that the whole entire session will
be in "read only" (at least when the proxy data is being fetched). See
HHH-1352
Read-only state of an entity in a session to propagate into
subsequently lazy-loaded entities.
----------------------------------------------------------------------------------------------
Key: HHH-2501
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2501
Project: Hibernate Core
Issue Type: New Feature
Components: core
Environment: any
Reporter: Gunther Schadow
Priority: Minor
Attachments: HHH-2501.patch
ISSUE:
Given an Entity entity and after Session.setReadOnly(entity), if the entity has lazy
collections, lazy properties etc., other Entities are loaded into the Session upon
navigating the object graph in the default read-writable state. However, it seems more
reasonable to maintain the read-only state of the owning object.
REQUEST:
Ability to propagate read-only state of an entity in a session into other lazy-loaded
entities.
BACKGROUND:
We have a system which permits users to make concurrent transactions which involve many
of the same objects. Usually no changes happen on these shared objects, but instead
connections (links) are made between these objects and new objects. For example, say you
have an online meeting system, and every Meeting held has a link to a number of User
object. The User objects are never changed in a Meeting, but there is a Relation called
Participation (of User in Meeting) to which new relationships are added. When a new
meeting is saved, it wants to save the User objects simply because a new Participation
link entry was added to the collection.
To an extent we can prevent this from happening by setting the Users explicitly to
read-only. However, now suppose we added a function "Invite your Friends" to a
Meeting, in which we would simply go:
for(User friend : currentUser.getFriends())
meeting.addInvitation(friend);
Now an Invitation is like a Participation, and would be added into the User but now it
wants to save these users just for a version upgrade only because they have received an
Invitation.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
12:24 p.m.
New subject: [Hibernate-JIRA] Closed: (HHH-2501) Read-only state of an entity in a session to propagate into subsequently lazy-loaded entities.
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2501?page=c...
]
Steve Ebersole closed HHH-2501.
-------------------------------
Resolution: Duplicate
Actually it is really a duplicate of the underlying phenomena described on HHH-1352
Read-only state of an entity in a session to propagate into
subsequently lazy-loaded entities.
----------------------------------------------------------------------------------------------
Key: HHH-2501
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2501
Project: Hibernate Core
Issue Type: New Feature
Components: core
Environment: any
Reporter: Gunther Schadow
Priority: Minor
Attachments: HHH-2501.patch
ISSUE:
Given an Entity entity and after Session.setReadOnly(entity), if the entity has lazy
collections, lazy properties etc., other Entities are loaded into the Session upon
navigating the object graph in the default read-writable state. However, it seems more
reasonable to maintain the read-only state of the owning object.
REQUEST:
Ability to propagate read-only state of an entity in a session into other lazy-loaded
entities.
BACKGROUND:
We have a system which permits users to make concurrent transactions which involve many
of the same objects. Usually no changes happen on these shared objects, but instead
connections (links) are made between these objects and new objects. For example, say you
have an online meeting system, and every Meeting held has a link to a number of User
object. The User objects are never changed in a Meeting, but there is a Relation called
Participation (of User in Meeting) to which new relationships are added. When a new
meeting is saved, it wants to save the User objects simply because a new Participation
link entry was added to the collection.
To an extent we can prevent this from happening by setting the Users explicitly to
read-only. However, now suppose we added a function "Invite your Friends" to a
Meeting, in which we would simply go:
for(User friend : currentUser.getFriends())
meeting.addInvitation(friend);
Now an Invitation is like a Participation, and would be added into the User but now it
wants to save these users just for a version upgrade only because they have received an
Invitation.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
12:37 p.m.
New subject: [Hibernate-JIRA] Commented: (HHH-2501) Read-only state of an entity in a session to propagate into subsequently lazy-loaded entities.
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2501?page=c...
]
Shawn Clowater commented on HHH-2501:
-------------------------------------
Steve, the one difference is that my patch was to apply a mechanism to attempt to throw a
whole session into a read-only state and not just an individual object so while I think
there is still an underlying issue with proxies I think there is still merit for that
functionality (i.e. we take a hit in our reporting while it puts the objects into a
MANAGED state not to mention if we happen to trigger a flush)
Read-only state of an entity in a session to propagate into
subsequently lazy-loaded entities.
----------------------------------------------------------------------------------------------
Key: HHH-2501
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2501
Project: Hibernate Core
Issue Type: New Feature
Components: core
Environment: any
Reporter: Gunther Schadow
Priority: Minor
Attachments: HHH-2501.patch
ISSUE:
Given an Entity entity and after Session.setReadOnly(entity), if the entity has lazy
collections, lazy properties etc., other Entities are loaded into the Session upon
navigating the object graph in the default read-writable state. However, it seems more
reasonable to maintain the read-only state of the owning object.
REQUEST:
Ability to propagate read-only state of an entity in a session into other lazy-loaded
entities.
BACKGROUND:
We have a system which permits users to make concurrent transactions which involve many
of the same objects. Usually no changes happen on these shared objects, but instead
connections (links) are made between these objects and new objects. For example, say you
have an online meeting system, and every Meeting held has a link to a number of User
object. The User objects are never changed in a Meeting, but there is a Relation called
Participation (of User in Meeting) to which new relationships are added. When a new
meeting is saved, it wants to save the User objects simply because a new Participation
link entry was added to the collection.
To an extent we can prevent this from happening by setting the Users explicitly to
read-only. However, now suppose we added a function "Invite your Friends" to a
Meeting, in which we would simply go:
for(User friend : currentUser.getFriends())
meeting.addInvitation(friend);
Now an Invitation is like a Participation, and would be added into the User but now it
wants to save these users just for a version upgrade only because they have received an
Invitation.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
1:32 a.m.
New subject: [Hibernate-JIRA] Reopened: (HHH-2501) Read-only state of an entity in a session to propagate into subsequently lazy-loaded entities.
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2501?page=c...
]
Gail Badner reopened HHH-2501:
------------------------------
Assignee: Gail Badner
Setting a default read-only/modifiable setting for a session was not implemented for
HHH-1352. It will be done for this issue instead.
Read-only state of an entity in a session to propagate into
subsequently lazy-loaded entities.
----------------------------------------------------------------------------------------------
Key: HHH-2501
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2501
Project: Hibernate Core
Issue Type: New Feature
Components: core
Environment: any
Reporter: Gunther Schadow
Assignee: Gail Badner
Priority: Minor
Attachments: HHH-2501.patch
ISSUE:
Given an Entity entity and after Session.setReadOnly(entity), if the entity has lazy
collections, lazy properties etc., other Entities are loaded into the Session upon
navigating the object graph in the default read-writable state. However, it seems more
reasonable to maintain the read-only state of the owning object.
REQUEST:
Ability to propagate read-only state of an entity in a session into other lazy-loaded
entities.
BACKGROUND:
We have a system which permits users to make concurrent transactions which involve many
of the same objects. Usually no changes happen on these shared objects, but instead
connections (links) are made between these objects and new objects. For example, say you
have an online meeting system, and every Meeting held has a link to a number of User
object. The User objects are never changed in a Meeting, but there is a Relation called
Participation (of User in Meeting) to which new relationships are added. When a new
meeting is saved, it wants to save the User objects simply because a new Participation
link entry was added to the collection.
To an extent we can prevent this from happening by setting the Users explicitly to
read-only. However, now suppose we added a function "Invite your Friends" to a
Meeting, in which we would simply go:
for(User friend : currentUser.getFriends())
meeting.addInvitation(friend);
Now an Invitation is like a Participation, and would be added into the User but now it
wants to save these users just for a version upgrade only because they have received an
Invitation.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
1:38 a.m.
New subject: [Hibernate-JIRA] Updated: (HHH-2501) Add capability to set a default read-only/modifiable setting for a session
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2501?page=c...
]
Gail Badner updated HHH-2501:
-----------------------------
Fix Version/s: 3.5.0-Beta-4
Requires Release Note: [Affirmative]
Summary: Add capability to set a default read-only/modifiable setting
for a session (was: Read-only state of an entity in a session to propagate into
subsequently lazy-loaded entities.)
Add capability to set a default read-only/modifiable setting for a
session
--------------------------------------------------------------------------
Key: HHH-2501
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2501
Project: Hibernate Core
Issue Type: New Feature
Components: core
Environment: any
Reporter: Gunther Schadow
Assignee: Gail Badner
Priority: Minor
Fix For: 3.5.0-Beta-4
Attachments: HHH-2501.patch
ISSUE:
Given an Entity entity and after Session.setReadOnly(entity), if the entity has lazy
collections, lazy properties etc., other Entities are loaded into the Session upon
navigating the object graph in the default read-writable state. However, it seems more
reasonable to maintain the read-only state of the owning object.
REQUEST:
Ability to propagate read-only state of an entity in a session into other lazy-loaded
entities.
BACKGROUND:
We have a system which permits users to make concurrent transactions which involve many
of the same objects. Usually no changes happen on these shared objects, but instead
connections (links) are made between these objects and new objects. For example, say you
have an online meeting system, and every Meeting held has a link to a number of User
object. The User objects are never changed in a Meeting, but there is a Relation called
Participation (of User in Meeting) to which new relationships are added. When a new
meeting is saved, it wants to save the User objects simply because a new Participation
link entry was added to the collection.
To an extent we can prevent this from happening by setting the Users explicitly to
read-only. However, now suppose we added a function "Invite your Friends" to a
Meeting, in which we would simply go:
for(User friend : currentUser.getFriends())
meeting.addInvitation(friend);
Now an Invitation is like a Participation, and would be added into the User but now it
wants to save these users just for a version upgrade only because they have received an
Invitation.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
12:42 a.m.
New subject: [Hibernate-JIRA] Resolved: (HHH-2501) Add capability to set a default read-only/modifiable setting for a session
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2501?page=c...
]
Gail Badner resolved HHH-2501.
------------------------------
Resolution: Fixed
Fixed in trunk.
Add capability to set a default read-only/modifiable setting for a
session
--------------------------------------------------------------------------
Key: HHH-2501
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2501
Project: Hibernate Core
Issue Type: New Feature
Components: core
Environment: any
Reporter: Gunther Schadow
Assignee: Gail Badner
Priority: Minor
Fix For: 3.5.0-Beta-4
Attachments: HHH-2501.patch
ISSUE:
Given an Entity entity and after Session.setReadOnly(entity), if the entity has lazy
collections, lazy properties etc., other Entities are loaded into the Session upon
navigating the object graph in the default read-writable state. However, it seems more
reasonable to maintain the read-only state of the owning object.
REQUEST:
Ability to propagate read-only state of an entity in a session into other lazy-loaded
entities.
BACKGROUND:
We have a system which permits users to make concurrent transactions which involve many
of the same objects. Usually no changes happen on these shared objects, but instead
connections (links) are made between these objects and new objects. For example, say you
have an online meeting system, and every Meeting held has a link to a number of User
object. The User objects are never changed in a Meeting, but there is a Relation called
Participation (of User in Meeting) to which new relationships are added. When a new
meeting is saved, it wants to save the User objects simply because a new Participation
link entry was added to the collection.
To an extent we can prevent this from happening by setting the Users explicitly to
read-only. However, now suppose we added a function "Invite your Friends" to a
Meeting, in which we would simply go:
for(User friend : currentUser.getFriends())
meeting.addInvitation(friend);
Now an Invitation is like a Participation, and would be added into the User but now it
wants to save these users just for a version upgrade only because they have received an
Invitation.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
3:50 a.m.
New subject: [Hibernate-JIRA] Updated: (HHH-2501) Add capability to set a default read-only/modifiable setting for a session
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2501?page=c...
]
Gail Badner updated HHH-2501:
-----------------------------
Requires Release Note: (was: [Affirmative])
Add capability to set a default read-only/modifiable setting for a
session
--------------------------------------------------------------------------
Key: HHH-2501
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2501
Project: Hibernate Core
Issue Type: New Feature
Components: core
Environment: any
Reporter: Gunther Schadow
Assignee: Gail Badner
Priority: Minor
Fix For: 3.5.0-Beta-4
Attachments: HHH-2501.patch
ISSUE:
Given an Entity entity and after Session.setReadOnly(entity), if the entity has lazy
collections, lazy properties etc., other Entities are loaded into the Session upon
navigating the object graph in the default read-writable state. However, it seems more
reasonable to maintain the read-only state of the owning object.
REQUEST:
Ability to propagate read-only state of an entity in a session into other lazy-loaded
entities.
BACKGROUND:
We have a system which permits users to make concurrent transactions which involve many
of the same objects. Usually no changes happen on these shared objects, but instead
connections (links) are made between these objects and new objects. For example, say you
have an online meeting system, and every Meeting held has a link to a number of User
object. The User objects are never changed in a Meeting, but there is a Relation called
Participation (of User in Meeting) to which new relationships are added. When a new
meeting is saved, it wants to save the User objects simply because a new Participation
link entry was added to the collection.
To an extent we can prevent this from happening by setting the Users explicitly to
read-only. However, now suppose we added a function "Invite your Friends" to a
Meeting, in which we would simply go:
for(User friend : currentUser.getFriends())
meeting.addInvitation(friend);
Now an Invitation is like a Participation, and would be added into the User but now it
wants to save these users just for a version upgrade only because they have received an
Invitation.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
5447
days inactive
6492
days old
hibernate-issues@lists.jboss.org
13 comments
5 participants
participants (5)
-
Christian Bauer (JIRA) -
Gail Badner (JIRA)
-
Gunther Schadow (JIRA)
-
Shawn Clowater (JIRA)
-
Steve Ebersole (JIRA)