Multiple calls to storer.store(...)

[sare3th]

Hi all, @hg-ms

According to
its possible to do more than one store() with Storer

the output of the following simple example would be that only "name" and "id" would be stored. "version" will be null
can someone explain what I am doing wrong?
Thanks!

public class Main {
    public static void main(String[] args) {
        try (StorageManager storageManager = initStorage()) {
            TopologyRoot root = new TopologyRoot();
            storageManager.setRoot(root);
            storageManager.storeRoot();

            Storer storer = storageManager.createStorer();

            Device device = new Device();
            device.setId(1);
            device.setName("device");

            root.getDevices().add(device);
            storer.store(root.getDevices()); //first store

            Device deviceToUpdate = root.getDevices().get(0);
            deviceToUpdate.setVersion("123");
            storer.store(deviceToUpdate); //second store (will be ignored)

            storer.commit();
        }
    }

    @Data
    public static class Device {
        private Integer id;
        private String name;
        private String version;
    }

    @Data
    public static class TopologyRoot {
        private List<Device> devices = new ArrayList<>();
    }

    private static StorageManager initStorage() {
        var foundation = EmbeddedStorageConfiguration.Builder()
                .setStorageDirectory("topology")
                .setChannelCount(1)
                .createEmbeddedStorageFoundation();
        var storageManager = foundation.createEmbeddedStorageManager();
        storageManager.start();
        return storageManager;
    }
}

microstream version is 08.01.01-MS-GA

[hg-ms]

Hello,
The described behavior is intended.
In your example the first store of the devices will also store the new device object with version being null. The second store will recognize that the device objects has been processed already by the first store and ignore it.
In general, storer only process objects the first time they are encountered. Calling “commit” resets the storer after peristsing the data.

To update the object, you have two options:

1. Call “commit” after the first store.
2. Do the store after the last modification of the Device object.

In the example code there is also another thing to be aware of:
When setting the storage root at the beginning any existing root will be replaced with a new and empty TopologyRoot object. To avoid that you can check if there is a root already set by simple null check:

TopologyRoot root;
if(storageManager.root() == null) {
	root = new TopologyRoot();
	storageManager.setRoot(root);
	storageManager.storeRoot();
} else {
	root = (TopologyRoot) storageManager.root();
}

[sare3th]

Thanks for the answer!
could you please explain what do you mean by "You can do more than one ’store()’." in the topic about XA transactions?
I understand that I can commit after every store, but that means I will have multiple transactions and I'm trying to do multiple writes as a single transaction.

[guykatz]

@hg-ms I was wondering also:
when calling storer.store(some object), does microstream mark that object along with that object's graph, such that modifying that object and its children, AFTER the store was called but BEFORE commiting, are ignored until commit is called after which I am free again to make changes?
can you please shed some light on the inner workings? its hard from get a good grasp from the docs on this topic (it has a section but hard to undertsand the details)
thanks!

[hg-ms]

Here is a more detailed description how the storers work:

The persisting process is divided into two phases:

1. Store: collect and serialize all data to be persisted.
   The store method can be called multiple times to add different objects.
2. Commit: persist (write) the collected binary data to the storage target,
   resets the storer afterwards.
   The convenient API “PersistenceManager.store(Object)” does both steps in one call.
   Calling the ‘clear’ method (before commit) aborts the store. The storer clears all collected data by resetting the storer to its initial, empty state. This is done after commit automatically.

The store methods start by checking if the passed object has been processed by the storer already. If so, it will be ignored. If the object was not processed yet it will be processed.

If referenced objects are processed depends on the storer implementation (Lazy or Eager):
An eager storer will processes referenced objects if they have not been processed by the current storer in the current cycle yet.
A lazy storer will, additionally, not processes referenced objects if they are already persisted.
Regardless of the storer type an object will be processed only the first time it is encountered. This applies to subsequent store calls too until either a commit() or clear() is done.
One reason why we do that is to break up circular references.

To answer your question:
An object is always persisted in the first state it is encountered during (subsequent) the store calls. After a commit() or clear() you can change it again.

[guykatz]

@hg-ms thanks a lot for the clarification...