Free database abstraction layer software for linux

Database Independent Abstraction Layer for C (libdbi) implements a database-independent abstraction layer in C, similar to the DBI/DBD layer in Perl.
Writing one generic set of code, programmers can leverage the power of multiple databases and multiple simultaneous database connections by using this framework.
Main features:
Database-level abstraction:
Your programs dont need to deal with the arbitrary interfaces and oddities of each database library. libdbi handles all the details for you, you just tell it what you want the database to do.
Modularity:
Since database code written with libdbi is not tied to one specific database server, you can effortlessly switch databases or give your users the option to specify their own database settings.
Clean interface:
With ample documentation describing libdbi and its well thought out object-oriented design, programming with libdbi should be less painful than programming with native database libraries. And you only need to learn it once instead of learning each database librarys syntax.
Accommodates coder apathy:
libdbi is written to do The Right Thing(tm), not just some quick hack that does the job in a half-assed fashion. This saves tons of your $100/hour time from debugging, so that you can mess around having fun during the hours that clients are paying you to debug. It also strives to reduce the worldwide crisis of carpal tunnel syndrome, so it uses constructs such as this one to pack multiple function calls into one line, saving you the bother of typing more than you have to:
dbi_result_get_fields(result, "id.%i firstname.%s lastname.%s fractional_value.%f", &id, &firstname, &lastname, &floatval);
Driver interface:
The dynamic linking used by libdbi allows for driver authors to license their drivers however they please - they are not restricted to the GPL or LGPL. Drivers are easy to write, and require no special installation.
Error handling:
Instead of checking every single database call for errors, libdbi gives programmers the option of registering an error handler callback, similar to a signal handler. Because we know youll "forget" to check for errors otherwise :)
Convenience:
Spend your time writing clever code, not reinventing the wheel with your own single-use, #define-abusing, less featureful database interface.
libdbi implements a database-independent abstraction layer in C, similar to the DBI/DBD layer in Perl. Writing one generic set of code, programmers can leverage the power of multiple databases and multiple simultaneous database connections by using this framework.
The libdbi-drivers project maintains drivers for libdbi. Drivers are distributed seperately from the library itself.
There are currently drivers for MySQL, PostgreSQL, SQLite, and mSQL. More are on the way.
Enhancements:
- Support for a timezone suffix in time and date types was added.
- Error handling and error reporting were vastly improved.
- Some memory leaks were fixed.

DBIx::SQL::Abstract is a Perl module that provides a convenient abstraction layer to a database.

SYNOPSIS

use DBIx::SQL::Abstract;

my $dbh = DBIx::SQL::Abstract->new( %dbcfg );

Building SQL Abstractions.

my($query, @bind) = $dbh->select($table, @fields, %where, @order);
my($query, @bind) = $dbh->insert($table, %fieldvals || @values);
my($query, @bind) = $dbh->update($table, %fieldvals, %where);
my($query, @bind) = $dbh->delete($table, %where);

Using DBI methods

my $sth = $dbh->prepare($query);
$sth->execute(@bind_params);
...
my $rc = $dbh->begin_work;
my $rc = $dbh->commit;
my $rc = $dbh->rollback;
my $rc = $dbh->disconnect;

Anything else DBI method can be used, by Example:

my $err = $dbh->err;
my $err = $dbh->errstr;
my $rv = $dbh->state;
my $rc = $dbh->DESTROY;

The intention of this module is to join some methods from the DBI and the SQL::Abstract modules, for a convenient and easy use.

To begin, we create an object, but first we must create a hash which contains the database parameters as follows.

my %dbcfg = { PrintError => 1,
RaiseError => 0,
AutoCommit => 0,
ChopBlanks => 1
driver => Pg,
dbname => db,
host => undef,
port => undef,
user => user,
passwd => undef
};

Notice that this parameters are set as default unless you set your required values.
my $dbh = DBIx::SQL::Abstract->new( %dbcfg );

This object automatically creates the connection with the database, and gets the methods listed above.

GNUstep Database Library 2 (GDL2) is a set of libraries to map Objective-C objects to rows of relational database management systems (RDBMS).
GNUstep Database Library 2 aims to be compatible with Enterprise Objects Framework (EOF) as released with WebObjects 4.5 from Apple Inc.
Main features:
- EOControl (gnustep-db2control)
- The fundamental abstraction library which includes many non RDBMS related extensions such as KeyValueCoding extensions and other categories. Most importantly it contains the classes which handle the coordination of object graphs namely EOEditingContext.
- EOAccess (gnustep-db2)
- This library implements the underlying mechanism to retrieve and store data in RDBMS. It defines the abstract classes like EOAdaptor which are subclassed to interface with concrete RDBMS implementations.
- EOInterface
- This library implements classes used to synchronize UI components such as NSTextFields, NSButtons and NSTableViews with the state of objects which an EOEditingContext contains.
- EOAdaptors
- This is a collection of concrete EOAdaptor projects needed to connect to specific databases. GDL2 currently only supplies an Adaptor for the PostgreSQL database. Even though the Adaptor is still called Postgres95 we aim to support PostgreSQL 7.2 and higher API. In fact the Adaptor may very soon be renamed to PostgreSQL.
- DBModeler

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.

