Read how db4o has evolved since 1/1/2000, when the first line of code was written.
| 2006-03-22 |
Product changes are now tracked in the Product News Blog. |
2006-02-24
version 5.2 |
- Insert, delete and commit performance have been tuned considerably. Our results for comparing db4o versions with the PolePosition benchmark show that db4o 5.2 [FlushFileBuffers=true] is considerably faster than db4o 4.x [FlushFileBuffers=false].
- The Native Query optimization processor has been enhanced for new usecases, including many String method calls. Many examples like the following will now run optimized:
IList<Employee>employees = db.Query<Employee>(delegate(Employee e)
{
return e.FirstName.StartsWith("P");
});
- A new Query result sorting interface is available both for Native Queries and for SODA. It allows passing a standard java.util.Comparator / System.Collections.IComparer as an argument.
- The Mono version now has full Native Querying support and comes with PascalCase calling conventions.
- The tutorial is now also available in a Visual Basic version and in a Japanese version. |
2006-01-26
version 5.1 |
- db4objects introduces db4o Replication System (dRS), powered by Hibernate.
dRS provides functionality to replicate db4o object databases with relational databases, in disconnected and partially connected topologies. dRS is available under the GPL in the development stream of the download center area. |
2005-11-14
version 5.0 |
- db4o introduces Native Queries, a new querying interface that allows to use the semantics of the Java / C# / VB.NET programming language for querying. Native queries are 100% refactorable, 100% typesafe, 100% compile-time checked, they do not break OO encapsulation and they work with fields, properties and method calls. The db4o Native Query implementation is very fast because it analyzes and converts bytecode/IL-code to run against database indexes. Examples of Native Queries:
Native query in C# for .NET 2.0
IList<Student>students = db.Query<Student>(delegate(Student student){
return student.Age < 20
&& student.Grade == gradeA;});
Native query in Java JDK 5
List<Student> students = database.query( new Predicate<Student> (){
public boolean match(Student student){
return student.getAge() < 20
&& student.getGrade().equals(gradeA);}})
- A new freespace management system, which operates against indexes, is now the default freespace system. The freespace system can be configured with Db4o.configure().freespace()
- The performance of the query index processor was heavily tuned to work faster for ranges of values ( value greater than x and smaller than y ). |
2005-07-28
version 4.6 |
- The ObjectSet returned by db4o queries now exends System.Collections.IList, java.util.List and java.util.Iterator.
- The query processor was considerably tuned to provide better performance, especially for indexed fields two or more nodes away from the root of a query. |
2005-05-05
version 4.5 |
- The new db4o ObjectManager GUI tool is available for querying and browsing the content of databases.
- db4o supplies automated replication functionality with UUIDs and update version control for all objects. The feature can be used to automate the distribution of objects to multiple disconnected databases, to track their changes and to merge versions of objects to a consistent and up-to-date state.
- A new generic reflector implementation allows to work with objects without access to the classes that they were stored with. |
2005-03
version 4.4 |
.NET and Mono - This release is built with a completely new Java-To-C# converter. The C# sources are now perfectly readable and well formatted and they use the same variable names as the Java original.
- All calls to reflection have been refactored to be routed through our own new reflection interface. The modification prepares future usecases like
- running a db4o server without deploying application classes
- running db4o on Java dialects without reflection (J2ME CLDC, MIDP)
- more easily accessing stored objects where classes or fields are not available
- running refactorings in the reflector
- building interfaces to db4o from any programming language
|
2005-02-14
version 4.3 |
- File IO has been made pluggable and allows the creation of customized IO adapters for usecases such as maximized performance, encryption, hardware fail-safety checks, mirrored IO.
- Support for Mono has been considerably improved. The Mono distribution is now available either as a noarch RPM or as a source RPM with a regression test suite for Mono and special documentation. |
2005-01
version 4.2 |
- Full support for all JDK 5 (1.5) features including generics, enums and autoboxing.
- On Sun Java VMs 1.4 and 1.5 constructors and field initialisation code is no longer called. The behaviour is configurable with: Db4o.configure().callConstructors() |
2004-12
version 4.1 |
- The maximum database file size is raised from 2GB to 254GB. Use Db4o.configure().blockSize() to configure the multitude of 2GB that you need.
- Local Blob file transfer is now buffered and improves storage and retrieval of blobs dramatically.
- The behaviour of Constraint#like() was modified to do a string lowercase contains comparison. |
2004-11-06
version 4.0 |
- db4objects opens all db4o core sources and supplies them under a free GPL version.
- The new interactive Formula 1 tutorial allows "live" execution of all samples. |
2004-10-01
version 3.0 |
- db4o supplies indexed fields for improved querying performance. Use:
Java - Db4o.configure().objectClass(YourClass.class)
.objectField("yourField").indexed(true);
.NET - Db4o.configure().objectClass(typeof(YourClass))
.objectField("yourField").indexed(true);
- db4o supplies built-in collection functionalities for improved collection performance, automated storage on addition of objects to the collection and automated activation upon access to collection elements. See:
ObjectContainer#ext().collections().newLinkedList()
ObjectContainer#ext().collections().newHashMap()
ObjectContainer#ext().collections().newIdentityHashMap()
- Deep updates are possible with one single call: ObjectContainer#set(object, depth)
.NET - All struct objects will cascade-on-delete by default.
.NET - Custom attributes can be used to mark fields as transient. See Db4o.configure().markTransient(String attributeName).
Java - The ExtDb4o.use() method was removed without replacement. We recommend Java WebStart users to sign their applications instead of using a JNLPRandomAccessFile. |
2004-03-15
version 2.9
|
- db4o supplies online backup functionality to run backups against an open ObjectServer/ObjectContainer. See ExtObjectContainer#backup()
- The new ExtObjectContainer#refresh(object,depth) method makes it a lot easier to load changes made by other transactions. The feature also allows to reload objects upon rollback.
- All object data can now be inspected and loaded with API calls, even if the original classes are no longer available. See ExtObjectContainer#storedClasses() and the methods in com.db4o.ext.StoredClass and com.db4o.ext.StoredField. The new feature simplifies the deployment of unattended complex refactorings to customers.
- The downloads include wrappers to wrap the db4o ObjectSet to standard JDK/.NET collection functionality. See ../com/db4o/wrap/. Using standard collections, an ObjectSet can be bound to Swing/SWT/JSP/ Winform/ASP controls with very few lines of code (1 statement in most cases).
- The new TransientClass interface allows to mark classes not to be persisted.
- Problems with ObjectClass#persistStaticFieldValues() in Client/Server mode were fixed. The feature now handles updateable singletons as expected.
.NET - S.O.D.A. Evaluations can now execute delegate code in queries. Usage:
Query#constrain(new EvaluationDelegate(yourMethod)); |
2003-11-30
version 2.8
|
- The S.O.D.A. query processor was tuned to execute faster and to require less memory. Performance has been observed to improve between 25% and several powers of 10.
- The engine has undergone a thorough refactoring that reduces the size of the library from 250kB to 225kB. The automatic regression tests (included with the download) were improved from a coverage percentage of 75% to more than 85% to secure the quality standard. Thanks to Quest Software for their superb JProbe Profiler and CodeCoverage tools that made a big leap forward possible in a short timespan.
.NET - There were problems storing structs. Fixed.
.NET - The decimal datatype would behave strange in QBE queries. Fixed.
.NET - Blob features would not work. Fixed.
Java - It was possible to return to one db4o.jar for JDKs 1.2, 1.3 and 1.4 by using reflection calls, where they are available. A separate JDK 1.1 Jar is available with the download.
Java - The ExtDb4o.use() method was removed without replacement. We recommend Java WebStart users to sign their applications instead of using a JNLPRandomAccessFile. |
2003-09-22
version 2.7
|
.NET - The new C# version for all .NET languages now contains all the functionality of the Java version. In the future both versions will be maintained in parallel. Our fully automated Java-to-C# conversion process ensures equivalent quality on all platforms.
.NET - The .NET version now also runs on the .NET CompactFramework (WindowsCE, PocketPC, Windows Mobile 2003).
Java - The Java version was partially repackaged. Four different db4o.jar libraries are available with the download, for JDKs, 1.1, 1.2, 1.3 and 1.4. db4o has been successfully tested to run with many additional JVMs such as IBMs J9 foundation profile.
- ObjectServer#openClient() adds the possibility to run a client embedded within the server VM. Every client uses it's own transaction and memory space.
- The mechanism for WeakReference collection (minimum JDK 1.2 or .NET) is now triggered by a timer thread. The frequency can be controlled with Db4o.configure().weakReferenceCollectionInterval(milliseconds)
- Client/Server connection timeouts can now be configured externally. See all methods that begin with timeout... in the configuration interface.
Java - The servlet API now comes with two different transactional interfaces:
Db4oServlet.sharedTransaction() and Db4oServlet.sessionTransaction()
The functionality was removed from db4o.jar. It is now supplied as source code in the path ../servlet/WEB-INF/src/com/db4o/servlet/. An example how to use the interface is provided in a very simple web application. The servlet interface was optimised to use ObjectServer#openClient().
Java - The Db4o.openClient(InetAddress address, int port, String user, String password) method was removed without replacement. Please use Db4o.openClient(String hostName, int port, String user, String password) only. |
2003-04-17
version 2.6
|
- Support to store/restore static fields/constants. See ObjectClass#persistStaticFieldValues().
- Query comparisons can now be run on attributes and other substitutes of objects. See ObjectClass#compare(). The new feature was used to improve built-in S.O.D.A. query support for java.lang.StringBuffer.
- Several minor bugfixes including:
- enabling Query.descend("member").constrain(Class)
- enabling db4o on JDK 1.4.0 on Win95 (workaround for a JDK bug) |
2002-11-04
version 2.5
|
- db4o implements the S.O.D.A. query interface.
Further to the previous query-by-example functionality this now allows:
- queries constrained by an unlimited number of different objects
- queries greater/smaller/like
- queries for object identity
- queries for abstract classes and interfaces
- ORs and ANDs between all query criteria
- sorted queries
- queries for null
S.O.D.A. provides a callback feature that allows calling any Java code during query execution. With the power of Java, queries of any degree of complexity may be constructed. In a client/server environment the callback code will be executed on the server side. Some 580 test cases are delivered with the db4o download to demonstrate the use of S.O.D.A.
- Weak reference memory management would not clean up references correctly in all cases. Fixed. Weak reference memory management can now be turned on and off with Configuration#weakReferences().
- The Defragment tool was tuned and modified slightly to cope with changed weak reference behaviour.
- Upon abnormal termination of a db4o session (JVM crash, debugger stop, computer crash or the like) all classes newly added since the last start of the engine could be lost. Fixed.
- The internal java.util.Hashtable translator was misconfigured and left over com.db4o.config.Entry objects upon updates and deletes. Fixed. All unnecessary com.db4o.config.Entry objects can be cleared out in a Defragment run.
- The Logger tool was moved to com.db4o.tools.
- Cascaded update and cascaded delete is now automatically passed on through member arrays, collections and maps to their child elements.
- Cascaded update (ObjectClass#cascadeOnUpdate()) would update one member too deep. Fixed.
- Cascaded delete (ObjectClass#cascadeOnDelete()) did not work for untyped fields. Fixed.
- ShutdownHook deinstallation did not work. This would result in additional threads on some JDK implementations upon multiple open and close calls within one JVM session. To reduce threads, db4o now pools all ObjectContainers to use one single shutdownHook in one VM session.
- On JDKs 1.4.x and above the database file is now locked by using NIO. This replaces the previous implementation that would create one Thread per opened database file. (An exception: NIO will not be used on Sun's JDK 1.4.0 for Linux because of a bug in the JDK implementation of FileChannel#tryLock(). The bug is fixed in JDK 1.4.1.)
- The above two modifications reduce thread creation drastically and ensure better performance and a consistent low memory footprint, even if a multitude of ObectContainers is rapidly opened and closed.
- On JDKs 1.2.x and above db4o now installs it's default ClassLoader from Thread.currentThread().getContextClassLoader(). With this setting it is possible to run db4o.jar in the ../jre/lib/ext/ directory of the JDK or in Tomcat's ../lib/ folder. The setting may be overridden by calling Db4o.configure().setClassLoader().
- Arrays stored to untyped Object variables (as in Collections) would loose some database filespace upon updates. Fixed.
- Discrete object array types stored to untyped variables would be instantiated as Object[]. Discrete object array types stored in an array type of a type derived from the declared type would be instantiated as the declared type. Fixed.
- The client/server communication protocol was optimized to reduce the number of packets sent. The resulting performance improvement for client/server applications is dramatic, especially in low-bandwidth WAN applications. |
2002-07-19
version 2.1 |
- All use of reflection functionality was refactored out of the core engine. By implementing the com.db4o.reflect.* interfaces, it is possible to replace the default java.lang.reflect.* wrappers with a custom implementation. Possible usecases:
- Speed tuning
- Running db4o on J2ME and other JVMs that do not support reflection.
- Automatic session shutdown in servlet sessions could fail in some cases. Fixed.
- MemoryFile speed can be tuned by setting initial size and enlargement parameters. |
2002-04-02
version 2.0 |
- db4o now provides Client/Server functionality. See Db4o.openServer() and Db4o.openClient().
- db4o now comes with clean transaction support. Disk write operations were rewritten to ensure 100% fail-safety and clean ACID behaviour. ObjectContainer#commit() now commits the transaction associated with the ObjectContainer. ObjectContainer#rollback() was newly added.
- One single db4o.jar can now be run on all JDKs from 1.1.x to 1.4.x. The engine adjusts it's functionality to the available API methods automatically.
- Thread-safety was completely reengineered.
- The main API was refactored and split into two packages: com.db4o and com.db4o.ext. This allows the addition of an unlimited number of new features to com.db4o.ext while retaining lucidity in com.db4o. The ext() methods allow casting the respective Interface to full extended functionality.
- Every ObjectContainer can now be configured individually with ExtObjectContainer#configure(). Upon creation of an ObjectContainer with any of the open statements, the global Configuration context is copied to the new ObjectContainer.
- db4o can now also be run on in-memory files. See the documentation to ExtDb4o.openMemoryFile(). db4o operates approximately three times as fast on memory files than in normal RandomAccessFile mode. The feature may be useful to store db4o byte data to other databases or media.
- Cascaded activation, update and delete is now configurable per class and per field of a class.
- The servlet functionality has moved to ExtObjectContainer.objectContainer().
- The update depth can now be configured globally.
- Configuration#exceptionsOnNotStorable() can be turned on to analyse, if objects have storage problems due to a missing usable constructor or constructor code side events.
- Configuration#setClassLoader() allows the use of a custom class loader for stored classes.
- Configuration#refreshClasses() can be used to tell db4o to analyze all classes again in a running session.
- ExtObjectContainer#bind(Object object, long internalID) allows the association of an object in memory with the id of a stored object. The mechanism can be used to replace stored objects and to reassociate objects in a running session with their stored equivalents.
- The method setOut(PrintStream) was moved from the Db4o class to the Configuration class. Use Db4o.configure().setOut(PrintStream) or ObjectContainer#configure().setOut(PrintStream).
- The emergency shutdown mechanism now uses a JDK 1.3 shutDownHook instead of a response to finalize. This ensures a clean shutdown on CTRL + C. On JDKs 1.1.x and 1.2.x a shutdown is attempted in the finalizer.
- Classes implementing java.util.Collection would loose null elements. Fixed. The change will cause null objects to be contained in Collections if member elements are deleted independantly.
- Self references in member arrays could lead to exceptions. Fixed.
- Updating objects of classes derived from java.util.AbstractMap would leave over one object of the translated type com.db4o.config.Entry for every entry. Fixed.
- Endless loops were possible if callback events would call eachother. The behaviour was modified. Only one call on one callback method per object will be executed.
- A timing problem in the engine shutdown could lead to the message "The database file is locked by another process." in a subsequent open. Fixed.
- com.db4o.samples now contains another subfolder "constructors" to demonstrate, how db4o decides, which constructor to use.
- ...and many, many more new features can be found in the JavaDocs. |
2001-11-29
version 1.5 |
- Version 1.5 required a file format change. Conversion of old 0.4x to 1.4x database files takes place automatically upon opening a file for the first time. Since the modified files are not backward compatible to earlier versions, please back up your database files.
- db4o is now available in four versions:
- mobile edition (was: JDK 1.1.x)
- community edition (was: standard edition)
- professional edition (new)
- dotnet edition for Microsoft's .NET platform
- db4o no longer needs to create a lock file. Locking takes place internally within the database file. For performance reasons, the mobile edition does not lock files. It is the responsibility of mobile developers to ensure that only one thread in one VM accesses a db4o database file.
- The new methods ObjectContainer#getID(Object) and ObjectContainer#getByID(long) allow the use of the very performant internal db4o IDs.
- db4o now distinguishes between Unicode and non-Unicode database files automatically. To store strings in the more performant and less space consuming ISO8859-1 format, call Db4o.configure().unicode(false) before creating a database file with the first call to Db4o.openFile().
- The new method ObjectContainer#isClosed() allows to determine if an ObjectContainer instance was closed by a previous call or a possible emergency condition like an OutOfMemoryError.
- The following deprecated methods were removed:
- ObjectContainer#activate(Object)
Use: ObjectContainer#activate(Object, depth)
- ObjectContainer#deactivate(Object)
Use: ObjectContainer#deactivate(Object, depth)
- ObjectSet#current()
You need to cache the result of ObjectSet#next() manually.
- ObjectSet#isEmpty()
Use: ObjectSet#size() == 0
- Db4o.echo(boolean)
Use: Db4o.configure().messageLevel(level)
- ObjectContainer#freeMemory() was renamed to ObjectContainer#purge().
- ObjectContainer#purge(Object) was added to allow more efficient memory management in the mobile edition version.
- Synchronisation was removed from the JDK 1.1.x version (now mobile edition) to provide maximum performance.
- Upon an unexpected shutdown (typical: OutOfMemoryException) a subsequent call to Db4o.openFile() within the same JVM session could return the closed ObjectContainer. Fixed.
- Storing member objects explicitely with ObjectContainer#set() in objectOnNew callback methods (not necessary, since db4o recurses automatically) could lead to exceptions. Fixed.
- Storing objects with references to classes derived from themselves would lead to exceptions. Fixed.
- The db4o.jar format could not be used with Jikes and VAJ without unzipping it. Fixed.
- The professional edition comes with the following new features:
- encryption
- password protection
- a servlet framework |
2001-09-09
version 1.40 |
- JDK2 versions only: Memory management was greatly improved by switching to WeakReferences.
- Performance is not affected in a negative manner, since other improvements compensate the change easily. Performance should even appear to improve in most cases. The JDK 1.x versions also benefit from these changes.
- ObjectContainer#freeMemory() now allows to discard all clean object indices from memory. A call after ObjectContainer#commit() will achieve the lowest memory footprint possible.
- Using many commit() calls previously lead to more fragmentation of the database file than necessary. Fixed. As a result applications will produce drastically smaller database files.
- ObjectContainer#deactivate(Object, depth) can now be used to set all fields of any object to null / zero, even if the object is not stored to the ObjectContainer. This allows to use "naked" objects for queries, in spite of constructor or initialisation side effects, that set member variables. |
2001-08-08
version 1.30 |
- Automatic activation to the respective default activation depth is now triggered by ObjectSet#next(). Applications that do not necessarily iterate through all results of ObjectSets may encounter drastic performance and memory usage improvements. Deactivating objects from within the iterator loop may be used to keep memory usage at a very low level. Note that the new lazy activation behaviour requires the ObjectContainer to remain open while the ObjectSet is used.
- ObjectContainer#deactivate(Object, depth) now allows to cascade deactivation conveniently to any depth.
- ObjectContainer#deactivate(Object) is deprecated. ObjectContainer#deactivate(Object, 1) can be used instead.
- com.db4o.tools.Statistics can be used to print statistics about the used database file to System.out. All tools are distributed as sourcecode and they are not included in db4o.jar.
- com.db4o.tools.Defragment is a new tool to defragment database files. Read the documentation thoroughly and backup database files before using this tool.
- Configuration.messageLevel(int) now allows to specify, how detailed db4o is to log events. Possible levels are 0 to 3. Use Db4o.configure().messageLevel(3) for very detailed messages during debugging and to learn what is happening.
- Configuration.callbacks(boolean) now allows to turn ObjectCallback events off temporarily. This may be desirable for maintenance operations. The Defragment tool operates with callbacks turned off.
- Activation depth was partially inconsistent. Fixed.
- ObjectContainer#activate(Object, depth) and ObjectContainer#deactivate(Object, depth) now also lead to the desired effect, if an array is passed as an argument.
- Exception handling was modified to prevent successful shutdowns on fatal errors like OutOfMemoryError or StackOverflowError.
- A major bug that could lead to database file corruption on the above fatal errors, CTRL + C and other abnormal database engine process terminations was fixed.
- Multidimensional arrays containing empty ([]) or zero ([0]) dimensions would produce exceptions. Fixed.
- ObjectClass#rename() was only possible, if an old version of the class was present. Fixed.
- com.db4o.samples now contains the subfolders "activate", "callbacks" and "update" with examples to explain activation and callback methods and the update behaviour of ObjectContainer#set(). |
2001-07-06
version 1.20 |
- All ObjectContainer methods are now threadsafe. Usage of db4o in Java Server Pages and servlets is now possible without additional synchronisation efforts.
- Db4o.openFile() now allows multiple calls with the same file name. Every call will return the same ObjectContainer. Every openFile() needs a corresponding ObjectContainer#close(). db4o will close the respective ObjectContainer on the last call.
- An additional file locking mechanism provides more safety in concurrency environments.
- Exception handling was enhanced to provide more developer information, for instance on using a closed ObjectContainer or on not being able to find a class in the CLASSPATH.
- All db4o versions now run on Tomcat. A special CLASSPATH issue: It is recommended to place db4o.jar in the WEB-INF\lib of your webapp and not to include db4o.jar in the global CLASSPATH.
- The RandomAccessFile patch for EPOC is now incorporated into the JDK 1.x standard versions. Accordingly a special EPOC version is not necessary anymore.
- JDK2 Collection classes would produce problems on certain JDKs. Fixed. Storing TreeMap and TreeSet objects now also persists possible custom Comparators.
- If not all previously used applications classes were accessible with Class.forName(className), some methods like ObjectContainer#get(null) would throw exceptions. Fixed. db4o now marks classes as unusable during startup and ignores objects of unavailable classes.
- The new ObjectConstructor extension of ObjectTranslator allows writing custom translators that construct the object.
- A translator that uses Java serialisation is now built into the engine. It can be optionally used to quickly implement persistence for classes with problematic constructors.
- The sourcecode of all built-in translators is delivered with the download in ../com/db4o/samples/translators.
- To ensure future compatibility with C# keywords, 2 ObjectTranslator method names were renamed:
ObjectTranslator#in() >> ObjectTranslator#onStore()
ObjectTranslator#out() >> ObjectTranslator#onActivate()
- The methods ObjectContainer#activate(object), ObjectSet#current() and ObjectSet#isEmpty() and Db4o.echo(boolean) are deprecated. See the documentation for replacements. |
2001-06-07
version 1.10 |
- automatic activation on querying objects changed to preconfigured depth of 5, independent of the QBE example object, configurable globally and class-specific.
- additional ObjectContainer#activate(Object, depth) method to activate a tree of any size with one call.
- explicit commit() method for checkpoints.
- support for simple type wrappers in Object variables.
- support for multi-dimensional arrays.
- query evaluation mode changed to "contains" for arrays.
- support for Vector and Hashtable including "contains" queries.
- JDK 2 specific:
- support for all Collection classes including "contains" queries.
- support for private or parameterised constructors.
- support for inner classes.
- ObjectCallback methods to allow code execution upon storage events. Examples of use: cascaded delete, cascaded copy and cascaded update.
- Configuration interface for
- refactoring classnames and fieldnames.
- customized activation depths.
- customized update depths.
- activation events.
- translation of objects on storage and instantiation.
- configurable storage of transient members.
- ignoring fields in queries.
- automatic schema evolution now allows to change the data type of members.
- db4o used to store and restore static members and use them for query evaluation. Fixed.
- additional security handling to prevent user application code to open a database file twice.
- performance improvements > 10%.
- regression test code is included with the download. |
2001-01-31
version 1.0 |
- completely revised interface.
- Smart reflection allows the storage of objects without any modifications to their class files.
- A JDK 2 version enables the storage of private and protected members.
- Unicode version.
- A dedicated EPOC version contains a workaround for an EPOC JVM bug.
- members of class Object are stored.
- Interface members are stored.
- storage wrapper for java.util.Date |
2000-12-11
version 0.40 |
- fully revised architecture and file format.
- x50 performance boost.
- x50 decrease of database file size.
- x50 decrease in resource consumption.
- delete() is implemented. |
2000-10-22
version 0.20 |
- The new db4o JDBC interface completely exports and imports object data. The jdbc documentation provides further information. |
2000-09-18
version 0.10 |
- db4o was repackaged. All classes are now found in com.db4o.*.
- The interface naming was streamlined.
PersistentHandle >> DbHandle.
getPersistentHandle() >> db().
- db4o is now distributed as a jar.
- Navigation through member links is now possible with PersistentObject.db().activate() |
| 2000-08-20 |
- Support for inheritance. |
| 2000-08-05 |
- Support for arrays.
- The schema updating mechanism is started automatically with every start of the engine. |
| 2000-07-18 |
The indexing mechanism is implemented with a red-black binary tree.
A test with the benchmark database showed an improvement by more than 500%. |
| 2000-07-08 |
- The read algorithm now only reads objects, which are actually needed.
- First concept of the db4o query interface |
| 2000-07-06 |
First JDBC import run on an SQL database with 1 MB size. Large amounts of data are now available for testing and performance analysis. |
| 2000-06-30 |
- Support for Double, double, Float, float, Short, short, Character, char, Boolean, boolean, Byte, byte. |
| 2000-06-23 |
Support for Long, long, Integer, int, Boolean and boolean. |
| 2000-06-17 |
- Update is implemented.
- Address indirection is implemented. |
| 2000-06-15 |
The name db4o (database 4objects) was found. Thanks to Christian Runte for the suggestion. |
| 2000-05-28 |
get() and set() are implemented. Java classes with String- and Object-Members can be stored and retrieved. |
| 2000-01-01 |
The first line of code. |