Free dbi software for linux

DBI is a database independent interface for Perl.

SYNOPSIS

use DBI;

@driver_names = DBI->available_drivers;
%drivers = DBI->installed_drivers;
@data_sources = DBI->data_sources($driver_name, %attr);

$dbh = DBI->connect($data_source, $username, $auth, %attr);

$rv = $dbh->do($statement);
$rv = $dbh->do($statement, %attr);
$rv = $dbh->do($statement, %attr, @bind_values);

$ary_ref = $dbh->selectall_arrayref($statement);
$hash_ref = $dbh->selectall_hashref($statement, $key_field);

$ary_ref = $dbh->selectcol_arrayref($statement);
$ary_ref = $dbh->selectcol_arrayref($statement, %attr);

@row_ary = $dbh->selectrow_array($statement);
$ary_ref = $dbh->selectrow_arrayref($statement);
$hash_ref = $dbh->selectrow_hashref($statement);

$sth = $dbh->prepare($statement);
$sth = $dbh->prepare_cached($statement);

$rc = $sth->bind_param($p_num, $bind_value);
$rc = $sth->bind_param($p_num, $bind_value, $bind_type);
$rc = $sth->bind_param($p_num, $bind_value, %attr);

$rv = $sth->execute;
$rv = $sth->execute(@bind_values);
$rv = $sth->execute_array(%attr, ...);

$rc = $sth->bind_col($col_num, $col_variable);
$rc = $sth->bind_columns(@list_of_refs_to_vars_to_bind);

@row_ary = $sth->fetchrow_array;
$ary_ref = $sth->fetchrow_arrayref;
$hash_ref = $sth->fetchrow_hashref;

$ary_ref = $sth->fetchall_arrayref;
$ary_ref = $sth->fetchall_arrayref( $slice, $max_rows );

$hash_ref = $sth->fetchall_hashref( $key_field );

$rv = $sth->rows;

$rc = $dbh->begin_work;
$rc = $dbh->commit;
$rc = $dbh->rollback;

$quoted_string = $dbh->quote($string);

$rc = $h->err;
$str = $h->errstr;
$rv = $h->state;

$rc = $dbh->disconnect;

DBI::FAQ is a Perl module for the Frequently Asked Questions of the Perl5 Database Interface.

What is DBI, DBperl, Oraperl and *perl?

To quote Tim Bunce, the architect and author of DBI:

``DBI is a database access Application Programming Interface (API)
for the Perl Language. The DBI API Specification defines a set
of functions, variables and conventions that provide a consistent
database interface independant of the actual database being used.

In simple language, the DBI interface allows users to access multiple database types transparently. So, if you connecting to an Oracle, Informix, mSQL, Sybase or whatever database, you dont need to know the underlying mechanics of the 3GL layer. The API defined by DBI will work on all these database types.

A similar benefit is gained by the ability to connect to two different databases of different vendor within the one perl script, ie, I want to read data from an Oracle database and insert it back into an Informix database all within one program. The DBI layer allows you to do this simply and powerfully.

DBperl is the old name for the interface specification. Its usually now used to denote perl4 modules on database interfacing, such as, oraperl, isqlperl, ingperl and so on. These interfaces didnt have a standard API and are generally not supported.

Heres a list of DBperl modules, their corresponding DBI counterparts and support information. Please note, the authors listed here generally do not maintain the DBI module for the same database. These email addresses are unverified and should only be used for queries concerning the perl4 modules listed below. DBI driver queries should be directed to the dbi-users mailing list.

However, some DBI modules have DBperl emulation layers, so, DBD::Oracle comes with an Oraperl emulation layer, which allows you to run legacy oraperl scripts without modification. The emulation layer translates the oraperl API calls into DBI calls and executes them through the DBI switch.

Heres a table of emulation layer information:

Module Emulation Layer Status
------ --------------- ------
DBD::Oracle Oraperl Complete
DBD::Informix Isqlperl Under development
DBD::Ingres Ingperl Complete?
DBD::Sybase Sybperl Working? ( Needs verification )
DBD::mSQL Msqlperl Experimentally released with
DBD::mSQL-0.61

The Msqlperl emulation is a special case. Msqlperl is a perl5 driver for mSQL databases, but does not conform to the DBI Specification. Its use is being deprecated in favour of DBD::mSQL. Msqlperl may be downloaded from CPAN via:

http://www.perl.com/cgi-bin/cpan_mod?module=Msqlperl

guile-dbi is a database generic interface. The main lib provide a way to use dbds (data base drivers) which are linked at run-time (like perl dbi or php or...).
This provide a very flexible way to use guile scheme implementation for db works. Now, implemented main dbi interface lib, mysql and postgres plugins... In near future more drivers will be available.
Enhancements:
- The API has been upgraded to Guile 1.8.

dbitotcl is a Tcl extension for using Perl DBI (Database independent interface) from tcl. This project allow to use nearly all functions of Perl DBI from Tcl as new Tcl commands. The use of Perl is hidden from the Tcl-User. Perl is loaded as embedded interpreter in the dbitotcl library and the library map all commands between Perl and Tcl.

It is in principle better way to use special Tcl-Extension for your Database (mysqltcl,oratcl,pgtcl,adatcl) but by using this library you can access to database, which have no Tcl-Extension and you have more generic API (like ODBC) and some special functions as Meta-Data (Catalog) access. So you can use very good Perl-DBI interface from Tcl.

DBI::Changes Perl module contains a list of significant changes to the DBI.

Thesaurus::DBI is a Perl module that can store and query synonyms (Thesaurus) in an SQL database.

SYNOPSIS

use Thesaurus::DBI;

# create new database connection
my $th = new Thesaurus::DBI(dbhost=> localhost, dbname=>thesaurus,dbuser=>user,dbpassword=>pass);

# use existing database connection
my $th = new Thesaurus::DBI(dbhandle => $dbi, dbname=>thesaurus,dbuser=>user,dbpassword=>pass);

# initialize database
$th->create_tables();

# query thesaurus
my @synonyms = $th->find(synonym);

# add synonyms
$th->add([word, synonym]);

# delete word
$th->delete(word);

This subclass of Thesaurus implements persistence by using an SQL database.
This module requires the DBI module from CPAN. To use it with certain database servers, the corresponding database drivers are needed, too. (Mysql -> DBD::mysql)

Please note, that database servers like MySQL doesnt take care of case-sensitivity. So the queries to the thesaurus-database wil all bei case-insensitive.

DBI::ProfileData can manipulate DBI::ProfileDumper data dumps.

SYNOPSIS

The easiest way to use this module is through the dbiprof frontend (see dbiprof for details):

dbiprof --number 15 --sort count

This module can also be used to roll your own profile analysis:

# load data from dbi.prof
$prof = DBI::ProfileData->new(File => "dbi.prof");

# get a count of the records (unique paths) in the data set
$count = $prof->count();

# sort by longest overall time
$prof->sort(field => "longest");

# sort by longest overall time, least to greatest
$prof->sort(field => "longest", reverse => 1);

# exclude records with key2 eq disconnect
$prof->exclude(key2 => disconnect);

# exclude records with key1 matching /^UPDATE/i
$prof->exclude(key1 => qr/^UPDATE/i);

# remove all records except those where key1 matches /^SELECT/i
$prof->match(key1 => qr/^SELECT/i);

# produce a formatted report with the given number of items
$report = $prof->report(number => 10);

# clone the profile data set
$clone = $prof->clone();

# get access to hash of header values
$header = $prof->header();

# get access to sorted array of nodes
$nodes = $prof->nodes();

# format a single node in the same style as report()
$text = $prof->format($nodes->[0]);

# get access to Data hash in DBI::Profile format
$Data = $prof->Data();

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.