Beacon is the SIMPLE free wiki and tag based publishing system!
Beacon allows non technical people easy page editing and categorization of web pages making Beacon idea for groups of people wishing to collaborate around a documentation or composition project.
Main features:
- Wiki article formatting and linking
- Tag based categorisation of articles
- Customisable menus
- File upload and inclusion in article content
- RSS feed
- Article commenting
- Open or restricted editing
- Templated design
- Captcha security
- Database abstraction layer (works with many types of database)
- Multilingual (content and interface)
- Spellchecking
- Search
- Newsletter
Enhancements:
- This release adds a Captcha session check, upgrades PHPMailer, and fixes the PHPMailer error display in Beacon, a comment display error, and links in the default template.

Wiaflos Accounting project is an attempt to create a multi-platform server-client based accounting system.
The goal is to have a central accounting engine which can either run on a dedicated server or on the same PC as the client interface. The accounting engine will provide a full SOAP API for easy writing of GUI/Web interfaces or tieing into inhouse systems. Seeing as the accounting engine is written in Perl and makes use of a database abstraction layer, the engine should run on nearly any operating system and use nearly any database system supported by Perl and the target OS.
We want this package to be of equal use to the one-man-show as a full accounting package running on a single PC aswell as to large multi-national corporate entities with dedicated accounting servers using the package as a fast stable accounting function, solution or full package.
Main features:
Platform independant
- Wiaflos Accountings core and engine is written in Perl. Perl is an interpreted programming language capable of running on many different platforms including Unix/Linux, Mac, Windows, BSD and many more.
Database independent
- Wiaflos Accountings database interface utilizes the Perl DBI module. This module allows Wiaflos Accounting to access multiple database types transparently, allowing you to utilize the database of your choice, be it MySQL, MSSQL, Oracle, Informix, Sybase or ODBC (or basically anything else).
Folding database transactions
- All modules use database transactions to ensure that if an error occurs everything is rolled back to a safe state. When different modules are integrated to provide functionality like invoicing and purchasing, there are sometimes quite a number of transactions involved which both update, insert and query data. The Wiaflos Accounting database engine automatically merges all transactions during a specific operation into one, this ensures a clean rollback should anything go wrong.
SOAP API (WebServices)
- The interface to Wiaflos Accounting is based on SOAP (Simple Object Access Protocol). The SOAP protocol is a critical communication protocol on the Internet due in large part to the fact that it has become native to so many development platforms, this allows Wiaflos Accounting the maximum benefit of integration and interpolation with other software packages. The SOAP API supports communication over HTTP and HTTPS and includes a full user-based access control system, allowing only certain users access to certain API functions.
Persistent sessions
- Not only does Wiaflos Accounting support SOAP, but it supports persistent SOAP sessions. Authentication is only required once, after that a session cookie is handed to the client application which can then be used in future function calls to authenticate.
Enhancements:
- This version includes support for statements and "balance brought forward" when requesting GL entries.
- Some bugfixes and feature enhancements were made.

DaDaBIK project is a free PHP application that allows you to easily create a highly customizable front-end for a database in order to search, update, insert and delete records; all you need to do is specifying a few configuration parameters.

Starting from version 4.0 alpha DaDaBIK uses the ADOdb Database Abstraction Library in order to support as many DBMS as possible, at the moment it has been tested on MySQL, PostgreSQL, Oracle and MS SQL Server.

The strength of DaDaBIK lies in its ability to be customized. For each field of a table you can choose:

- if the field should be included or not in the search/insert/update form and results table
- its label (what will appear in the form near the input field)
- its content format (e.g. numeric, alphabetic, e-mail, url......)
- the input type (e.g. select, date, text, rich text editor, password......)
- the possible values, also driven from another table (foreign key support)
and more...

DaDaBIK also allows you to handle multiple tables. Other features include file uploading, export to CSV, checking for possible duplication during an insert, authentication and authorization restrictions on view/update/delete.
The graphic layout of DaDaBIK is customizable to help you to embed its forms in your own site.

DaDaBIK differs from other applications like PHPMyAdmin since it doesnt enable the complete administration of a database, but rather to easily create a simple and customizable Web application that manages a group of tables by allowing search/insert/update/delete operations. DaDaBIKs target user is not the DB administrator but rather the final user.

DaDaBIK is available in Italian, English, Dutch, German, Spanish, French, Portuguese, Croatian, Polish, Catalan, Estonian, Rumanian, Hungarian and Slovak.