Free db flay software for linux

DB_File is a Perl5 access to Berkeley DB version 1.x.

SYNOPSIS

use DB_File;

[$X =] tie %hash, DB_File, [$filename, $flags, $mode, $DB_HASH] ;
[$X =] tie %hash, DB_File, $filename, $flags, $mode, $DB_BTREE ;
[$X =] tie @array, DB_File, $filename, $flags, $mode, $DB_RECNO ;

$status = $X->del($key [, $flags]) ;
$status = $X->put($key, $value [, $flags]) ;
$status = $X->get($key, $value [, $flags]) ;
$status = $X->seq($key, $value, $flags) ;
$status = $X->sync([$flags]) ;
$status = $X->fd ;

# BTREE only
$count = $X->get_dup($key) ;
@list = $X->get_dup($key) ;
%list = $X->get_dup($key, 1) ;
$status = $X->find_dup($key, $value) ;
$status = $X->del_dup($key, $value) ;

# RECNO only
$a = $X->length;
$a = $X->pop ;
$X->push(list);
$a = $X->shift;
$X->unshift(list);
@r = $X->splice(offset, length, elements);

# DBM Filters
$old_filter = $db->filter_store_key ( sub { ... } ) ;
$old_filter = $db->filter_store_value( sub { ... } ) ;
$old_filter = $db->filter_fetch_key ( sub { ... } ) ;
$old_filter = $db->filter_fetch_value( sub { ... } ) ;

untie %hash ;
untie @array ;

DB_File is a module which allows Perl programs to make use of the facilities provided by Berkeley DB version 1.x (if you have a newer version of DB, see "Using DB_File with Berkeley DB version 2 or greater"). It is assumed that you have a copy of the Berkeley DB manual pages at hand when reading this documentation. The interface defined here mirrors the Berkeley DB interface closely.

Berkeley DB is a C library which provides a consistent interface to a number of database formats. DB_File provides an interface to all three of the database types currently supported by Berkeley DB.

Db::DFC is the Perls Object-oriented interface to Documentums DFC.

SYNOPSIS

use Db::DFC;
$dfc = Db::DFC->new();

$DOCBASE = "docbase";
$USER = "user";
$PASSWORD = "passwd";
$DOMAIN = "domain";
$FILE = $0;

$dfclient = DfClient->new();
$idfclient = $dfclient->getLocalClient();
$idflogininfo = DfLoginInfo->new();

$idflogininfo->setUser($USER);
$idflogininfo->setPassword($PASSWORD);
$idflogininfo->setDomain($DOMAIN);

$idfsession = $idfclient->newSession($DOCBASE,$idflogininfo);

$pobj = $idfsession->newObject("dm_document");
$doc = $dfc->castToIDfDocument($pobj);

$doc->setObjectName("this file");
$doc->setContentType("crtext");
$doc->setFile($FILE);
$doc->save();

print "nDocument Id:" . $doc->getObjectId()->toString() . " created.n";
$idfsession->disconnect;

