>七猫的藏经阁>

db4o is designed to be a simple, easy-to-use, and fast, native object database. Software developers using popular Java and .NET object-oriented frameworks know that using an object oriented databases is a more natural way to get work done. Developers have three ways to storing and retrieving data: relational, non-native object and native object.

Relational databases, such as Oracle, IBM’s DB2 and Microsoft’s SQL server, store data in a tabular, row-and-column metaphor. The organization of traditional data in a relational database is easy to understand. The concept took off and today most data is stored in relational databases.

However, as object-oriented models became popular, developers were spending time trying to map objects into a relational database. Today, developers are forced to rely on relational-to-object mappers, but this technology compromise adds a layer of complexity and degrades performance. It is best suited for organizations that rely on legacy data.

Non-native object databases came on to the market in the early 1990s with great fanfare. But their promise was largely unfulfilled. Developers found the technology expensive, complex and hard to use. The first native object databases had similar shortcomings.

db4o is based on new native object database technology. It offers Java and .NET developers the simplest and easiest way to store even complex objects and achieve highest performance. db4o is the only native object database designed for both Java and .NET, supplied as one single programming library (Java: .jar /.NET: .dll) to be included with developer applications. Whether you look for a Java database, a .NET database, a C# database, a Mono database, or any embedded database - db4o is the right choice for you.

Key Features	Key Benefits
	Saves more than 50% costs to develop your application Saves more than 50% time to release your application No need for training and administration Build lean, structured and manageable code Improve your software lifecycle with better refactorability and re-use

One line of code stores any object
public void store(Car car){    ObjectContainer db =       Db4o.openFile("car.yap");    db.set(car);    db.commit();    db.close(); }	Avoid writing object mapping code Focus on building a clean object-oriented model

db4o is native Java / native .NET
Portable to all Java platforms from JDK 1.1.x Portable to .NET 1.0, 1.1 and CompactFramework Runnable with all .NET programming languages Objects "live" within the application, within the server Full control over memory management Speed profiling possible over entire system No bottleneck through language conversions	Simple installation and deployment No waste of time, resources or memory with language conversions

class model == database schema
No tables and columns need to be maintained No additional database schema description No additional XML files for persistence	Refactoring becomes very simple: Your development environment does it for you Less development time Less sources of error Code stays healthy because it becomes so easy to frequently refactor the code

Just store objects as they are
No enhancer or other pre- or post-compiler process No need to derive from a common base class No need to implement a specific interface Support for all Java / .NET types and classes: simple types, simple type wrappers, collections, arrays, also multi-dimensional and asymmetric, inner classes, non-public constructors	Smooth integration into production process No problems with debuggers No time-consuming build process Use and persist existing bytecode class libraries and all libraries from the JDK without modification No worries about modifications to existing deploy processes

Automatic schema versioning
Add fields Remove fields Rename fields Continue to use the same database file No reorganisation process necessary	Develop with a copy of your production data Deploy modifications to your application only, the database schema will adjust automatically

Query by Example (QbE)
public car[] query(  ObjectContainer db, Car car){    ObjectSet objectSet =     db.get(car);    Car[] cars =     new Car[objectSet.size()];    int i = 0;    while(objectSet.hasNext()){       cars[i++] = (Car)objectSet.next();    }    return cars; }	Stay within the object world, even when querying Use existing setters to create query templates

S.O.D.A. active queries
final Pattern pattern =  Pattern.compile("In*Si"); query.constrain(new Evaluation() {    public void evaluate(     Candidate candidate) {       String str =        (String)candidate.getObject();       boolean ok =        pattern.matcher(str).matches();       candidate.include(ok);    } });	Run your own Java/.NET code within queries Benefit from fast serverside query execution

250kB footprint
One single 250kB Java Jar/.NET DLL	Save ressources Be ready for next generation applications Deploy by web or to mobile devices Use database technology where your competition needs to store binary

--------------------next---------------------