Free object relational software for linux

Object::Relation::Meta::Type is an Object::Relation Data type validation and accessor building.

Synopsis

Object::Relation::Meta::Type->add(
key => "state",
name => "State",
builder => Object::Relation::Meta::AccessorBuilder,
raw => sub { ref $_[0] ? shift->value : shift },
store_raw => sub { shift->store_value },
check => sub {
UNIVERSAL::isa($_[0], Object::Relation::DataType::State)
or throw_invalid([Value "[_1]" is not a valid [_2] object,
$_[0], Object::Relation::DataType::State]);
throw_invalid([Cannot assign permanent state])
if $_[0] == Object::Relation::DataType::State->PERMANENT;
}
);

This class subclasses Class::Meta::Type to provide additional attributes. These attributes can optionally be set via the call to new(), and may be fetched via their accessors.

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.

Object::AutoAccessor is an accessor class by using AUTOLOAD.

SYNOPSIS

use Object::AutoAccessor;

my $struct = {
foo => {
bar => {
baz => BUILD OK,
},
},
};

# Now lets easily accomplish it.
my $obj = Object::AutoAccessor->build($struct);

print $obj->foo->bar->baz; # prints BUILD OK

# OK, now reverse it!
$obj->foo->bar->baz(TO HASHREF);
my $hashref = $obj->as_hashref;
print $hashref->{foo}->{bar}->{baz}; # prints TO HASHREF;

# Of course, new() can be used.
$obj = Object::AutoAccessor->new();

# setter methods
$obj->foo(bar);
$obj->set_foo(bar);
$obj->param(foo => bar);

# getter methods
$obj->foo();
$obj->get_foo();
$obj->param(foo);

# $obj->param() is compatible with HTML::Template->param()
my @keywords = $obj->param();
my $val = $obj->param(hash);
$obj->param(key => val);

my $tmpl = HTML::Template->new(..., associate => [$obj], ...);

Object::AutoAccessor is a Accessor class to get/set values by AUTOLOADed method automatically. Moreover, param() is compatible with HTML::Template module, so you can use Object::AutoAccessor object for HTML::Templates associate option.

Object::Trampoline is a Perl module for delay object construction, and optionally using the class module, until a method is actually dispatched, simplifies runtime definition of handler classes.

SYNOPSIS

# adding "use_class" will perform an "eval use $class"
# at the point where the object is first accessed.

use Object::Trampoline;

# the real class name is added to the normal constructor
# and Object::Trampoline used instead. the destination
# class constructor is called when object is actually
# used for something.

my $dbh = Object::Trampoline->connect( DBI, $dsn, $user, $pass, $conf );

my $sth = $dbh->prepare( select foo from bar );

# or specify the package and args from a config file
# or via inherited data.
#
# the constructor lives in the destination class
# and has nothing to do with Object::Trampoline.

my %config = Config->read( $config_file_path );

my ( $class, $const, @argz )
= @config{ qw( class const args ) };

my $handle = Object::Trampoline->$const( $class, @argz );

# at this point ref $handle is Object::Trampoline::Bounce.

$handle->frobnicate( @stuff );

# at this point ref $handle is $class

# there are times when it is helpful to delay using
# the objects class module until the object is
# instantiated. O::T::U adds the callers package
# and a "use $class" before the constructor.

my $lazy = Object::Trampoline::Use->frobnicate( $class, @stuff );

my $result = $lazy->susan( dessert );

There are times when constructing an object is expensive or has to be delayed -- database handles in heavily forked apache servers are one example. This module creates a "trampoline" object: when called it replaces the object you have with the object you want. The module itself consists only of two AUTOLOADS: one with captures the constructor call, the other the first method call. The first class blesses a closure which creates the necessary object into the second class, which replces $_[0] with a new object and re-dispatches the call into the proper class.

Using an autoload as the constructor allows Object::Trampoline to use whatever constructor name the "real" class uses without having to pass it as another argument.

The Object Oriented Database Kit is a set of tools to help database applications developers to handle database communication, reporting, and printing. It has a solid, stable, and easy to use API. The project is also GUI toolkit agnostic and portable.

Object::InsideOut is a comprehensive inside-out object support module.

SYNOPSIS