DB Copy Plugin is a database copying plugin for the SQuirreL SQL Client. DB Copy Plugin makes it possible to copy and paste tables from one session to another and between different databases and includes primary key and foreign key constraints for copied tables, and uses Hibernate 3.0 internally to perform database object type mappings.
It supports Firebird, Oracle, Sybase, MS SQL Server, MySQL, HyperSonic, Pointbase, and PostgreSQL, and allows the user to select a Hibernate dialect for the destination database if one couldnt be determined automatically.
Enhancements:
- Ran latest version of findbugs (http://findbugs.sourceforge.net/) and fixed Ran latest version of findbugs (http://findbugs.sourceforge.net/) and fixed

man-db is a manual page browser.
This package provides the man command.
This utility is the primary way of examining the on-line help files (manual pages).
It uses the groff suite of programs to format and display the manual pages.
Other utilities provided include the whatis and apropos commands for searching the manual page database, the manpath utility for determining the manual page search path, and the maintenance utilities mandb, catman, and zsoelim.
Quick Install:
RUN `./configure
EDIT configuration files/headers if necessary
RUN `make
RUN `make install
Enhancements:
- README: Update or remove references to "man-db-2.3" and similar.
- man-db.gnu: Update and sync with GNU.
- man-db.lsm: Update.
- manual/man_db.me: Replace "2.3.x" with "2.4.x".
- po/ca.po, po/cs.po, po/da.po, po/de.po, po/es.po, po/fr.po, po/it.po, po/ja.po: Update with msgmerge.

DB2::db is a framework wrapper around DBD::DB2 for a specific database.

SYNOPSIS

package myDB;
use DB2::db
our @ISA = qw( DB2::db );

...

use myDB;

my $db = myDB->new;
my $tbl = $db->get_table(myTable);
my $row = $tbl->find($id);

The DB2::db module can simplify your interaction with a DB2 database using the DBI module. The cost is generally a little bit of speed since it cannot know which columns you may be interested in. This is not always bad since you may not know either.

Please note that unlike many of the DBIx::* modules, this framework is intended to create your tables (and database) as well as manage them. Most DBIx modules will assume your tables are already created and leave the ability to recreate your tables up to you. The design for DB2::db is intended to allow you to develop on one machine and deploy on another with a little less effort. In exchange, however, it can be significantly more work to set up your perl scripts in the first place. That said, the extra work in setting up your perl modules is probably only a little more than the work it would require to create a DDL script to create all your tables.

SimpleCDB - A Perl-only Constant Database.

SYNOPSIS

use SimpleCDB;

# writer
# - tie blocks until DB is available (exclusive), or timeout
tie %h, SimpleCDB, db, O_WRONLY
or die "tie failed: $SimpleCDB::ERRORn";
$h{$k} = $v;
die "store: $SimpleCDB::ERROR" if $SimpleCDB::ERROR;
untie %h; # release DB (exclusive) lock

# reader
# - tie blocks until DB is available (shared), or timeout
tie %h, SimpleCDB, db, O_RDONLY
or die "tie failed: $SimpleCDB::ERRORn";
$v = $h{$i};
die "fetch: $SimpleCDB::ERROR" if $SimpleCDB::ERROR;
untie %h; # release DB (shared) lock

This is a simple perl-only DB intended for constant DB applications. A constant DB is one which, once created, is only ever read from (though this implementation allows appending of new data). That is, this is an "append-only DB" - records may only be added and/or extracted.

Course-grained locking provided to allow multiple users, as per flock semantics (i.e. write access requires an exclusive lock, read access needs a shared lock (see notes below re. perl < 5.004)). As (exclusive) updates may be take some time to complete, shared lock attempts will timeout after a defined waiting period (returning $! == EWOULDBLOCK). Concurrent update attempts will behave similarly, but with a longer timeout.

The DB files are simple flat files, with one record per line. Records (both keys and values) may be arbitrary (binary) data. Records are extracted from these files via a plain linear search. Unsurprisingly, this search is a relatively inefficient operation. To improve extraction speed, records are randomly distributed across N files, with the average search space is reduced by 1/N compared to a single file. (See below for some example performance times.) One advantage of this flat file based solution is that the DB is human readable (assuming the data is), and with some care can be edited with a plain ol text editor.

Finally, note that this DB does not support duplicate entries. In practice, the first record found matching a given key is returned, any duplicates will be ignored.

Audio::DB are tools for generating relational databases of MP3s.

SYNOPSIS

use Audio::DB;
my $mp3 = Audio::DB->new(-user =>user,
-pass =>password,
-host =>db_host,
-dsn =>music_db,
-adaptor => mysql);

$mp3->initialize(1);

$mp3->load_database(-dirs =>[/path/to/MP3s/],
-tmp =>/tmp);

Audio::DB is a module for creating relational databases of MP3 files directly from data stored in ID3 tags or from flatfiles of information of track information. Once created, Audio::DB provides various methods for creating reports and web pages of your collection.

Although its nutritious and delicious on its own, Audio::DB was created for use with Apache::Audio::DB, a subclass of Apache::MP3. This module makes it easy to make your collection web-accessible, complete with browsing, searching, streaming, multiple users, playlists, ratings, and more!