Free persistence software for linux

Simple persistence for Java is an object/relation mapping framework for Java. It is designed to be easy to use.
There are no XML files to write, no tables to create, no IDs to generate, and no primary keys to fiddle with; just point it to the database, check the API documentation for three basic methods, and code away.
Simple persistence for Java supports transactions, has its own simple query language (very similar to SQL), and can handle object references, lists, and maps.
You may ask: Why another O/R mapping library? Well.. Ive searched the net for a suitable O/R tool for a long time now, also tried a few in live projects, but each time, at the end of the project, I had always had a few thoughts to simplify the database interaction code. Ive started with EJB around 2000. Now, I think everyone who used EJBs also at least once wondered why saveing a friggin object requires a separate server installation, the extensive knowledge of a 200+ page documentation, generating 3 classes/interfaces per object, installing stubs, rmi, and other things I dont even want to know about. Lets just skip this chapter of my life directly to my last experience with an O/R library: pbeans. This library is generally good, I can recommend it for those, who want a stable O/R mapping tool, but it was not the one for me. I found a few points I couldnt get over:
- Save and insert should be one method. I usually dont care if an object is inserted or saved phisically, as long as its saved.
- It should handle Lists and Maps. Well, "Lists should be enough for everybody", but sometimes Maps are handy too. Lists are used very often, I think it should be handled automatically.
- The query code is too difficult, and at the same time does not offer enough features.
- The code you have to write wont be "pretty". It requires classes to be parameters, at least for queries, and I cant read the query itself.
- The Id handling is not transparent.
Enhancements:
- A major scalability feature has been added: the library is now capable of working in a distributed environment, such as load-balanced Web server clusters.
- All the library nodes connected to the same database will form a self-regulating, self-organizing, failure-tolerant network to manage exclusive resources (such as locks, etc).
- The documentation and site were updated accordingly.

Open Tranquera is a repository of reusable components for J2EE application development.

There are UI extensions, Services, and a Persistence layer, integrated with existing open source frameworks.

LiteSQL is a C++ library that integrates C++ objects tightly to relational database and thus provides an object persistence layer.
LiteSQL supports SQLite3, PostgreSQL and MySQL as backends. LiteSQL creates tables, indexes and sequences to database and upgrades schema when needed.
LiteSQL provides object relations, in addition to object persistence which can be used to model any kind of C++ data structures. Objects can be selected, filtered and ordered using template- and class-based API with type checking at compile time.
Main features:
- SQLite3, PostgreSQL and MySQL - backend support
- object persistence layer with relation support
- automatic database schema creation and upgrading
- create complex SQL queries using compile time checked class API; minimizes need to write SQL query strings

KAON project consists of an ontology management infrastructure targeted at business applications.

It includes a comprehensive tool suite allowing easy ontology creation and management and provides a framework for building ontology-based applications.

An important focus of KAON is scalable and efficient reasoning with ontologies.

Persistence mechanisms of KAON are based on relational databases.

EasyBeans is an implementation of an EJB3 container. EasyBeans library aims to provide an implementation for the full EJBCore API.
For the persistence matter, it relies on Hibernate EJB 3 or, in upcoming versions, on Speedo, the ObjectWebs JDO implementation.
it is divided in three parts :
- Core part
- Persistence part (Which is the persistence provider)
- Simplified specification : it contains new features.
Enhancements:
- EAR deployment (and undeployment) is now supported in JOnAS, Tomcat, and Jetty.
- For JOnAS, if the EAR contains EJB 2.1 components, they will be deployed in the EJB 2.1 container.
- The WAR files of the EAR will be deployed in the Tomcat or Jetty Web container.
- An ear example is provided in this version.
- The timer service which is based on the Quartz component is supported.
- A timer example is provided.
- OpenJPA is supported as a persistence provider.

Object::Mediator is a generic object persistence framework.

SYNOPSIS

package Persistent;

use base qw( Object::Mediator );

__PACKAGE__->mk_attr ( qw(foo bar) );

sub _set_id {
my $self = shift;

my $id = generate_identity();

$self->identity( $id );
}

sub _insert {
my $self = shift;

$db_handle->insert ( $self->id, $self->foo, $self->bar );
}

sub _update {
my $self = shift;

$db_handle->update ( $self );
}

sub _delete {
my $self = shift;

$db_handle->delete ( $self->id );
}

sub _select {
my $self = shift;

my ( $foo, $bar ) = $db_handle->select ( $self->id );

$self->foo ( $foo );
$self->bar ( $bar );
}

Object::Mediator attempts to be simple and fairly minimalistic object mapping framework. Main aims of development were: usage simplicity, end user transparency, database independency and minimization of database interaction with some kind of in-memory object state control system.

SLOOPS - Simple, Light, Object Oriented Persistence System.

SLOOPS is a lightweight Object Oriented persistence system.

If you want to follow the tutorial, uncompress the distribution from command line !

It has been designed with simplicity and reliability in mind. So you should expect:

- VERY EASY AND QUICK implementation of your own datamodel. - VERY EASY retrieving of your data. - Some limitations that are negligable for 90% of cases !

It has been tested in production environment for months, so you can relie on it !
It allows to make objects persistents with just a few lines of declarative code. It supports:

- Inheritance
- Class polymorphism.
- Scalar attributes ( can be Object ! )
- SQL Free queries !
- MySQL database ( other ones in the future ).
- Optionnal caching based on Cache::FastMemoryCache .

It doesnt support :

- nonscalar attributes. So you have to do helper objects to support n-n relations . Is it so bad ?
- transaction . Thats a serious issue. Will be implemented with other database support !

DB_DataContainer is a PEAR compliant database persistence layer and data encapsulation class. A persistence layer can encapsulate the behaviour needed to make objects persistent like for exemple: to load, save and delete objects to and from persistent storage. Currently the only supported persistence mechanisms are relational databases. Database abstraction is provided by PEAR DB.
Data encapsulation is provided by overloaded accessor methods. This means that if you have a property named $foo and you do not write getFoo() and setFoo() methods in the extending class yourself, they will be automatically provided by DB_DataContainer.
As a result of the provided persistence mechanism and data encapsulation DB_DataContainer together with few lines of extra code can be used to implement the Active Record Pattern as described by Martin Fowler:
An object that wraps a row in a database table or view, encapsulates the database access, and adds domain logic on that data.
The class does not use any external configuration files. The extending class itself IS the configuration. All you need to take care about is to have matching propertyname - columname pairs in the class and the database table.
If your database schema changes, for example you add an column foo to the table, all you need to do is to add a property name foo to your class which extends DB_DataContainer. There is no need to rewrite any internal SQL queries.
The class does not provide direct support for JOIN:s or table linking. For extreme cases it is still possible to pass hardcoded SQL queries. This usage is discouraged since it breaks the basic idea of using DB_DataContainer.
Main features:
- Simple API
- Persistence mechanism encapsulation. You only need to call load(), save() or delete(). Note that there are no separate methods for INSERT and UPDATE. save() figures itself out which query to use.
- Overloaded accessor methods for class properties without such methods.
- PEAR DB supported databases as persistence mechanisms (tested with Postgres, MySQL, MSSQL and SQLite).
- Multi-object actions provided by a static getObjects() call.
- Possibility to use hardcoded SQL queries in multi-object actions.
- Regression tests.
- Supports PHP4 and PHP5 (starting from version 1.3.0)
Enhancements:
- This release fixes problems with protected and private data members when using PHP5.