package My::Class; {
use Object::InsideOut;

# Numeric field
# With combined get+set accessor
my @data
:Field
:Type(numeric)
:Accessor(data);

# Takes INPUT (or input, etc.) as a mandatory parameter to ->new()
my %init_args :InitArgs = (
INPUT => {
Regex => qr/^input$/i,
Mandatory => 1,
Type => numeriC,
},
);

# Handle class-specific args as part of ->new()
sub init :Init
{
my ($self, $args) = @_;

# Put input parameter into data field
$self->set(@data, $args->{INPUT});
}
}

package My::Class::Sub; {
use Object::InsideOut qw(My::Class);

# List field
# With standard get_X and set_X accessors
# Takes INFO as an optional list parameter to ->new()
# Value automatically added to @info array
# Defaults to [ empty ]
my @info
:Field
:Type(list)
:Standard(info)
:Arg(Name => INFO, Default => empty);
}

package Foo; {
use Object::InsideOut;

# Field containing My::Class objects
# With combined accessor
# Plus automatic parameter processing on object creation
my @foo
:Field
:Type(My::Class)
:All(foo);
}

package main;

my $obj = My::Class::Sub->new(Input => 69);
my $info = $obj->get_info(); # [ empty ]
my $data = $obj->data(); # 69
$obj->data(42);
$data = $obj->data(); # 42

$obj = My::Class::Sub->new(INFO => help, INPUT => 86);
$data = $obj->data(); # 86
$info = $obj->get_info(); # [ help ]
$obj->set_info(qw(foo bar baz));
$info = $obj->get_info(); # [ foo, bar, baz ]

my $foo_obj = Foo->new(foo => $obj);
$foo_obj->foo()->data(); # 86

Firebird is a relational database offering many ANSI SQL-99 features that runs on Linux, Windows, and a variety of Unix platforms.

Firebird offers excellent concurrency, high performance, and powerful language support for stored procedures and triggers. Firebird Relational Database has been used in production systems and under a variety of names since 1981.

Firebird is a commercially independent project of C and C++ programmers, technical advisors and supporters developing and enhancing a multi-platform relational database management system based on the source code released by Inprise Corp (now known as Borland Software Corp) on 25 July, 2000 under the InterBase Public License v.1.0.


New code modules added to Firebird are licensed under the Initial Developers Public License. (IDPL). The original modules released by Inprise are licensed under the InterBase Public License v.1.0. Both licences are modified versions of the Mozilla Public License v.1.1.

Installing:

In order to install the firebird version of IB 6.0 you will need to perform the following steps:

1. Get the required packages:

Get the glibc update from RedHat, the one I used
was from ftp://updates.redhat.com/7.0/i386/glibc-2.2-5.i386.rpm

Get ncurses4 from
ftp://carrier.ision.net/pub/ftp.redhat.com/i386/en/RedHat/RPMS/ncurses4-5.0-2.i386.rpm
or another redhat mirror.

Get Firebird from
ftp://firebird.sourceforge.net/pub/firebird/release/FirebirdSS-0.9-1.i386.rpm

2. Prepare the installation:

Log in as root.
Use a plain text console to do this and be sure
that all Gnome desktops are closed.
(One user reported that the Gnome desktop
(apparently ICEwm)
blocked port 3050. I could not reproduce this
here, but it seems that it uses port numbers
that arent assigned in /etc/services for own
purposes)

3. Add localhost.localdomain to /etc/hosts.equiv:
echo localhost.localdomain >>/etc/hosts.equiv

4. Change to the directory where you have placed
the downloaded packages.

5. Install the glibc update:
rpm --install --force glibc-2.2-5.i386.rpm

6. Install libncurses.so.4:
rpm --install --force ncurses4-5.0-2.i386.rpm

7. Install Firebird:
rpm --install --force FirebirdSS-0.9-1.i386.rpm

8. Add /opt/interbase/bin to your path:
You can either change /etc/profile
or do
export PATH=$PATH: /opt/interbase/bin
or
change the profiles in your users home directories

9. Check that all went well:

Read /opt/interbase/SYSDBA.password
to get your SYSDBA password.

gsec -display
should display the list of known users
(SYSDBA only after a fresh install)

isql /opt/interbase/examples/employee.gdb
SQL> SHOW TABLES;
should display all tables from this database
SQL>quit;