@bytebase/dbhub 0.3.3 → 0.4.1

package/README.md

@@ -22,6 +22,8 @@ DBHub is a universal database gateway implementing the Model Context Protocol (M
  |                  |    |              |    |                  |
  |                  |    |              +--->+    MariaDB       |
  |                  |    |              |    |                  |
+ |                  |    |              +--->+     Oracle       |
+ |                  |    |              |    |                  |
  +------------------+    +--------------+    +------------------+
       MCP Clients           MCP Server             Databases
 ```
@@ -36,28 +38,28 @@ https://demo.dbhub.ai/sse connects a [sample employee database](https://github.c
 
 ### Database Resources
 
-| 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}` |     ✅     |  ✅   |   ✅    |     ✅     |   ❌   |
+| 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}` |     ✅     |  ✅   |   ✅    |     ✅     |   ❌   |   ✅   |
 
 ### Database Tools
 
-| Tool            | Command Name      | PostgreSQL | MySQL | MariaDB | SQL Server | SQLite |
-| --------------- | ----------------- | :--------: | :---: | :-----: | :--------: | ------ |
-| Execute SQL     | `execute_sql`     |     ✅     |  ✅   |   ✅    |     ✅     | ✅     |
-| List Connectors | `list_connectors` |     ✅     |  ✅   |   ✅    |     ✅     | ✅     |
+| Tool            | Command Name      | PostgreSQL | MySQL | MariaDB | SQL Server | SQLite | Oracle |
+| --------------- | ----------------- | :--------: | :---: | :-----: | :--------: | ------ | :----: |
+| Execute SQL     | `execute_sql`     |     ✅     |  ✅   |   ✅    |     ✅     | ✅     |   ✅   |
+| List Connectors | `list_connectors` |     ✅     |  ✅   |   ✅    |     ✅     | ✅     |   ✅   |
 
 ### Prompt Capabilities
 
-| Prompt              | Command Name   | PostgreSQL | MySQL | MariaDB | SQL Server | SQLite |
-| ------------------- | -------------- | :--------: | :---: | :-----: | :--------: | ------ |
-| Generate SQL        | `generate_sql` |     ✅     |  ✅   |   ✅    |     ✅     | ✅     |
-| Explain DB Elements | `explain_db`   |     ✅     |  ✅   |   ✅    |     ✅     | ✅     |
+| Prompt              | Command Name   | PostgreSQL | MySQL | MariaDB | SQL Server | SQLite | Oracle |
+| ------------------- | -------------- | :--------: | :---: | :-----: | :--------: | ------ | :----: |
+| Generate SQL        | `generate_sql` |     ✅     |  ✅   |   ✅    |     ✅     | ✅     |   ✅   |
+| Explain DB Elements | `explain_db`   |     ✅     |  ✅   |   ✅    |     ✅     | ✅     |   ✅   |
 
 ## Installation
 
@@ -85,6 +87,28 @@ docker run --rm --init \
    --demo
 ```
 
+```bash
+# Oracle example
+docker run --rm --init \
+   --name dbhub \
+   --publish 8080:8080 \
+   bytebase/dbhub \
+   --transport sse \
+   --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 sse \
+   --port 8080 \
+   --dsn "oracle://username:password@localhost:1521/service_name"
+```
+
 ### NPM
 
 ```bash
@@ -199,13 +223,35 @@ For real databases, a Database Source Name (DSN) is required. You can provide th
 
 DBHub supports the following database connection string formats:
 
-| Database   | DSN Format                                               | Example                                                                                                     |
-| ---------- | -------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------- |
-| MySQL      | `mysql://[user]:[password]@[host]:[port]/[database]`     | `mysql://user:password@localhost:3306/dbname`                                                               |
-| MariaDB    | `mariadb://[user]:[password]@[host]:[port]/[database]`   | `mariadb://user:password@localhost:3306/dbname`                                                             |
-| 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`                                                           |
-| SQLite     | `sqlite:///[path/to/file]` or `sqlite::memory:`          | `sqlite:///path/to/database.db`, `sqlite:C:/Users/YourName/data/database.db (windows)` or `sqlite::memory:` |
+| Database   | DSN Format                                                | Example                                                                                                     |
+| ---------- | --------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------- |
+| MySQL      | `mysql://[user]:[password]@[host]:[port]/[database]`      | `mysql://user:password@localhost:3306/dbname`                                                               |
+| MariaDB    | `mariadb://[user]:[password]@[host]:[port]/[database]`    | `mariadb://user:password@localhost:3306/dbname`                                                             |
+| 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`                                                           |
+| 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`                                                    |
+
+#### 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
 

package/dist/index.js

@@ -355,13 +355,13 @@ var PostgresConnector = class {
       client.release();
     }
   }
