db4o update behavior is regulated by Update Depth. Understanding update depth will help you to improve performance and avoid unnecessary memory usage. A common pitfall is that the update-depth is to small and that the objects are not updated. In such cases you either need to explicitly store the related objects individually or increase the update-depth.
For example in this code we add a new friend and store the object. Since a collection is also handled like a regular object, it is affected by the update-depth. In this example we only store the person-object, but not the friend-collection-object. Therefore with the default-update depth of one the update isn't store. In order to update this properly, you either need to set the update depth to two or store the friend-list explicitly.
ObjectContainer container = Db4oEmbedded.openFile(DATABASE_FILE); try { Person jodie = queryForJodie(container); jodie.add(new Person("Jamie")); // Remember that a collection is also a regular object // so with the default-update depth of one, only the changes // on the person-object are stored, but not the changes on // the friend-list. container.store(jodie); } finally { container.close(); } container = Db4oEmbedded.openFile(DATABASE_FILE); try { Person jodie = queryForJodie(container); for (Person person : jodie.getFriends()) { // the added friend is gone, because the update-depth is to low System.out.println("Friend="+person.getName()); } } finally { container.close(); }
So for this example setting the update-depth to two will fix the issue. For lots of operation a update-depth of two is pretty reasonable. This allows you to update collections without storing them explicitly.
EmbeddedConfiguration config = Db4oEmbedded.newConfiguration(); config.common().updateDepth(2); ObjectContainer container = Db4oEmbedded.openFile(config,DATABASE_FILE);
When the update depth is set to a big value on objects with a deep reference hierarchy it will cause each update on the top-level object to trigger updates on the lower-level objects, which can impose a huge performance penalty.
Try transparent persistence, which removes the issue of the update-depth completly.