Free dbix version software for linux

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.

Module::Versions is a Perl module to handle versions of loaded modules with flexible result interface.

SYNOPSIS

use Module::Versions;

# Simple Interface
list Module::Versions; # prints formatted results to STDOUT
Module::Versions->list; # prints formatted results to STDOUT

# Shortcuts
$vers = get Module::Versions; # retrieves loaded modules

$vers = Module::Versions->get; # retrieves loaded modules

$array = Module::Versions->ARRAY; # returns array with version infos
$hash = Module::Versions->HASH; # returns hash with version infos

$list = Module::Versions->SCALAR; # returns text list with version infos
$csv = Module::Versions->CSV; # returns csv list with version infos
$xml = Module::Versions->XML; # returns xml struct with version infos
$xsd = Module::Versions->XSD; # returns xml schema of version infos
$dtd = Module::Versions->DTD; # returns DTD of version infos

# Individual Parameters
$vers = Module::Versions # retrieves mods and vars as defined
->new($mods,$vars)
->get($criteria);

$vers->list($fd,$mask); # prints formatted results to file
$vers->list($fd,$preform); # prints preformatted results to file
$vers->list($fd,&cb); # prints serialied results as handled
# in callback routine
$vers->data(&cb); # returns transformed results as
# defined in callback routine
# Individual formatted output
list Module::Versions(*LOG, %5d %1s %-20s %10s %-16s);
# prints individually formatted
# results to LOG
list Module::Versions(*DBIMPORT, %s|%s|%s);
# prints individually formatted
# results to Database Import file

list Module::Versions(*FD, SCALAR);# prints text list results to file
list Module::Versions(*FD, CSV); # prints csv list results to file
list Module::Versions(*FD, XML); # prints xml struct results to file
list Module::Versions(*FD, XSD); # prints xml schema to file
list Module::Versions(*FD, DTD); # prints DTD to file

list Module::Versions(*FD, ARRAY); # prints serialized results to file
list Module::Versions(*FD, HASH); # prints serialized results to file

Module::Versions->list(*LOG); # prints formatted results to LOG

# Pretty Compact
Module::Versions->list # prints formatted results on STDOUT
->list(*XML,XML); # prints xml struct results to XML file

Module::Versions->list # prints formatted results on STDOUT
->list(*XSD,XSD) # prints xml schema to XSD file
->list(*XML,XML); # prints xml struct results to XML file

Module::Versions->list # prints formatted results on STDOUT
->list(*DTD,DTD) # prints DTD to DTD file
->list(*XML,XML); # prints xml struct results to XML file

Module::Versions handles versions of loaded modules with a flexible result interface. The main goal is to get as much version informations as possible about a module or module list with a simple call interface and an absolutely flexible result interface. Module::Versions handles *loaded* and *loadable* modules.

The motivation for writing this module was the need for better support facilities to get informations about the used modules and versions in the productivity environment. Module::Versions allows shipping applications basically with something like a -version option (See Getopt::Long) but with expanded functions.

Module::Versions tries to read the loaded/loadable modules $VERSION. For extended purposes any private project version variables can be fetched ($_VERSION, $version, $REV, etc.).

Module::Versions has a flexible result interface to satisfy different needs: results can be lists and data structures with different formats - pre-formed ARRAY, HASH, SCALAR, CSV, XML/XSD/DTD and a full flexible user callback interface.
It is for example very simple to print a good formatted version list to the console and save a version.xml file (in conjunction with an xsd-schema) at the same time with an absolutely minimum of coding (SYNOPSIS, Pretty Compact) .
Module::Versions tries to load version.pm to support Perl 5.10.0s $VERSION formatting.

Sort::Versions is a Perl 5 module for sorting of revision-like numbers.

SYNOPSIS

use Sort::Versions;
@l = sort { versioncmp($a, $b) } qw( 1.2 1.2.0 1.2a.0 1.2.a 1.a 02.a );

...

