OpenLink Software Logo

OpenLink ODBC to JDBC Bridge Connector

Seamlessly connect any ODBC-compliant application to any JDBC data source on Windows

Product Overview

Enterprise Architecture

The OpenLink ODBC to JDBC Bridge implements a multi-tier architecture that enables seamless interoperability between ODBC-compliant clients and JDBC data sources:

OpenLink ODBC-JDBC Bridge Enterprise Architecture

Figure 1: Multi-tier ODBC-JDBC Bridge Architecture

Value Proposition

The OpenLink ODBC to JDBC Bridge Connector solves three fundamental enterprise connectivity challenges:

1. Universal Platform Access

Enables ODBC-compliant applications running on Windows to connect seamlessly to databases and data platforms that are only accessible via JDBC drivers or provide superior connectivity through JDBC—eliminating data silos and expanding application reach without costly rewrites.

2. Centralized Configuration Management

Removes the operational burden of configuring ODBC Data Source Names (DSNs) on individual client machines. Configuration is centralized and managed server-side, dramatically reducing deployment complexity and maintenance overhead across enterprises.

3. Enterprise-Grade Access Controls

Provides powerful attribute-based access control (ABAC) integrated into every ODBC session. Access policies can be informed by user identity, client application, network address/range, target DBMS, and other contextual attributes—enabling granular security without application changes.

Primary Solution

The OpenLink ODBC to JDBC Bridge Connector enables ODBC-compliant applications (including BI tools, spreadsheets, and custom applications) to access data from databases that only provide JDBC drivers—such as modern big data platforms, NoSQL databases, and various Java-based systems.

Deployment Architecture

This client-side, multi-tier driver installs on a Windows machine (Personal or Application Server) and acts as a client to a remote database server. The bridge intelligently translates ODBC calls from the client application into JDBC calls that the target database understands, providing seamless interoperability between disparate technologies.

Ready to Get Started?

Discover the complete OpenLink Enterprise JDBC to ODBC Bridge Connector solution and explore all available features, documentation, and support resources.

Learn More About Enterprise JDBC to ODBC Bridge →

Installation Guide

Follow these four steps to install the OpenLink ODBC to JDBC Bridge Connector on your Windows system.

1
Download the Installer Archive
Visit the OpenLink ODBC Enterprise Edition Driver Download Page or use curl to download the required MSI installer archives for the driver components.
You will need three MSI files: waajzzzz.msi, wabrzzzz.msi, and wao3zzzz.msi.
2
Pre-Installation Configuration
Ensure a 64-bit JVM is installed, the target JDBC driver is available, and connection details like class name and URL are known.
The JDBC driver's .jar file must be in the CLASSPATH, and the jvm.dll file must be located in the PATH environment variable.
3
Installation
Log onto the target machine and run each downloaded MSI installer to install the client and server components of the Enterprise Multi-Tier ODBC-JDBC Bridge.
Take care to enter correct information when prompted, such as ports and passwords, and note them for future use.
4
Post-Installation Configuration
Set Java CLASSPATH and PATH variables in the OpenLink Rule Book (oplrqb.ini) if not set system-wide, and place license files in the installation's bin directory.
Place the oplrqb.lic and jdbc.lic files in the {OPENLINK_INSTALL}/bin directory.

Java Environment Setup & JDBC Testing

Before configuring ODBC DSNs, verify that your JDBC drivers are properly installed and accessible. This section guides you through environment setup and provides a Java utility to test JDBC driver connectivity.

Step 1: Locate JDBC Driver JAR Files

Determine the location of the JAR files for each JDBC driver you plan to use. Ideally, place all JDBC driver JARs in a common directory for easier management.

Example Directory Structure:
C:\Program Files\JDBC\
├── postgresql-42.7.jar
├── mysql-connector-java-8.0.jar
├── ojdbc8.jar
└── other-jdbc-drivers.jar
ℹ Common JDBC driver locations:
  • C:\Program Files\Java\
  • C:\Program Files\JDBC\
  • Application-specific directories

Step 2: Set CLASSPATH Environment Variable

Ensure the CLASSPATH operating system environment variable includes entries for each JDBC driver JAR file location.

Setting CLASSPATH on Windows:
  1. Press Win + X and select System
  2. Click Advanced system settings
  3. Click Environment Variables
  4. Under System variables, click New
  5. Variable name: CLASSPATH
  6. Variable value: C:\Program Files\JDBC\* (or your driver directory)
  7. Click OK and close dialogs
  8. Restart any open command terminals for changes to take effect

Step 3: Create and Run UniversalJDBCTest

Save the following Java source code as UniversalJDBCTest.java. This utility discovers installed JDBC drivers and tests their connectivity interactively.

Save Location: Create this file in your project directory or a dedicated test folder.
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Driver;
import java.util.Enumeration;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.io.Console;

public class UniversalJDBCTest {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Console console = System.console();

        System.out.println("=== Universal JDBC Connection Test ===\n");

        // Collect registered JDBC drivers
        List<Driver> driverList = new ArrayList<>();
        Enumeration<Driver> drivers = DriverManager.getDrivers();
        System.out.println("Available JDBC Drivers:\n");

        int index = 1;
        while (drivers.hasMoreElements()) {
            Driver driver = drivers.nextElement();
            driverList.add(driver);
            System.out.printf("%d) %s (v%d.%d)\n",
                    index++, driver.getClass().getName(),
                    driver.getMajorVersion(), driver.getMinorVersion());
        }

        if (driverList.isEmpty()) {
            System.out.println("⚠️ No JDBC drivers are registered with DriverManager.");
            System.out.println("Make sure your driver JARs are on the classpath.\n");
            scanner.close();
            return;
        }

        System.out.print("\nEnter driver number to test: ");
        int driverChoice = scanner.nextInt();
        scanner.nextLine();

        if (driverChoice < 1 || driverChoice > driverList.size()) {
            System.out.println("Invalid driver selection.");
            scanner.close();
            return;
        }

        Driver selectedDriver = driverList.get(driverChoice - 1);
        System.out.println("\nTesting " + selectedDriver.getClass().getName() + "...\n");

        System.out.print("Enter JDBC URL: ");
        String url = scanner.nextLine();

        System.out.print("Enter username: ");
        String user = scanner.nextLine();

        System.out.print("Enter password: ");
        String password = scanner.nextLine();

        try {
            System.out.println("\n⏳ Attempting connection...");
            Connection conn = DriverManager.getConnection(url, user, password);
            System.out.println("✓ Connection successful!\n");

            DatabaseMetaData metadata = conn.getMetaData();
            System.out.println("Database Information:");
            System.out.println("  Database Name: " + metadata.getDatabaseProductName());
            System.out.println("  Version: " + metadata.getDatabaseProductVersion());
            System.out.println("  URL: " + metadata.getURL());
            System.out.println("  Username: " + metadata.getUserName());

            conn.close();
            System.out.println("\n✓ Test completed successfully.");

        } catch (SQLException e) {
            System.err.println("\n❌ SQL Error: " + e.getMessage());
            e.printStackTrace();
        } finally {
            scanner.close();
        }
    }
}
✓ To compile and run:
  • Compile: javac UniversalJDBCTest.java
  • Run: java -cp "C:\Program Files\JDBC\*" UniversalJDBCTest
  • Follow the interactive prompts to test your JDBC drivers

Step 4: Verify Test Results

The utility will display:

  • ✓ Success: Database connection established with metadata display
  • ⚠️ No drivers: CLASSPATH needs adjustment or drivers are missing
  • ❌ Connection error: Check URL format, credentials, and database accessibility

Configuration Guide

Once installed and your Java environment is verified, configure your Data Source Names (DSNs) and test the connection using these steps.

1
Open ODBC Data Source Administrator
Launch the ODBC Data Source Administrator program to create a new DSN.
ODBC Data Source Administrator

Figure 2: ODBC Data Source Administrator

2
Add New Driver
Click the Add button and select the OpenLink Generic ODBC Driver (Unicode)(9.0) from the list.
Select OpenLink ODBC Driver

Figure 3: Select OpenLink Generic ODBC Driver

3
Configure Connection Details
Enter the ODBC DSN name and connection details (hostname and port number). Default is localhost:5000 for local connections.
Enter DSN Name and Hostname

Figure 4: Enter DSN Name and Hostname:Port

4
Specify JDBC Connection Parameters
Select the Domain Jdbc 1.8, enter the JDBC Driver Name, JDBC Connect String URL, and login credentials (username and password). Check Connect now to verify that all settings are correct and click Next to test the connection.
Configure JDBC Parameters

Figure 5: Configure JDBC Domain, Driver, URL, and Credentials

5
Verify Additional Options
Review the optional settings in the next dialog. These options can normally be left as the defaults.
Advanced Options

Figure 6: Additional Options (Default Settings)

6
Review DSN Configuration
A summary of your DSN configuration is displayed. Use the Test Data Source button to verify the connection to your target database.
DSN Configuration Summary

Figure 7: DSN Configuration Summary and Test Data Source Button

7
Confirm Successful Connection
The connection should complete successfully, confirming that your ODBC DSN is properly configured and can communicate with your target JDBC data source.
Successful Connection

Figure 8: Successful DSN Connection Confirmation

✓ Verification: After configuration, test your connection using the included C++ Demo application to ensure all settings are correct and your application can communicate with the target database.

Using the C++ Demo Application

The C++ Demo sample application is included with the OpenLink installation and provides an interactive interface to test ODBC connections and execute SQL queries against your JDBC data source.

1
Launch C++ Demo Application
Navigate to the OpenLink Software program menu and select C++ Demo from the applications list.
The application provides a menu-driven interface for connecting to ODBC data sources and executing queries.
C++ Demo Application Menu

Figure 9: C++ Demo Application

2
Open Connection
Select Environment → Open Connection from the menu to initiate a new database connection.
You will be prompted to select an ODBC DSN from the list of configured data sources.
Environment Menu - Open Connection

Figure 10: Environment → Open Connection Menu

