Free object relational database software for linux

Object Relational Membrane is a Python package that provides the functionality of an object relational layer like EJB or other persistence storage systems.
Object Relational Membrane is a thin compatibility layer between SQL table layouts and Object Oriented Python. While providing a good deal of functionality, it tries to be as small and simple as possible. It currently works with PostgreSQL and Gadfly.
Adapters for Firebird and MySQL are planed.
Enhancements:
- A number of small changes and enhancements.
- The last release previous to a "beta" release.

Object::Relation::Meta::Class::Schema is a Perl module for Object::Relation database store builder.

This module is provides metadata for all Object::Relation classes while building a storage schema. Loading Object::Relation::Schema causes it to be used instead of Object::Relation::Meta::Class. This is so that extra metadata methods are available that are useful in constructing the schema, but are not otherwise useful when an application is actually in use.

At this point, those attributes tend to be database-specific. Once other types of data stores are added (XML, LDAP, etc.), other attributes may be added to allow their schemas to be built, as well.

Mckoi SQL Database is a full featured SQL-92 relational database management system written in Java.

The software can operate as either a dedicated multi-client, multi-threaded database server, or can be used as an embedded database inside a Java application.

The engine is designed to be easy to use and maintain and versatile for sophisticated database development tasks. The software provides a JDBC 2.0 driver.

To use Mckoi SQL Database, you will need a JavaTM runtime environment version 1.2 or greater. Sun provides Java runtimes for Win32, Solaris and Linux from their website at http://www.javasoft.com/j2se/. IBM also provides various Java runtimes for a number of platforms at http://www.ibm.com/java/jdk/download/.

When Java has been installed on your system, unpack the mckoi distribution file to a directory in your file system. Then you are ready to create a database and develop your database application.

Creating A Database

Before you can begin development of your database application, you will need to create and configure a blank database. The database configuration file describes all of the configurable properties of the database (details of the database configuration file are covered in the next section). The software ships with a default configuration that looks for a database at path ./data in your filesystem.

To create a database using the default configuration with an admin username of admin_user and password aupass00, go to a prompt, change to the Mckoi Database distribution directory and type:

java -jar mckoidb.jar -create "admin_user" "aupass00"

We do not advise using either this username or password in a production system. The user created here has full control over every aspect of the database so choose a username / password carefully.

When the command has completed, a sub-directory called data will have been generated. This directory is used to store data from the database. A sub-directory called log is also generated which stores debugging and query log information.

Database Configuration

When you run the mckoidb.jar package, it looks for a file named db.conf in the current directory. This file contains a number of variables that determine where the database looks for information, as well as other user-definable properties. The configuration file can be renamed and copied to a different location. If you change the configuration file location, you must supply the location when you run the database;

java -jar mckoidb.jar -conf [location of conf file] .....

You can edit the configuration file with a text editor. The default configuration file that ships with the software contains extensive comments on what each variable does.

Valentina is cross-platform DBMS that makes it easy to switch between a local embedded database and server using the same sources. It supports disk and in-memory databases, field types from Bit to BLOB, and both a SQL92(99) and non-SQL API.
Valentina supports Relational, Extended Navigational, and Object-Relational data models. It introduces a revolutionary model abstraction "Link". It works natively in UTF-16, can accept 270 encodings, and features advanced features such as regular expressions, XML, full-text search, pictures, functions, and calculated fields. It offers triggers, views, and stored procedures.
Enhancements:
- Valentina Studio now has a Diagrams panel for database schema.
- There are new examples on the usage of Link refactorings API and SQL commands.
- There are about 40 bugfixes over the entire product line (kernel, PHP, REALbasic, Director, VCOM, and VStudio).

Haskell Database Connectivity project provides an abstraction layer between Haskell programs and SQL relational databases. This lets you write database code once, in Haskell, and have it work with any number of backend SQL databases (MySQL, Oracle, PostgreSQL, ODBC-compliant databases, etc.)
HDBC is modeled loosely on Perls DBI interface http://search.cpan.org/~timb/DBI/DBI.pm, though it has also been influenced by Pythons DB-API v2, JDBC in Java, and HSQL in Haskell.
HDBC is a from-scratch effort. It is not a reimplementation of HSQL, though its purpose is the same.
Main features:
- Ability to use replacable parameters to let one query be executed multiple times (eliminates the need for an escape function)
- Ability to access returned rows by column number
- Ability to read data from the SQL server on-demand rather than reading the entire result set up front
- HUnit testsuite for each backend driver
- Well-defined standard API and easy backend driver implementation
- Lazy reading of the entire result set (think hGetContents, but for the results of SELECT) (see sFetchAllRows)
- Support for translation between Haskell and SQL types
- Support for querying database server properties
- Add-on package (hdbc-missingh) to integrate with MissingH, providing a database backend for AnyDBM.
- Support for querying metadata such as column names.
- Support for querying additional metadata (column types, etc.)

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

