Perst - High Performance OOBD

Perst - An open source, object-oriented embedded database

McObject high-performance object-oriented embedded database.

Supported Platforms

• J2SE 1.4 and above
• Android (Open Handset Alliance)
• J2ME MIDP 2.0 / CLDC 1.1
• .NET Framework (1.0, 2.0, 3.0, 3.5)
• .NET Compact Framework (1.0, 2.0)
• Mono

Main features

• Stores data directly in Java and .NET objects, excluding the conversion time required by relational and object-oriented databases.
• Compact (build for .NET only weighs a little over 500 kb)
• Transaction support
• Easily used development tools (below is the code by which you can evaluate it)
• It is possible to use a SQL-like query language (for .NET 3.5, you can use LINQ)
• Export to XML
• Replication
• Full-text index (indexing speed certainly doesn’t compare with Sphinx or Lucene, but still it will be useful for some tasks)
• Base encryption using RC4 algorithm
• Fast DB recovery system after failures (without using log-files)
• The rest of the possibilities you can find on the Perst specification page .

License

Dual: either GNU General Public License version 2, or if you are not comfortable with the GNU GPL v2 is commercial.

Speed ​​performance

The official site posted tests from two companies PolePosition and TestIndex. PolePosition compares Perst with db4o, which was mentioned more than once on Habré. The result, as you probably guessed, is Perst faster. The same result is reported to us by TestIndex, which tested on an Android emulator and a T-Mobile G1 smartphone comparing Perst to SQLite. Pdfs with charts can be downloaded from the official site .
')

C # example

Everything is really simple here - all objects (classes) that need to be stored in the Perst database are inherited from the Persistent class . Create a class simple data class:

/// <summary> /// . /// </summary> class MyData : Persistent { public int intKey; public string strData; } * This source code was highlighted with Source Code Highlighter .

1. /// <summary> /// . /// </summary> class MyData : Persistent { public int intKey; public string strData; } * This source code was highlighted with Source Code Highlighter .
2. /// <summary> /// . /// </summary> class MyData : Persistent { public int intKey; public string strData; } * This source code was highlighted with Source Code Highlighter .
3. /// <summary> /// . /// </summary> class MyData : Persistent { public int intKey; public string strData; } * This source code was highlighted with Source Code Highlighter .
4. /// <summary> /// . /// </summary> class MyData : Persistent { public int intKey; public string strData; } * This source code was highlighted with Source Code Highlighter .
5. /// <summary> /// . /// </summary> class MyData : Persistent { public int intKey; public string strData; } * This source code was highlighted with Source Code Highlighter .
6. /// <summary> /// . /// </summary> class MyData : Persistent { public int intKey; public string strData; } * This source code was highlighted with Source Code Highlighter .
7. /// <summary> /// . /// </summary> class MyData : Persistent { public int intKey; public string strData; } * This source code was highlighted with Source Code Highlighter .
8. /// <summary> /// . /// </summary> class MyData : Persistent { public int intKey; public string strData; } * This source code was highlighted with Source Code Highlighter .

/// <summary> /// . /// </summary> class MyData : Persistent { public int intKey; public string strData; } * This source code was highlighted with Source Code Highlighter .

Now we need to create a class that will create the indices we need, as well as being the root element of the database.

1. /// <summary>
2. /// The root element of the database.
3. /// </ summary>
4. class MyRoot: Persistent
5. {
6. /// <summary>
7. /// Index across the intKey field in the MyData class.
8. /// </ summary>
9. public FieldIndex < int , MyData> intKeyIndex;
11. public MyRoot (Storage db)
12. : base (db)
13. {
14. intKeyIndex = db.CreateFieldIndex < int , MyData> ( "intKey" , false ); // False indicates non-unique key.
15. }
16. public MyRoot ()
17. {
18. }
19. }

* This source code was highlighted with Source Code Highlighter .

Well, now it remains only to connect to the database and work with it. At the same time we will test the speed.

1. class program
2. {
3. static void Main ( string [] args)
4. {
5. DateTime t1;
6. DateTime t2;
7. Storage db = StorageFactory.Instance.CreateStorage ();
8. MyRoot Root;
9. MyData Obj;
10. MyData [] ObjList;
12. // Select Perst 10MB of RAM for working with the database, which would slightly reduce the load on the disk and
13. // increase speed.
14. db.Open ( "MyDB.pdb" , 10 * 1024 * 1024, "My_SecreT_k3y" );
15. // If the database does not have a root element yet, create it.
16. if (db.Root == null )
17. {
18. db.Root = new MyRoot (db);
19. }
20. Root = (MyRoot) db.Root;
22. // Add the MyData object to the database.
24. t1 = DateTime .Now;
25. for ( int i = 0; i <100000; i ++)
26. {
27. Obj = new MyData ();
28. Obj.intKey = i;
29. Obj.strData = "Hello world !!!" ;
30. Root.intKeyIndex.Put (Obj);
31. }
32. t2 = DateTime .Now;
33. Console .WriteLine ((t2 - t1) .TotalMilliseconds.ToString () + "ms" );
35. // Now try to get it.
36. //T.k. we created an index with a non-unique key, then we use the overloaded function Get (from, till).
37. ObjList = Root.intKeyIndex.Get (1000, 1000);
38. foreach (MyData Obj1 in ObjList)
39. {
40. Console .WriteLine (Obj1.strData);
41. }
43. db.Close ();
44. }
45. }

* This source code was highlighted with Source Code Highlighter .

On my laptop, the creation of 100,000 objects is performed in 2.4 seconds, i.e. ~ 42k records per second

Conclusion

Perst is really fast and compact OODB, which is suitable not only for your PC application, but also for mobile devices.
But can it be applied on sites you ask? The answer will be as follows: the tutorial claims support for a multi-client application using ThreadTransaction and the database property perst.multiclient.support, but I was not able to achieve high performance (10 threads create 10 records of 21 seconds each). Most likely I do something wrong? In any case, I will post the source code that you were able to correct me and test it yourself.

Links

1. Official site
2. Download Page
3. Sources of examples on VB.NET
4. Sample C # Sources