3
Select DSN and Credentials
Choose your ODBC-to-JDBC Bridge DSN from the list and enter the username and password for the target database.
These credentials must match those configured during DSN setup for successful authentication.
Select ODBC DSN

Figure 11: Select ODBC DSN for Connection

Enter Username and Password

Figure 12: Enter Username and Password for Target Database

4
Execute SQL Queries
Select SQL → Execute SQL from the menu to enter and execute SQL queries against the connected database.
Enter your SQL query in the dialog box and click OK. Results will display in the output area, confirming successful JDBC-to-ODBC translation.
SQL Execute Menu

Figure 13: SQL → Execute SQL Menu

5
View Query Results
Query results are displayed in the output area, demonstrating successful ODBC-to-JDBC communication and SQL execution.
This confirms that the ODBC-to-JDBC Bridge is functioning correctly and translating queries properly.
Query Results

Figure 14: Query Results Display

✓ Successful Test: If your query executes and returns results, your ODBC-to-JDBC Bridge is functioning correctly and is ready for use with your applications.

Testing & Troubleshooting

Connection Test Verification

The C++ Demo application provides a straightforward method to verify that all components of the ODBC-to-JDBC Bridge are working correctly:

ℹ Test Scenarios:
  • ✓ Successful: Query executes and returns expected results
  • ⚠️ DSN Not Found: Verify DSN exists in ODBC Administrator
  • ❌ Authentication Failed: Check username/password and database credentials
  • ❌ No Connection: Verify JDBC driver is installed and CLASSPATH is set correctly

Common Troubleshooting Steps

  • CLASSPATH Issues: Ensure JDBC driver JAR files are accessible via CLASSPATH environment variable
  • JVM Not Found: Verify 64-bit JVM is installed and jvm.dll path is correct in system environment
  • License Errors: Check that license files (oplrqb.lic, jdbc.lic) are in {OPENLINK_INSTALL}/bin directory
  • Port Conflicts: Verify the Request Broker port (default 5000) is not in use by another service
  • Database Connectivity: Test JDBC driver independently to verify it can connect to your target database
✓ Resolution: After addressing any issues, repeat the C++ Demo connection test to verify the problem has been resolved.

Additional Resources

Glossary

Key terms and concepts used throughout the OpenLink ODBC to JDBC Bridge documentation:

Data Source Name
Acronym: DSN
A data structure that contains the information required for an application to connect to a specific database.
Request Broker
A server-side component of the OpenLink Multi-Tier architecture that manages client connections and routes requests to the appropriate database agent.
Bridge Agent
A component that acts as a bridge between different database connectivity standards, in this case, translating ODBC calls to JDBC calls.
CLASSPATH
An environment variable that tells the Java Virtual Machine (JVM) where to find class libraries, including the JDBC driver JAR files.

Frequently Asked Questions

What is a key prerequisite for installing the OpenLink ODBC to JDBC Bridge Driver?
A 64-bit Java Virtual Machine (JVM) must be installed and configured on the machine where the driver will be installed. This is essential for the bridge to function properly.
Where should the JDBC driver .jar file be located?
The JDBC driver .jar file must be installed on the same machine as the OpenLink Request Broker and Bridge Agent, and included in the CLASSPATH environment variable so the JVM can locate it.
How can the installer files be downloaded?
You can download the MSI files from the OpenLink ODBC Enterprise Edition Driver Download Page or directly using a command-line tool like curl.
Where should the product license files be placed after installation?
The license files (e.g., oplrqb.lic, jdbc.lic) must be placed in the {OPENLINK_INSTALL}/bin directory.
How can you configure the driver's environment variables if they are not set system-wide?
You can edit the {OPENLINK_INSTALL}/bin/oplrqb.ini file and set variables like CLASSPATH in the [Environment JDBC18] section of the OpenLink Rule Book.
What is the name of the ODBC driver to select when creating a new DSN?
Select the 'OpenLink Generic ODBC Driver (Unicode)(9.0)' from the list in the ODBC Data Source Administrator.
What is the default hostname and port for a local connection?
The default is 'localhost:5000' when making a connection on the same machine.
Which 'Domain' should be selected during DSN configuration for a JDBC connection?
You should select the 'Jdbc 1.8' domain during DSN configuration.
What sample application can be used to test the ODBC connection?
The 'C++ Demo' sample application, found in the OpenLink Software program menu, can be used for testing ODBC connections.
What information is required in the DSN setup to connect to the target database?
You need the JDBC Driver Name, the JDBC Connect String URL, and the login credentials (username and password) for the target database.
What are the specific MSI files required for the installation?
The required MSI files are waajzzzz.msi, wabrzzzz.msi, and wao3zzzz.msi.
How can you verify the database connection during the DSN setup?
In the DSN configuration wizard, you can click the 'Connect now to verify that all settings are correct' checkbox and then the 'Next' button. You can also use the 'Test Data Source' button at the end of the setup.
What is the purpose of the oplrqb.ini file?
The oplrqb.ini file, also known as the OpenLink Rule Book, is used to set driver-specific configurations, such as environment variables like CLASSPATH if they are not already set system-wide.