{"id":840,"date":"2009-12-02T21:00:46","date_gmt":"2009-12-02T20:00:46","guid":{"rendered":"http:\/\/www.gamlor.info\/wordpress\/?p=840"},"modified":"2021-03-11T09:44:57","modified_gmt":"2021-03-11T08:44:57","slug":"db4o-transparent-persistence","status":"publish","type":"post","link":"https:\/\/www.gamlor.info\/wordpress\/2009\/12\/db4o-transparent-persistence\/","title":{"rendered":"db4o: Transparent-Persistence"},"content":{"rendered":"

It has been a while since I\u2019ve wrote my last post about db4o. You may remember the post about the activation-mechanism<\/a>. Don\u2019t you think that this is quite painful? Activating objects with the right activation depth and so forth? Wouldn\u2019t it be nice if db4o actually activates the objects as soon as you need then? Well db4o can do that, it\u2019s called Transparent-Activation<\/a>.<\/p>\n

(All posts of this series: the basics<\/a>, activation<\/a>, object-identity<\/a>, transactions<\/a>, persistent classes<\/a>, single container concurrency<\/a>, Queries in Java, C# 2.0<\/a>, client-server concurrency<\/a>, transparent persistence<\/a>, adhoc query tools<\/a>)<\/p>\n

\"activation<\/a>

activation pain<\/p><\/div>\n

Prepare The Persistent Classes<\/h3>\n

We don\u2019t want to activate the object manually all over our codebase. Therefore a object has to activate it self. To achieve this, the class needs to implement the IActivatable-Interface. For example:<\/p>\n

internal<\/span> class<\/span> Person : IActivatable\r\n{\r\n    private<\/span> string<\/span> _firstname;\r\n    private<\/span> Person _parent;\r\n\r\n    [Transient] private<\/span> IActivator _activator;\r\n\r\n    public<\/span> string<\/span> Firstname\r\n    {\r\n        get\r\n        {\r\n            Activate(ActivationPurpose.Read);\r\n            return<\/span> _firstname;\r\n        }\r\n        set { _firstname = value<\/span>; }\r\n    }\r\n\r\n   \/** Other properties like above.<\/span>\r\n     Every time you read a field you need to call <\/span>\r\n     Activate(ActivationPurpose.Read); first *\/<\/span>\r\n\r\n    public<\/span> void<\/span> Bind(IActivator activator)\r\n    {\r\n        if<\/span> (_activator == activator)\r\n            return<\/span>;\r\n        if<\/span> (activator != null<\/span> && _activator != null<\/span>)\r\n            throw<\/span> new<\/span> InvalidOperationException(\"cannot rebind with another activator\"<\/span>);\r\n        _activator = activator;\r\n    }\r\n\r\n    public<\/span> void<\/span> Activate(ActivationPurpose purpose)\r\n    {\r\n        if<\/span> (null<\/span> != _activator)\r\n            _activator.Activate(purpose);\r\n    }\r\n}<\/pre>\n
Now db4o calls the Bind()-method for each object. As soon as a property is read the Activate-method is called. The activator now is responsible for reading the data from the database and set the fields.<\/p>\n
It\u2019s extremely important that the implementation ensures that the activator is called before any field is accessed. Notice also that the \u2018_activator\u2019-field is marked as transient. It quite useless to store the activator.<\/p>\n
First Test Run<\/h3>\n
The first test-run is easy. We create a deep object-graph. Then we access it and check if we get the expected data. For example:<\/p>\n
using<\/span> (var db = OpenDB(FilePath))\r\n{\r\n    var me = (from Person p in<\/span> db\r\n              where<\/span> p.Firstname.Equals(\"Roman\"<\/span>)\r\n              select p).Single();\r\n    var adam = me.Father.Father.Father.Father.Father.Father.Father;\r\n    AssertEqual(\"Adam\"<\/span>, adam.Firstname);\r\n}<\/pre>\n
When you just run the code it will throw a NullReferenceException. Because first\u00a0you\u00a0need to activate the support for Transparent Activation. To do this, add the Transparent Activation support in the configuration:<\/p>\n
var cfg = Db4oEmbedded.NewConfiguration();\r\ncfg.Common.Add(new<\/span> TransparentActivationSupport());\r\nvar db = Db4oEmbedded.OpenFile(cfg, path);\u00a0<\/pre>\n
After adding the configuration-piece it works wonderful. No more activation-depth tweaking, no more NullReferenceException due to not activated objects.\u00a0<\/p>\n
\"transparent<\/a>
transparent activation at work<\/p><\/div>\n
No Way! I\u2019m Not Writing All This Boiler Plate Code<\/h3>\n
As you see above, writing Transparent Activation aware classes by hand is quite painful. All this boiler plate code\u00a0distracts from the important stuff and introduces potential bugs. That\u2019s why there\u2019s a byte-code enhancer tool which adds this behavior for you.<\/p>\n
There are two ways to achieve this: First there\u2019s command-line tool which you can use manually or call from your build-script. Additionally there\u2019s an MSBuild task. I use the MSBuild task here, since most people use Visual Studio anyway.<\/p>\n
So it\u2019s quite easy, you add an additional-task to your project-file. First you refer to the db4oTool.MSBuild-assembly. It\u2019s up to you where to put it. In my projects its in the lib-directory of the project. The you specify what to want to enhance, done. Note the additional \u2018debug\u2019-flag. This also updates the debug-information to allow you to step through your code.<\/p>\n
  <<\/span>UsingTask<\/span> AssemblyFile<\/span>=\".\\lib\\db4o\\Db4oTool.MSBuild.dll\"<\/span> TaskName<\/span>=\"Db4oTool.MSBuild.Db4oEnhancerMSBuildTask\"<\/span> \/><\/span>\r\n  <<\/span>ItemGroup<\/span>><\/span>\r\n    <<\/span>Db4oEnhance<\/span> Include<\/span>=\"$(TargetPath)\"<\/span> \/><\/span>\r\n  <\/<\/span>ItemGroup<\/span>><\/span>\r\n  <<\/span>Target<\/span> Name<\/span>=\"AfterBuild\"<\/span>><\/span>\r\n    <<\/span>Db4oEnhancerMSBuildTask<\/span> Assemblies<\/span>=\"@(Db4oEnhance)\"<\/span> CommandLine<\/span>=\"-debug\"<\/span>\/><\/span>\r\n  <\/<\/span>Target<\/span>><\/span><\/pre>\n
Normally you create a separate assembly which contains only the persisted classes. Therefore you add this build-step only to the persisted-classes-project.<\/p>\n
You can also mark the classes by an attribute and tell the enhancer-task to updated only the marked classes. For example:<\/p>\n
[AttributeUsage(AttributeTargets.Class,AllowMultiple = false<\/span>,Inherited = true<\/span>)]\r\ninternal<\/span> class<\/span> PersistedAttribute : Attribute\r\n{\r\n}<\/pre>\n
And then:<\/p>\n
<Db4oEnhancerMSBuildTask Assemblies=\"@(Db4oEnhance)\"<\/span> CommandLine=\"-by-attribute:Db4OSeries.PersistedAttribute\"<\/span>\/><\/pre>\n
\u00a0\r\n\r\n
\"bytecode<\/a>
bytecode enhancer<\/p><\/div><\/pre>\n
Collections<\/h3>\n
You probably use collections in your persisted class like a list or a map. Since you cannot change the code of the official .NET-collections, you need to use the db4o Transparent Activation aware implementations of collections. For example:<\/p>\n
[Persisted]\r\ninternal<\/span> class<\/span> Person\r\n{\r\n    private<\/span> readonly<\/span> IList<Person> knowsPeople = new<\/span> ArrayList4<Person>();\r\n\r\n    public<\/span> IEnumerable<Person> KnowsPeople\r\n    {\r\n        get { return<\/span> knowsPeople; }\r\n    }\r\n\r\n    public<\/span> void<\/span> GetToKnow(Person person)\r\n    {\r\n        knowsPeople.Add(person);\r\n    }\r\n}<\/pre>\n
\"db4o-collections\"<\/a>\u00a0<\/pre>\n
Mix IActivatable With Non-Activatable<\/h3>\n
What happens when you mix and match IActivatable-classes with normal classes? Let\u2019s do a little experiment:<\/p>\n
internal<\/span> class<\/span> Pet\r\n{\r\n    public<\/span> Pet(Pet otherPet)\r\n    {\r\n        OtherPet = otherPet;\r\n        Name = otherPet.Name + \"\u2019s-child\"<\/span>;\r\n    } \r\n\r\n    public<\/span> Pet(string<\/span> name)\r\n    {\r\n        Name = name;\r\n    } \r\n\r\n    public<\/span> string<\/span> Name { get; set; }\r\n    public<\/span> Pet OtherPet { get; set; }\r\n}<\/pre>\n
Extend the Person class above with:<\/p>\n
        public<\/span> Pet Pet\r\n        {\r\n            get\r\n            {\r\n                Activate(ActivationPurpose.Read);\r\n                return<\/span> _pet;\r\n            }\r\n            set { _pet = value<\/span>; }\r\n        }<\/pre>\n
\u00a0<\/pre>\n
And access the a deep pet-object-graph:<\/pre>\n
\u00a0<\/pre>\n
         var me = (from Person p in<\/span> db\r\n               where<\/span> p.Firstname.Equals(\"Roman\"<\/span>)\r\n               select p).Single();\r\n         var adam = me.Father.Father.Father.Father.Father.Father.Father;\r\n         var pet = me.Pet.OtherPet.OtherPet.OtherPet.OtherPet.OtherPet.OtherPet.OtherPet.OtherPet;\r\n         AssertEqual(\"Adam\"<\/span>, adam.Firstname);\r\n         AssertEqual(\"Fun\"<\/span>, pet.Name);<\/pre>\n
\u00a0<\/pre>\n
This work\u2019s absolutely fine. The objects which are not activatable are just eagerly activated. For example: Some pure, simple Value-Object don\u2019t need to be lazy loaded from the database. It\u2019s just a small object and represents the end of the object-graph anyway.<\/p>\n
\"mix<\/a>
mix transparent activation with normal objects<\/p><\/div>\n
Hybrid Approach<\/h3>\n
Now we\u2019ve seen what Transparent Activation is. It\u2019s really useful. But what if you want to stay in control and therefore avoid the bytecode-enhancer? Making every persisted class IActivateable by hand is just extremely painful.<\/p>\n
Based on the the observation above you could use a hybrid approach: Most of the classes do not implement IActivatable. But you use the Transparent Activation aware collections of db4o. Then you have already a quite useful construct: Everything is eager activated excluding the collections. Additionally you could\u00a0introduce a \u2018TransparentActivated\u2019-class. This class just represents a reference which is lazy loaded. So only\u00a0‘special’ references\u00a0and the collections are transparently activated. The rest of the object graph is just loaded normally.<\/p>\n
Take a looks at this small example (<<TA>> = Transparent Persistance used in this association):<\/p>\n
\u00a0\"TA-Hybrid\"<\/a><\/p>\n
So we could implement is like this:<\/p>\n
internal<\/span> class<\/span> Person\r\n{\r\n    private<\/span> Gender _gender;\r\n    private<\/span> IList<Address> _addresses = new<\/span> ArrayList4<Address>();\r\n    private<\/span> readonly<\/span> TransparentActivated<House> _house = new<\/span> TransparentActivated<House>();\r\n\r\n    public<\/span> IEnumerable<Address> Addresses\r\n    {\r\n        get { return<\/span> _addresses; }\r\n    }\r\n\r\n    public<\/span> void<\/span> Add(Address item)\r\n    {\r\n        _addresses.Add(item);\r\n    }\r\n\r\n    public<\/span> House House\r\n    {\r\n        get { return<\/span> _house.Value; }\r\n        set { _house.Value = value<\/span>; }\r\n    }\r\n\r\n    public<\/span> Gender Gender\r\n    {\r\n        get { return<\/span> _gender; }\r\n        set { _gender = value<\/span>; }\r\n    }\r\n}<\/pre>\n
\/\/\/ <summary><\/span>\r\n\/\/\/ Use this class to interrupt the eager loading of the database data into memory:<\/span>\r\n\/\/\/ this class represents a reference to <see cref=\"T\"\/>, whereas <see cref=\"T\"\/> is<\/span>\r\n\/\/\/ lazy activated as soon as <see cref=\"Value\"\/> is used<\/span>\r\n\/\/\/ <\/summary><\/span>\r\n\/\/\/ <typeparam name=\"T\"><\/typeparam><\/span>\r\ninternal<\/span> class<\/span> TransparentActivated<T>\r\n{\r\n    private<\/span> T _instance;\r\n    [Transient]\r\n    private<\/span> IActivator _activator;\r\n\r\n    public<\/span> T Value\r\n    {\r\n        get\r\n        {\r\n            Activate(ActivationPurpose.Read);\r\n            return<\/span> _instance;\r\n        }\r\n        set { _instance = value<\/span>; }\r\n    }\r\n    public<\/span> void<\/span> Bind(IActivator activator)\r\n    {\r\n        if<\/span> (_activator == activator)\r\n            return<\/span>;\r\n        if<\/span> (activator != null<\/span> && _activator != null<\/span>)\r\n            throw<\/span> new<\/span> InvalidOperationException(\"cannot rebind with another activator\"<\/span>);\r\n        _activator = activator;\r\n    }\r\n\r\n    public<\/span> void<\/span> Activate(ActivationPurpose purpose)\r\n    {\r\n        if<\/span> (null<\/span> != _activator)\r\n            _activator.Activate(purpose);\r\n    }\r\n}<\/pre>\n
\u00a0<\/pre>\n
However, this\u00a0 has a huge drawback: Now the \u2018_house\u2019-field has additional indirection. Therefore the object-graph is even deeper which isn\u2019t free. Especially queries are more complex since more objects are involved.<\/p>\n
Anyway this hybrid approach isn\u2019t the indented use case for Transparent Activation. But it\u2019s a little demonstration that you can use Transparent Activation also very selective.<\/p>\n
Transparent Persistence<\/h3>\n
There we are, we have a\u00a0nice solution to lazy load the object from the database as we need then. For this we make the persisted classes database aware. But wait! Why don\u2019t the persisted objects also manage changes? A object could notice when a property changes and store the changes to the database. That\u2019s exactly what Transparent Persistence does.<\/p>\n
First we need to extend also the setter, like this:<\/p>\n
public<\/span> string<\/span> Firstname\r\n{\r\n    get\r\n    {\r\n        Activate(ActivationPurpose.Read);\r\n        return<\/span> _firstname;\r\n    }\r\n    set\r\n    {\r\n        Activate(ActivationPurpose.Write);\r\n        _firstname = value<\/span>;\r\n    }\r\n}<\/pre>\n
\u00a0<\/p>\n
As said, it\u2019s way smarter to the do this with the bytecode-enhancer. Guess what, the byte-code-enhancer already does this. So you don\u2019t have to change a thing. Just use the MSBuild-Task like above =).<\/p>\n
Furthermore you have to change the configuration. Instead of the TransparentActivationSupport you add the TransparentPersistenceSupport:<\/p>\n
cfg.Common.Add(new<\/span> TransparentPersistenceSupport());<\/pre>\n
Now your ready for the easiest way to persist your objects. You have to store a object only once. From now on db4o knows that the object is persisted. The object stores all changes by itself. You get the objects from the database, manipulate the objects as you wish. As soon as you call commit, the changes are persisted. Isn\u2019t this wonderful =) An small example:<\/p>\n
using<\/span> (var db = OpenDB(FilePath))\r\n{\r\n    var pers = new<\/span> Person();\r\n    pers.Add(new<\/span> Address(\"Main.Street\"<\/span>, \"A City\"<\/span>));\r\n    pers.House = new<\/span> House { Name = \"My House\"<\/span> };\r\n    pers.Gender = Gender.Female;\r\n\r\n    \/\/ initial store<\/span>\r\n    db.Store(pers);\r\n}\r\nusing<\/span> (var db = OpenDBWithTA(FilePath))\r\n{\r\n    var me = LoadPerson(db);\r\n    \/\/ some changes, note, NO STORE<\/span>\r\n    me.Add(new<\/span> Address(\"Holiday-House\"<\/span>, \"Other City\"<\/span>));\r\n    me.Gender=Gender.Male;\r\n    me.House.Name = \"BiggerHouse\"<\/span>;\r\n}\r\nusing<\/span> (var db = OpenDBWithTA(FilePath))\r\n{\r\n    var me = LoadPerson(db);\r\n    \/\/ everything is stored =)<\/span>\r\n    AssertTrue(me.Addresses.Count() == 2);\r\n    AssertTrue(me.Gender == Gender.Male);\r\n    AssertTrue(me.House.Name == \"BiggerHouse\"<\/span>);\r\n}\u00a0<\/pre>\n
\"transparent<\/a>
transparent persistance<\/p><\/div>\n
Conclusion<\/h3>\n
Transparent Activation and Persistence are a powerful mechanisms which save you a lot of work. Use it wisely. =)<\/p>\n
The example-project with transparent persistance: TransparentPersistance.zip<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
It has been a while since I\u2019ve wrote my last post about db4o. You may remember the post about the activation-mechanism. Don\u2019t you think that this is quite painful? Activating… <\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":"","_links_to":"","_links_to_target":""},"categories":[150],"tags":[21,100],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/www.gamlor.info\/wordpress\/wp-json\/wp\/v2\/posts\/840"}],"collection":[{"href":"https:\/\/www.gamlor.info\/wordpress\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.gamlor.info\/wordpress\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.gamlor.info\/wordpress\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.gamlor.info\/wordpress\/wp-json\/wp\/v2\/comments?post=840"}],"version-history":[{"count":19,"href":"https:\/\/www.gamlor.info\/wordpress\/wp-json\/wp\/v2\/posts\/840\/revisions"}],"predecessor-version":[{"id":3823,"href":"https:\/\/www.gamlor.info\/wordpress\/wp-json\/wp\/v2\/posts\/840\/revisions\/3823"}],"wp:attachment":[{"href":"https:\/\/www.gamlor.info\/wordpress\/wp-json\/wp\/v2\/media?parent=840"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.gamlor.info\/wordpress\/wp-json\/wp\/v2\/categories?post=840"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.gamlor.info\/wordpress\/wp-json\/wp\/v2\/tags?post=840"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}