|Written in||C#, Java|
|License||GNU General Public License (GPL)
db4o Opensource Compatibility License (dOCL)
db4o is written in Java and .NET and provides the respective APIs. db4o can run on any operating system that supports Java or .NET. db4o is offered under multiple licenses, including the GNU General Public License (GPL), the db4o Opensource Compatibility License (dOCL), and a commercial license for use in proprietary software.
- 1 History
- 2 Place in the database world
- 3 Features
- 4 Disadvantages
- 5 Portability and cross-platform deployment
- 6 Documentation and support
- 7 Object Manager
- 8 Community
- 9 Development process
- 10 Versions
- 11 References
- 12 Further reading
- 13 External links
The term Object-oriented Database System dates back to around 1985, though the first research developments in this area started during the mid-1970s. The first commercial object database management systems appeared in the early 1990s; these added the concept of native database driven persistence into the sphere of object-oriented development.
The second wave of growth was observed in the first decade of the 21st century, when Object-Oriented Databases written completely in an Object-Oriented language appeared on the market. db4o is one of the examples of such systems written completely in Java and C#.
The db4o project was started in 2000 by Chief Architect Carl Rosenberger, shipping a year later in 2001. Some 100 commercial pilot customers and community users have supported db4o from its earliest days and it has seen successful use in enterprise and academic applications prior to its commercial launch in 2004 by newly created private company Db4objects Inc.
In 2008 the db4o OODBMS was purchased by Versant corporation, who are as of 2012 the current owners and developers of db4o. db4o is offered to the market as an open-source bi-licensed software (commercial and GPL). Since the initial launch db4o has gone through many changes and improvements (see #Versions) leading up to the release of version 8 in the latter half of 2011.
Place in the database world
db4o represents an object-oriented database model. One of its main goals is to provide an easy and native interface to persistence for object oriented programming languages. Development with db4o database does not require a separate data model creation, the application’s class model defines the structure of the data in db4o database. db4o attempts to avoid the object/relational impedance mismatch by eliminating the relational layer from a software project. For more information see db4o features.
Developers using relational databases can also benefit from using db4o, which can be viewed as a complementary tool. The db4o-RDBMS data exchange can be implemented using db4o Replication System (dRS). dRS can also be used for migration between object (db4o) and relational (RDBMS) technologies.
As an embedded database db4o can be run in application process. It is distributed as a library (jar/dll).
db4o contains a function to store any object with a single command:
Note that SomeClass here does not require any interface implementations, annotations or attributes added. It can be just any application class including third-party classes contained in referenced libraries.
All field objects (including collections) are saved automatically. Special cases can be handled through writing custom type handlers.
db4o is designed to be embedded in clients or other software components completely invisible to the end user. Thus, db4o needs no separate installation mechanism, but comes as a single library file with a footprint of around 670kB in .NET version and around 1MB in java version.
Client/server version allows db4o to communicate between client and server-side applications. db4o uses TCP/IP for client-server communication and allows to configure port number. Communication is implemented through messaging.
Due to a feature referred to as "Generic Reflection", db4o can work without implementing persistent classes on the server. However, this mode has certain limitations.
Client-server performance is dependent on the network bandwidth. The querying performance can be enhanced by using Lazy Queries.
Dynamic schema evolution
db4o supports automatic object schema evolution for the basic class model changes (field name deletion/addition). More complex class model modifications, like field name change, field type change, hierarchy move are not automated out-of-the box, but can be automated by writing small utility update program (see documentation).
This feature can be viewed as an advantage over relational model, where any change in the schema results in mostly manual code review and upgrade to match the schema changes. In most cases the code upgrade cannot be automated as the actual query language is string based (SQL) and is not recognised by IDE autocompletion and code generation tools like Intellisense.
Rather than using string-based APIs (such as SQL, OQL, JDOQL, EJB QL, and SODA), Native Queries (NQ) allow developers to simply use the programming language itself (e.g., Java, C#, or VB.NET) to access the database and thus avoid a constant, productivity-reducing context switch between programming language and data access API. Native Queries also provide type safety, as well as remove the need to sanitize against code injection (see SQL Injection).
LINQ support is fully integrated in db4o for .NET version 3.5. LINQ allows to create object-oriented queries of any complexity with the benefit of compile-time checking, IDE Intellisense integration and automated refactoring.
Due to integration with some open-source libraries db4o also allows optimized LINQ queries on Compact Framework.
LINQ can be used both against relational and object data storage, thus providing a bridge between them, which can be valuable for projects using both technologies, or for the projects migrating between the two. It can also be used as an abstraction layer, allowing to easily switch the underlying database technology.
The drawbacks and difficulties faced by other Object Databases apply to Db4o as well:
- Other things that work against ODBMS seem to be the lack of interoperability with a great number of tools/features that are taken for granted in the SQL world, including but not limited to industry standard connectivity, reporting tools, OLAP tools, and backup and recovery standards. Additionally, object databases lack a formal mathematical foundation, unlike the relational model, and this in turn leads to weaknesses in their query support. However, this objection is offset by the fact that some ODBMSs fully support SQL in addition to navigational access, e.g. Objectivity/SQL++, Matisse, and InterSystems CACHÉ. Effective use may require compromises to keep both paradigms in sync.
Issues specific to Db4o may include:
- Lack of full-text indexing, poor performance on full-text search
- Lack of Indexing for string types, text based searches can potentially be very slow
- "There is no general query language like SQL which can be used for data analyzing or by other applications. This does not allow db4o to be very flexible in a heterogeneous environment."
- Replication cannot be done administratively—i.e. one needs to program an application to achieve replication. "This is contrary to most RDBMS, where administrators manage servers and replication between them."
- Deleted fields are never removed but just hidden until the next Defrag, a delicate and potentially dangerous operation which can often lead to massive data losses
- There is no built-in support to import/export data to/from text, XML or JSON files.
- Support of Unique constraints and cascaded operation is partially incomplete and highly immature
- The system is generally careless about referential integrity and data unicity, the most typical bug with db4o is object duplication[unreliable source]
Portability and cross-platform deployment
db4o supports Java's JDK 1.1.x through 6.0 and runs on Java EE and Java SE. db4o also runs with Java ME dialects that support reflection, such as CDC, Personal Profile, Symbian OS, SavaJe and Zaurus. Depending on customer demand, db4o will also run on dialects without reflection, such as CLDC, MIDP, BlackBerry and Palm OS.
db4o runs out of the box on Android.
db4o uses a custom feature called "generic reflector" to represent class information, when class definitions are not available, which allows to use it in a mixed Java-.NET environment, for example Java client - .NET server and vice versa. Generic reflector also makes it easy[neutrality is disputed] to convert the project between environments, as the database does not have to be converted.
Documentation and support
db4o provides various sources of documentation: tutorial, reference documentation, API documentation, online paircasts and blogs. Lots of important information can also be retrieved from forums and community additions (articles, translated documentation sources, sample projects etc.).
For commercial users db4o suggests dDN (db4o developer network) subscription with guaranteed 24-hour support and live pairing sessions with the client – Xtreme Connect.
Object Management Enterprise (OME) is a db4o database browsing tool, which is available as a plugin to Eclipse and MS Visual Studio 2005/2008. OME allows to browse classes and objects in the database, connect to a database server, build queries using drag&drop, view database statistics etc.
In addition to graphical interface to db4o database OME provide some administrative functions as:
OME was initially suggested to the customers as a commercial product only available to dDN subscribers. From the db4o version 7.8 OME was included into standard db4o distribution and the source was made available to the public in db4o svn repository.
Over the years the community of db4o registered members has grown to over 60,000 members. Many important db4o-related projects, such as standalone Object Manager, encryption support, Mono support etc., are fully driven by community members. db4o's Code Commander program defines the terms and conditions of community project development.
db4o provides free access to its code, documentation, forums and releases to the community members. The community votes for most important features and most critical bugs is taken into consideration when defining the road map and weekly iteration plans. From time to time db4o holds different contests allowing the community members to come up with the best suggestion for an improvement of a specific db4o aspect, which are later on integrated into the core code.
The db4o team uses Extreme Programming (XP) practices. Some of the tools used in the development process include:
- JIRA is used for close tracking of the development process, progress reporting, prioritization of tasks, and collecting user feedback.
- SVN is used for version control.
- A wiki is used for collaboration on design and documentation, as well as process notes.
db4o releases development, production and stable builds. Development version provides the newest features and is released for testing, community feedback and evaluation.
Production version is meant to be used in production environment and includes features that have been already evaluated and proven by time.
Stable version is meant to be used in final product shipment.
db4o also runs a continuous build, which is triggered by any new change committed to the SVN code repository. This build is open to community and can be used to evaluate the latest changes and get the newest features hot.
db4o build name format is meant to provide all the necessary information about the version, time of build and supported platform:
For example: db4o-126.96.36.19965-java.zip
db4o – name of the product, i.e. db4o database engine
7.2 – the release number
30 – iteration number, i.e. a sequential number identifying a development week
9165 – svn revision number, corresponding to the last commit that triggered the build
java – Java version of db4o. .NET version is identified by “net” for .NET 2.0 releases or “net35” for .NET 3.5 version. .NET version includes the corresponding Compact Framework release.
db4o public SVN repository is also available for the developers to get the source code and build versions locally with or without custom modifications.
Below is a short summary of the main features of the current stable, production and development builds:
|Stable (db4o-7.4)||Sharpen release (java to c# converter)|
|Production (db4o-7.4)||Sharpen release (java to c# converter)|
- Product Information
- Stefan Edlich, Jim Paterson, Henrik Hörning, Reidar Hörning, The definitive guide to db4o, Apress, 2006, ISBN 1-59059-656-0
- Ted Neward, The busy Java developer's guide to db4o, (7-article series), IBM DeveloperWorks