Free jdbc driver software for linux

Driver on demand is an attempt to ease driver installations in linux. Basically, what happens is that a user plugs any device into the computer, and if a driver isnt found, the client connects to a CGI server, to check if the device is known, and if its not in the database, then the driver lookup fails and the user is no worse off then they currently are.
However, if the device is found online, the driver information file (similar to .infs, just XML and more versatile) is analysed. If its built into newer versions of kernels, but theres a driver available, the driver is installed, but the system recommends strongly that the user upgrades their kernel, automatically, otherwise it just installs.
If the vendor chooses to, they can create their own driverinstall files, put it on their site, and put a reference on the Driver On Demand server, so the user will always have the newest files.. As opposed to having to wait for the admin to update their definitions.
To people who dont care about the specifics, all they need to care about is that if a device on their system needs a driver, this will find it on the internet, and install it for them automatically.
Main features:
- Uses HTTP/plaintext, so proxy compatible
- Allows the use of always up to date file.driverinstall files users can just click to install their latest hardware
- Takes the hassle of installing drivers away from the users
- XML based driver definitions, so extremely extendable, and is written in perl, so easy to edit and handle
- System handles licenses, allowing users to add them or remove licenses of drivers (promotes GPL drivers too, because that licence is accepted by default)
- Open source, GPL.. Which means u dont need to worry about licensing..
- Allows one click install of drivers (the first linux driver listing standard)
- Promotes Open source

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.

Panther is a lightweight, modular Java application server, suitable for embedding in a web server.
The intention of the project is not to duplicate all the functionality found in a J2EE app server, rather just some of the most commonly used features (Note: panther was formerly known as Wicker).
1. Panther is not trying to be a full application server, rather it provides a limited subset of services that most app servers provide.
2. Most app servers seem to be huge monolithic behemoths where its all or nothing. If you want one service, then you pretty much need them all. Even where you can modify the configuration to only include the services you require, based upon our experience, many projects dont.
3. Many projects only use a microscopic subset of the features an app server provides. This is particularly true if you want to be cross-appserver/cross-platform, so a modular app server, where you include the bits you want, makes a lot of sense (at least to us). This is, of course, rather similar to the argument certain luminaries have used in the past against the feature bloat in Office software like Word.
4. There isnt another open source app server out there that does what we want (or that we could get working just the way we wanted).
Main features:
- A Stateless Session Bean container.
- Note 1: SSBs were not pooled prior to version 0.9.1, so there -was- a single instance of each EJB in the container. There didnt seem to be any overhead/negative impact doing things this way, except that the beans are truly/completely stateless -- if youre writing code with this is mind, then you shouldnt have any problems, but we recommend using the latest release anyway.
- Note 2: At time of writing only the ejbCreate method has been implemented in panther (the other ejb* methods are not currently called).
- deployment and configuration by Jython
- transaction manager -- linked to the data source service. This only works with JDBC data sources, and has only been tested with Postgres so far. (Note, transactions do not cross VM boundaries.)
- a basic messaging service (multicast, broadcast and lightweight reliable multicast options available)
- jdbc distributed caching service, codenamed c3d -- basically a jdbc driver that caches selects to reduce load on the database and to improve performance (slightly)
- a python-scripted (well, jython) telnet management console
- example mail and datasource (using Jakarta DBCP) python scripts are also included
Version restrictions:
- You cannot currently pass parameters to ejbCreate, or indeed include parameters in your home create methods.
- transaction support is currently extremely limited. The transaction manager is a basic service written to get us going -- "Required", "Supports" and "NotSupported" should (hopefully) work as advertised, anything else (i.e. "RequiresNew") may get unpredictable results. Were working on the transaction service at the moment.
Enhancements:
NOTES
- Fix a bunch of bugs I discovered this morning with the build process, demo, etc
CHANGES
- Reorganised the doc directory. Moved example files to doc/examples
- added jetty.sh, start.sh and stop.sh, to be used for running jetty5. Create a bin dir in $JETTY_HOME, put both files there (along with panther in the root of jetty home) and run start.sh to use.
- tidied up readme.txt
BUG FIXES
- added a Makefile for the simple demo. Fixed a bug with the ant build. Moved the jsp to a plain servlet
- distribution tars werent created with the correct directory (shouldve had a root panther dir).

Datastream Pro is a database browser and SQL client for JDBC databases.
It is intuitive and easy to use.
Datastream Pro is avaliable on both Linux and Windows
Main features:
- Browse and edit the data in your database.
- Run and edit SQL scripts in a user friendly environment.
- Use the query editor to edit your SQL queries.
- Simultaneously connect to multiple databases
- Supports almost any JDBC compliant database (tested on Oracle, MySQL, postgreSQL and HSQLDb)
- Easy to use connection wizard.
- Secure, personalised settings for connections and preferences
- Built in text editor
- Reliable and stable

Craftsman Spy is a an open source and free framework for JDBC logging. Craftsman Spy is a JDBC driver implementation.

This logger logs all SQL connection and processings with execution spent time, all the stored procedures with arguments, all the batch processings and the result sets.

No need to modify your application in order to integrate JDBC logging with Craftsman Spy. The application MUST use the craftsman.spy.SpyDriver and MUST be launched with the -Dspy.driver=... system property.

