Free dbix software for linux

DBIx::OO is a database to Perl objects abstraction.

SYNOPSIS

package MyDB;
use base DBIx::OO;

# We need to overwrite get_dbh since its an abstract function.
# The way you connect to the DB is really your job; this function
# should return the database handle. The default get_dbh() croaks.

my $dbh;
sub get_dbh {
$dbh = DBI->connect_cached(dbi:mysql:test, user, passwd)
if !defined $dbh;
return $dbh;
}

package MyDB::Users;
use base MyDB;

__PACKAGE__->table(Users);
__PACKAGE__->columns(P => [ id ],
E => [qw/ first_name last_name email /]);
__PACKAGE__->has_many(pages => MyDB::Pages, user);

package MyDB::Pages;
use base MyDB;

__PACKAGE__->table(Pages);
__PACKAGE__->columns(P => [ id ],
E => [qw/ title content user /]);
__PACKAGE__->has_a(user => MyDB::Users);

package main;

my $u = MyDB::Users->create({ id => userid,
first_name => Q,
last_name => W });

my $foo = MyDB::Users->retrieve(userid);
my @p = @{ $foo->fk_pages };
print "User: ", $foo->first_name, " ", $foo->last_name, " pages:n";
foreach (@p) {
print $_->title, "n";
}

$foo->first_name(John);
$foo->last_name(Doe);
# or
$foo->set(first_name => John, last_name => Doe);
$foo->update;

DBIx::Frame is a Perl module for creating and maintaining DBI frameworks.

SYNOPSIS

use DBIx::Frame;
DBIx::Frame->init(server, dbtype) || exit(0);
my $DB = DBIx::Frame->new(database, user, pass)
or die("Couldnt connect to database: ", DBI->errstr);
See below for how to actually use this object.

DBIx::Frame is an extension of the standard DBI perl module, designed around mysql, and used to create and maintain frameworks for databases. It has query logging, and a standardized interface for standard SQL statements like update and insert that doesnt require understanding SQL to any great degree.

Ideally, the user or developer shouldnt have to know too much SQL to be able to administer a database. On the other hand, it does require a certain setup that isnt necessarily easy to pick up, and isnt standard SQL - with all the problems that this entails.

Database design is discussed below.

DBIx::PDlib is a Perl with DBI SQL abstraction and convenience methods.

SYNOPSIS

use DBIx::PDlib;
my $db = DBIx::PDlib->connect({
driver => mydriver,
host => myhost.com,
dbname => mydb,
user => myuser,
password => mypassword,
});

my ($name) = $db->select(name,table1,"id = 10");

my $dbi_sth = $db->iterated_select(name,table1,
"id > 2",ORDER BY name);
while (my ($name) = $dbi_sth->fetchrow_array) { ...do stuff... }

my $rv = $db->insert(table1,[id,name],[11,Bob]);

my $rv = $db->update(table1,[name],[Bob Jr.],"id = 11");

my $rv = $db->delete(table1,"id = 11");

my @quoted = $db->quote( "something", $foo, $bar, @moredata );

my $rv = $db->raw_query("CREATE TABLE table1 (id int, name char)");

if ($db->connected) { ...were connected... }

$db->disconnect;

ABSTRACT

DBIx::PDlib provides a simplified way to interact with DBI. It provides methods for SELECT, INSERT, UPDATE, and DELETE which result in having to type less code to do the DBI queries. It does as little as possible to make things easier.

What it doesnt do... It isnt trying to replace DBI. Its not trying to completely abstract SQL statement building into some 100% perllike syntax (though that is REALLY cool, and what I liked about DBIx::Abstract), but it does abstract it some.

DBIx::Wrapper library is a Perl module that serves as a wrapper around DBI, providing additional functionality and convenience methods.
Enhancements:
- This release adds convenience methods for generating CSV, XML, and bencoded strings from query results.
- The connect_from_config() method was added in version 0.23, allowing database connection parameters to be specified in a file rather than in your code.

DBIx::XML_RDB is a Perl extension for creating XML from existing DBI datasources.

SYNOPSIS

use DBIx::XML_RDB;
my $xmlout = DBIx::XML_RDB->new($datasource,
"ODBC", $userid, $password, $dbname) || die "Failed to make new xmlout";
$xmlout->DoSql("select * from MyTable");
print $xmlout->GetData;

This module is a simple creator of XML data from DBI datasources. It allows you to easily extract data from a database, and manipulate later using XML::Parser.

One use of this module might be (and will be soon from me) to extract data on the web server, and send the raw data (in XML format) to a clients browser, and then use either XML::Parser from PerlScript, or MSXML from VBScript/JavaScript on the clients machine to generate HTML (obviously this relies upon using MS IE for their Active Scripting Engine, and MSXML comes with IE5beta).