-  async executeQuery(query) {
+  async executeSQL(sql2) {
     if (!this.pool) {
       throw new Error("Not connected to database");
     }
     const client = await this.pool.connect();
     try {
-      return await client.query(query);
+      return await client.query(sql2);
     } finally {
       client.release();
     }
@@ -688,12 +688,12 @@ var SQLServerConnector = class {
       throw new Error(`Failed to get stored procedure details: ${error.message}`);
     }
   }
-  async executeQuery(query) {
+  async executeSQL(sql2) {
     if (!this.connection) {
       throw new Error("Not connected to SQL Server database");
     }
     try {
-      const result = await this.connection.request().query(query);
+      const result = await this.connection.request().query(sql2);
       return {
         rows: result.recordset || [],
         fields: result.recordset && result.recordset.length > 0 ? Object.keys(result.recordset[0]).map((key) => ({
@@ -897,12 +897,12 @@ var SQLiteConnector = class {
       "SQLite does not support stored procedures. Functions are defined programmatically through the SQLite API, not stored in the database."
     );
   }
-  async executeQuery(query) {
+  async executeSQL(sql2) {
     if (!this.db) {
       throw new Error("Not connected to SQLite database");
     }
     try {
-      const rows = this.db.prepare(query).all();
+      const rows = this.db.prepare(sql2).all();
       return { rows };
     } catch (error) {
       throw error;
@@ -1247,12 +1247,12 @@ var MySQLConnector = class {
     const [rows] = await this.pool.query("SELECT DATABASE() AS DB");
     return rows[0].DB;
   }
-  async executeQuery(query) {
+  async executeSQL(sql2) {
     if (!this.pool) {
       throw new Error("Not connected to database");
     }
     try {
-      const [rows, fields] = await this.pool.query(query);
+      const [rows, fields] = await this.pool.query(sql2);
       return { rows, fields };
     } catch (error) {
       console.error("Error executing query:", error);
@@ -1598,12 +1598,12 @@ var MariaDBConnector = class {
     const [rows] = await this.pool.query("SELECT DATABASE() AS DB");
     return rows[0].DB;
   }
-  async executeQuery(query) {
+  async executeSQL(sql2) {
     if (!this.pool) {
       throw new Error("Not connected to database");
     }
     try {
-      const [rows, fields] = await this.pool.query(query);
+      const [rows, fields] = await this.pool.query(sql2);
       return { rows, fields };
     } catch (error) {
       console.error("Error executing query:", error);
@@ -1614,6 +1614,489 @@ 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 {
+  // 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 URL(dsn);
+          const username = url.username;
+          const password = url.password;
+          const host = url.hostname;
+          const port = url.port ? parseInt(url.port, 10) : 1521;
+          let serviceName = url.pathname;
+          if (serviceName.startsWith("/")) {
+            serviceName = serviceName.substring(1);
+          }
+          const connectString = `${host}:${port}/${serviceName}`;
+          const config = {
+            user: username,
+            password,
+            connectString,
+            poolMin: 0,
+            poolMax: 10,
+            poolIncrement: 1
+          };
+          url.searchParams.forEach((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;
+            }
+          });
+          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";
+      },
+      isValidDSN: (dsn) => {
+        try {
+          const url = new URL(dsn);
+          return url.protocol === "oracle:";
+        } catch (error) {
+          return false;
+        }
+      }
+    };
+    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");
+      }
+    } catch (err) {
+      console.error("Failed to initialize Oracle client:", err);
+    }
+    oracledb.autoCommit = true;
+  }
+  async connect(dsn, initializationScript) {
+    try {
+      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();
+  }
+};
+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 { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
@@ -2212,29 +2695,30 @@ 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"]
+  sqlserver: ["select", "with", "explain", "showplan"],
+  oracle: ["select", "with", "explain"]
 };
 
 // src/tools/execute-sql.ts
 var executeSqlSchema = {
-  query: z.string().describe("SQL query to execute (SELECT only)")
+  sql: z.string().describe("SQL query to execute (SELECT only)")
 };
-function isReadOnlyQuery(query, connectorType) {
-  const normalizedQuery = query.trim().toLowerCase();
-  const firstWord = normalizedQuery.split(/\s+/)[0];
+function isReadOnlySQL(sql2, connectorType) {
+  const normalizedSQL = sql2.trim().toLowerCase();
+  const firstWord = normalizedSQL.split(/\s+/)[0];
   const keywordList = allowedKeywords[connectorType] || allowedKeywords.default || [];
   return keywordList.includes(firstWord);
 }
-async function executeSqlToolHandler({ query }, _extra) {
+async function executeSqlToolHandler({ sql: sql2 }, _extra) {
   const connector = ConnectorManager.getCurrentConnector();
   try {
-    if (isReadOnlyMode() && !isReadOnlyQuery(query, connector.id)) {
+    if (isReadOnlyMode() && !isReadOnlySQL(sql2, connector.id)) {
       return createToolErrorResponse(
         `Read-only mode is enabled. Only the following SQL operations are allowed: ${allowedKeywords[connector.id]?.join(", ") || "none"}`,
         "READONLY_VIOLATION"
       );
     }
-    const result = await connector.executeQuery(query);
+    const result = await connector.executeSQL(sql2);
     const responseData = {
       rows: result.rows,
       count: result.rows.length

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytebase/dbhub",
-  "version": "0.3.3",
+  "version": "0.4.1",
   "description": "Universal Database MCP Server",
   "main": "dist/index.js",
   "type": "module",
@@ -24,10 +24,12 @@
     "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": {
+    "@types/oracledb": "^6.6.0",
     "@types/better-sqlite3": "^7.6.12",
     "@types/express": "^4.17.21",
     "@types/mssql": "^9.1.7",