Free ha jdbc 2.0 software for linux

JDBC is a Perl 5 interface to Java JDBC (via Inline::Java).

SYNOPSIS

use JDBC;

JDBC->load_driver("org.apache.derby.jdbc.EmbeddedDriver");

my $con = JDBC->getConnection($url, "test", "test");

my $s = $con->createStatement();

$s->executeUpdate("create table foo (foo int, bar varchar(200), primary key (foo))");
$s->executeUpdate("insert into foo (foo, bar) values (42,notthis)");
$s->executeUpdate("insert into foo (foo, bar) values (43,notthat)");

my $rs = $s->executeQuery("select foo, bar from foo");
while ($rs->next) {
my $foo = $rs->getInt(1);
my $bar = $rs->getString(2);
print "row: foo=$foo, bar=$barn";
}

This JDBC module provides an interface to the Java java.sql.* and javax.sql.* JDBC APIs.

HDBC is a Haskell Database Connectivity.

HDBC provides an abstraction layer between Haskell programs and SQL relational databases. This lets you write database code once, in Haskell, and have it work with any number of backend SQL databases (MySQL, Oracle, PostgreSQL, ODBC-compliant databases, etc.)

HDBC is modeled loosely on Perls DBI interface http://search.cpan.org/~timb/DBI/DBI.pm, though it has also been influenced by Pythons DB-API v2, JDBC in Java, and HSQL in Haskell.

HDBC is a from-scratch effort. It is not a reimplementation of HSQL, though its purpose is the same.

Hydrate is a Java tool that provides for fast efficient and error-free transformation of data between three different representations: relational databases, objects in an object-oriented programming language and extended markup language (XML).
Each of these representations has its strengths and weaknesses as shown in the diagram below; but which should you use as a basis for your application design?
Hydrate relaxes some of the pressure on this decision by providing tools for moving data from one representation to another, guided by a master UML class representation of that data.
- You want to lay a domain object model view over an existing database or set of databases. Hydrate gives you the tools to design that model in UML and map your existing data to that model. Once in the object space, you can perform complex manipulations on the objects, calculate results and save information back to a relational cache for searching or reloading, as well as converting the results to XML for sending to downstream systems or transforming to a readable format for display.
- Your project involves taking various data files fed from external systems that you want to pull into an object model on your server before writing the results down to a fully relational database. You can now respond to requests from external systems by rehydrating the data from its relational form and sending it out as XML documents or transforming those documents to a readable format for display.
- You are building a data warehouse in which you have the broad specifications for the model, but want to provide for flexibility and adaptability for future unpredicted requests. Based on a core data model, Hydrate gives you the tools to create you database schema, and write information to it, but more significantly to subsequently lay a completely different object model perhaps aggregating some of the data over the top of that schema to process it in unforeseen ways.
- You need to integrate data from many different data sources in a highly performant manner. SQL permits you to read a huge data set a row at a time and perform running calculations and filtering on that data. But the performance pressures can lead to code that is highly coupled with the database and what do you do if you need to integrate data from elsewhere in order to complete your calculations? Hydrate permits you to operate in the object space and integrate information from other sources on-the-fly.
Main features:
- To integrate legacy and other data schemas over which you have little control. Map data from many different data sources into a single self-consistent in-memory model. Different parts of the same object, as well as different sub-populations of the same object type can be drawn from different data sources, different schemas and even different database architectures.
- Load, populate and connect up multiple object types from a single query. There is no limit to the number of object types that can be loaded from a single query, or to the complexity of the relationships that can be resolved between them. Objects read from a query are automatically merged into objects already in memory.
- Full control over the SQL that runs against the database (if you need it). Any SQL queries simultaneously from multiple JDBC drivers, even using database specific optimizations, as long as they returns a result set.
- Access and manipulate the same data through the rich and powerful XML toolset. Use the same meta data that describes your objects to easily read from, write to and validate any consistent XML schema. Use XML for display, data transmission or XSLT transformation. Load XML data back into objects.
- Highly optimized performance for reading and writing SQL and XML. Since native types are used and SQL chatter is non-existent, database performance is comparable with doing the mapping by hand. XML reading and writing uses SAX exclusively.

HA-Tools provide some programs to improve shell scripting in a High Availability environment.
The halockrun program provides a simple and reliable way to implement a locking in shell scripts. A typical usage for halockrun is to prevent cronjobs to run simultanously. halockrun uses a lock on a file via fcntl(2) which ensures the release of the lock even if the process gets killed via SIGKILL.
The hatimerun program provides a time-out mechanism which can be used from shell scripts.
Enhancements:
- This release features some extensions and clarifications about the exit codes returned by halockrun and hatimerun.

Linux-HA provides a heartbeat and IP address takeover functions for a high-availability Linux cluster.
The basic goal of the High Availability Linux project is to:
Provide a high-availability (clustering) solution for Linux which promotes reliability, availability, and serviceability (RAS) through a community development effort.
The Linux-HA project is a widely used and important component in many interesting High-Availability solutions. We estimate that we currently have around thirty thousand installations up in mission-critical uses in the real world since it became suitable for mission critical production in 1999. Interest in this project continues to grow. These web pages are average more than 17000 hits per day, and we see around 100 downloads of our software per day.
Heartbeat now ships as part of SUSE Linux, Mandriva Linux, MSC Linux, Debian GNU/Linux, Ubuntu Linux, Red Flag Linux, and Gentoo Linux. Ultra Monkey, and several companys embedded systems are also based on it. Although this is called the Linux-HA project, the software is highly portable and runs on FreeBSD and Solaris as well (even MacOS X from time to time).
There have been many articles and chapters in books written on this project and software. See the PressRoom for more details.
We have put our foot on the road to being competitive with commercial systems similar to those described in D. H. Browns 1998 or March 2000 analysis of RAS cluster features and functions. In most important respects, we think youll find that Linux-HA has achieved this level of competitiveness with our release 2 software.
This release 2 series brings technologies and basic capabilities which match or exceed the capabilities of many commercial HA systems. We think youll be surprised. An R2 getting started guide is available.
We also work well with the LVS (Linux Virtual Server) project and expect to continue to collaborate with them in the future, since our goals are complementary.
Enhancements:
- This release has significant bugfixes and enhancements, making it a worthwhile upgrade for anyone running R2 CRM-style configurations, or who would like to.
- An OCF RA for Xen guests and Chinese GUI support have been added.
- ipfail has been replaced and generalized (limited testing). Master/slave testing and fixes.
- Significant cibadmin fixes.

SQLiteJDBC is a JDBC driver for SQLite which is written as a Java JNI layer over the SQLite 3.3.x API.

SQLiteJDBC supports the most commonly used features of JDBC that can be efficiently implemented on top of SQLite. Only a single native JNI library is required, and SQLite is compiled in.

Binaries are provided for Linux, Mac OS X, and Windows.

Ajaxdo is a Ajax persistent Data Objects framwork.
Ajax Data Objects (ajaxdo) provides an easy database persistency framework for JavaScript objects. Ajaxdo enables runtime loading, saving, deleting, and listing of JavaScript objects stored on the server database.
Using Ajaxdo can dramatically reduce server side code and make a Web 2.0 application port easily from one server-side programming language to another.
Enhancements:
- This release adds a fully functional Java server-side implementation in addition to the pre-existing PHP server-side implementation.
- Ajaxdo enabled applications can now work in a JSP/JDBC environment and port easily from PHP to Java and vice versa.