@bytebase/dbhub 0.7.0 → 0.8.4

package/README.md

@@ -1,3 +1,6 @@
+> [!NOTE]  
+> Brought to you by [Bytebase](https://www.bytebase.com/), open-source database DevSecOps platform.
+
 <p align="center">
 <a href="https://dbhub.ai/" target="_blank">
 <picture>
@@ -8,6 +11,7 @@
 
 <p align="center">
   <a href="https://cursor.com/install-mcp?name=dbhub&config=eyJjb21tYW5kIjoibnB4IEBieXRlYmFzZS9kYmh1YiIsImVudiI6eyJUUkFOU1BPUlQiOiJzdGRpbyIsIkRTTiI6InBvc3RncmVzOi8vdXNlcjpwYXNzd29yZEBsb2NhbGhvc3Q6NTQzMi9kYm5hbWU%2Fc3NsbW9kZT1kaXNhYmxlIiwiUkVBRE9OTFkiOiJ0cnVlIn19"><img src="https://cursor.com/deeplink/mcp-install-dark.svg" alt="Add dbhub MCP server to Cursor" height="32" /></a>
+  <a href="https://discord.gg/BjEkZpsJzn"><img src="https://img.shields.io/badge/%20-Hang%20out%20on%20Discord-5865F2?style=for-the-badge&logo=discord&labelColor=EEEEEE" alt="Join our Discord" height="32" /></a>
 </p>
 
 DBHub is a universal database gateway implementing the Model Context Protocol (MCP) server interface. This gateway allows MCP-compatible clients to connect to and explore different databases.
@@ -26,8 +30,6 @@ DBHub is a universal database gateway implementing the Model Context Protocol (M
  |                  |    |              |    |                  |
  |                  |    |              +--->+    MariaDB       |
  |                  |    |              |    |                  |
- |                  |    |              +--->+    Oracle        |
- |                  |    |              |    |                  |
  +------------------+    +--------------+    +------------------+
       MCP Clients           MCP Server             Databases
 ```
@@ -42,27 +44,27 @@ https://demo.dbhub.ai/message connects a [sample employee database](https://gith
 
 ### Database Resources
 
-| Resource Name               | URI Format                                             | PostgreSQL | MySQL | MariaDB | SQL Server | SQLite | Oracle |
-| --------------------------- | ------------------------------------------------------ | :--------: | :---: | :-----: | :--------: | :----: | :----: |
-| schemas                     | `db://schemas`                                         |     ✅     |  ✅   |   ✅    |     ✅     |   ✅   |   ✅   |
-| tables_in_schema            | `db://schemas/{schemaName}/tables`                     |     ✅     |  ✅   |   ✅    |     ✅     |   ✅   |   ✅   |
-| table_structure_in_schema   | `db://schemas/{schemaName}/tables/{tableName}`         |     ✅     |  ✅   |   ✅    |     ✅     |   ✅   |   ✅   |
-| indexes_in_table            | `db://schemas/{schemaName}/tables/{tableName}/indexes` |     ✅     |  ✅   |   ✅    |     ✅     |   ✅   |   ✅   |
-| procedures_in_schema        | `db://schemas/{schemaName}/procedures`                 |     ✅     |  ✅   |   ✅    |     ✅     |   ❌   |   ✅   |
-| procedure_details_in_schema | `db://schemas/{schemaName}/procedures/{procedureName}` |     ✅     |  ✅   |   ✅    |     ✅     |   ❌   |   ✅   |
+| Resource Name               | URI Format                                             | PostgreSQL | MySQL | MariaDB | SQL Server | SQLite |
+| --------------------------- | ------------------------------------------------------ | :--------: | :---: | :-----: | :--------: | :----: |
+| schemas                     | `db://schemas`                                         |     ✅     |  ✅   |   ✅    |     ✅     |   ✅   |
+| tables_in_schema            | `db://schemas/{schemaName}/tables`                     |     ✅     |  ✅   |   ✅    |     ✅     |   ✅   |
+| table_structure_in_schema   | `db://schemas/{schemaName}/tables/{tableName}`         |     ✅     |  ✅   |   ✅    |     ✅     |   ✅   |
+| indexes_in_table            | `db://schemas/{schemaName}/tables/{tableName}/indexes` |     ✅     |  ✅   |   ✅    |     ✅     |   ✅   |
+| procedures_in_schema        | `db://schemas/{schemaName}/procedures`                 |     ✅     |  ✅   |   ✅    |     ✅     |   ❌   |
+| procedure_details_in_schema | `db://schemas/{schemaName}/procedures/{procedureName}` |     ✅     |  ✅   |   ✅    |     ✅     |   ❌   |
 
 ### Database Tools
 
-| Tool            | Command Name      | Description                                                         | PostgreSQL | MySQL | MariaDB | SQL Server | SQLite | Oracle |
-| --------------- | ----------------- | ------------------------------------------------------------------- | :--------: | :---: | :-----: | :--------: | ------ | :----: |
-| Execute SQL     | `execute_sql`     | Execute single or multiple SQL statements (separated by semicolons) |     ✅     |  ✅   |   ✅    |     ✅     | ✅     |   ✅   |
+| Tool        | Command Name  | Description                                                         | PostgreSQL | MySQL | MariaDB | SQL Server | SQLite |
+| ----------- | ------------- | ------------------------------------------------------------------- | :--------: | :---: | :-----: | :--------: | ------ |
+| Execute SQL | `execute_sql` | Execute single or multiple SQL statements (separated by semicolons) |     ✅     |  ✅   |   ✅    |     ✅     | ✅     |
 
 ### Prompt Capabilities
 
-| Prompt              | Command Name   | PostgreSQL | MySQL | MariaDB | SQL Server | SQLite | Oracle |
-| ------------------- | -------------- | :--------: | :---: | :-----: | :--------: | ------ | :----: |
-| Generate SQL        | `generate_sql` |     ✅     |  ✅   |   ✅    |     ✅     | ✅     |   ✅   |
-| Explain DB Elements | `explain_db`   |     ✅     |  ✅   |   ✅    |     ✅     | ✅     |   ✅   |
+| Prompt              | Command Name   | PostgreSQL | MySQL | MariaDB | SQL Server | SQLite |
+| ------------------- | -------------- | :--------: | :---: | :-----: | :--------: | ------ |
+| Generate SQL        | `generate_sql` |     ✅     |  ✅   |   ✅    |     ✅     | ✅     |
+| Explain DB Elements | `explain_db`   |     ✅     |  ✅   |   ✅    |     ✅     | ✅     |
 
 ## Installation
 
@@ -90,27 +92,6 @@ docker run --rm --init \
    --demo
 ```
 
-```bash
-# Oracle example
-docker run --rm --init \
-   --name dbhub \
-   --publish 8080:8080 \
-   bytebase/dbhub \
-   --transport http \
-   --port 8080 \
-   --dsn "oracle://username:password@localhost:1521/service_name"
-```
-
-```bash
-# Oracle example with thick mode for connecting to 11g or older
-docker run --rm --init \
-   --name dbhub \
-   --publish 8080:8080 \
-   bytebase/dbhub-oracle-thick \
-   --transport http \
-   --port 8080 \
-   --dsn "oracle://username:password@localhost:1521/service_name"
-```
 
 ### NPM
 
@@ -190,7 +171,6 @@ You can specify the SSL mode using the `sslmode` parameter in your DSN string:
 | MySQL      |        ✅         |        ✅         |    Certificate verification    |
 | MariaDB    |        ✅         |        ✅         |    Certificate verification    |
 | SQL Server |        ✅         |        ✅         |    Certificate verification    |
-| Oracle     |        ✅         |        ✅         | N/A (use Oracle client config) |
 | SQLite     |        ❌         |        ❌         |        N/A (file-based)        |
 
 **SSL Mode Options:**
@@ -235,7 +215,7 @@ npx @bytebase/dbhub  --demo
 ```
 
 > [!WARNING]
-If your user/password contains special characters, you need to escape them first. (e.g. `pass#word` should be escaped as `pass%23word`)
+> If your user/password contains special characters, you need to escape them first. (e.g. `pass#word` should be escaped as `pass%23word`)
 
 For real databases, a Database Source Name (DSN) is required. You can provide this in several ways:
 
@@ -271,28 +251,7 @@ DBHub supports the following database connection string formats:
 | PostgreSQL | `postgres://[user]:[password]@[host]:[port]/[database]`   | `postgres://user:password@localhost:5432/dbname?sslmode=disable`                                               |
 | SQL Server | `sqlserver://[user]:[password]@[host]:[port]/[database]`  | `sqlserver://user:password@localhost:1433/dbname?sslmode=disable`                                              |
 | SQLite     | `sqlite:///[path/to/file]` or `sqlite:///:memory:`        | `sqlite:///path/to/database.db`, `sqlite:C:/Users/YourName/data/database.db (windows)` or `sqlite:///:memory:` |
-| Oracle     | `oracle://[user]:[password]@[host]:[port]/[service_name]` | `oracle://username:password@localhost:1521/service_name?sslmode=disable`                                       |
-
-#### Oracle
-
-If you see the error "NJS-138: connections to this database server version are not supported by node-oracledb in Thin mode", you need to use Thick mode as described below.
-
-##### Docker
-
-Use `bytebase/dbhub-oracle-thick` instead of `bytebase/dbhub` docker image.
 
-##### npx
-
-1. Download and install [Oracle Instant Client](https://www.oracle.com/database/technologies/instant-client/downloads.html) for your platform
-1. Set the `ORACLE_LIB_DIR` environment variable to the path of your Oracle Instant Client:
-
-```bash
-# Set environment variable to Oracle Instant Client directory
-export ORACLE_LIB_DIR=/path/to/instantclient_19_8
-
-# Then run DBHub
-npx @bytebase/dbhub --dsn "oracle://username:password@localhost:1521/service_name"
-```
 
 #### SQL Server
 
@@ -317,13 +276,13 @@ Extra query parameters:
 
 ### Command line options
 
-| Option    | Environment Variable | Description                                                     | Default                      |
-| --------- | -------------------- | --------------------------------------------------------------- | ---------------------------- |
-| dsn       | `DSN`                | Database connection string                                      | Required if not in demo mode |
-| transport | `TRANSPORT`          | Transport mode: `stdio` or `http`                               | `stdio`                      |
+| Option    | Environment Variable | Description                                                      | Default                      |
+| --------- | -------------------- | ---------------------------------------------------------------- | ---------------------------- |
+| dsn       | `DSN`                | Database connection string                                       | Required if not in demo mode |
+| transport | `TRANSPORT`          | Transport mode: `stdio` or `http`                                | `stdio`                      |
 | port      | `PORT`               | HTTP server port (only applicable when using `--transport=http`) | `8080`                       |
-| readonly  | `READONLY`           | Restrict SQL execution to read-only operations                  | `false`                      |
-| demo      | N/A                  | Run in demo mode with sample employee database                  | `false`                      |
+| readonly  | `READONLY`           | Restrict SQL execution to read-only operations                   | `false`                      |
+| demo      | N/A                  | Run in demo mode with sample employee database                   | `false`                      |
 
 The demo mode uses an in-memory SQLite database loaded with the [sample employee database](https://github.com/bytebase/dbhub/tree/main/resources/employee-sqlite) that includes tables for employees, departments, titles, salaries, department employees, and department managers. The sample database includes SQL scripts for table creation, data loading, and testing.
 
@@ -349,10 +308,90 @@ The demo mode uses an in-memory SQLite database loaded with the [sample employee
 
 ### Testing
 
-The project uses Vitest for comprehensive unit testing:
+The project uses Vitest for comprehensive unit and integration testing:
 
 - **Run all tests**: `pnpm test`
 - **Run tests in watch mode**: `pnpm test:watch`
+- **Run integration tests**: `pnpm test:integration`
+
+#### Integration Tests
+
+DBHub includes comprehensive integration tests for all supported database connectors using [Testcontainers](https://testcontainers.com/). These tests run against real database instances in Docker containers, ensuring full compatibility and feature coverage.
+
+##### Prerequisites
+
+- **Docker**: Ensure Docker is installed and running on your machine
+- **Docker Resources**: Allocate sufficient memory (recommended: 4GB+) for multiple database containers
+- **Network Access**: Ability to pull Docker images from registries
+
+##### Running Integration Tests
+
+**Note**: This command runs all integration tests in parallel, which may take 5-15 minutes depending on your system resources and network speed.
+
+```bash
+# Run all database integration tests
+pnpm test:integration
+```
+
+```bash
+# Run only PostgreSQL integration tests
+pnpm test src/connectors/__tests__/postgres.integration.test.ts
+# Run only MySQL integration tests
+pnpm test src/connectors/__tests__/mysql.integration.test.ts
+# Run only MariaDB integration tests
+pnpm test src/connectors/__tests__/mariadb.integration.test.ts
+# Run only SQL Server integration tests
+pnpm test src/connectors/__tests__/sqlserver.integration.test.ts
+# Run only SQLite integration tests
+pnpm test src/connectors/__tests__/sqlite.integration.test.ts
+# Run JSON RPC integration tests
+pnpm test src/__tests__/json-rpc-integration.test.ts
+```
+
+All integration tests follow these patterns:
+
+1. **Container Lifecycle**: Start database container → Connect → Setup test data → Run tests → Cleanup
+2. **Shared Test Utilities**: Common test patterns implemented in `IntegrationTestBase` class
+3. **Database-Specific Features**: Each database includes tests for unique features and capabilities
+4. **Error Handling**: Comprehensive testing of connection errors, invalid SQL, and edge cases
+
+##### Troubleshooting Integration Tests
+
+**Container Startup Issues:**
+
+```bash
+# Check Docker is running
+docker ps
+
+# Check available memory
+docker system df
+
+# Pull images manually if needed
+docker pull postgres:15-alpine
+docker pull mysql:8.0
+docker pull mariadb:10.11
+docker pull mcr.microsoft.com/mssql/server:2019-latest
+```
+
+**SQL Server Timeout Issues:**
+
+- SQL Server containers require significant startup time (3-5 minutes)
+- Ensure Docker has sufficient memory allocated (4GB+ recommended)
+- Consider running SQL Server tests separately if experiencing timeouts
+
+
+**Network/Resource Issues:**
+
+```bash
+# Run tests with verbose output
+pnpm test:integration --reporter=verbose
+
+# Run single database test to isolate issues
+pnpm test:integration -- --testNamePattern="PostgreSQL"
+
+# Check Docker container logs if tests fail
+docker logs <container_id>
+```
 
 #### Pre-commit Hooks (for Developers)
 

package/dist/index.js

@@ -148,12 +148,55 @@ var SafeURL = class {
   }
 };
 
+// src/utils/dsn-obfuscate.ts
+function obfuscateDSNPassword(dsn) {
+  if (!dsn) {
+    return dsn;
+  }
+  try {
+    const protocolMatch = dsn.match(/^([^:]+):/);
+    if (!protocolMatch) {
+      return dsn;
+    }
+    const protocol = protocolMatch[1];
+    if (protocol === "sqlite") {
+      return dsn;
+    }
+    const protocolPart = dsn.split("://")[1];
+    if (!protocolPart) {
+      return dsn;
+    }
+    const lastAtIndex = protocolPart.lastIndexOf("@");
+    if (lastAtIndex === -1) {
+      return dsn;
+    }
+    const credentialsPart = protocolPart.substring(0, lastAtIndex);
+    const hostPart = protocolPart.substring(lastAtIndex + 1);
+    const colonIndex = credentialsPart.indexOf(":");
+    if (colonIndex === -1) {
+      return dsn;
+    }
+    const username = credentialsPart.substring(0, colonIndex);
+    const password = credentialsPart.substring(colonIndex + 1);
+    const obfuscatedPassword = "*".repeat(Math.min(password.length, 8));
+    return `${protocol}://${username}:${obfuscatedPassword}@${hostPart}`;
+  } catch (error) {
+    return dsn;
+  }
+}
+
 // src/connectors/postgres/index.ts
 var { Pool } = pg;
 var PostgresDSNParser = class {
   async parse(dsn) {
     if (!this.isValidDSN(dsn)) {
-      throw new Error(`Invalid PostgreSQL DSN: ${dsn}`);
+      const obfuscatedDSN = obfuscateDSNPassword(dsn);
+      const expectedFormat = this.getSampleDSN();
+      throw new Error(
+        `Invalid PostgreSQL DSN format.
+Provided: ${obfuscatedDSN}
+Expected: ${expectedFormat}`
+      );
     }
     try {
       const url = new SafeURL(dsn);
@@ -491,8 +534,12 @@ import { DefaultAzureCredential } from "@azure/identity";
 var SQLServerDSNParser = class {
   async parse(dsn) {
     if (!this.isValidDSN(dsn)) {
+      const obfuscatedDSN = obfuscateDSNPassword(dsn);
+      const expectedFormat = this.getSampleDSN();
       throw new Error(
-        "Invalid SQL Server DSN format. Expected: sqlserver://username:password@host:port/database"
+        `Invalid SQL Server DSN format.
+Provided: ${obfuscatedDSN}
+Expected: ${expectedFormat}`
       );
     }
     try {
@@ -512,6 +559,7 @@ var SQLServerDSNParser = class {
       if (options.sslmode) {
         if (options.sslmode === "disable") {
           options.encrypt = false;
+          options.trustServerCertificate = false;
         } else if (options.sslmode === "require") {
           options.encrypt = true;
           options.trustServerCertificate = true;
@@ -526,9 +574,9 @@ var SQLServerDSNParser = class {
         database: url.pathname ? url.pathname.substring(1) : "",
         // Remove leading slash
         options: {
-          encrypt: options.encrypt ?? true,
-          // Default to encrypted connection
-          trustServerCertificate: options.trustServerCertificate === true,
+          encrypt: options.encrypt ?? false,
+          // Default to unencrypted for development
+          trustServerCertificate: options.trustServerCertificate ?? false,
           connectTimeout: options.connectTimeout ?? 15e3,
           requestTimeout: options.requestTimeout ?? 15e3
         }
@@ -556,7 +604,7 @@ var SQLServerDSNParser = class {
     }
   }
   getSampleDSN() {
-    return "sqlserver://username:password@localhost:1433/database?sslmode=require";
+    return "sqlserver://username:password@localhost:1433/database?sslmode=disable";
   }
   isValidDSN(dsn) {
     try {
@@ -836,7 +884,13 @@ import Database from "better-sqlite3";
 var SQLiteDSNParser = class {
   async parse(dsn) {
     if (!this.isValidDSN(dsn)) {
-      throw new Error(`Invalid SQLite DSN: ${dsn}`);
+      const obfuscatedDSN = obfuscateDSNPassword(dsn);
+      const expectedFormat = this.getSampleDSN();
+      throw new Error(
+        `Invalid SQLite DSN format.
+Provided: ${obfuscatedDSN}
+Expected: ${expectedFormat}`
+      );
     }
     try {
       const url = new SafeURL(dsn);
@@ -907,7 +961,7 @@ var SQLiteConnector = class {
     if (!this.db) {
       throw new Error("Not connected to SQLite database");
     }
-    return [this.dbPath === ":memory:" ? "main" : this.dbPath];
+    return ["main"];
   }
   async getTables(schema) {
     if (!this.db) {
@@ -951,15 +1005,17 @@ var SQLiteConnector = class {
         `
         SELECT 
           name as index_name,
-          CASE 
-            WHEN "unique" = 1 THEN 1
-            ELSE 0
-          END as is_unique
+          0 as is_unique
         FROM sqlite_master 
         WHERE type = 'index' 
         AND tbl_name = ?
       `
       ).all(tableName);
+      const indexListRows = this.db.prepare(`PRAGMA index_list(${tableName})`).all();
+      const indexUniqueMap = /* @__PURE__ */ new Map();
+      for (const indexListRow of indexListRows) {
+        indexUniqueMap.set(indexListRow.name, indexListRow.unique === 1);
+      }
       const tableInfo = this.db.prepare(`PRAGMA table_info(${tableName})`).all();
       const pkColumns = tableInfo.filter((col) => col.pk > 0).map((col) => col.name);
       const results = [];
@@ -969,7 +1025,7 @@ var SQLiteConnector = class {
         results.push({
           index_name: indexInfo.index_name,
           column_names: columnNames,
-          is_unique: indexInfo.is_unique === 1,
+          is_unique: indexUniqueMap.get(indexInfo.index_name) || false,
           is_primary: false
         });
       }
@@ -995,8 +1051,8 @@ var SQLiteConnector = class {
       const columns = rows.map((row) => ({
         column_name: row.name,
         data_type: row.type,
-        is_nullable: row.notnull === 0 ? "YES" : "NO",
-        // In SQLite, 0 means nullable
+        // In SQLite, primary key columns are automatically NOT NULL even if notnull=0
+        is_nullable: row.notnull === 1 || row.pk > 0 ? "NO" : "YES",
         column_default: row.dflt_value
       }));
       return columns;
@@ -1025,14 +1081,21 @@ var SQLiteConnector = class {
     try {
       const statements = sql2.split(";").map((statement) => statement.trim()).filter((statement) => statement.length > 0);
       if (statements.length === 1) {
-        const rows = this.db.prepare(statements[0]).all();
-        return { rows };
+        const trimmedStatement = statements[0].toLowerCase().trim();
+        const isReadStatement = trimmedStatement.startsWith("select") || trimmedStatement.startsWith("with") || trimmedStatement.startsWith("explain") || trimmedStatement.startsWith("analyze") || trimmedStatement.startsWith("pragma") && (trimmedStatement.includes("table_info") || trimmedStatement.includes("index_info") || trimmedStatement.includes("index_list") || trimmedStatement.includes("foreign_key_list"));
+        if (isReadStatement) {
+          const rows = this.db.prepare(statements[0]).all();
+          return { rows };
+        } else {
+          this.db.prepare(statements[0]).run();
+          return { rows: [] };
+        }
       } else {
         const readStatements = [];
         const writeStatements = [];
         for (const statement of statements) {
           const trimmedStatement = statement.toLowerCase().trim();
-          if (trimmedStatement.startsWith("select") || trimmedStatement.startsWith("with") || trimmedStatement.startsWith("explain") || trimmedStatement.startsWith("analyze") || trimmedStatement.startsWith("pragma")) {
+          if (trimmedStatement.startsWith("select") || trimmedStatement.startsWith("with") || trimmedStatement.startsWith("explain") || trimmedStatement.startsWith("analyze") || trimmedStatement.startsWith("pragma") && (trimmedStatement.includes("table_info") || trimmedStatement.includes("index_info") || trimmedStatement.includes("index_list") || trimmedStatement.includes("foreign_key_list"))) {
             readStatements.push(statement);
           } else {
             writeStatements.push(statement);
@@ -1061,7 +1124,13 @@ import mysql from "mysql2/promise";
 var MySQLDSNParser = class {
   async parse(dsn) {
     if (!this.isValidDSN(dsn)) {
-      throw new Error(`Invalid MySQL DSN: ${dsn}`);
+      const obfuscatedDSN = obfuscateDSNPassword(dsn);
+      const expectedFormat = this.getSampleDSN();
+      throw new Error(
+        `Invalid MySQL DSN format.
+Provided: ${obfuscatedDSN}
+Expected: ${expectedFormat}`
+      );
     }
     try {
       const url = new SafeURL(dsn);
@@ -1430,7 +1499,13 @@ import mariadb from "mariadb";
 var MariadbDSNParser = class {
   async parse(dsn) {
     if (!this.isValidDSN(dsn)) {
-      throw new Error(`Invalid MariaDB DSN: ${dsn}`);
+      const obfuscatedDSN = obfuscateDSNPassword(dsn);
+      const expectedFormat = this.getSampleDSN();
+      throw new Error(
+        `Invalid MariaDB DSN format.
+Provided: ${obfuscatedDSN}
+Expected: ${expectedFormat}`
+      );
     }
     try {
       const url = new SafeURL(dsn);
@@ -1441,8 +1516,10 @@ var MariadbDSNParser = class {
         // Remove leading '/' if exists
         user: url.username,
         password: url.password,
-        multipleStatements: true
+        multipleStatements: true,
         // Enable native multi-statement support
+        connectTimeout: 5e3
+        // 5 second timeout for connections
       };
       url.forEachSearchParam((value, key) => {
         if (key === "sslmode") {
@@ -1485,7 +1562,7 @@ var MariaDBConnector = class {
       const config = await this.dsnParser.parse(dsn);
       this.pool = mariadb.createPool(config);
       console.error("Testing connection to MariaDB...");
-      const [rows] = await this.pool.query("SELECT 1");
+      await this.pool.query("SELECT 1");
       console.error("Successfully connected to MariaDB database");
     } catch (err) {
       console.error("Failed to connect to MariaDB database:", err);
@@ -1503,7 +1580,7 @@ var MariaDBConnector = class {
       throw new Error("Not connected to database");
     }
     try {
-      const [rows] = await this.pool.query(`
+      const rows = await this.pool.query(`
         SELECT SCHEMA_NAME 
         FROM INFORMATION_SCHEMA.SCHEMATA
         ORDER BY SCHEMA_NAME
@@ -1521,7 +1598,7 @@ var MariaDBConnector = class {
     try {
       const schemaClause = schema ? "WHERE TABLE_SCHEMA = ?" : "WHERE TABLE_SCHEMA = DATABASE()";
       const queryParams = schema ? [schema] : [];
-      const [rows] = await this.pool.query(
+      const rows = await this.pool.query(
         `
         SELECT TABLE_NAME 
         FROM INFORMATION_SCHEMA.TABLES 
@@ -1543,7 +1620,7 @@ var MariaDBConnector = class {
     try {
       const schemaClause = schema ? "WHERE TABLE_SCHEMA = ?" : "WHERE TABLE_SCHEMA = DATABASE()";
       const queryParams = schema ? [schema, tableName] : [tableName];
-      const [rows] = await this.pool.query(
+      const rows = await this.pool.query(
         `
         SELECT COUNT(*) AS COUNT
         FROM INFORMATION_SCHEMA.TABLES 
@@ -1565,7 +1642,7 @@ var MariaDBConnector = class {
     try {
       const schemaClause = schema ? "TABLE_SCHEMA = ?" : "TABLE_SCHEMA = DATABASE()";
       const queryParams = schema ? [schema, tableName] : [tableName];
-      const [indexRows] = await this.pool.query(
+      const indexRows = await this.pool.query(
         `
         SELECT 
           INDEX_NAME,
@@ -1621,7 +1698,7 @@ var MariaDBConnector = class {
     try {
       const schemaClause = schema ? "WHERE TABLE_SCHEMA = ?" : "WHERE TABLE_SCHEMA = DATABASE()";
       const queryParams = schema ? [schema, tableName] : [tableName];
-      const [rows] = await this.pool.query(
+      const rows = await this.pool.query(
         `
         SELECT 
           COLUMN_NAME as column_name, 
@@ -1648,7 +1725,7 @@ var MariaDBConnector = class {
     try {
       const schemaClause = schema ? "WHERE ROUTINE_SCHEMA = ?" : "WHERE ROUTINE_SCHEMA = DATABASE()";
       const queryParams = schema ? [schema] : [];
-      const [rows] = await this.pool.query(
+      const rows = await this.pool.query(
         `
         SELECT ROUTINE_NAME
         FROM INFORMATION_SCHEMA.ROUTINES
@@ -1670,7 +1747,7 @@ var MariaDBConnector = class {
     try {
       const schemaClause = schema ? "WHERE r.ROUTINE_SCHEMA = ?" : "WHERE r.ROUTINE_SCHEMA = DATABASE()";
       const queryParams = schema ? [schema, procedureName] : [procedureName];
-      const [rows] = await this.pool.query(
+      const rows = await this.pool.query(
         `
         SELECT 
           r.ROUTINE_NAME AS procedure_name,
@@ -1708,7 +1785,7 @@ var MariaDBConnector = class {
         const schemaValue = schema || await this.getCurrentSchema();
         if (procedure.procedure_type === "procedure") {
           try {
-            const [defRows] = await this.pool.query(`
+            const defRows = await this.pool.query(`
               SHOW CREATE PROCEDURE ${schemaValue}.${procedureName}
             `);
             if (defRows && defRows.length > 0) {
@@ -1719,7 +1796,7 @@ var MariaDBConnector = class {
           }
         } else {
           try {
-            const [defRows] = await this.pool.query(`
+            const defRows = await this.pool.query(`
               SHOW CREATE FUNCTION ${schemaValue}.${procedureName}
             `);
             if (defRows && defRows.length > 0) {
@@ -1730,7 +1807,7 @@ var MariaDBConnector = class {
           }
         }
         if (!definition) {
-          const [bodyRows] = await this.pool.query(
+          const bodyRows = await this.pool.query(
             `
             SELECT ROUTINE_DEFINITION, ROUTINE_BODY 
             FROM INFORMATION_SCHEMA.ROUTINES
@@ -1765,7 +1842,7 @@ var MariaDBConnector = class {
   }
   // Helper method to get current schema (database) name
   async getCurrentSchema() {
-    const [rows] = await this.pool.query("SELECT DATABASE() AS DB");
+    const rows = await this.pool.query("SELECT DATABASE() AS DB");
     return rows[0].DB;
   }
   async executeSQL(sql2) {
@@ -1774,17 +1851,20 @@ var MariaDBConnector = class {
     }
     try {
       const results = await this.pool.query(sql2);
-      const [firstResult] = results;
-      if (Array.isArray(firstResult) && firstResult.length > 0 && Array.isArray(firstResult[0]) && firstResult[0].length === 2) {
-        let allRows = [];
-        for (const [rows, _fields] of firstResult) {
-          if (Array.isArray(rows)) {
-            allRows.push(...rows);
+      if (Array.isArray(results)) {
+        if (results.length > 0 && Array.isArray(results[0]) && results[0].length > 0) {
+          let allRows = [];
+          for (const result of results) {
+            if (Array.isArray(result)) {
+              allRows.push(...result);
+            }
           }
+          return { rows: allRows };
+        } else {
+          return { rows: results };
         }
-        return { rows: allRows };
       } else {
-        return { rows: Array.isArray(firstResult) ? firstResult : [] };
+        return { rows: [] };
       }
     } catch (error) {
       console.error("Error executing query:", error);
@@ -1795,505 +1875,6 @@ var MariaDBConnector = class {
 var mariadbConnector = new MariaDBConnector();
 ConnectorRegistry.register(mariadbConnector);
 
-// src/connectors/oracle/index.ts
-import oracledb from "oracledb";
-oracledb.outFormat = oracledb.OUT_FORMAT_OBJECT;
-var _OracleConnector = class _OracleConnector {
-  // constructor(config: ConnectionConfig) { // Removed config
-  constructor() {
-    // Connector ID and Name are part of the Connector interface
-    this.id = "oracle";
-    this.name = "Oracle Database";
-    this.pool = null;
-    this.currentSchema = null;
-    // Oracle DSN Parser implementation
-    this.dsnParser = {
-      parse: async (dsn) => {
-        if (!this.dsnParser.isValidDSN(dsn)) {
-          throw new Error(`Invalid Oracle DSN: ${dsn}`);
-        }
-        try {
-          const url = new SafeURL(dsn);
-          let serviceName = url.pathname;
-          if (serviceName.startsWith("/")) {
-            serviceName = serviceName.substring(1);
-          }
-          const port = url.port ? parseInt(url.port) : 1521;
-          const connectString = `${url.hostname}:${port}/${serviceName}`;
-          const config = {
-            user: url.username,
-            password: url.password,
-            connectString,
-            poolMin: 0,
-            poolMax: 10,
-            poolIncrement: 1
-          };
-          url.forEachSearchParam((value, key) => {
-            switch (key.toLowerCase()) {
-              case "poolmin":
-                config.poolMin = parseInt(value, 10);
-                break;
-              case "poolmax":
-                config.poolMax = parseInt(value, 10);
-                break;
-              case "poolincrement":
-                config.poolIncrement = parseInt(value, 10);
-                break;
-              case "sslmode":
-                switch (value.toLowerCase()) {
-                  case "disable":
-                    break;
-                  case "require":
-                    config.sslServerDNMatch = false;
-                    break;
-                }
-                break;
-            }
-          });
-          return config;
-        } catch (error) {
-          throw new Error(`Failed to parse Oracle DSN: ${error instanceof Error ? error.message : String(error)}`);
-        }
-      },
-      getSampleDSN: () => {
-        return "oracle://username:password@host:1521/service_name?sslmode=require";
-      },
-      isValidDSN: (dsn) => {
-        try {
-          return dsn.startsWith("oracle://");
-        } catch (error) {
-          return false;
-        }
-      }
-    };
-    oracledb.autoCommit = true;
-  }
-  // Initialize Oracle client only once
-  initClient() {
-    if (_OracleConnector.clientInitialized) {
-      return;
-    }
-    try {
-      if (process.env.ORACLE_LIB_DIR) {
-        oracledb.initOracleClient({ libDir: process.env.ORACLE_LIB_DIR });
-        console.error("Oracle client initialized in Thick mode");
-      } else {
-        console.error("ORACLE_LIB_DIR not specified, will use Thin mode by default");
-      }
-      _OracleConnector.clientInitialized = true;
-    } catch (err) {
-      console.error("Failed to initialize Oracle client:", err);
-    }
-  }
-  async connect(dsn, initializationScript) {
-    try {
-      this.initClient();
-      const config = await this.dsnParser.parse(dsn);
-      this.pool = await oracledb.createPool(config);
-      const conn = await this.getConnection();
-      try {
-        const result = await conn.execute("SELECT SYS_CONTEXT('USERENV', 'CURRENT_SCHEMA') as SCHEMA FROM DUAL");
-        if (result.rows && result.rows.length > 0) {
-          this.currentSchema = result.rows[0].SCHEMA;
-        }
-        if (initializationScript) {
-          await conn.execute(initializationScript);
-        }
-      } finally {
-        await conn.close();
-      }
-      console.error("Successfully connected to Oracle database");
-      if (this.currentSchema) {
-        console.error(`Current schema: ${this.currentSchema}`);
-      }
-    } catch (error) {
-      console.error("Failed to connect to Oracle database:", error);
-      if (error instanceof Error && error.message.includes("NJS-138")) {
-        const enhancedError = new Error(
-          `${error.message}
-
-This error occurs when your Oracle database version is not supported by node-oracledb in Thin mode.
-To resolve this, you need to use Thick mode:
-1. Download Oracle Instant Client from https://www.oracle.com/database/technologies/instant-client/downloads.html
-2. Set ORACLE_LIB_DIR environment variable to the path of your Oracle Instant Client
-   Example: export ORACLE_LIB_DIR=/path/to/instantclient_19_8
-3. Restart DBHub`
-        );
-        throw enhancedError;
-      }
-      throw error;
-    }
-  }
-  async disconnect() {
-    if (this.pool) {
-      try {
-        await this.pool.close();
-        this.pool = null;
-        this.currentSchema = null;
-      } catch (error) {
-        console.error("Error disconnecting from Oracle:", error);
-        throw error;
-      }
-    }
-  }
-  async getSchemas() {
-    try {
-      const conn = await this.getConnection();
-      try {
-        const result = await conn.execute(
-          `SELECT USERNAME AS SCHEMA_NAME 
-           FROM ALL_USERS 
-           ORDER BY USERNAME`
-        );
-        return result.rows?.map((row) => row.SCHEMA_NAME) || [];
-      } finally {
-        await conn.close();
-      }
-    } catch (error) {
-      console.error("Error getting schemas from Oracle:", error);
-      throw error;
-    }
-  }
-  async getTables(schemaName) {
-    try {
-      const conn = await this.getConnection();
-      try {
-        const schema = schemaName || this.currentSchema;
-        const result = await conn.execute(
-          `SELECT TABLE_NAME 
-           FROM ALL_TABLES 
-           WHERE OWNER = :schema
-           ORDER BY TABLE_NAME`,
-          { schema: schema?.toUpperCase() }
-        );
-        return result.rows?.map((row) => row.TABLE_NAME) || [];
-      } finally {
-        await conn.close();
-      }
-    } catch (error) {
-      console.error("Error getting tables from Oracle:", error);
-      throw error;
-    }
-  }
-  async getTableColumns(tableName, schemaName) {
-    try {
-      const conn = await this.getConnection();
-      try {
-        const schema = schemaName || this.currentSchema;
-        const result = await conn.execute(
-          `SELECT 
-             COLUMN_NAME, 
-             DATA_TYPE,
-             NULLABLE as IS_NULLABLE,
-             DATA_DEFAULT as COLUMN_DEFAULT
-           FROM ALL_TAB_COLUMNS
-           WHERE OWNER = :schema
-           AND TABLE_NAME = :tableName
-           ORDER BY COLUMN_ID`,
-          {
-            schema: schema?.toUpperCase(),
-            tableName: tableName.toUpperCase()
-          }
-        );
-        return result.rows?.map((row) => ({
-          column_name: row.COLUMN_NAME,
-          data_type: row.DATA_TYPE,
-          is_nullable: row.IS_NULLABLE === "Y" ? "YES" : "NO",
-          column_default: row.COLUMN_DEFAULT
-        })) || [];
-      } finally {
-        await conn.close();
-      }
-    } catch (error) {
-      console.error("Error getting columns from Oracle:", error);
-      throw error;
-    }
-  }
-  // Method to ensure boolean return type
-  ensureBoolean(value) {
-    return value === true;
-  }
-  async getTableIndexes(tableName, schemaName) {
-    try {
-      const conn = await this.getConnection();
-      try {
-        const schema = schemaName || this.currentSchema;
-        const indexesResult = await conn.execute(
-          `SELECT 
-             i.INDEX_NAME,
-             i.UNIQUENESS
-           FROM ALL_INDEXES i
-           WHERE i.OWNER = :schema
-           AND i.TABLE_NAME = :tableName`,
-          {
-            schema: schema?.toUpperCase(),
-            tableName: tableName.toUpperCase()
-          }
-        );
-        if (!indexesResult.rows || indexesResult.rows.length === 0) {
-          return [];
-        }
-        const indexes = [];
-        for (const idx of indexesResult.rows) {
-          const indexRow = idx;
-          const indexName = indexRow.INDEX_NAME;
-          const isUnique = indexRow.UNIQUENESS === "UNIQUE";
-          const columnsResult = await conn.execute(
-            `SELECT 
-               COLUMN_NAME
-             FROM ALL_IND_COLUMNS
-             WHERE INDEX_OWNER = :schema
-             AND INDEX_NAME = :indexName
-             ORDER BY COLUMN_POSITION`,
-            {
-              schema: schema?.toUpperCase(),
-              indexName
-            }
-          );
-          const columnNames = columnsResult.rows?.map((row) => row.COLUMN_NAME) || [];
-          const pkResult = await conn.execute(
-            `SELECT COUNT(*) AS IS_PK
-             FROM ALL_CONSTRAINTS
-             WHERE CONSTRAINT_TYPE = 'P'
-             AND OWNER = :schema
-             AND TABLE_NAME = :tableName
-             AND INDEX_NAME = :indexName`,
-            {
-              schema: schema?.toUpperCase(),
-              tableName: tableName.toUpperCase(),
-              indexName
-            }
-          );
-          const isPrimary = pkResult.rows && pkResult.rows.length > 0 && pkResult.rows[0].IS_PK > 0;
-          indexes.push({
-            index_name: indexName,
-            column_names: columnNames,
-            is_unique: isUnique,
-            is_primary: !!isPrimary
-            // Ensure boolean
-          });
-        }
-        return indexes;
-      } finally {
-        await conn.close();
-      }
-    } catch (error) {
-      console.error("Error getting indexes from Oracle:", error);
-      throw error;
-    }
-  }
-  async tableExists(tableName, schemaName) {
-    try {
-      const conn = await this.getConnection();
-      try {
-        const schema = schemaName || this.currentSchema;
-        const result = await conn.execute(
-          `SELECT COUNT(*) AS COUNT
-           FROM ALL_TABLES
-           WHERE OWNER = :schema
-           AND TABLE_NAME = :tableName`,
-          {
-            schema: schema?.toUpperCase(),
-            tableName: tableName.toUpperCase()
-          }
-        );
-        return !!(result.rows && result.rows.length > 0 && result.rows[0].COUNT > 0);
-      } finally {
-        await conn.close();
-      }
-    } catch (error) {
-      console.error("Error checking table existence in Oracle:", error);
-      throw error;
-    }
-  }
-  async getTableSchema(tableName, schema) {
-    return this.getTableColumns(tableName, schema);
-  }
-  async getStoredProcedures(schema) {
-    try {
-      const conn = await this.getConnection();
-      try {
-        const schemaName = schema || this.currentSchema;
-        const result = await conn.execute(
-          `SELECT OBJECT_NAME
-           FROM ALL_OBJECTS
-           WHERE OWNER = :schema
-           AND OBJECT_TYPE IN ('PROCEDURE', 'FUNCTION')
-           ORDER BY OBJECT_NAME`,
-          { schema: schemaName?.toUpperCase() }
-        );
-        return result.rows?.map((row) => row.OBJECT_NAME) || [];
-      } finally {
-        await conn.close();
-      }
-    } catch (error) {
-      console.error("Error getting stored procedures from Oracle:", error);
-      throw error;
-    }
-  }
-  async getStoredProcedureDetail(procedureName, schema) {
-    try {
-      const conn = await this.getConnection();
-      try {
-        const schemaName = schema || this.currentSchema;
-        const typeResult = await conn.execute(
-          `SELECT OBJECT_TYPE
-           FROM ALL_OBJECTS
-           WHERE OWNER = :schema
-           AND OBJECT_NAME = :procName`,
-          {
-            schema: schemaName?.toUpperCase(),
-            procName: procedureName.toUpperCase()
-          }
-        );
-        if (!typeResult.rows || typeResult.rows.length === 0) {
-          throw new Error(`Procedure or function ${procedureName} not found`);
-        }
-        const objectType = typeResult.rows[0].OBJECT_TYPE;
-        const isProcedure = objectType === "PROCEDURE";
-        const sourceResult = await conn.execute(
-          `SELECT TEXT
-           FROM ALL_SOURCE
-           WHERE OWNER = :schema
-           AND NAME = :procName
-           AND TYPE = :objectType
-           ORDER BY LINE`,
-          {
-            schema: schemaName?.toUpperCase(),
-            procName: procedureName.toUpperCase(),
-            objectType
-          }
-        );
-        let definition = "";
-        if (sourceResult.rows && sourceResult.rows.length > 0) {
-          definition = sourceResult.rows.map((row) => row.TEXT).join("");
-        }
-        const paramsResult = await conn.execute(
-          `SELECT 
-             ARGUMENT_NAME,
-             IN_OUT,
-             DATA_TYPE,
-             DATA_LENGTH,
-             DATA_PRECISION,
-             DATA_SCALE
-           FROM ALL_ARGUMENTS
-           WHERE OWNER = :schema
-           AND OBJECT_NAME = :procName
-           AND POSITION > 0
-           ORDER BY SEQUENCE`,
-          {
-            schema: schemaName?.toUpperCase(),
-            procName: procedureName.toUpperCase()
-          }
-        );
-        let parameterList = "";
-        let returnType = "";
-        if (paramsResult.rows && paramsResult.rows.length > 0) {
-          const params = paramsResult.rows.map((row) => {
-            const argRow = row;
-            if (argRow.IN_OUT === "OUT" && !isProcedure) {
-              returnType = formatOracleDataType(
-                argRow.DATA_TYPE,
-                argRow.DATA_LENGTH,
-                argRow.DATA_PRECISION,
-                argRow.DATA_SCALE
-              );
-              return null;
-            }
-            const paramType = formatOracleDataType(
-              argRow.DATA_TYPE,
-              argRow.DATA_LENGTH,
-              argRow.DATA_PRECISION,
-              argRow.DATA_SCALE
-            );
-            return `${argRow.ARGUMENT_NAME} ${argRow.IN_OUT} ${paramType}`;
-          }).filter(Boolean);
-          parameterList = params.join(", ");
-        }
-        return {
-          procedure_name: procedureName,
-          procedure_type: isProcedure ? "procedure" : "function",
-          language: "PL/SQL",
-          parameter_list: parameterList,
-          return_type: returnType || void 0,
-          definition: definition || void 0
-        };
-      } finally {
-        await conn.close();
-      }
-    } catch (error) {
-      console.error("Error getting stored procedure details from Oracle:", error);
-      throw error;
-    }
-  }
-  async executeSQL(sql2, params) {
-    try {
-      const conn = await this.getConnection();
-      try {
-        let bindParams = void 0;
-        if (params && params.length > 0) {
-          bindParams = {};
-          for (let i = 0; i < params.length; i++) {
-            bindParams[`param${i + 1}`] = params[i];
-          }
-          let paramIndex = 1;
-          sql2 = sql2.replace(/\?/g, () => `:param${paramIndex++}`);
-        }
-        const options = {
-          outFormat: oracledb.OUT_FORMAT_OBJECT,
-          autoCommit: true
-        };
-        const result = await conn.execute(sql2, bindParams || {}, options);
-        return {
-          rows: result.rows || [],
-          rowCount: result.rows?.length || 0,
-          fields: result.metaData?.map((col) => ({
-            name: col.name,
-            type: col.dbType?.toString() || "UNKNOWN"
-          })) || []
-        };
-      } finally {
-        await conn.close();
-      }
-    } catch (error) {
-      console.error("Error executing query in Oracle:", error);
-      throw error;
-    }
-  }
-  // Helper method to get a connection from the pool
-  async getConnection() {
-    if (!this.pool) {
-      throw new Error("Connection pool not initialized. Call connect() first.");
-    }
-    return this.pool.getConnection();
-  }
-};
-// Track if we've already initialized the client
-_OracleConnector.clientInitialized = false;
-var OracleConnector = _OracleConnector;
-function formatOracleDataType(dataType, dataLength, dataPrecision, dataScale) {
-  if (!dataType) {
-    return "UNKNOWN";
-  }
-  switch (dataType.toUpperCase()) {
-    case "VARCHAR2":
-    case "CHAR":
-    case "NVARCHAR2":
-    case "NCHAR":
-      return `${dataType}(${dataLength || ""})`;
-    case "NUMBER":
-      if (dataPrecision !== void 0 && dataScale !== void 0) {
-        return `NUMBER(${dataPrecision}, ${dataScale})`;
-      } else if (dataPrecision !== void 0) {
-        return `NUMBER(${dataPrecision})`;
-      }
-      return "NUMBER";
-    default:
-      return dataType;
-  }
-}
-ConnectorRegistry.register(new OracleConnector());
-
 // src/server.ts
 import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
@@ -2898,8 +2479,7 @@ var allowedKeywords = {
   mysql: ["select", "with", "explain", "analyze", "show", "describe", "desc"],
   mariadb: ["select", "with", "explain", "analyze", "show", "describe", "desc"],
   sqlite: ["select", "with", "explain", "analyze", "pragma"],
-  sqlserver: ["select", "with", "explain", "showplan"],
-  oracle: ["select", "with", "explain"]
+  sqlserver: ["select", "with", "explain", "showplan"]
 };
 
 // src/tools/execute-sql.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytebase/dbhub",
-  "version": "0.7.0",
+  "version": "0.8.4",
   "description": "Universal Database MCP Server",
   "main": "dist/index.js",
   "type": "module",
@@ -24,21 +24,24 @@
     "mariadb": "^3.4.0",
     "mssql": "^11.0.1",
     "mysql2": "^3.13.0",
-    "oracledb": "^6.5.1",
     "pg": "^8.13.3",
     "zod": "^3.24.2"
   },
   "devDependencies": {
+    "@testcontainers/mariadb": "^11.0.3",
+    "@testcontainers/mssqlserver": "^11.0.3",
+    "@testcontainers/mysql": "^11.0.3",
+    "@testcontainers/postgresql": "^11.0.3",
     "@types/better-sqlite3": "^7.6.12",
     "@types/express": "^4.17.21",
     "@types/mssql": "^9.1.7",
     "@types/node": "^22.13.10",
-    "@types/oracledb": "^6.6.0",
     "@types/pg": "^8.11.11",
     "cross-env": "^7.0.3",
     "husky": "^9.0.11",
     "lint-staged": "^15.2.2",
     "prettier": "^3.5.3",
+    "testcontainers": "^11.0.3",
     "ts-node": "^10.9.2",
     "tsup": "^8.4.0",
     "tsx": "^4.19.3",
@@ -67,6 +70,7 @@
     "crossdev": "cross-env NODE_ENV=development tsx src/index.ts",
     "test": "vitest run",
     "test:watch": "vitest",
+    "test:integration": "vitest run --testNamePattern='Integration Tests'",
     "pre-commit": "lint-staged"
   }
 }