{"id":671,"date":"2009-10-01T22:30:54","date_gmt":"2009-10-01T21:30:54","guid":{"rendered":"http:\/\/www.gamlor.info\/wordpress\/?p=671"},"modified":"2021-03-11T09:44:58","modified_gmt":"2021-03-11T08:44:58","slug":"db4o-transactions","status":"publish","type":"post","link":"https:\/\/www.gamlor.info\/wordpress\/2009\/10\/db4o-transactions\/","title":{"rendered":"db4o: Transactions"},"content":{"rendered":"

So I showed the basics<\/a>, explained the activation-system<\/a> and pointed out how db4o manages object-identities<\/a>. So far so good, but I\u2019ve never explain a very important\u00a0feature of most databases, the transactions. Time to catch up.<\/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

Transactions<\/h3>\n

Actually we never used transaction so far, right? So it’s like auto commit? Lets try it out. First we run a little application which stores a object. After that the application goes into an endless loop. What do you do with application which hangs like this? Right, kill that bastard. So we kill our application with the Task-Manager or the Visual-Studio-Debugger.<\/p>\n

File.Delete(\"database.db4o\"<\/span>);\r\nusing<\/span> (var db = StartDataBase())\r\n{\r\n    db.Store(new<\/span> SimpleObject(\"A New Object\"<\/span>));\r\n    while<\/span> (true<\/span>)\r\n    {\r\n        Console.Out.WriteLine(\"Demo: Kill this process now!! (Yay, Ctrl Alt Delete\"<\/span>);\r\n        Console.Read();\r\n    }\r\n}<\/pre>\n
So our demo-application was terminated abnormally. So let\u2019s check what is in our database.<\/p>\n
using<\/span> (var db = StartDataBase())\r\n{\r\n    var objects = (from SimpleObject o in<\/span> db select o);\r\n    AssertEquals(1, objects.Count());\r\n}<\/pre>\n
Surprise, surprise, the test fails. Nothing is in the database. The reason is simple. Db4o automatically creates a transaction for you. As soon as you open the object-container a transaction is started. This transaction has the ACID-properties (Wikipedia<\/a>, db4o<\/a>) like other databases.<\/p>\n
\"db4o<\/a>
db4o transactions<\/p><\/div>\n
Controlling The Transaction<\/h3>\n
Well it\u2019s wonderful that db4o creates the transaction by default. But it would be pretty useless if you cannot control it. Of course you can do that. The IObjectContainer interface has two methods for this: Commit()- and Rollback(). When you call those, the transaction is committed or rolled back and a new transaction is started immediately . For example:<\/p>\n
File.Delete(\"database.db4o\"<\/span>);\r\nvar db = StartDataBase();\r\ntry<\/span>\r\n{\r\n    db.Store(new<\/span> SimpleObject(\"Expect-To-Be-Committed\"<\/span>));\r\n    db.Commit();\r\n    db.Store(new<\/span> SimpleObject(\"Expect-To-Be-Not-Committed\"<\/span>));\r\n    throw<\/span> new<\/span> SomethingWentWrongException();\r\n} catch<\/span>(SomethingWentWrongException)\r\n{\r\n    db.Rollback();\r\n} finally<\/span>\r\n{\r\n    db.Dispose();\r\n}\r\nusing<\/span> (var checkDB = StartDataBase())\r\n{\r\n    var exists = (from SimpleObject o in<\/span> checkDB\r\n                  where<\/span> o.Content.Equals(\"Expect-To-Be-Committed\"<\/span>)\r\n                  select o);\r\n    AssertEquals(1, exists.Count());\r\n    var wasNotCommited = (from SimpleObject o in<\/span> checkDB\r\n                          where<\/span> o.Content.Equals(\"Expect-To-Be-Not-Committed\"<\/span>)\r\n                  select o);\r\n    AssertEquals(0, wasNotCommited.Count());\r\n}<\/pre>\n
So this works fine. By the way, the Close()- and Dispose()-methods call Commit() implicitly, so with the C# using-statement you commit automatically.<\/p>\n
\"db4o-commit\"<\/a><\/p>\n
\"db4o-rollback\"<\/a><\/p>\n
Personally I use a wrapper around the transaction handling. It takes a closure which contains the db-operations and ensures that everything runs through or everything is rolled back:<\/p>\n
dataBase.InTransaction(\r\n    tx=>{\r\n        db.Store(new<\/span> DemoObject());\r\n    });<\/pre>\n
Don\u2019t Let Your Objects Fall Behind<\/h3>\n
Now to a really nasty detail of the db4o-transaction-handling. We retrieve a object and change a property. Then we update this object in the database with Store(). After that we rollback the transaction. The demo-code:<\/p>\n
using<\/span>(var db = StartDataBase())\r\n{\r\n    var single = (from SimpleObject o in<\/span> db\r\n                  select o).Single();\r\n    single.Content = \"New Value\"<\/span>;\r\n    db.Store(single);\r\n    db.Rollback();\r\n    AssertEquals(\"Old-Value\"<\/span>, single.Content);\r\n}<\/pre>\n
Unfortunately this test will fail =(. When you rollback a transaction your objects in memory aren\u2019t rolled back automatically<\/a>. So you have to be very careful when try to resume after a some kind of error. So if you want to set a object in the state of database you can use Refresh():<\/p>\n
db.Rollback();\r\ndb.Ext().Refresh(single,int<\/span>.MaxValue);<\/pre>\n
\"db4-state\"<\/a><\/pre>\n
Resume-Strategy<\/h3>\n
Now we know how we can commit and rollback a transaction. Also we know that when we rollback a transaction, the objects in memory keep their state. So when you want to resume after a rollback, you have to have some kind of strategy. This strategy heavily depends on your use case.<\/p>\n
Isolation<\/h3>\n
In a client-server-model the isolation guarantees are important. Db4o has read-committed isolation properties<\/a>.\u00a0<\/p>\n
Next time<\/h3>\n
So far I\u2019ve showed some basics of db4o. Of course this is only the tip of the iceberg. You can read up all the details in the documentation<\/a>. So next time I give some tips on how to model your persisted classes.<\/p>\n","protected":false},"excerpt":{"rendered":"
So I showed the basics, explained the activation-system and pointed out how db4o manages object-identities. So far so good, but I\u2019ve never explain a very important\u00a0feature of most databases, the… <\/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\/671"}],"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=671"}],"version-history":[{"count":5,"href":"https:\/\/www.gamlor.info\/wordpress\/wp-json\/wp\/v2\/posts\/671\/revisions"}],"predecessor-version":[{"id":3835,"href":"https:\/\/www.gamlor.info\/wordpress\/wp-json\/wp\/v2\/posts\/671\/revisions\/3835"}],"wp:attachment":[{"href":"https:\/\/www.gamlor.info\/wordpress\/wp-json\/wp\/v2\/media?parent=671"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.gamlor.info\/wordpress\/wp-json\/wp\/v2\/categories?post=671"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.gamlor.info\/wordpress\/wp-json\/wp\/v2\/tags?post=671"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}