Free oracle database tool software for linux

Oracle::Trace is a Perl Module for parsing Oracle Trace files.

SYNOPSIS

use Oracle::Trace;

print Oracle::Trace->new($tracefilename)->parse->test_report;

Currently the parsing and statistics are very rudimentary, and in certain matters may be fundamentally flawed - you have been warned! Expect this to improve as further development takes place.

new

Create a new object for a given Orace Trace file.
my $o_trc = Oracle::Trace->new($tracefile);

init

Initialise the object (check the tracefile).
$o_trc->init.

opentracefile

Perform basic exists/read/etc. checks on given tracefile.
Returns object or undef.
$o_trc = $o_trc->checkfile($tfile);

header

Return the Header object.
my $o_hdr = $o_trc->header;

entries

Return Entry objects which comply with given regex criteria.
my @o_ents = $o_trc->entries(type=>EXEC #d+, key=>dep, value=>0);

oids

Return the unique object ids for the currently known Entryies
my @oids = $o_trc->oids;

footer

Return the Footer object
my $o_ftr = $o_trc->footer;

test_report

Return a simple test_report of the current object.
print $o_trc->test_report(string);

mini_report

Return a simple string of descending order timings for the statements retrieved from the given objects.
my $s_str = $o_trc->mini_report($i_max, @o_objs);

Note that we use microsecond resolution for Oracle 9i and above and centisecond resolution otherwise

Zild Database Library implements a small and easy to use database API with an easy to use API.
Main features:
- ability to connect to multiple database systems
- zero runtime configuration
- ability to connect using a URL scheme
- thread-safe connection pooling.

Used Textbook Database provides a database for listing used textbooks.

Used Textbook Database is a Web-based textbook database that lets users to create an account and list their used textbooks or books.

It is very modular and customizable and allows for easy integration into an existing Web site.

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.

XML::DB::Database::Exist is a Perl module with XML:DB driver for the eXist database.

SYNOPSIS

use XML::DB::Database::Exist;

This is the eXist XML-RPC driver. It is intended to be used through the XML:DB API, so that it is never called directly from user code. It implements the internal API defined in XML::DB::Database

The methods required to implement the Database interface are documented in Database.pm; only methods unique to eXist, and not required by the XML:DB API are documented here.

Generator is an command line application written in java that have the goal to make easy the construction of little applications that needs some database objects stuff.
Database Bean Generator isnt a replacement of complex object persistence solutions, like hibernate or TopLink but it covers a different target. The little java web applications that dont use sofisticated persistence options.
Generator invocation is simple, just type:
java -jar generator.jar -xml (config-file.xml)
where config-file is a xml config file with the definitions to connect to the database and generate the bean classes.
Main features:
- Generates classes to access via custom connection resources to database tables.
- Configuration files are in clear xml format and can be embedded or separate.
- Supports individual or global field updates.
- Supports custom set of Exceptions.
- Provides toXML function for each entity generated.
- Provides automatic generation of finders coonfigured in the xml configuration file.
- Provides some utility static methods via the BdUtils.java class generation.
- Generates an xml file with the database structure.
- Supports configuration of the methods that produces XML (String as CDATA, data as attributes or values, ...)
- Initial support for MySQL and Oracle (Oracle support is in initial stage at this moment).
- Provides an ant task for automatic integration builds.
- Supports transparent renaming of the generated class individual fields.
- Supports normal or CDATA output in individual fields.
- Supports utilization in all database methods with your own external connection.
- Preliminar support of a pluggable logging system (The goal is use log4j integration)
- Support for SEQUENCES in Oracle and AUTOINCREMENT in MySQL
- Support arbitrary raw code and imports from configuration file
- Correct treatment for NULL values of the fields in the generated class
Enhancements:
- Optionally, you may include the extra jars to get JSON support.
- JSON output for finders and generic JSON output for general have been added.

Oracle Aggregate C++ Library allows C++ programmers to easily create new aggregate functions for Oracle.

Oracle Aggregate C++ Library can be used as a glue library to existing C++ and C libraries. Detailed knowledge of the OCI aggregate interface is not required to use the library.

With automatic conversion of Oracle built-in types to C++ types it is possible to use the library without using any OCI functions directly.

The Oracle OCI interface for aggregate functions provides a straightforward way to implement aggregate functions in C or C++. There is, however, a certain amount of bookkeeping that needs to be performed in order to use the interface. The goal of this library is to take care of all the bookkeeping details for your, all you need to provide is the aggregate function itself. This makes it particularly easy to use existing C++ code and libraries in Oracle aggregate functions.

Design

The way the library works is that it defines the shared library entry point functions required by Oracle. The entry point functions simply forward all arguments to the static functions of the Aggregate class.

The Aggregate class along with a number of helper classes and functions takes care of converting arguments, configuring the environment, creating implementation instances and such. When everything is ready the arguments originally sent by Oracle are passed to your aggregate implementation.