Free jdbc database connection software for linux

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.

phpMysqlConnection provides a PHP class for handling MySQL database connections.
phpMysqlConnection is an interface class to be used with the PHP programming language to help projects connect to a MySQL database server and perform queries.
The methods of this class prevent the programmer from having to memorize all the different steps needed to connect to the database, perform a query, and retrieve results.
Enhancements:
- A function to return XML-formatted data record sets from queries has been added.

H2 Database Engine is a free SQL database engine writen in Java.
JDBC and ODBC APIs are supported. Embedded and server modes are available. A Web console application is included. Clustering is supported.H2 Database Engine is a web based java database engine.
Main features:
Fast database engine
- Free, source code is included
- Supports standard SQL
- Written in Java
- Disk based or in-memory databases
- Browser base Console application
- JDBC API
- Limited ODBC support
- Embedded and client/server (network) mode
- High availablility support (clustering / failover)
- Wide range of data types including large objects (BLOB/CLOB)
- Strong security features (SSL, users, roles, encrypted files)
- Multiple connections, table level locking
- Cost based optimizer, using a genetic algorithm for complex queries
- Transaction support (serializable transaction isolation)
- Zero-administration, automatic recovery
- Large resultset, external sorting
- Scrollable and updatable resultset support
- Read only views and inline views
- Inner and outer joins, subqueries
- Many functions already built-in
- Triggers and Java functions / stored procedures
- Referential integrity / foreign key constraints with cascade, check constraints
- Multiple schema support
- Compatibility modes for HSQLDB, MySQL and PostgreSQL
- Sequence and autoincrement columns
- Well tested (high code coverage, randomized stress tests)
- Small footprint (smaller than 1 MB)
- Uses a small number of database files
- Can be compiled to native code using GCJ
- Primary keys, multiple index types (b-tree, linear hash, tree, hash)
- ORDER BY, GROUP BY, HAVING, UNION, LIMIT
- Information Schema
- Multiple connections
- Collation support
- EXPLAIN PLAN support
- The database can generate SQL script files
- Support for linked tables, and a built-in virtual range table
- Automatic re-compilation of prepared statements
- Sophisticated trace options
- Low memory requirements
- Easy to understand exception messages
- Standard handling of NULL values
- Multilanguage console application (at this time, English and German)
Currently, this is not traditional GPL software, but the source code is included. It is free for private and commercial use.
Enhancements:
- H2 now supports the PostgreSQL network protocol, and can be accessed using the PostgreSQL ODBC driver.
- Regular expressions are now supported.
- The per session undo log and referential integrity can be disabled.
- Default settings have been changed to save memory. NOT, boolean columns, and certain joins are optimized now.
- Part of the documentation has been translated to Japanese.

Database Independent Abstraction Layer for C (libdbi) implements a database-independent abstraction layer in C, similar to the DBI/DBD layer in Perl.
Writing one generic set of code, programmers can leverage the power of multiple databases and multiple simultaneous database connections by using this framework.
Main features:
Database-level abstraction:
Your programs dont need to deal with the arbitrary interfaces and oddities of each database library. libdbi handles all the details for you, you just tell it what you want the database to do.
Modularity:
Since database code written with libdbi is not tied to one specific database server, you can effortlessly switch databases or give your users the option to specify their own database settings.
Clean interface:
With ample documentation describing libdbi and its well thought out object-oriented design, programming with libdbi should be less painful than programming with native database libraries. And you only need to learn it once instead of learning each database librarys syntax.
Accommodates coder apathy:
libdbi is written to do The Right Thing(tm), not just some quick hack that does the job in a half-assed fashion. This saves tons of your $100/hour time from debugging, so that you can mess around having fun during the hours that clients are paying you to debug. It also strives to reduce the worldwide crisis of carpal tunnel syndrome, so it uses constructs such as this one to pack multiple function calls into one line, saving you the bother of typing more than you have to:
dbi_result_get_fields(result, "id.%i firstname.%s lastname.%s fractional_value.%f", &id, &firstname, &lastname, &floatval);
Driver interface:
The dynamic linking used by libdbi allows for driver authors to license their drivers however they please - they are not restricted to the GPL or LGPL. Drivers are easy to write, and require no special installation.
Error handling:
Instead of checking every single database call for errors, libdbi gives programmers the option of registering an error handler callback, similar to a signal handler. Because we know youll "forget" to check for errors otherwise :)
Convenience:
Spend your time writing clever code, not reinventing the wheel with your own single-use, #define-abusing, less featureful database interface.
libdbi implements a database-independent abstraction layer in C, similar to the DBI/DBD layer in Perl. Writing one generic set of code, programmers can leverage the power of multiple databases and multiple simultaneous database connections by using this framework.
The libdbi-drivers project maintains drivers for libdbi. Drivers are distributed seperately from the library itself.
There are currently drivers for MySQL, PostgreSQL, SQLite, and mSQL. More are on the way.
Enhancements:
- Support for a timezone suffix in time and date types was added.
- Error handling and error reporting were vastly improved.
- Some memory leaks were fixed.

