# What Databases Are Supported via Native Drivers vs JDBC Agents in DBX

> DBX supports Oracle & XuguDB with native Go drivers. Discover which other databases connect via JDBC agents for seamless integration.

- Repository: [skyler/dbx](https://github.com/t8y2/dbx)
- Tags: api-reference
- Published: 2026-07-10

---

**DBX supports Oracle and XuguDB through native Go drivers, while all other databases—including PostgreSQL, MySQL, BigQuery, and Cassandra—connect via JDBC agents that DBX automatically provisions with a bundled JRE.**

DBX is a universal database client from the `t8y2/dbx` repository that abstracts connection details behind a unified JSON-RPC interface. According to the source code, the project maintains two distinct agent architectures: lightweight native executables written in Go, and Java-based JDBC agents. Understanding which databases use native drivers versus JDBC agents helps optimize startup performance and deployment requirements.

## Native Driver Support in DBX

DBX ships native Go implementations for databases where mature, license-compatible drivers exist. These agents require no Java Runtime Environment (JVM) and start significantly faster than their JDBC counterparts.

### Oracle (oracle-go)

The Oracle agent is implemented in [`agents/drivers/oracle-go/main.go`](https://github.com/t8y2/dbx/blob/main/agents/drivers/oracle-go/main.go) using the **go-ora** driver. This native implementation eliminates JVM overhead for Oracle Database connections. The executable is built as a self-contained binary that communicates with the DBX core process via JSON-RPC 2.0 over stdin/stdout.

### XuguDB (xugu)

XuguDB support is provided by the native agent located in [`agents/drivers/xugu/main.go`](https://github.com/t8y2/dbx/blob/main/agents/drivers/xugu/main.go). Like the Oracle driver, this is a Go-based executable that operates without a JVM, making it ideal for environments where minimizing memory footprint is critical.

## JDBC Agent Support

All databases beyond Oracle and XuguDB connect through **JDBC agents**. These include popular engines such as PostgreSQL, MySQL, Trino, Hive, DB2, Informix, Neo4j, Cassandra, BigQuery, Apache Kylin, SunDB, TDengine, and YashanDB, along with specialized databases like Access, Dameng, and Kingbase.

Each JDBC agent ships as an `agent.jar` file built from Gradle scripts located in `agents/drivers/<db>/build.gradle`. The DBX core automatically provisions a JRE for these agents, which run as separate Java processes communicating via the same JSON-RPC 2.0 contract used by native drivers. The mapping of agent modules to versions is maintained in [`agents/versions.json`](https://github.com/t8y2/dbx/blob/main/agents/versions.json).

## Agent Selection and Fallback Behavior

When multiple implementations exist for the same database, DBX prefers native drivers and maintains JDBC versions as compatibility fallbacks. As documented in [`agents/README.md`](https://github.com/t8y2/dbx/blob/main/agents/README.md), the system transparently switches between agent types without requiring configuration changes, ensuring that Oracle connections use the Go-based `oracle-go` agent by default while keeping the legacy Java implementation available if needed.

## Configuration Examples

Both native and JDBC agents use identical connection configuration syntax, differing only in the agent identifier and connection parameters.

Native driver configuration for Oracle:

```json
{
  "agent": "oracle",
  "host": "oracle.example.com",
  "port": 1521,
  "user": "dbuser",
  "password": "********",
  "database": "ORCL"
}

```

JDBC agent configuration for PostgreSQL:

```json
{
  "agent": "postgres",
  "jdbcUrl": "jdbc:postgresql://pg.example.com:5432/mydb",
  "user": "dbuser",
  "password": "********"
}

```

In both cases, DBX spawns the appropriate executable—either the native binary from `agents/drivers/oracle-go` or the Java agent packaged by `agents/drivers/postgres/build.gradle`—and manages JSON-RPC message forwarding through stdin/stdout.

## Summary

- **Native Go drivers** are available exclusively for **Oracle** and **XuguDB**, requiring no JVM and offering faster startup times.
- **JDBC agents** support all other databases, including PostgreSQL, MySQL, BigQuery, and Cassandra, via Java-based `agent.jar` files that DBX provisions automatically.
- Both architectures implement the identical JSON-RPC 2.0 contract defined in [`agents/README.md`](https://github.com/t8y2/dbx/blob/main/agents/README.md), allowing transparent switching between native and Java implementations.
- DBX prefers native drivers when available, using JDBC agents as fallbacks for maximum compatibility.

## Frequently Asked Questions

### Which databases in DBX do not require a Java Runtime Environment?

Only **Oracle** and **XuguDB** use native Go drivers that operate without a JVM. All other databases require the JDBC agent, which DBX automatically provisions with its own bundled JRE.

### Can I force DBX to use the JDBC agent instead of the native driver for Oracle?

Yes. While DBX automatically prefers the native `oracle-go` agent, the system maintains the Java implementation as a compatibility fallback. You can configure the connection to use the JDBC agent by specifying the appropriate agent identifier, though the native driver is recommended for better performance.

### How does DBX handle JDBC driver dependencies for databases like BigQuery or Cassandra?

DBX packages each JDBC agent as a self-contained `agent.jar` file built via Gradle scripts in `agents/drivers/<db>/build.gradle`. These JAR files include all necessary JDBC driver dependencies, and DBX automatically manages the JRE provisioning, eliminating manual classpath configuration.

### Where is the complete list of supported databases documented?

The authoritative list is maintained in [`agents/README.md`](https://github.com/t8y2/dbx/blob/main/agents/README.md) at the repository root, which includes the full table of JDBC-based agents and specific implementation details for the native Oracle and Xugu drivers in `agents/drivers/oracle-go` and `agents/drivers/xugu` respectively.