[Hibernate-JIRA] Created: (HHH-2344) Persistent collection queued operation ignored with lazy inverse one-to-many collection.
9:10 p.m.
Persistent collection queued operation ignored with lazy inverse one-to-many collection.
----------------------------------------------------------------------------------------
Key: HHH-2344
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2344
Project: Hibernate3
Type: Bug
Components: core
Versions: 3.2.1
Environment: Hibernate 3.2.1
Reporter: Sebastien Robert
I load an Object that contains a lazy inverse collection (one-to-many).
Hibernate wrap my collection with a PersistentMap
There is objects in the collection in the database but in my case the PersistentMap is not
yet initialized.
I perform a remove operation on the persistentMap with a known key of one of the objects.
The map is not initialized (and the relation is an inverse one-to-many) so the map queue
the removeOperation.
I perform a get operation with the same key and the value is still returned.
If we look closer at what happened in the PersistentMap, it's look like this.
//*****
public Object remove(Object key) {
if ( isPutQueueEnabled() ) { // This returned true, the
// map
is not yet
//
initialized
Object old = readElementByIndex( key ); // This method triggered
// an
initialization of the
//
map.
//
Queued operation are
//
processed in the after
// init
method
queueOperation( new Remove( key, old ) ); // The remove operation
// is
queued.
return old;
}
....
//*******
When i perform the get operation on the map the map is now initialized. The get is
processed by the underlying map and the value is returned. The queued operation is
completely ignored.
Currently i fixed my code by performing a containsKey before the remove . The containsKey
initialize the map and then the remove do not queue the operation. But by looking at all
the PersistentCollection it seem that i may have the same problem using put and remove
with other persistentCollection.
--
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:08 p.m.
New subject: [Hibernate-JIRA] Commented: (HHH-2344) Persistent collection queued operation ignored with lazy inverse one-to-many collection.
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2344?page=c...
]
Sebastien Robert commented on HHH-2344:
---------------------------------------
Important to note that my collection is not extra lazy. That's the reason why in the
readElementByIndex, the read() method is called and the collection is initialized.
Persistent collection queued operation ignored with lazy inverse
one-to-many collection.
----------------------------------------------------------------------------------------
Key: HHH-2344
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2344
Project: Hibernate3
Type: Bug
Components: core
Versions: 3.2.1
Environment: Hibernate 3.2.1
Reporter: Sebastien Robert
I load an Object that contains a lazy inverse collection (one-to-many).
Hibernate wrap my collection with a PersistentMap
There is objects in the collection in the database but in my case the PersistentMap is
not yet initialized.
I perform a remove operation on the persistentMap with a known key of one of the
objects.
The map is not initialized (and the relation is an inverse one-to-many) so the map queue
the removeOperation.
I perform a get operation with the same key and the value is still returned.
If we look closer at what happened in the PersistentMap, it's look like this.
//*****
public Object remove(Object key) {
if ( isPutQueueEnabled() ) { // This returned true, the
// map
is not yet
//
initialized
Object old = readElementByIndex( key ); // This method triggered
// an
initialization of the
//
map.
//
Queued operation are
//
processed in the after
//
init method
queueOperation( new Remove( key, old ) ); // The remove operation
//
is queued.
return old;
}
....
//*******
When i perform the get operation on the map the map is now initialized. The get is
processed by the underlying map and the value is returned. The queued operation is
completely ignored.
Currently i fixed my code by performing a containsKey before the remove . The containsKey
initialize the map and then the remove do not queue the operation. But by looking at all
the PersistentCollection it seem that i may have the same problem using put and remove
with other persistentCollection.
--
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:01 p.m.
New subject: [Hibernate-JIRA] Commented: (HHH-2344) Persistent collection queued operation ignored with lazy inverse one-to-many collection.
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2344?page=c...
]
Niklas Therning commented on HHH-2344:
--------------------------------------
We're having the same problem in 3.2.0GA with put(). Our work around is to call size()
on the map before doing the put(). It used to work fine with 3.0.
Persistent collection queued operation ignored with lazy inverse
one-to-many collection.
----------------------------------------------------------------------------------------
Key: HHH-2344
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2344
Project: Hibernate3
Type: Bug
Components: core
Versions: 3.2.1
Environment: Hibernate 3.2.1
Reporter: Sebastien Robert
I load an Object that contains a lazy inverse collection (one-to-many).
Hibernate wrap my collection with a PersistentMap
There is objects in the collection in the database but in my case the PersistentMap is
not yet initialized.
I perform a remove operation on the persistentMap with a known key of one of the
objects.
The map is not initialized (and the relation is an inverse one-to-many) so the map queue
the removeOperation.
I perform a get operation with the same key and the value is still returned.
If we look closer at what happened in the PersistentMap, it's look like this.
//*****
public Object remove(Object key) {
if ( isPutQueueEnabled() ) { // This returned true, the
// map
is not yet
//
initialized
Object old = readElementByIndex( key ); // This method triggered
// an
initialization of the
//
map.
//
Queued operation are
//
processed in the after
//
init method
queueOperation( new Remove( key, old ) ); // The remove operation
//
is queued.
return old;
}
....
//*******
When i perform the get operation on the map the map is now initialized. The get is
processed by the underlying map and the value is returned. The queued operation is
completely ignored.
Currently i fixed my code by performing a containsKey before the remove . The containsKey
initialize the map and then the remove do not queue the operation. But by looking at all
the PersistentCollection it seem that i may have the same problem using put and remove
with other persistentCollection.
--
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:49 a.m.
New subject: [Hibernate-JIRA] Commented: (HHH-2344) Persistent collection queued operation ignored with lazy inverse one-to-many collection.
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2344?page=c...
]
Yajun Shi commented on HHH-2344:
--------------------------------
Please validate the following KB:
Title: Persistent collection queued operation ignored with lazy inverse one-to-many
collection
There is an known issue since Hibernate 3.2.0 that queued operations of a persistent
collection with a lazy inverse one-to-many relationship can be possibly ignored. For
example, a remove operation will be queued if it is performed on an uninitialized
persistentMap with an known key of one of the objects. A get operation with the same key
afterwards will trigger the initialization of the map but the queued operation is ignored
and the value is returned. The problem can occur as well when the put operation is
performed on a persistentCollection.
The workaround can be either call containsKey() or size() before the collection is
modified.
Persistent collection queued operation ignored with lazy inverse
one-to-many collection.
----------------------------------------------------------------------------------------
Key: HHH-2344
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2344
Project: Hibernate3
Issue Type: Bug
Components: core
Affects Versions: 3.2.1
Environment: Hibernate 3.2.1
Reporter: Sebastien Robert
I load an Object that contains a lazy inverse collection (one-to-many).
Hibernate wrap my collection with a PersistentMap
There is objects in the collection in the database but in my case the PersistentMap is
not yet initialized.
I perform a remove operation on the persistentMap with a known key of one of the
objects.
The map is not initialized (and the relation is an inverse one-to-many) so the map queue
the removeOperation.
I perform a get operation with the same key and the value is still returned.
If we look closer at what happened in the PersistentMap, it's look like this.
//*****
public Object remove(Object key) {
if ( isPutQueueEnabled() ) { // This returned true, the
// map
is not yet
//
initialized
Object old = readElementByIndex( key ); // This method triggered
// an
initialization of the
//
map.
//
Queued operation are
//
processed in the after
//
init method
queueOperation( new Remove( key, old ) ); // The remove operation
//
is queued.
return old;
}
....
//*******
When i perform the get operation on the map the map is now initialized. The get is
processed by the underlying map and the value is returned. The queued operation is
completely ignored.
Currently i fixed my code by performing a containsKey before the remove . The containsKey
initialize the map and then the remove do not queue the operation. But by looking at all
the PersistentCollection it seem that i may have the same problem using put and remove
with other persistentCollection.
--
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:27 p.m.
New subject: [Hibernate-JIRA] Commented: (HHH-2344) Persistent collection queued operation ignored with lazy inverse one-to-many collection.
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2344?page=c...
]
Yajun Shi commented on HHH-2344:
--------------------------------
Sorry, please ignore the above comment.
Persistent collection queued operation ignored with lazy inverse
one-to-many collection.
----------------------------------------------------------------------------------------
Key: HHH-2344
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2344
Project: Hibernate3
Issue Type: Bug
Components: core
Affects Versions: 3.2.1
Environment: Hibernate 3.2.1
Reporter: Sebastien Robert
I load an Object that contains a lazy inverse collection (one-to-many).
Hibernate wrap my collection with a PersistentMap
There is objects in the collection in the database but in my case the PersistentMap is
not yet initialized.
I perform a remove operation on the persistentMap with a known key of one of the
objects.
The map is not initialized (and the relation is an inverse one-to-many) so the map queue
the removeOperation.
I perform a get operation with the same key and the value is still returned.
If we look closer at what happened in the PersistentMap, it's look like this.
//*****
public Object remove(Object key) {
if ( isPutQueueEnabled() ) { // This returned true, the
// map
is not yet
//
initialized
Object old = readElementByIndex( key ); // This method triggered
// an
initialization of the
//
map.
//
Queued operation are
//
processed in the after
//
init method
queueOperation( new Remove( key, old ) ); // The remove operation
//
is queued.
return old;
}
....
//*******
When i perform the get operation on the map the map is now initialized. The get is
processed by the underlying map and the value is returned. The queued operation is
completely ignored.
Currently i fixed my code by performing a containsKey before the remove . The containsKey
initialize the map and then the remove do not queue the operation. But by looking at all
the PersistentCollection it seem that i may have the same problem using put and remove
with other persistentCollection.
--
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
10:33 p.m.
New subject: [Hibernate-JIRA] Commented: (HHH-2344) Persistent collection queued operation ignored with lazy inverse one-to-many collection.
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2344?page=c...
]
Gail Badner commented on HHH-2344:
----------------------------------
Please attach a runnable test case (Java + mapping).
Persistent collection queued operation ignored with lazy inverse
one-to-many collection.
----------------------------------------------------------------------------------------
Key: HHH-2344
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2344
Project: Hibernate3
Issue Type: Bug
Components: core
Affects Versions: 3.2.1
Environment: Hibernate 3.2.1
Reporter: Sebastien Robert
I load an Object that contains a lazy inverse collection (one-to-many).
Hibernate wrap my collection with a PersistentMap
There is objects in the collection in the database but in my case the PersistentMap is
not yet initialized.
I perform a remove operation on the persistentMap with a known key of one of the
objects.
The map is not initialized (and the relation is an inverse one-to-many) so the map queue
the removeOperation.
I perform a get operation with the same key and the value is still returned.
If we look closer at what happened in the PersistentMap, it's look like this.
//*****
public Object remove(Object key) {
if ( isPutQueueEnabled() ) { // This returned true, the
// map
is not yet
//
initialized
Object old = readElementByIndex( key ); // This method triggered
// an
initialization of the
//
map.
//
Queued operation are
//
processed in the after
//
init method
queueOperation( new Remove( key, old ) ); // The remove operation
//
is queued.
return old;
}
....
//*******
When i perform the get operation on the map the map is now initialized. The get is
processed by the underlying map and the value is returned. The queued operation is
completely ignored.
Currently i fixed my code by performing a containsKey before the remove . The containsKey
initialize the map and then the remove do not queue the operation. But by looking at all
the PersistentCollection it seem that i may have the same problem using put and remove
with other persistentCollection.
--
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
10:35 p.m.
New subject: [Hibernate-JIRA] Commented: (HHH-2344) Persistent collection queued operation ignored with lazy inverse one-to-many collection.
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2344?page=c...
]
Gail Badner commented on HHH-2344:
----------------------------------
Please attach a runnable test case (Java + mapping).
Persistent collection queued operation ignored with lazy inverse
one-to-many collection.
----------------------------------------------------------------------------------------
Key: HHH-2344
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2344
Project: Hibernate3
Issue Type: Bug
Components: core
Affects Versions: 3.2.1
Environment: Hibernate 3.2.1
Reporter: Sebastien Robert
I load an Object that contains a lazy inverse collection (one-to-many).
Hibernate wrap my collection with a PersistentMap
There is objects in the collection in the database but in my case the PersistentMap is
not yet initialized.
I perform a remove operation on the persistentMap with a known key of one of the
objects.
The map is not initialized (and the relation is an inverse one-to-many) so the map queue
the removeOperation.
I perform a get operation with the same key and the value is still returned.
If we look closer at what happened in the PersistentMap, it's look like this.
//*****
public Object remove(Object key) {
if ( isPutQueueEnabled() ) { // This returned true, the
// map
is not yet
//
initialized
Object old = readElementByIndex( key ); // This method triggered
// an
initialization of the
//
map.
//
Queued operation are
//
processed in the after
//
init method
queueOperation( new Remove( key, old ) ); // The remove operation
//
is queued.
return old;
}
....
//*******
When i perform the get operation on the map the map is now initialized. The get is
processed by the underlying map and the value is returned. The queued operation is
completely ignored.
Currently i fixed my code by performing a containsKey before the remove . The containsKey
initialize the map and then the remove do not queue the operation. But by looking at all
the PersistentCollection it seem that i may have the same problem using put and remove
with other persistentCollection.
--
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
9:22 a.m.
New subject: [Hibernate-JIRA] Commented: (HHH-2344) Persistent collection queued operation ignored with lazy inverse one-to-many collection.
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2344?page=c...
]
Pavel V. Shabalin commented on HHH-2344:
----------------------------------------
I have the same problem with put().
We use Hibernate 3.2.0GA, our workaround is also in call size() on the map.
Persistent collection queued operation ignored with lazy inverse
one-to-many collection.
----------------------------------------------------------------------------------------
Key: HHH-2344
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2344
Project: Hibernate Core
Issue Type: Bug
Components: core
Affects Versions: 3.2.1
Environment: Hibernate 3.2.1
Reporter: Sebastien Robert
I load an Object that contains a lazy inverse collection (one-to-many).
Hibernate wrap my collection with a PersistentMap
There is objects in the collection in the database but in my case the PersistentMap is
not yet initialized.
I perform a remove operation on the persistentMap with a known key of one of the
objects.
The map is not initialized (and the relation is an inverse one-to-many) so the map queue
the removeOperation.
I perform a get operation with the same key and the value is still returned.
If we look closer at what happened in the PersistentMap, it's look like this.
//*****
public Object remove(Object key) {
if ( isPutQueueEnabled() ) { // This returned true, the
// map
is not yet
//
initialized
Object old = readElementByIndex( key ); // This method triggered
// an
initialization of the
//
map.
//
Queued operation are
//
processed in the after
//
init method
queueOperation( new Remove( key, old ) ); // The remove operation
//
is queued.
return old;
}
....
//*******
When i perform the get operation on the map the map is now initialized. The get is
processed by the underlying map and the value is returned. The queued operation is
completely ignored.
Currently i fixed my code by performing a containsKey before the remove . The containsKey
initialize the map and then the remove do not queue the operation. But by looking at all
the PersistentCollection it seem that i may have the same problem using put and remove
with other persistentCollection.
--
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
10:39 p.m.
New subject: [Hibernate-JIRA] Commented: (HHH-2344) Persistent collection queued operation ignored with lazy inverse one-to-many collection.
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2344?page=c...
]
Sebastian Gooren commented on HHH-2344:
---------------------------------------
I have the same issue on Hibernate 3.2.6GA;
What seems to be happening is this:
- I call remove() on an uninitialized collection
- persistentMap.remove() calls readElementByIndex(), which loads the collection
- persistentMap.remove() then stores the remove action in the operations queue
- the queue is never executed?
This is a normal use-case for me, and I still don't get why I should be required to
call size() (or any other function which initializes the collection) to be able to delete
an item from a persistent collection.
Entities:
- Product:
@Entity
@Table( name = "products" )
public class Product
{
@OneToMany( mappedBy = "pk.product", fetch = FetchType.LAZY, cascade = {
CascadeType.ALL } )
@MapKey( name = "pk.locale" )
@OnDelete( action = OnDeleteAction.CASCADE )
@Cascade( { org.hibernate.annotations.CascadeType.DELETE_ORPHAN } )
@Fetch( FetchMode.SUBSELECT )
private Map<Locale, ProductI18n> localizations = new HashMap<Locale,
ProductI18n>();
public Map<Locale, ProductI18n> getLocalizations()
{
return localizations;
}
}
- ProductI18n:
@Entity
@Table( name = "products_i18n" )
public class ProductI18n
{
@EmbeddedId
private Pkey pk = new Pkey();
private String name;
@Lob
private String description;
protected ProductI18n()
{
}
public ProductI18n( final Product product, final Locale locale )
{
this.pk.product = product;
this.pk.locale = locale;
}
public String getName()
{
return name;
}
public void setName( String name )
{
this.name = name;
}
public String getDescription()
{
return description;
}
public void setDescription( String description )
{
this.description = description;
}
public Product getProduct()
{
return pk.product;
}
public Locale getLocale()
{
return pk.locale;
}
@Embeddable
private static class Pkey implements Serializable
{
@Transient
private static final long serialVersionUID = 1L;
@ManyToOne( optional = false )
@JoinColumn( name = "productid" )
@NotNull
private Product product;
@NotNull
private Locale locale;
@Override
public boolean equals( Object obj )
{
if (obj instanceof Pkey)
{
Pkey other = (Pkey) obj;
return other.product.equals( product ) && other.locale.equals( locale );
}
return false;
}
@Override
public int hashCode()
{
return super.hashCode();
}
}
}
Code:
class Testcase
{
public void setup()
{
Session session = ...
Product p = new Product();
List<ProductI18n> localizations = p.getLocalizations();
ProductI18n en_US = new ProductI18n( p, new Locale("en", "US") );
en_US.setName( "product 1" );
en_US.setDescription( "This is product1" );
localizations.put( en_US.getLocale(), en_US );
ProductI18n nl_NL = new ProductI18n( p, new Locale("nl", "NL") );
nl_NL.setName( "product 1" );
nl_NL.setDescription( "Dit is product 1" );
localizations.put( nl_NL.getLocale(), nl_NL );
session.persist( p );
session.flush();
}
public void test()
{
Session session = ...;
List<Product> products = session.createQuery( "from Product" ).list();
for( Product p : products )
{
p.getLocalizations().remove( new Locale( "nl", "NL" ) );
session.persist( p );
session.flush();
// getLocalizations().size() is still 2, both locally and in the database
}
}
}
Persistent collection queued operation ignored with lazy inverse
one-to-many collection.
----------------------------------------------------------------------------------------
Key: HHH-2344
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2344
Project: Hibernate Core
Issue Type: Bug
Components: core
Affects Versions: 3.2.1
Environment: Hibernate 3.2.1
Reporter: Sebastien Robert
I load an Object that contains a lazy inverse collection (one-to-many).
Hibernate wrap my collection with a PersistentMap
There is objects in the collection in the database but in my case the PersistentMap is
not yet initialized.
I perform a remove operation on the persistentMap with a known key of one of the
objects.
The map is not initialized (and the relation is an inverse one-to-many) so the map queue
the removeOperation.
I perform a get operation with the same key and the value is still returned.
If we look closer at what happened in the PersistentMap, it's look like this.
//*****
public Object remove(Object key) {
if ( isPutQueueEnabled() ) { // This returned true, the
// map
is not yet
//
initialized
Object old = readElementByIndex( key ); // This method triggered
// an
initialization of the
//
map.
//
Queued operation are
//
processed in the after
//
init method
queueOperation( new Remove( key, old ) ); // The remove operation
//
is queued.
return old;
}
....
//*******
When i perform the get operation on the map the map is now initialized. The get is
processed by the underlying map and the value is returned. The queued operation is
completely ignored.
Currently i fixed my code by performing a containsKey before the remove . The containsKey
initialize the map and then the remove do not queue the operation. But by looking at all
the PersistentCollection it seem that i may have the same problem using put and remove
with other persistentCollection.
--
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:25 p.m.
New subject: [Hibernate-JIRA] Commented: (HHH-2344) Persistent collection queued operation ignored with lazy inverse one-to-many collection.
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2344?page=c...
]
cleverpig commented on HHH-2344:
--------------------------------
I use hibernate3.3.1.GA.jar,and met the same problem.
Lazy setting is a big problem,I met this as you yesterday.
if you change lazy to true,you can really delete orphan objects.
or another solution,when setting lazy=false,after open session,call Hibernate.initialize()
to manually load associations,and then remove them from the list.
with these tow way,maybe you can work out. I think it seem like a Hibernate's bug.
Persistent collection queued operation ignored with lazy inverse
one-to-many collection.
----------------------------------------------------------------------------------------
Key: HHH-2344
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2344
Project: Hibernate Core
Issue Type: Bug
Components: core
Affects Versions: 3.2.1
Environment: Hibernate 3.2.1
Reporter: Sebastien Robert
I load an Object that contains a lazy inverse collection (one-to-many).
Hibernate wrap my collection with a PersistentMap
There is objects in the collection in the database but in my case the PersistentMap is
not yet initialized.
I perform a remove operation on the persistentMap with a known key of one of the
objects.
The map is not initialized (and the relation is an inverse one-to-many) so the map queue
the removeOperation.
I perform a get operation with the same key and the value is still returned.
If we look closer at what happened in the PersistentMap, it's look like this.
//*****
public Object remove(Object key) {
if ( isPutQueueEnabled() ) { // This returned true, the
// map
is not yet
//
initialized
Object old = readElementByIndex( key ); // This method triggered
// an
initialization of the
//
map.
//
Queued operation are
//
processed in the after
//
init method
queueOperation( new Remove( key, old ) ); // The remove operation
//
is queued.
return old;
}
....
//*******
When i perform the get operation on the map the map is now initialized. The get is
processed by the underlying map and the value is returned. The queued operation is
completely ignored.
Currently i fixed my code by performing a containsKey before the remove . The containsKey
initialize the map and then the remove do not queue the operation. But by looking at all
the PersistentCollection it seem that i may have the same problem using put and remove
with other persistentCollection.
--
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:27 p.m.
New subject: [Hibernate-JIRA] Commented: (HHH-2344) Persistent collection queued operation ignored with lazy inverse one-to-many collection.
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2344?page=c...
]
cleverpig commented on HHH-2344:
--------------------------------
Sebastian Gooren had gave testcase,but there's still no response from dev managers.
which version fixed it,please?
Persistent collection queued operation ignored with lazy inverse
one-to-many collection.
----------------------------------------------------------------------------------------
Key: HHH-2344
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2344
Project: Hibernate Core
Issue Type: Bug
Components: core
Affects Versions: 3.2.1
Environment: Hibernate 3.2.1
Reporter: Sebastien Robert
I load an Object that contains a lazy inverse collection (one-to-many).
Hibernate wrap my collection with a PersistentMap
There is objects in the collection in the database but in my case the PersistentMap is
not yet initialized.
I perform a remove operation on the persistentMap with a known key of one of the
objects.
The map is not initialized (and the relation is an inverse one-to-many) so the map queue
the removeOperation.
I perform a get operation with the same key and the value is still returned.
If we look closer at what happened in the PersistentMap, it's look like this.
//*****
public Object remove(Object key) {
if ( isPutQueueEnabled() ) { // This returned true, the
// map
is not yet
//
initialized
Object old = readElementByIndex( key ); // This method triggered
// an
initialization of the
//
map.
//
Queued operation are
//
processed in the after
//
init method
queueOperation( new Remove( key, old ) ); // The remove operation
//
is queued.
return old;
}
....
//*******
When i perform the get operation on the map the map is now initialized. The get is
processed by the underlying map and the value is returned. The queued operation is
completely ignored.
Currently i fixed my code by performing a containsKey before the remove . The containsKey
initialize the map and then the remove do not queue the operation. But by looking at all
the PersistentCollection it seem that i may have the same problem using put and remove
with other persistentCollection.
--
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
4993
days inactive
6321
days old
hibernate-issues@lists.jboss.org
10 comments
7 participants
participants (7)
-
cleverpig (JIRA) -
Gail Badner (JIRA)
-
Niklas Therning (JIRA)
-
Pavel V. Shabalin (JIRA)
-
Sebastian Gooren (JIRA)
-
Sebastien Robert (JIRA)
-
Yajun Shi (JIRA)