use Sort::Versions;
print lower if versioncmp(1.2, 1.2a) == -1;

...

use Sort::Versions;
%h = (1 => d, 2 => c, 3 => b, 4 => a);
@h = sort { versioncmp($h{$a}, $h{$b}) } keys %h;

Sort::Versions allows easy sorting of mixed non-numeric and numeric strings, like the version numbers that many shared library systems and revision control packages use. This is quite useful if you are trying to deal with shared libraries. It can also be applied to applications that intersperse variable-width numeric fields within text. Other applications can undoubtedly be found.

For an explanation of the algorithm, its simplest to look at these examples:

1.1 < 1.2
1.1a < 1.2
1.1 < 1.1.1
1.1 < 1.1a
1.1.a < 1.1a
1 < a
a < b
1 < 2
1.1-3 < 1.1-4
1.1-5 < 1.1.6

More precisely (but less comprehensibly), the two strings are treated as subunits delimited by periods or hyphens. Each subunit can contain any number of groups of digits or non-digits. If digit groups are being compared on both sides, a numeric comparison is used, otherwise a ASCII ordering is used. A group or subgroup with more units will win if all comparisons are equal. A period binds digit groups together more tightly than a hyphen.

Some packages use a different style of version numbering: a simple real number written as a decimal. Sort::Versions has limited support for this style: when comparing two subunits which are both digit groups, if either subunit has a leading zero, then both are treated like digits after a decimal point. So for example:

0002 < 1
1.06 < 1.5

This wont always work, because there wont always be a leading zero in real-number style version numbers. There is no way for Sort::Versions to know which style was intended. But a lot of the time it will do the right thing. If you are making up version numbers, the style with (possibly) more than one dot is the style to use.

USAGE

The function versioncmp() takes two arguments and compares them like cmp. With perl 5.6 or later, you can also use this function directly in sorting:

@l = sort versioncmp qw(1.1 1.2 1.0.3);

The function versions() can be used directly as a sort function even on perl 5.005 and earlier, but its use is deprecated.

DBIx::Wrapper::Config Perl module allows the use of a configuration file in XML specifying information required to connect to databases using DBIx::Wrapper.

This way, your database connection specifications can be kept in one place.

Each "db" element specifies a key/name for the database connection, which should be passed as the $db_key argument to connect() in order to connect to that database.

The "db" elements children specify the dsn, authentication, and attribute information. dbi:mysql:database=test_db;host=example.com;port=3306 test_user test_pwd test_user test_pwd connect($db_key, $conf_path, %dbix_wrapper_attrs) Return a DBIx::Wrapper object connected to the database specified by $db_key in the file at $conf_path.

%dbix_wrapper_attrs is the optional 5th argument to DBIx::Wrappers connect() method, specifying handlers, etc. The file specified by $conf_path should be in the format specified in the DESCRIPTION section of this document.

Installation:

perl Makefile.PL
make
make test
make install

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::Timeout is a Perl module that provides a safe method of timing out DBI requests.

The method described in the DBI documentation uses unsafe signals, which may cause memory corruption. DBIx::Timeout instead uses a separate timeout process.

The problem with using POSIX sigaction() is that it relies on unsafe signals to work. Unsafe signals are well known to cause instability. For example, imagine your DB client code is in the middle of updating some global state when the signal arrives. That global state could be left in an inconsitent state, just wait for the next time it is needed to cause problems. Since this will likely occur far from the cause, and only ocur rarely, it can be a very difficult problem to track down.

Instead, this module:

- Forks a child process which sleeps for $timeout seconds.
- Runs your long-running query in the parent process.
- If the parent process finishes first it kills the child and returns.
- If the child process wakes up it kills the parents DB thread and exits with a code so the parent knows it was timed out.

NOTE: After this call your database connection may be killed even if no timeout occurred. This is due to a race condition - the child may wake up just as parent process finishes. Patches addressing this bug are welcome. Until this is fixed you should be ready to reconnect after call_with_timeout().

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.