Eliminate Mapping Complexity with db4o

All object-oriented software developers are familiar with the difficulty of transitioning from object-oriented thinking to relational persistence. The difficulty comes from the fact that the schema in the database does not match your application schema and you're forced to bridge that gap. Transformations between representations in memory and what goes to disk often take a good share of your CPU processing power. With an object database like db4o your application schema IS your data schema, no mapping required, no extra work - which translates into ease of use and higher performance!

The secret of db4o's success is its ease of use. db4o is native to Java and .NET, storing data objects exactly in the way they are defined by the application. Therefore, db4o easily integrates into the application. No matter how complex your object models, db4o performs highly reliable and scalable persistence tasks with as little as one single line of code. With db4o, you are no longer required to predefine or maintain a separate, rigid data model, because the model is now created and updated 'on demand' by db4o itself during a transaction.

db4o's unmatched ease-of-use results in drastically reduced development time and allows for efficient deployment. It eliminates the entire work and the constraints of (pre-)designing, implementing and maintaining the database schema, because with db4o, the class model is the database schema. Even when deploying software updates, db4o's automatic schema versioning takes care that the software and the database are always in sync, while you can focus on building value-add product features.

Execute Powerful Queries with db4o

Unlike string-based query languages, db4o offers truly native and object-oriented data access APIs which are setting new standards in the computing industry:

• db4o's language integrated queries allow you to use the native program language, Java or .NET, to query the database which eliminates all strings from queries. With db4o, they are 100% type-safe, 100% refactorable, and 100% object-oriented. They improve developer productivity and allow for easier product customization (e.g., using inheritance)
• db4o's Query by Example (QbE) makes it easy to search for matching objects
• db4o's retrieval by object graph allows to use normal methods to retrieve objects on demand without creating new queries
• db4o's powerful ad-hoc query tools for debugging and exploration during run-time

Benefit from Zero Administration with db4o

db4o has been designed to meet the demands of all environments where no DBA is present. The unique approach of db4o's native object database engine makes it the ideal choice to be embedded in packaged software running on desktop platforms, industrial equipment and devices, real-time control systems and mobile platforms.

Application design often changes from version to version, from one customer implementation to another. And the database changes together with the application. For relational databases this process is called Schema Evolution, for object databases we use the term: Refactoring.


db4o sets you free of db maintenance by handling simple schema changes automatically: adding a new field in a class, removing a field, adding interfaces, new subclasses, etc. Additionally, db4o offers a special API which can help you move classes between packages (Java)/namespaces(.NET), rename classes or fields, and perform more advanced refactorings.

In addition, other tasks normally associated with the DBA, like backup and restore, can be automated using db4o's built in API's.

db4o Real-Time Performance

A lightweight, robust and fast persistence engine like db4o is the perfect companion for real-time systems. The elimination of data transformation in db4o leads to less demand on CPU for persistence operations, which shifts critical resources to your application logic and query processing. With a lightweight object persistence engine like db4o, you can achieve the flexibility of database triggers (no heavy-weight triggers) via callbacks to manage your objects, freeing up the CPU, optimizing I/O, avoiding chatty network protocols, and, of course, completely avoiding OR mapping.

For low-latency filtering, correlating, aggregating, and computing on real-world event data, db4o provides a rich set of features like native storage of complex objects, high throughput, support for callbacks, embedded C/S mode, and more.

db4o is fast. As seen below in the PolePosition open source database benchmark, db4o displays significant performance advantages, especially when it comes to storing complex object structures. Several "circuits" represent different use cases. You can download, modify, and run them for yourself.

The Barcelona circuit, for instance, shows transaction performance (100 selects on 30,000 objects over 5 levels of inheritance structures) for different database products and data access methods. As you can plainly see, resolving the object-relational mismatch by using an object-relational mapper like Hibernate costs a lot of performance. db4o overcomes the trade-off between object-orientation and speed: With db4o, you can now store objects natively and enjoy great performance gains.