Multi-Simulator Interface, in shrot MSI, is a simulation interconnection engine. In other words it is a program that connects simulations together by synchronizing their clocks and data. Multi-Simulation Interface serves the same purpose as HLA and supports most of HLAs functionality (and more).
The MSI is an HLA alternative. The major motivating factors in the design of the MSI are speed, interoperability, and ease of use.
The MSI was written as a cutting edge distributed simulation component to connect multiple instances of ATLs premiere simulation software, CSIM, and it can be used to interface any compatible simulations.
How does the MSI compare to HLA?
The MSI was originally created to be just a light weight HLA RTI. However, as it was written, limitations in HLA were discovered. The MSI is an improvement on both the design and implementation of HLA. Some highlights include:
A 1,536 to 1 reduction in size over the publicly available (until late 2002) HLA RTI.
At least one order of magnitude of bandwidth consumption less than the publicly available (until late 2002) HLA RTI.
The ability to subscribe to an object name in addition to a type.
Time synchronization that allows for proper causality when used with discrete event simulators.
Support for systems-of-systems (SoS) and hierarchically organized simulations.
Availability for many platforms.
MSI Concept - A Synchronized Data Broker
The concept behind MSI is the synchronized data broker. There are many connected software systems that posses state data that changes over the life of that system. In the case where these systems need to exchange this changing data with other systems and the other systems will exhibit the effects of this data on their own state, the synchronization of this data may need to be managed.
Historically the management of this data has been as simple as tagging it with the time of its release. If there is any conflict in the data the most recent version of the data is used. If the data is late an extrapolation can potentially be used. In SQL relational databases transactions and locking are used to ensure data integrity. Most data brokering services offer little or no sychronization, only delivery.
MSI Setup and Use
The MSI uses a XML stream through a direct socket connection for communications. This enables the MSI to be used from any programming language that can use sockets (C, C++, Java, Ada, Lisp, Perl, etc.). Also, the MSI was written with cross-platform libraries that make it portable to all the major OS platforms (Linux, Solaris, Mac OS X, Microsoft Windows, IRIX, HPUX, etc.).
The MSI is a single executable file and is distributed with example code for the simulator/federate side interface.
MSI Time Synchronization
The MSI time synchronizer can mix unconstrained with time constrained simulations. Each constrained simulation reports the time of the next event that will occur in that simulation/federate. This time may be artificially inflated to cause loose synchronization (less overhead but less guarantee of accuracy). The simulations/federates will advance to the announced time.
MSI Data Synchronization
The MSI implements a publish/subscribe data broker. The MSI is presently not validating, therefore it does not require a separate data format specification (like the HLA FOM). When data format validation is implemented, it will be an optional feature and not written in Lisp. This greatly reduces MSIs setup time. Also, not being locked to a predetermined data format allows for dynamic data types.
There are five commands associated with the MSI data broker: publish, subscribe, update, unsubscribe, destroy (destroy is not implemented yet). Simulations/federates may subscribe to object names in addition to object types. This allows simulations to subscribe to specific objects of a type without needing to receive updates of all objects of that type. The update command is both an incoming and outgoing command. When a simulation/federate receives an update command, it is expected to reflect the new values of that object.
The MSI has a very flexible publish and subscribe system. A federate may subscribe to an object type or an object name. In addition a federate may specify particular attributes of an object or object type. For example, if an object has attributes name, x, y, and z, a federate that only considers two dimensions may choose to subscribe only to name, x, and y.
The MSI also supports systems of systems and object hierarchy in simulations. A publishing federate may designate a parent object. Subscribers may then subscribe to the objects children.
MSI Messaging
The MSI allows simulations/federates to send messages (interactions in HLA) to each other. These messages can contain multiple attributes and be multicast to a specific group of simulations.
Recently Added Features
Removed external library dependencies to improve the portability and fragility of the MSI.
Added a better client library.
Improved documentation.
Enhancements:
- An XML parsing bug in the utilities library was fixed.
- The socket library was enhanced with more protocols, Win32 tricks, and the ability to key off of addresses as well as names.
- The --wait-for command line argument was added.
- Several internal bugs were fixed.
- More of the client library and the CSIM interface were flushed out.
- All standard functionality was tested.

Aqua Data Studio program is a database query tool and administration tool that allows developers to easily create, edit, and execute SQL scripts, as well as browse and visually modify database structures.
Aqua Data Studio provides an integrated database environment with a single consistent interface to all major relational databases. This allows the database administrator or developer to tackle multiple tasks simultaneously from one application.
Main features:
Query Analyzer/Window
- Aqua Data Studios sophisticated Query Analyzer allows users to work on database scripts with specific RDBMS syntax highlighting and auto-completion to develop and test SQL scripts. Other features to speed up development include SQL automation, auto-describe and sortable multi-grid results. The query analyzer also provides client side variable binding, allowing a user to execute stored procedures or functions with local variables binded to receive out parameters. The query window also provides two modes of operation, using a SplitPane View or a MultiTab View for the editor and the query results.
Schema Browser & Visual Editing
- Its graphical browsing capabilities allow you to understand the structure and dependencies of the database schema with a single mouse click. The schema browser also allows you to visually edit any schema object with a graphical design form to CREATE, ALTER or DROP the object. Visual editing supports Tables, Indexes, Procedures, Data Types and other schema objects. The visual editors also provides an SQL preview of all the commands to be executed to commit the operation.
Schema Extraction & DDL Scripting
- Its graphical browsing allows you to extract the structure definition of all schema objects and to script the SQL DDL and DML (eg CREATE, ALTER, DROP, SELECT, INSERT, UPDATE and DELETE) syntax for database schema objects (including Tables, Views, Triggers, Stored Procedures and Functions).
Table Data Editor
- A powerful Table Data Editor allows you to modify your results graphically and save them. By writing a single table SELECT statement in the Query Analyzer and clicking on the Execute Edit button, a separate window is opened with the query results for you to edit and save. You may also browser to a table in the schema browser and select the Edit Table from the popup menu to edit the first 1000 records in a table.
Enhancements:
- Enhancements in this release include OS X Integration, Windows integration, complete and customizable keymapping, a schema difference tool, a directory difference tool, a file difference tool, a tab difference tool, a copy history difference tool, SQL Server DBA tools, and Sybase DBA tools.
- In total, there were over 100 new features.