Net::FreeDB2::Connection is a FreeDB/CDDB abstract connection class.

Net::FreeDB2::Connection is an abstract class to represent connections to FreeDB/CDDB servers. After a successfull connection, FreeDB/CDDB queries, reads etc can be made to obtain/provide information from/to FreeDB/CDDB databases.

CONSTRUCTOR

new (OPT_HASH_REF)

Creates a new Net::FreeDB2::Connection object. By default connect () is called to initiate the connection but see option no_connect. See the implementation for complements/restrictions.

Options for OPT_HASH_REF may include:

client_name

Mandatory option to name the connecting client software.

client_version

Mandatory option with the client software version string.

client_host

The hostname of the client. Defaults to &Sys::Hostname::hostname ().

client_user

The user of the client. Defaults to scalar (getpwuid ($>));

freedb_host

The FreeDB/CDDB host. Defaults to freedb.freedb.org.

freedb_port

The port on the FreeDB/CDDB host.

proxy_host

Proxy host.

proxy_port

Port on the proxy host. Defaults to 8080.

proxy_user

Proxy user name to use.

proxy_passwd

Proxy password to use.

no_connect

Do not call connect () during instanciation.

JDBC SQL Profiler is a quickly hacked tool to do statistics on SELECT queries in order to know where it is most efficient to create indexes.

This small tool, released under an Apache-based license connects to the P6Spy JDBC logger and displays in real time the queries going to the database. It uses an integrated SQL parser to build statistics on the most accessed tables and columns and can generate SQL index creation files.

Other information is also gathered and displayed, such as the request time for a single request, for a class of request, and for all the requests. Sorting may be done on these views to detect database problems efficiently.

This tool can be very useful when you have a big volume of queries that you need to analyze not one by one (meaning that the specific time isnt that much of interest), but rather when you want to know what "group" of queries is taking a lot of time, such as queries on the same tables and columns but with different query values. The integrated SQL parser (built with ANTLR) is used to analyze the incoming SELECT queries.

The Swing GUI was based on Apaches Log4J Chainsaw, but all the bugs are mine. Also contributors are welcome to test, make new suggestions, give their opinion and submit patches.

Test::TempDatabase is a Perl module for temporary database creation and destruction.

SYNOPSIS

use Test::TempDatabase;

my $td = Test::TempDatabase->create(dbname => temp_db);
my $dbh = $td->handle;

... some tests ...
# Test::TempDatabase drops database

This module automates creation and dropping of test databases.

USAGE

Create test database using Test::TempDatabase->create. Use handle to get a handle to the database. Database will be automagically dropped when Test::TempDatabase instance goes out of scope.

$class->become_postgres_user

When running as root, this function becomes different user. It decides on the user name by probing TEST_TEMP_DB_USER, SUDO_USER environment variables. If these variables are empty, default "postgres" user is used.
create

Creates temporary database. It will be dropped when the resulting instance will go out of scope.

Arguments are passed in as a keyword-value pairs. Available keywords are:
dbname: the name of the temporary database.

rest: the rest of the database connection string. It can be used to connect to a different host, etc.

username, password: self-explanatory.

euCatalogue is a catalogue framework in Java to help you build a generic catalogue structure.
euCatalogue includes an "admin Web interface" to help with constructing the catalogue and a "user Web interface" which allows browsing the catalogue.
Installation:
1. Set up a database on the default port 5432 under the name eucatalogue with user/pass eucatalogue
2. Use "database.sql" file under the "installation" dir to generate the required table structure.
Note:
If You want to change the default database settings, use "hibernate.cfg.xml" under the "installation" dir and place it under "/src/resources" before creating the .war file.
hibernate.connection.url (jdbc:postgresql://localhost:5432/eucatalogue)
hibernate.connection.username (eucatalogue)
hibernate.connection.password (eucatalogue)
hibernate.connection.driver_class (PostgreSQL by default)
dialect (PostgreSQL by default. See Hibernate reference for available dialects)
Do not forget to place the required JDBC driver in the classpath!
Enhancements:
- Support for multiple catalogs was added through the CatalogueElement and CatalogueSpawn interfaces.
- A UUID generator is now used instead of an increment for better handling of multi-user environments.
- Hibernate was updated to 3.2.1 and eupersistence to 2.0.
- Previous database schemas must be deleted and replaced with the new one using the .sql script provided under the "installation" dir.