Another use is a simple database extraction tool, which is included, called sql2xml. This tool simply dumps a table in a database to an XML file. This can be used in conjunction with xml2sql (part of the XML::DBI(?) package) to transfer databases from one platform or database server to another.

Binary data is encoded using UTF-8. This is automatically decoded when parsing with XML::Parser.

Included with the distribution is a "Scriptlet" - this is basically a Win32 OLE wrapper around this class, allowing you to call this module from any application that supports OLE. To install it, first install the scriptlets download from microsoft at http://msdn.microsoft.com/scripting. Then right-click on XMLDB.sct in explorer and select "Register". Create your object as an instance of "XMLDB.Scriptlet".

DBIx::Version is a Perl extension for getting database software name and version.

SYNOPSIS

use DBIx::Version;

my $dbh = DBI->connect( ... );
my ($dbname, $dbver, $dbverfull) = DBIx::Version::Version($dbh);

DBIx::Version lets you query which database software and version you are connected to.

Return Examples:

(undef, undef, undef)
(mysql, 4.0.17, 4.0.17-standard-log)
(postgresql, 7.4.1, PostgreSQL 7.4.1 on i686-pc-linux-gnu, compiled by GCC gcc (GCC) 3.3.2 20031107 (Red Hat Linux 3.3.2-2))
(oracle, 8.1.7.0.0, 8.1.7.0.0)
(sqlserver, 8.00.384, Microsoft SQL Server 2000 - 8.00.384 (Intel X86)
May 23 2001 00:02:52
Copyright (c) 1988-2000 Microsoft Corporation
Standard Edition on Windows NT 5.0 (Build 2195: Service Pack 2))
(sybase,12.5.0.1,Adaptive Server Enterprise/12.5.0.1/SWR 9982 IR/P/Sun_svr4/OS 5.8/rel12501/1776/ 64-bit/FBO/Tue Feb 26 01:22:10 2002)
(sybase,12.5.0.2,Adaptive Server Enterprise/12.5.0.2/EBF 14000 IR/P/Sun_svr4/OS 5.8/rel12502/1776/64-bit/FBO/Tue Jun 4 01:22:10 2002)

Answer 1: This module is useful for cross-platform coding, and in environments like shared hosting where you actually didnt install the database yourself and are curious.

DBIx::Log4perl is a Perl extension for DBI to selectively log SQL, parameters, result-sets, transactions etc to a Log::Log4perl handle.

SYNOPSIS

use Log::Log4perl;
use DBIx::Log4perl;

Log::Log4perl->init("/etc/mylog.conf");
my $dbh = DBIx::Log4perl->connect(DBI:odbc:mydsn, $user, $pass);
$dbh->DBI_METHOD(args);

or

use DBIx::Log4perl;
my $dbh = DBIX::Log4perl->connect(DBI:odbc:mydsn, $user, $pass
{DBIx_l4p_init => "/etc/mylog.conf",
DBIx_l4p_class => "My::Package");
$dbh->DBI_METHOD(args);

DBIx::Log4perl is a wrapper over DBI which adds logging of your DBI activity via a Log::Log4perl handle. Log::Log4perl has many advantages for logging but the ones probably most attractive are:

The ability to turn logging on or off or change the logging you see without changing your code.
Different log levels allowing you to separate warnings, errors and fatals to different files.

DBIx::FetchLoop is a Perl module that can fetch with change detection and aggregates.

SYNOPSIS

use DBIx::FetchLoop;

$lph = DBIx::FetchLoop->new($sth, $dbi_method);

$hash_ref = $lph->fetch_current_data;
$rowset = $hash_ref->{previous};
$rowset = $hash_ref->{current};
$rowset = $hash_ref->{next};

$rowset = $lph->fetch_current_row;

$rowset = $lph->previous;
$rowset = $lph->current;
$rowset = $lph->next;

$lph->set_aggregate($new_field, $field);
$lph->reset_aggregate($new_field);

$lph->set_concatenate($new_field, $field);
$lph->reset_concatenate($new_field);

$boolean = $lph->pre_loop($field);
$boolean = $lph->post_loop($field);

$boolean = $lph->pre_loop_substr($field,$offset,$length);
$boolean = $lph->post_loop_substr($field,$offset,$length);

$boolean = $lph->is_first;
$boolean = $lph->is_last;

$count = $lph->count;

DBIx::FetchLoop is a supplemental approach for data retrieval with DBI. Result rows are queued with hash references to previous, current and next rows. Utility functions allow for simplified comparison of a field between previous and current or current and next rows. Additional functions allow you automatically create new fields for aggregating or concatenating based on fields in the resulting dataset.

Note: This module was created with ease of use and performance in mind. This module is intended to eliminate the need for temporary variables for loop detection as well as aggregation and concatenation. The reason that not all DBI methods for data retrieval are not implemented (such as selectall_arrayref) is that the modules design for performance would be defeated.

In essence you can write cleaner looking, more efficient code minus a few hassles.