Free jdbc example software for linux

JDBCImporter provides a consistent mechanism for importing data from a file to a database, exporting data from a database to a file, and generating data.
JDBCImporter API can run from the command line using an XML config file or from inside an Ant build script. It works with CSV, fixed data, and XML files and supports numbers, strings, and date/times as database column types.
Custom classes can be used to parse different file formats, format column values into different file formats, translate column values before importing or after exporting, or allocate or release JDBC connections.
Installation:
Below are the installation steps for installing JDBC Importer:
unzip the jdbcimporter.zip file
add jdbcimporter.jar and commons-logging.jar to the CLASSPATH.
For example: set CLASSPATH=%CLASSPATH%;INSTALL_DIRlibjdbcimporter.jar;INSTALL_DIRlibcommons-logging.jar
JDBC Importer
Basic Usage:
> java [options] net.sourceforge.jdbcimporter.Importer [plugin file]
where :
config file : the import config file
plugin file : the (optional) property file that describes the plugins available during the import
options : two system properties may be set (both are optional)
jdbcimporter.engine = The import engine to use
jdbcimporter.failonerror = Flag indicating that the import should end if an error occurrs
Enhancements:
- This release fixes a bug with CSV delimiter parser.

DTLS Client/Server Example contains a simple DTLS client and DTLS server to show how to send UDP data over an encrypted channel using OpenSSL DTLSv1 support.

LIST OF FILES:

Directory: common - Contains callback functions and error reporting functions common to client and server

sslmgr.h
sslmgr.c

Directory: dtls_server

dtls_server.c - DTLS server part

Directory: dtls_client

dtls_client.c - DTLS client part

GNUstep examples is a collection of programs that are meant to show programmers how to use GNUstep.
GNUstep examples includes a calculator, a currency converter, finger, fractal, puzzle, hostaddress, and ink (a simple editor).
Enhancements:
- Minor feature enhancements

GCJ::Cni::Examples is a Perl module with examples of how to use GCJs CNI interface to write Perl Modules in Java.

EXAMPLES

Writing Treaded modules in Java

One benefit of using GCJ is that it takes advantage of POSIX threading. This is nice since Perls threading model is, shall we say, less than ideal. Now, you could theoretically write a module in C or C++ and and use the standard POSIX library to do your threaded work for you, however, why not take advantage of the nice Threading interface that Java provides to you by default. This may also come in handy if you have a massively threaded Java library that youd like to call from Perl.

For this example assume that I want to do matrix multiplication, albeit in a very crazy manner. Therefore, I will write a Java class, Matrix, and a method, multiply, which will take another matrix to perform the operation between. Heres the crazy part, for each cell in the resulting matrix I will spawn a new thread, as an internal class, and give it a row and a column from which they will derive the result. I know this is a little wierd but the point is that Ill be spawning a lot of new threads. To multiply two 10x10 matrices we will have to spawn 100 threads (one thread per cell in the resulting 10x10 matrix). Imagine doing this in Perl, then imagine doing it in Java; natively compiled Java. Much faster and a lot less headaches.

The Java Interface/pseudocode is as follows:

public class Matrix {
public Matrix ( int numRows, int numCols ) {
...Constructor stuff...
}

public void set ( int row, int col, int val ) {
...set an element...
}

public int get ( int row, int col ) {
...get an element...
}

public Matrix multiply ( Matrix times ) {
...set it up...
for ( int i = 0; i < rows; i++ ) {
for ( int j = 0; j < times.getCols(); j++ ) {
//GO NUTS!!!!
ArrayMultiplier multiplier = new ArrayMultiplier(this, times, result, i, j);
multiplier.start();
...etc...
}
}
...wait for the threads to exit and return the new matrix...
}

public int getRows ( ) {
...get number of rows...
}

public int getCols ( ) {
...get number of columns...
}

public void print ( ) {
...print the matrix to stdout...
}

private class ArrayMultiplier extends Thread {
public ArrayMultiplier ( Matrix a, Matrix b, Matrix result, int row, int col ) {
...Construct this bad boy...
}

public void run ( ) {
int sum = 0;
for ( int i = 0; i < a.getCols(); i++ ) {
sum += (a.get(row, i) * b.get(i, col));
}
result.set(row, col, sum);
}

}
}
Now, we want to call this class from Perl. My perferred manner is through SWIG so thats what were going to use. However, you do not need to use SWIG, you can use whatever method you prefer when wrapping C++ classes. We begin by creating a C++ header file from our above class. This is done by using GCJs gcjh utility. First we need to class compile Matrix.java

gcj -C Matrix.java

Then we go ahead and create the header file:

gcjh Matrix

Easy enough. We can then extract the interface we want to have available in Perl from the generated header file and from it create a i file to be used as input to SWIG. I usually start by copying my header file to the same named file but with an i extension instead. I then remove all of the grimy C++ gruff, private methods and variables, slap a module directive on it and call it done. It wont always be this easy though. When youre done an interface file for the above class should look something like this:

%module Matrix;

typedef int jint;

class Matrix
{
public:
Matrix (jint, jint);
virtual void set (jint, jint, jint);
virtual jint get (jint, jint);
virtual ::Matrix *multiply (::Matrix *);
virtual jint getRows ();
virtual jint getCols ();
virtual void print ();
};
We then put SWIG to work and generate our C++ wrapper for Perl:

swig -perl -c++ Matrix.i

After the above command we now will see two new files in our current directory, Matrix.pm and Matrix_wrap.cxx; these correspond the module directive we gave in Matrix.i.

At this point all we have left to do is compile, and use.

gcj -c Matrix.java
gcc -c -I -include Matrix.h Matrix_wrap.cxx
gcc -shared -lgcj -lstdc++ Matrix.o Matrix_wrap.o -oMatrix.so

A simple Perl file using this module might look something like:

sub populate_matrix {
my $matrix = shift;
for ( my $i = 0; $i < $matrix->getRows(); $i++ ) {
for ( my $j = 0; $j < $matrix->getCols(); $j++ ) {
$matrix->set($i, $j, $i * $j);
}
}
}

use GCJ::Cni;
use Matrix;

GCJ::Cni::JvCreateJavaVM(undef);
GCJ::Cni::JvAttachCurrentThread(undef, undef);

my $matrix = new Matrix::Matrix(10, 10);
populate_matrix($matrix);
my $matrix2 = new Matrix::Matrix(10, 10);
populate_matrix($matrix2);
$matrix3 = $matrix->multiply($matrix2);
$matrix3->print();

GCJ::Cni::JvDetachCurrentThread();

Ill leave it up to the reader to write a Perl module that does the same thing, that is, spawns 100 threads. In my own personal fiddling I found that just spawning that many threads (never mind doing any kind of work) was over 3 time slower in Perl. In this situation we at least get to use our favorite language, Perl, and offload some of the heavy hitting to a language more suited for it.

Where this really comes in handy is when you have an existing multi-threaded Java library that you would like to expose to Perl. You could theoretically natively compile various components of your library and then generate Perl bindings to access it. In this way, you get a little extra speed and efficiency as well as code reuse and binding.

Need a Type 3 JDBC Driver for MS Access or SQL Server? Think RmiJdbc!
RmiJdbc project is a client/server JDBC Driver that relies on Java RMI.
All JDBC classes (like Connection, ResultSet, etc...) are distributed as RMI objects, so that you can distribute as you like the access to any database supporting the JDBC API.
In fact, RmiJdbc is just a bridge to allow remote access to JDBC drivers.
Why RmiJdbc?
- You develop a client/server application with databases on Windows (NT)? Use RmiJdbc along with the JDBC/ODBC Bridge, your Windows (NT) databases become remotely accessible in Java.
- You implement a JDBC Driver? Just implement the JDBC classes locally, dont bother with remote access!
- You need serializable JDBC classes? Here they are.
Enhancements:
- Add features/limitations/changes here

JdbcTool project is a collection of command line utilities for making your life easy when working with Java JDBC databases. Included are:

jdbctool:

An interactive command line tool for executing SQL statements.

jdbcdump:

Dump the contents of a database as SQL statements into a file, like mysqldump.

jdbcload

Execute SQL statements from a file (the opposite of jdbcdump)

Currently, only HSQLDB is supported.

DBD::JDBC is a JDBC proxy driver for the DBI module.

SYNOPSIS

use DBI;

$dbh = DBI->connect("dbi:JDBC:hostname=$hostname;port=$port;url=$url",
$user, $password);

# See the DBI module documentation.

DBD::JDBC is a Perl module which works in conjunction with a server written in Java to provide a DBI front end to a JDBC driver. The Perl module and Java server may be installed on different machines, as long as socket connections are allowed. The Java server portion is multi-threaded and supports multiple simultaneous connections.

This driver currently supports JDBC drivers which implement the JDBC 1.22 interface. JDBC 2.0-compatible drivers are expected to work, but no JDBC 2.0 functionality is explicitly exposed via DBD::JDBC. The $h->jdbc_func method exposes additional JDBC and driver-specific methods. Only Java methods with primitive or String parameters and return types are currently supported in this way.

The expected use for this module is as a DBI interface to databases with JDBC drivers but no DBI drivers. The implementation of this module was originally done for a non-SQL database in order to take advantage of the existing SQL parser in the databases JDBC driver.

The Java classes provided with this module also allow a Java application or servlet to create a JDBC connection and then execute a Perl script which can use that pre-existing JDBC connection via DBI. This particular functionality was implemented in order to allow Perl customizations to a Java servlet-based application. See the example in the example/ directory.