Object-oriented database programming with db4o - Part 1

In Part 1 and Part 2 of the article entitled The Legend of Data Persistence, I have introduced you to the O-R impedance mismatch, O-R/M tools, ODBMS and its advantages and disadvantages in comparison with RDBMS.  Now, once you have decided that you would use an ODBMS for your project, which ODBMS should you use?  This article, as a follow-up of The Legend of Data Persistence, aims to introduce you to one of today’s most popular ODBMS implementations, db4objects (db4o). 

In the first part of this article, I will introduce you to db4o and show you how to create, update, delete, and query objects with it.  In the second part, I will discuss about db4o’s more advanced topics such as transaction and concurrency, custom translator, encryption, networking database, and schema evolution etc.  You can file the source code in this article in the Resource section.

I. What is db4o

db4o is an open-source native ODBMS available for both .NET and Java platforms.  As a native ODBMS, there is no separate schema kept track by db4o, instead the database schema and application object model are exactly the same, hence, no mapping or transformation is required for persistence and querying.  db4o has support for inheritance, deeply nested objects as well as exposes comprehensive query APIs for application developers to queries stored objects. 

Regarding usage mode, db4o can be deployed either as an embedded database or as a server-side database.  Finally, db4o has support for the schema evolution, indexing, transaction and concurrency, database encryption, and replication service (among db4o databases and certain relational databases).  The latest version of db4o is 6.1 and available under two licenses: GPL and a commercial runtime license.

Okay, enough for an introduction, let’s get to the code

II. The Domain Model

While db4o’s strengths are more obvious in applications with highly complex object model, the purpose of this article is more to offer an introduction to db4o, instead of exploring it in every level of dept.  As a result, I will use an object model which is very simple but still comprehensive enough to demonstrate features of db4o. 

What we have is an object model for a painting application.  There are two concrete shape types, Line, Circle, and ShapeList, which implement the IShape interface which has Paint() as its single method.  The ShapeList implements the composite design pattern and contains many instances of type IShape.  The CPoint represents a 2-D coordination used by Line (start point and end point) and Circle (center point).  (Yes,  I know there is a System.Drawing.Point, but that Point is a struct, not a class, and since Line and Circle already consist of System.Drawing.Color which is a struct, it is better to have a custom Point class instead to see the differences in how db4o handles classes and structs.)

III. Now, the Code

I will write code using C# 2.0.  If you are from the Java space, you should still easily understand the code because the db4o libraries for the two platforms are virtually identical. 

The first step we need to do is to download the binary of db4o from its website, and then in VS.NET 2005, add a reference to the Db4objects.Db4o.dll file which is located in the net-2.0 folder of the download. 

Below is what the solution explorer looks like after we’ve added the references as well as created the source files needed. 

The source code for the model classes are as follows

IShape.cs

public interface IShape
{
   void Paint(Graphics graphics);
}

CPoint.cs

public class CPoint
{
   private int x;
   private int y;

   public CPoint(int x, int y)
   {
      this.x = x;
      this.y = y;
   }

   public int X
   {
      get {return x;}
      set {x = value;}
   }

   public int Y
   {
      get {return y;}
      set {y = value;}
   }

   public override bool Equals(object obj)
   {
      if (obj == null || !(obj is CPoint))
      {
         return false;
      }
      CPoint point = obj as CPoint;
      return point.x == x && point.y == y;
   }

   public override int GetHashCode()
   {
      return x.GetHashCode() + y.GetHashCode();
   }

   public override string ToString()
   {
      return string.Format("Point [{0}, {1}]", x, y);
   }
}

Circle.cs

public class Circle : IShape
{
   private CPoint center;
   private Color color;
   private float radius;

   public Circle(CPoint center, float radius) : this(center, new Color(), radius)
   {
   }

   public Circle(CPoint center, Color color, float radius)
   {
      this.center = center;
      this.color = color;
      this.radius = radius;
   }

   public CPoint Center
   {
      get {return center;}
      set {center = value;}
   }

   public Color Color
   {
      get {return color;}
      set {color = value;}
   }

   public float Radius
   {
      get {return radius;}
      set {radius = value;}
   }

   public override bool Equals(object obj)
   {
      if (obj == null || !(obj is Circle))
      {
         return false;
      }
      Circle circle = obj as Circle;
      return (circle.center == null ? center == null : circle.center.Equals(center))
          && (circle.radius == radius)
          && (circle.color.Equals(color));
   }

   public override int GetHashCode()
   {
      return center == null ? 0 : center.GetHashCode()
          + color.GetHashCode() + radius.GetHashCode();
   }

   public override string ToString()
   {
      return string.Format("Circle [{0}, {1}, {2}]", center, radius, color);
   }

   public void Paint(Graphics graphics)
   {
      // No implementation
   }
}

Line.cs

public class Line : IShape
   private CPoint start;
   private CPoint end;
   private Color color;

   public Line(CPoint start, CPoint end) : this (start, end, new Color())
   {
   }

   public Line(CPoint start, CPoint end, Color color)
   {
      this.start = start;
      this.end = end;
      this.color = color;
   }

   public CPoint Start
   {
      get {return start;}
      set {start = value;}
   }

   public CPoint End
   {
      get {return end;}
      set {end = value;}
   }

   public Color Color
   {
      get {return color;}
      set {color = value;}
   }

   public override bool Equals(object obj)
   {
      if (obj == null || !(obj is Line))
      {
         return false;
      }
      Line line = obj as Line;
      return (line.start == null ? start == null : line.start.Equals(start))
          && (line.end == null ? end == null : line.end.Equals(end))
          && (line.color.Equals(color));
   }

   public override int GetHashCode()
   {
      return (start == null ? 0 : start.GetHashCode())
           + (end == null ? 0 : end.GetHashCode())
           + color.GetHashCode();
   }

   public override string ToString()
   {
      return string.Format("Line [{0}, {1}, {2}]", start, end, color.Name);
   }

   public void Paint(Graphics graphics)
   {
      // No implementation
   }
}
}

ShapeList.cs

public class ShapeList : IShape
   private IList shapeList;

   public ShapeList()
   {
      shapeList = new List();
   }

   public void Add(IShape shape)
   {
      shapeList.Add(shape);
   }

   public void Remove(IShape shape)
   {
      shapeList.Remove(shape);
   }

   public int Count
   {
      get {return shapeList.Count;}
   }

   public IShape this[int index]
   {
      get {return shapeList[index];}
      set {shapeList[index] = value;}
   }

   public override bool Equals(object obj)
   {
      if (obj == null || !(obj is ShapeList))
      {
         return false;
      }
      ShapeList otherList = obj as ShapeList;
      return shapeList.Equals(otherList);
   }

   public override int GetHashCode()
   {
      return shapeList.GetHashCode();

   }

   public override string ToString()
   {
      return shapeList.ToString();
   }

   public void Paint(Graphics graphics)
   {
      // No implementation
   }
}

Notes about the coding styles:

• I will use unit test cases to explore and validate the behaviors of db4o, instead of dumping the output to the console.  I would love to hear whether this approach makes it easier to understand the code or not. 
• I will try to explain the code by using as many comments embedded in the code as possible.  That will eliminate much of the text I would have to write (and you would have to read) had I not written the comments but will make the comments more elaborated than I, and possibly some of you, would expect to see in production code.

Pages: 1 2 3

March 7th, 2007 in .NET, Java, OOAD, Software Engineering, Technologies

Share this entry: