# How Many Databases Does dbx Support? A Complete Guide to All 62 Supported Database Types

> Discover the 62 databases dbx supports. This comprehensive guide covers relational, NoSQL, and vector databases, ensuring seamless integration for your projects.

- Repository: [skyler/dbx](https://github.com/t8y2/dbx)
- Tags: deep-dive
- Published: 2026-07-07

---

**dbx supports 62 distinct database types**, ranging from traditional relational databases like PostgreSQL and MySQL to modern vector databases like Milvus and Qdrant, as defined in the `DBX_CONNECTION_TYPE_DESCRIPTION` constant in the MCP server source code.

The open-source **dbx** project (repository `t8y2/dbx`) provides a unified database connector that abstracts interactions across dozens of database engines. Understanding the full scope of supported databases helps developers determine if dbx covers their specific data infrastructure requirements.

## The Complete List of 62 Supported Databases

According to the source code in [`packages/mcp-server/src/index.ts`](https://github.com/t8y2/dbx/blob/main/packages/mcp-server/src/index.ts), the `DBX_CONNECTION_TYPE_DESCRIPTION` constant explicitly enumerates every supported database type:

```typescript
export const DBX_CONNECTION_TYPE_DESCRIPTION =
  "Database type: postgres, mysql, sqlite, rqlite, redis, duckdb, clickhouse, sqlserver, mongodb, oracle, elasticsearch, etcd, doris, starrocks, manticoresearch, milvus, qdrant, weaviate, chromadb, redshift, dameng, kingbase, highgo, vastbase, goldendb, databend, gaussdb, kwdb, yashandb, databricks, saphana, teradata, vertica, firebird, exasol, opengauss, oceanbase-oracle, questdb, gbase, h2, snowflake, trino, prestosql, hive, spark, db2, informix, influxdb, iris, neo4j, cassandra, bigquery, kylin, sundb, oscar, tdengine, iotdb, xugu, zookeeper, jdbc, access, mq";

```

Parsing this comma-separated list yields **62 unique database identifiers**:

- **Relational Databases**: postgres, mysql, sqlite, sqlserver, oracle, db2, informix, firebird, h2, access, dameng, kingbase, highgo, vastbase, goldendb, gaussdb, opengauss, oceanbase-oracle, gbase, oscar, xugu, sundb, kylin, teradata, vertica, saphana, exasol, redshift, databricks, snowflake, trino, prestosql, hive, spark, yashandb
- **MySQL-Compatible**: doris, starrocks, manticoresearch
- **Embedded/Distributed**: rqlite, etcd, zookeeper
- **NoSQL/Document**: mongodb, redis, cassandra, neo4j, elasticsearch
- **Vector/AI**: milvus, qdrant, weaviate, chromadb
- **Time-Series**: influxdb, questdb, kwdb, tdengine, iotdb, iris
- **Cloud/Data Warehouses**: bigquery, clickhouse, databend
- **Connectivity**: jdbc, mq

## How Database Support Is Implemented in dbx

The dbx codebase organizes database support through several key constants that define capabilities and query types.

### Primary Database Enumeration

The `DBX_CONNECTION_TYPE_DESCRIPTION` constant in [`packages/mcp-server/src/index.ts`](https://github.com/t8y2/dbx/blob/main/packages/mcp-server/src/index.ts) (lines 70-71) serves as the canonical registry of supported databases. This string is used for validation and help text generation throughout the application.

### Direct Query Capabilities

A subset of databases supports direct SQL queries without intermediate translation. The `DIRECT_QUERY_TYPES` array in [`packages/node-core/src/diagnostics.ts`](https://github.com/t8y2/dbx/blob/main/packages/node-core/src/diagnostics.ts) (lines 1-12) lists these engines:

```typescript
export const DIRECT_QUERY_TYPES = [
  "postgres",
  "redshift",
  "mysql",
  "doris",
  "starrocks",
  "manticoresearch",
  "sqlite",
  "rqlite",
  "kwdb",
  "questdb",
];

```

### File-Based Connection Support

Certain databases support file-based imports and connections. The `FILE_CAPABLE_CONNECTION_TYPES` Set in [`packages/mcp-server/src/index.ts`](https://github.com/t8y2/dbx/blob/main/packages/mcp-server/src/index.ts) (line 72) identifies these:

```typescript
const FILE_CAPABLE_CONNECTION_TYPES = new Set(["sqlite", "duckdb", "access", "h2"]);

```

## Categorizing dbx Supported Database Types

To better understand the 62 supported databases, they can be grouped by architectural patterns and use cases.

### Relational and OLTP Databases

dbx provides comprehensive support for traditional relational databases including **PostgreSQL**, **MySQL**, **Oracle**, **SQL Server**, and **DB2**. The platform also covers emerging Chinese relational databases like **Dameng**, **Kingbase**, **HighGo**, **Vastbase**, **GoldenDB**, **GaussDB**, **OpenGauss**, **OceanBase**, **GBase**, **Oscar**, **Xugu**, and **SunDB**.

### Data Warehouses and Analytics Engines

For analytical workloads, dbx supports **Snowflake**, **Databricks**, **Redshift**, **BigQuery**, **ClickHouse**, **Apache Hive**, **Apache Spark**, **Trino**, **PrestoSQL**, **Teradata**, **Vertica**, **Exasol**, **SAP HANA**, **Kylin**, and **Databend**.

### Vector Databases and AI Infrastructure

Modern AI applications requiring vector search capabilities are supported through **Milvus**, **Qdrant**, **Weaviate**, and **ChromaDB**. These integrate with dbx's connection pooling and query execution systems.

### Time-Series and Specialized Stores

Time-series databases including **InfluxDB**, **QuestDB**, **TDengine**, **IoTDB**, **Iris**, and **KWDB** are supported alongside specialized engines like **Elasticsearch**, **Cassandra**, **Neo4j**, and **MongoDB**.

## Practical Implementation: Checking Database Support

Developers can programmatically verify database support using the dbx SDK. The following example demonstrates how to access the supported database list and check specific capabilities:

```typescript
import { DBX_CONNECTION_TYPE_DESCRIPTION } from "@dbx/mcp-server";

// Extract and count supported databases
const databaseList = DBX_CONNECTION_TYPE_DESCRIPTION
  .replace("Database type: ", "")
  .split(", ")
  .map(s => s.trim());

console.log(`Total supported databases: ${databaseList.length}`); // Outputs: 62

// Check if a specific database is supported
const targetDb = "postgres";
const isSupported = databaseList.includes(targetDb);
console.log(`${targetDb} support: ${isSupported}`);

```

For capability-specific checks, import the capability sets:

```typescript
import { DIRECT_QUERY_TYPES } from "@dbx/node-core";

// Check direct query support
const supportsDirectQuery = DIRECT_QUERY_TYPES.includes("postgres"); // true

```

## Summary

- **dbx supports 62 distinct database types** as enumerated in the `DBX_CONNECTION_TYPE_DESCRIPTION` constant.
- The canonical list resides in [`packages/mcp-server/src/index.ts`](https://github.com/t8y2/dbx/blob/main/packages/mcp-server/src/index.ts) (lines 70-71).
- **Direct query capabilities** are limited to 10 databases defined in [`packages/node-core/src/diagnostics.ts`](https://github.com/t8y2/dbx/blob/main/packages/node-core/src/diagnostics.ts).
- **File-based connections** are supported for SQLite, DuckDB, Access, and H2.
- The supported range covers relational, NoSQL, vector, time-series, and specialized databases.

## Frequently Asked Questions

### How many databases does dbx support in total?

**dbx supports exactly 62 database types** according to the source code constant `DBX_CONNECTION_TYPE_DESCRIPTION` in [`packages/mcp-server/src/index.ts`](https://github.com/t8y2/dbx/blob/main/packages/mcp-server/src/index.ts). This count includes relational databases, NoSQL stores, vector databases, time-series engines, and specialized connection types like JDBC and message queues.

### Where is the list of supported databases defined in the dbx source code?

The definitive list is defined in the string constant `DBX_CONNECTION_TYPE_DESCRIPTION` located at lines 70-71 of [`packages/mcp-server/src/index.ts`](https://github.com/t8y2/dbx/blob/main/packages/mcp-server/src/index.ts). This constant provides a comma-separated enumeration of all supported database identifiers used throughout the application for validation and documentation purposes.

### Does dbx support file-based database connections?

**Yes**, but only for a specific subset. The `FILE_CAPABLE_CONNECTION_TYPES` Set in [`packages/mcp-server/src/index.ts`](https://github.com/t8y2/dbx/blob/main/packages/mcp-server/src/index.ts) (line 72) restricts file-based connections to **SQLite**, **DuckDB**, **Microsoft Access**, and **H2** databases. Other database types require network-based connections.

### Which databases support direct SQL queries without translation in dbx?

The `DIRECT_QUERY_TYPES` array in [`packages/node-core/src/diagnostics.ts`](https://github.com/t8y2/dbx/blob/main/packages/node-core/src/diagnostics.ts) identifies 10 databases that support direct SQL queries: **PostgreSQL**, **Redshift**, **MySQL**, **Doris**, **StarRocks**, **ManticoreSearch**, **SQLite**, **RQLite**, **KWDB**, and **QuestDB**. These engines bypass intermediate query translation layers for improved performance.