Google Groups no longer supports new Usenet posts or subscriptions. Historical content remains viewable.
Dismiss

db4o - database for objects - 2.5 release announcement

0 views
Skip to first unread message

Carl Rosenberger

unread,
Nov 7, 2002, 7:12:09 PM11/7/02
to

Hi all,

we are proud to announce the release of db4o - database for objects - version
2.5.

For those of you who have never had a look at db4o, here is a short outline.

db4o is a client/server Java object database with ACID transactions.

Some points where db4o is different from all other products that we know:
- db4o detects the structure of your user classes at runtime and adjusts it's
storage
scheme automatically, even if you modify your classes. You don't have to worry
about
managing table schemes or XML mapping files. Simply store your objects.
- There is no need to modify your classes to be able to persist objects. Since
reflection is used and since the reference management system works separately
from
your user objects, it is possible to run an unlimited number of database file
sessions
in one VM and to move objects freely between database files.
- You can persist virtually any Java object, without touching it's sourcecode.
db4o
"understands" all Java data types, all arrays, all Collection types. For very
difficult
classes that perform initialisation work in constructors it is possible to
write your
own custom translators.
- db4o comes in a single 250 kB JAR that needs no further external packages.
The small
size of the JAR allows deployment in a Java Webstart application or online
deployment
to mobile phones.
- db4o runs on all JDKs from 1.1.x to present. It has successfully been tested
on
PersonalJava, the Symbian VM, Savaje and on the Zaurus. J2ME CDC-compliant VMs
will
open a great field on tomorrows mobile and handheld platforms.
- Client or server can be run with a memory footprint well below 10 MB.
- db4o has built-in servlet session management support. You can drop the JAR to
the
.../WEB-INF/lib/ folder of your ISP and your database engine is installed.
- db4o is threadsafe and the IO mechanism was designed to be VM- or
OS-crash-resistant
with a transaction recovery on restart. Regression tests included with the
download
allow you to test this yourself.


The major new feature in release 2.5:
db4o now comes with the S.O.D.A. (Simple Object Database Access) query
interface.
S.O.D.A. is a powerful, yet simple, query API based on the principle of
query-by-example:
Reuse existing objects in your code to describe, how retrieved objects should
look like.
You can add an unlimited number of objects to the query-template-graph and
describe how
they should be evaluated against the stored objects: equals, not, smaller,
greater, like,
by identity. Constraints can be ORed between eachother.
To make it possible to execute any Java code during query evaluation, S.O.D.A.
provides
a callback feature.
Well over 500 of our regression tests are included with the db4o download, to
demonstrate,
how S.O.D.A. can be used.

Here is a simple S.O.D.A. example. It performs a regular expression query for
all objects
in your database file that support the "CanGetName" interface where "getName()"
matches "*4o":

public ObjectSet regularExpression_4o(ObjectContainer db) {
Query q = db.query();
q.constrain(CanGetName.class);
final Pattern pattern = Pattern.compile("*4o");
q.constrain(new Evaluation() {
public void evaluate(Candidate candidate) {
candidate.include(
pattern.matcher(
((CanGetName) candidate.getObject()).getName()
).matches());
}
});
return q.execute();
}


If you use a client/server setup for the above example, all the code in the
"evaluate"
method will be executed on the server side.


S.O.D.A. has been developed in public. If you would like to contribute to
further S.O.D.A.
versions, here is a link to the S.O.D.A. homepage at SourceForge:
http://sourceforge.net/projects/sodaquery


Further modifications in the db4o 2.5 release can be read in the changelog:
http://www.db4o.com/db4o/changelog.html


Judging from our benchmark tests, db4o is exceptionally fast for storing data
and for
navigational and ID access. Please test for yourself. The trial version
available from
the website is fully functional except for a two-month expiration date. Here is
a direct
download link:
http://www.db4o.com/db4o/db4o2.5.zip

db4o is *not* JDO compliant, and we are proud it isn't.
- No enhancer!
- No ugly String/API query mixture.
- Very small footprint, for deployment and in-memory.
- Runnable on JDK 1.1.x (PersonalJava, J2ME CDC)
- Store all objects, all arrays, all JDK collection types, just any Java object.
- Direct control over what you want stored, loaded, instantiated and purged
from memory.


I hope you will enjoy testing db4o.

Feedback, comments, questions and suggestions are very welcome.
You are invited to post directly to our newsgroup:
news://news.db4odev.com/db4o.users

Kind regards,
Carl
--
Carl Rosenberger
db4o - database for objects
http://www.db4o.com

0 new messages