Be carefull this JDBC driver SHOULD not be used in production mode. Use it only in development or pre-production system.

,b>Usage:

Code

The two solutions can be used as the following examples :
System.setProperty("spy.driver","vendor.database.Driver");// or with the -Dspy.driver=vendor.database.Driver JVM option
Class.forName("craftsman.spy.SpyDriver");
Connection c = DriverManager.getConnection("jdbc:database:mydata");
Class.forName("craftsman.spy.SpyDriver");
Connection c = DriverManager.getConnection("jdbc:spy:vendor.database.Driver:database:mydata");

Log configuration

The log4j.properties or log4j.xml configuration file SHOULD contain the following lines :
log4j.category.craftsman.spy=DEBUG, SpyFile
log4j.appender.SpyFile=org.apache.log4j.DailyRollingFileAppender
log4j.appender.SpyFile.DatePattern=.yyyy.MM.dd
log4j.appender.SpyFile.File=spy.log
log4j.appender.SpyFile.layout=org.apache.log4j.PatternLayout
log4j.appender.SpyFile.layout.ConversionPattern=%m%n

Jaybird is JCA/JDBC driver suite to connect to Firebird database server. Historically Borland opened sources of type 3 JDBC driver called InterClient.

However due to some inherent limitations of Firebird client library it was decided that type 3 driver is a dead end, and Firebird team developed pure Java implementation of wire protocol.

This implementation became basis for JayBird, pure Java driver for Firebird relational database.

This driver is based on both the new JCA standard for application server connections to enterprise information systems and the well known JDBC standard.

The JCA standard specifies an architecture in which an application server can cooperate with a driver so that the application server manages transactions, security, and resource pooling, and the driver supplies only the connection functionality.

While similar to the JDBC 2 XADataSource idea, the JCA specification is considerably clearer on the division of responsibility between the application server and driver.

JayBird 1.5 provides extensions to some JDBC interfaces. All extension interfaces are released under modified BSD license, on “AS IS” basis, this should make linking to these classes safe from the legal point of view. All classes belong to org.firebirdsql.jdbc.* package.

JayBird 1.0 provided only pure Java wire protocol implementation. While being most effective in client-server setups (even more effective than native client libraries), it performed worser when connected to the server residing on the same host compared to native (C/C++/Delphi/etc) solutions. Reason is that type 4 driver communicates with the server using network sockets, which introduce additional overhead. Native client library has possibility to use IPC when connecting to the database on the same host. This might increase performance even by 100%.

JayBird 1.5 provides also type 2 JDBC driver that uses native client library to connect to the databases. Additionally JayBird 1.5 can use embedded version of Firebird relational database allowing to create Java applications that does not require separate server setup.

However type 2 driver has also limitations. Due to multi-threading issues in Firebird client library, it is not possible to access it from different threads simultaneously when running in local mode (IPC). In this case only one thread is allowed to access library at a time. Driver tries to provide needed synchronization.

Current implementation uses mutex that is local to the classloader that loaded JayBird classes. This poses some deployment limitations: firebirdsql.jar must be deployed so, that it is loaded by the system classloader. For standalone web containers like Resin or Tomcat, JayBird should usually be deployed in their lib/ directory. It is allowed to include it in the WAR archives, but if and only if it is guaranteed that only one application will access Firebird.

When accessing remote servers thread per connection policy applies. Driver provides necessary synchronization for this situation.

Embedded version of the server cannot be used on Linux systems in multi-threaded applications. In particular this makes embedded version of the server unusable for web applications, where usually each request is served in separate thread.

Card Terminal Driver Library aims to add support for smart card and magnetic stripe card terminals, such as the IBM 4779, to Linux, and other Posix compatible systems.

Things that should get done:

1) Add error checking to all routines (except read/write/open/close4779: those already include error checking and reporting.

2) Add to the examples in the examples directory.

3) Work on more abstract functions so we can integrate this with libcardterm (eventually). These include (amoung others):

InsertCard()
EjectCard()
ReadTrack()
SmartComm()
WriteDispAtPos()
GetPIN()
GetKeys()

4) Write README and INSTALL files

Schema Crawler project is a platform (database and OS) independent command-line tool to output your database schema and data in a readable form.
The output is designed to be diff-ed with previous versions of your database schema. Schema Crawler is also an API that improves on standard JDBC metadata.
Build
Ant Build
The ant build is a quick build that builds the Schema Crawler jar without compiling and running unit tests. Download ant, and run it from the Schema Crawler directory. The jar file will be created in the _distrib directory. The main targets are all.build and all.clean.
Maven Build
The maven build is a more comprehensive build that runs unit tests, and also creates the project web-site. Download maven, and run it from the Schema Crawler directory. The jar file will be created in the _distrib directory. The main goals are all.build and all.clean.
Eclipse
Schema Crawler consists of two Eclipse projects, dbconnector and schemacrawler. Since schemacrawler depends on dbconnector, you will need to import both projects into Eclipse.
Enhancements:
- Database properties are now retrieved, along with column data types, both system data types, and UDTs.
- A new command, maximum_schema, gives all possible details of the schema, including database system properties.
- Bugs with the merge rows option and with appending output for multiple runs of SchemaCrawler are fixed.
- An SQL exception with the Oracle Database 10g Express Edition driver on outputting views is fixed.