@bytebase/dbhub 0.1.2 → 0.2.3

package/dist/index.js

@@ -121,47 +121,112 @@ var PostgresConnector = class {
       this.pool = null;
     }
   }
-  async getTables() {
+  async getSchemas() {
     if (!this.pool) {
       throw new Error("Not connected to database");
     }
     const client = await this.pool.connect();
     try {
+      const result = await client.query(`
+        SELECT schema_name
+        FROM information_schema.schemata
+        WHERE schema_name NOT IN ('pg_catalog', 'information_schema', 'pg_toast')
+        ORDER BY schema_name
+      `);
+      return result.rows.map((row) => row.schema_name);
+    } finally {
+      client.release();
+    }
+  }
+  async getTables(schema) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    const client = await this.pool.connect();
+    try {
+      const schemaToUse = schema || "public";
       const result = await client.query(`
         SELECT table_name 
         FROM information_schema.tables 
-        WHERE table_schema = 'public'
+        WHERE table_schema = $1
         ORDER BY table_name
-      `);
+      `, [schemaToUse]);
       return result.rows.map((row) => row.table_name);
     } finally {
       client.release();
     }
   }
-  async tableExists(tableName) {
+  async tableExists(tableName, schema) {
     if (!this.pool) {
       throw new Error("Not connected to database");
     }
     const client = await this.pool.connect();
     try {
+      const schemaToUse = schema || "public";
       const result = await client.query(`
         SELECT EXISTS (
           SELECT FROM information_schema.tables 
-          WHERE table_schema = 'public' 
-          AND table_name = $1
+          WHERE table_schema = $1 
+          AND table_name = $2
         )
-      `, [tableName]);
+      `, [schemaToUse, tableName]);
       return result.rows[0].exists;
     } finally {
       client.release();
     }
   }
-  async getTableSchema(tableName) {
+  async getTableIndexes(tableName, schema) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    const client = await this.pool.connect();
+    try {
+      const schemaToUse = schema || "public";
+      const result = await client.query(`
+        SELECT 
+          i.relname as index_name,
+          array_agg(a.attname) as column_names,
+          ix.indisunique as is_unique,
+          ix.indisprimary as is_primary
+        FROM 
+          pg_class t,
+          pg_class i,
+          pg_index ix,
+          pg_attribute a,
+          pg_namespace ns
+        WHERE 
+          t.oid = ix.indrelid
+          AND i.oid = ix.indexrelid
+          AND a.attrelid = t.oid
+          AND a.attnum = ANY(ix.indkey)
+          AND t.relkind = 'r'
+          AND t.relname = $1
+          AND ns.oid = t.relnamespace
+          AND ns.nspname = $2
+        GROUP BY 
+          i.relname, 
+          ix.indisunique,
+          ix.indisprimary
+        ORDER BY 
+          i.relname
+      `, [tableName, schemaToUse]);
+      return result.rows.map((row) => ({
+        index_name: row.index_name,
+        column_names: row.column_names,
+        is_unique: row.is_unique,
+        is_primary: row.is_primary
+      }));
+    } finally {
+      client.release();
+    }
+  }
+  async getTableSchema(tableName, schema) {
     if (!this.pool) {
       throw new Error("Not connected to database");
     }
     const client = await this.pool.connect();
     try {
+      const schemaToUse = schema || "public";
       const result = await client.query(`
         SELECT 
           column_name, 
@@ -169,15 +234,104 @@ var PostgresConnector = class {
           is_nullable,
           column_default
         FROM information_schema.columns
-        WHERE table_schema = 'public'
-        AND table_name = $1
+        WHERE table_schema = $1
+        AND table_name = $2
         ORDER BY ordinal_position
-      `, [tableName]);
+      `, [schemaToUse, tableName]);
       return result.rows;
     } finally {
       client.release();
     }
   }
+  async getStoredProcedures(schema) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    const client = await this.pool.connect();
+    try {
+      const schemaToUse = schema || "public";
+      const result = await client.query(`
+        SELECT 
+          routine_name
+        FROM information_schema.routines
+        WHERE routine_schema = $1
+        ORDER BY routine_name
+      `, [schemaToUse]);
+      return result.rows.map((row) => row.routine_name);
+    } finally {
+      client.release();
+    }
+  }
+  async getStoredProcedureDetail(procedureName, schema) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    const client = await this.pool.connect();
+    try {
+      const schemaToUse = schema || "public";
+      const result = await client.query(`
+        SELECT 
+          routine_name as procedure_name,
+          routine_type,
+          CASE WHEN routine_type = 'PROCEDURE' THEN 'procedure' ELSE 'function' END as procedure_type,
+          external_language as language,
+          data_type as return_type,
+          routine_definition as definition,
+          (
+            SELECT string_agg(
+              parameter_name || ' ' || 
+              parameter_mode || ' ' || 
+              data_type,
+              ', '
+            )
+            FROM information_schema.parameters
+            WHERE specific_schema = $1
+            AND specific_name = $2
+            AND parameter_name IS NOT NULL
+          ) as parameter_list
+        FROM information_schema.routines
+        WHERE routine_schema = $1
+        AND routine_name = $2
+      `, [schemaToUse, procedureName]);
+      if (result.rows.length === 0) {
+        throw new Error(`Stored procedure '${procedureName}' not found in schema '${schemaToUse}'`);
+      }
+      const procedure = result.rows[0];
+      let definition = procedure.definition;
+      try {
+        const oidResult = await client.query(`
+          SELECT p.oid, p.prosrc
+          FROM pg_proc p
+          JOIN pg_namespace n ON p.pronamespace = n.oid
+          WHERE p.proname = $1
+          AND n.nspname = $2
+        `, [procedureName, schemaToUse]);
+        if (oidResult.rows.length > 0) {
+          if (!definition) {
+            const oid = oidResult.rows[0].oid;
+            const defResult = await client.query(`SELECT pg_get_functiondef($1)`, [oid]);
+            if (defResult.rows.length > 0) {
+              definition = defResult.rows[0].pg_get_functiondef;
+            } else {
+              definition = oidResult.rows[0].prosrc;
+            }
+          }
+        }
+      } catch (err) {
+        console.error(`Error getting procedure definition: ${err}`);
+      }
+      return {
+        procedure_name: procedure.procedure_name,
+        procedure_type: procedure.procedure_type,
+        language: procedure.language || "sql",
+        parameter_list: procedure.parameter_list || "",
+        return_type: procedure.return_type !== "void" ? procedure.return_type : void 0,
+        definition: definition || void 0
+      };
+    } finally {
+      client.release();
+    }
+  }
   async executeQuery(query) {
     if (!this.pool) {
       throw new Error("Not connected to database");
@@ -283,56 +437,232 @@ var SQLServerConnector = class {
       this.connection = void 0;
     }
   }
-  async getTables() {
+  async getSchemas() {
     if (!this.connection) {
       throw new Error("Not connected to SQL Server database");
     }
     try {
       const result = await this.connection.request().query(`
+        SELECT SCHEMA_NAME 
+        FROM INFORMATION_SCHEMA.SCHEMATA 
+        ORDER BY SCHEMA_NAME
+      `);
+      return result.recordset.map((row) => row.SCHEMA_NAME);
+    } catch (error) {
+      throw new Error(`Failed to get schemas: ${error.message}`);
+    }
+  }
+  async getTables(schema) {
+    if (!this.connection) {
+      throw new Error("Not connected to SQL Server database");
+    }
+    try {
+      const schemaToUse = schema || "dbo";
+      const request = this.connection.request().input("schema", sql.VarChar, schemaToUse);
+      const query = `
         SELECT TABLE_NAME 
         FROM INFORMATION_SCHEMA.TABLES 
+        WHERE TABLE_SCHEMA = @schema
         ORDER BY TABLE_NAME
-      `);
+      `;
+      const result = await request.query(query);
       return result.recordset.map((row) => row.TABLE_NAME);
     } catch (error) {
       throw new Error(`Failed to get tables: ${error.message}`);
     }
   }
-  async tableExists(tableName) {
+  async tableExists(tableName, schema) {
     if (!this.connection) {
       throw new Error("Not connected to SQL Server database");
     }
     try {
-      const result = await this.connection.request().input("tableName", sql.VarChar, tableName).query(`
-          SELECT COUNT(*) as count
-          FROM INFORMATION_SCHEMA.TABLES
-          WHERE TABLE_NAME = @tableName
-        `);
+      const schemaToUse = schema || "dbo";
+      const request = this.connection.request().input("tableName", sql.VarChar, tableName).input("schema", sql.VarChar, schemaToUse);
+      const query = `
+        SELECT COUNT(*) as count
+        FROM INFORMATION_SCHEMA.TABLES
+        WHERE TABLE_NAME = @tableName
+        AND TABLE_SCHEMA = @schema
+      `;
+      const result = await request.query(query);
       return result.recordset[0].count > 0;
     } catch (error) {
       throw new Error(`Failed to check if table exists: ${error.message}`);
     }
   }
-  async getTableSchema(tableName) {
+  async getTableIndexes(tableName, schema) {
     if (!this.connection) {
       throw new Error("Not connected to SQL Server database");
     }
     try {
-      const result = await this.connection.request().input("tableName", sql.VarChar, tableName).query(`
-          SELECT 
-            COLUMN_NAME as column_name,
-            DATA_TYPE as data_type,
-            IS_NULLABLE as is_nullable,
-            COLUMN_DEFAULT as column_default
-          FROM INFORMATION_SCHEMA.COLUMNS
-          WHERE TABLE_NAME = @tableName
-          ORDER BY ORDINAL_POSITION
-        `);
+      const schemaToUse = schema || "dbo";
+      const request = this.connection.request().input("tableName", sql.VarChar, tableName).input("schema", sql.VarChar, schemaToUse);
+      const query = `
+        SELECT 
+          i.name AS index_name,
+          i.is_unique,
+          i.is_primary_key,
+          c.name AS column_name,
+          ic.key_ordinal
+        FROM 
+          sys.indexes i
+        INNER JOIN 
+          sys.index_columns ic ON i.object_id = ic.object_id AND i.index_id = ic.index_id
+        INNER JOIN 
+          sys.columns c ON ic.object_id = c.object_id AND ic.column_id = c.column_id
+        INNER JOIN 
+          sys.tables t ON i.object_id = t.object_id
+        INNER JOIN 
+          sys.schemas s ON t.schema_id = s.schema_id
+        WHERE 
+          t.name = @tableName
+          AND s.name = @schema
+        ORDER BY 
+          i.name, 
+          ic.key_ordinal
+      `;
+      const result = await request.query(query);
+      const indexMap = /* @__PURE__ */ new Map();
+      for (const row of result.recordset) {
+        const indexName = row.index_name;
+        const columnName = row.column_name;
+        const isUnique = !!row.is_unique;
+        const isPrimary = !!row.is_primary_key;
+        if (!indexMap.has(indexName)) {
+          indexMap.set(indexName, {
+            columns: [],
+            is_unique: isUnique,
+            is_primary: isPrimary
+          });
+        }
+        const indexInfo = indexMap.get(indexName);
+        indexInfo.columns.push(columnName);
+      }
+      const indexes = [];
+      indexMap.forEach((info, name) => {
+        indexes.push({
+          index_name: name,
+          column_names: info.columns,
+          is_unique: info.is_unique,
+          is_primary: info.is_primary
+        });
+      });
+      return indexes;
+    } catch (error) {
+      throw new Error(`Failed to get indexes for table ${tableName}: ${error.message}`);
+    }
+  }
+  async getTableSchema(tableName, schema) {
+    if (!this.connection) {
+      throw new Error("Not connected to SQL Server database");
+    }
+    try {
+      const schemaToUse = schema || "dbo";
+      const request = this.connection.request().input("tableName", sql.VarChar, tableName).input("schema", sql.VarChar, schemaToUse);
+      const query = `
+        SELECT 
+          COLUMN_NAME as column_name,
+          DATA_TYPE as data_type,
+          IS_NULLABLE as is_nullable,
+          COLUMN_DEFAULT as column_default
+        FROM INFORMATION_SCHEMA.COLUMNS
+        WHERE TABLE_NAME = @tableName
+        AND TABLE_SCHEMA = @schema
+        ORDER BY ORDINAL_POSITION
+      `;
+      const result = await request.query(query);
       return result.recordset;
     } catch (error) {
       throw new Error(`Failed to get schema for table ${tableName}: ${error.message}`);
     }
   }
+  async getStoredProcedures(schema) {
+    if (!this.connection) {
+      throw new Error("Not connected to SQL Server database");
+    }
+    try {
+      const schemaToUse = schema || "dbo";
+      const request = this.connection.request().input("schema", sql.VarChar, schemaToUse);
+      const query = `
+        SELECT ROUTINE_NAME
+        FROM INFORMATION_SCHEMA.ROUTINES
+        WHERE ROUTINE_SCHEMA = @schema
+        AND (ROUTINE_TYPE = 'PROCEDURE' OR ROUTINE_TYPE = 'FUNCTION')
+        ORDER BY ROUTINE_NAME
+      `;
+      const result = await request.query(query);
+      return result.recordset.map((row) => row.ROUTINE_NAME);
+    } catch (error) {
+      throw new Error(`Failed to get stored procedures: ${error.message}`);
+    }
+  }
+  async getStoredProcedureDetail(procedureName, schema) {
+    if (!this.connection) {
+      throw new Error("Not connected to SQL Server database");
+    }
+    try {
+      const schemaToUse = schema || "dbo";
+      const request = this.connection.request().input("procedureName", sql.VarChar, procedureName).input("schema", sql.VarChar, schemaToUse);
+      const routineQuery = `
+        SELECT 
+          ROUTINE_NAME as procedure_name,
+          ROUTINE_TYPE,
+          DATA_TYPE as return_data_type
+        FROM INFORMATION_SCHEMA.ROUTINES
+        WHERE ROUTINE_NAME = @procedureName
+        AND ROUTINE_SCHEMA = @schema
+      `;
+      const routineResult = await request.query(routineQuery);
+      if (routineResult.recordset.length === 0) {
+        throw new Error(`Stored procedure '${procedureName}' not found in schema '${schemaToUse}'`);
+      }
+      const routine = routineResult.recordset[0];
+      const parameterQuery = `
+        SELECT 
+          PARAMETER_NAME,
+          PARAMETER_MODE,
+          DATA_TYPE,
+          CHARACTER_MAXIMUM_LENGTH,
+          ORDINAL_POSITION
+        FROM INFORMATION_SCHEMA.PARAMETERS
+        WHERE SPECIFIC_NAME = @procedureName
+        AND SPECIFIC_SCHEMA = @schema
+        ORDER BY ORDINAL_POSITION
+      `;
+      const parameterResult = await request.query(parameterQuery);
+      let parameterList = "";
+      if (parameterResult.recordset.length > 0) {
+        parameterList = parameterResult.recordset.map((param) => {
+          const lengthStr = param.CHARACTER_MAXIMUM_LENGTH > 0 ? `(${param.CHARACTER_MAXIMUM_LENGTH})` : "";
+          return `${param.PARAMETER_NAME} ${param.PARAMETER_MODE} ${param.DATA_TYPE}${lengthStr}`;
+        }).join(", ");
+      }
+      const definitionQuery = `
+        SELECT definition 
+        FROM sys.sql_modules sm
+        JOIN sys.objects o ON sm.object_id = o.object_id
+        JOIN sys.schemas s ON o.schema_id = s.schema_id
+        WHERE o.name = @procedureName
+        AND s.name = @schema
+      `;
+      const definitionResult = await request.query(definitionQuery);
+      let definition = void 0;
+      if (definitionResult.recordset.length > 0) {
+        definition = definitionResult.recordset[0].definition;
+      }
+      return {
+        procedure_name: routine.procedure_name,
+        procedure_type: routine.ROUTINE_TYPE === "PROCEDURE" ? "procedure" : "function",
+        language: "sql",
+        // SQL Server procedures are typically in T-SQL
+        parameter_list: parameterList,
+        return_type: routine.ROUTINE_TYPE === "FUNCTION" ? routine.return_data_type : void 0,
+        definition
+      };
+    } catch (error) {
+      throw new Error(`Failed to get stored procedure details: ${error.message}`);
+    }
+  }
   async executeQuery(query) {
     if (!this.connection) {
       throw new Error("Not connected to SQL Server database");
@@ -439,7 +769,13 @@ var SQLiteConnector = class {
     }
     return Promise.resolve();
   }
-  async getTables() {
+  async getSchemas() {
+    if (!this.db) {
+      throw new Error("Not connected to SQLite database");
+    }
+    return [this.dbPath === ":memory:" ? "main" : this.dbPath];
+  }
+  async getTables(schema) {
     if (!this.db) {
       throw new Error("Not connected to SQLite database");
     }
@@ -454,7 +790,7 @@ var SQLiteConnector = class {
       throw error;
     }
   }
-  async tableExists(tableName) {
+  async tableExists(tableName, schema) {
     if (!this.db) {
       throw new Error("Not connected to SQLite database");
     }
@@ -468,7 +804,49 @@ var SQLiteConnector = class {
       throw error;
     }
   }
-  async getTableSchema(tableName) {
+  async getTableIndexes(tableName, schema) {
+    if (!this.db) {
+      throw new Error("Not connected to SQLite database");
+    }
+    try {
+      const indexInfoRows = this.db.prepare(`
+        SELECT 
+          name as index_name,
+          CASE 
+            WHEN "unique" = 1 THEN 1
+            ELSE 0
+          END as is_unique
+        FROM sqlite_master 
+        WHERE type = 'index' 
+        AND tbl_name = ?
+      `).all(tableName);
+      const tableInfo = this.db.prepare(`PRAGMA table_info(${tableName})`).all();
+      const pkColumns = tableInfo.filter((col) => col.pk > 0).map((col) => col.name);
+      const results = [];
+      for (const indexInfo of indexInfoRows) {
+        const indexDetailRows = this.db.prepare(`PRAGMA index_info(${indexInfo.index_name})`).all();
+        const columnNames = indexDetailRows.map((row) => row.name);
+        results.push({
+          index_name: indexInfo.index_name,
+          column_names: columnNames,
+          is_unique: indexInfo.is_unique === 1,
+          is_primary: false
+        });
+      }
+      if (pkColumns.length > 0) {
+        results.push({
+          index_name: "PRIMARY",
+          column_names: pkColumns,
+          is_unique: true,
+          is_primary: true
+        });
+      }
+      return results;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async getTableSchema(tableName, schema) {
     if (!this.db) {
       throw new Error("Not connected to SQLite database");
     }
@@ -486,6 +864,18 @@ var SQLiteConnector = class {
       throw error;
     }
   }
+  async getStoredProcedures(schema) {
+    if (!this.db) {
+      throw new Error("Not connected to SQLite database");
+    }
+    return [];
+  }
+  async getStoredProcedureDetail(procedureName, schema) {
+    if (!this.db) {
+      throw new Error("Not connected to SQLite database");
+    }
+    throw new Error("SQLite does not support stored procedures. Functions are defined programmatically through the SQLite API, not stored in the database.");
+  }
   async executeQuery(query) {
     if (!this.db) {
       throw new Error("Not connected to SQLite database");
@@ -578,62 +968,255 @@ var MySQLConnector = class {
       this.pool = null;
     }
   }
-  async getTables() {
+  async getSchemas() {
     if (!this.pool) {
       throw new Error("Not connected to database");
     }
     try {
       const [rows] = await this.pool.query(`
-        SELECT table_name 
-        FROM information_schema.tables 
-        WHERE table_schema = DATABASE()
-        ORDER BY table_name
+        SELECT SCHEMA_NAME 
+        FROM INFORMATION_SCHEMA.SCHEMATA
+        ORDER BY SCHEMA_NAME
       `);
-      return rows.map((row) => row.table_name);
+      return rows.map((row) => row.SCHEMA_NAME);
+    } catch (error) {
+      console.error("Error getting schemas:", error);
+      throw error;
+    }
+  }
+  async getTables(schema) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    try {
+      const schemaClause = schema ? "WHERE TABLE_SCHEMA = ?" : "WHERE TABLE_SCHEMA = DATABASE()";
+      const queryParams = schema ? [schema] : [];
+      const [rows] = await this.pool.query(`
+        SELECT TABLE_NAME 
+        FROM INFORMATION_SCHEMA.TABLES 
+        ${schemaClause}
+        ORDER BY TABLE_NAME
+      `, queryParams);
+      return rows.map((row) => row.TABLE_NAME);
     } catch (error) {
       console.error("Error getting tables:", error);
       throw error;
     }
   }
-  async tableExists(tableName) {
+  async tableExists(tableName, schema) {
     if (!this.pool) {
       throw new Error("Not connected to database");
     }
     try {
+      const schemaClause = schema ? "WHERE TABLE_SCHEMA = ?" : "WHERE TABLE_SCHEMA = DATABASE()";
+      const queryParams = schema ? [schema, tableName] : [tableName];
       const [rows] = await this.pool.query(`
-        SELECT COUNT(*) as count
-        FROM information_schema.tables 
-        WHERE table_schema = DATABASE() 
-        AND table_name = ?
-      `, [tableName]);
-      return rows[0].count > 0;
+        SELECT COUNT(*) AS COUNT
+        FROM INFORMATION_SCHEMA.TABLES 
+        ${schemaClause} 
+        AND TABLE_NAME = ?
+      `, queryParams);
+      return rows[0].COUNT > 0;
     } catch (error) {
       console.error("Error checking if table exists:", error);
       throw error;
     }
   }
-  async getTableSchema(tableName) {
+  async getTableIndexes(tableName, schema) {
     if (!this.pool) {
       throw new Error("Not connected to database");
     }
     try {
+      const schemaClause = schema ? "TABLE_SCHEMA = ?" : "TABLE_SCHEMA = DATABASE()";
+      const queryParams = schema ? [schema, tableName] : [tableName];
+      const [indexRows] = await this.pool.query(`
+        SELECT 
+          INDEX_NAME,
+          COLUMN_NAME,
+          NON_UNIQUE,
+          SEQ_IN_INDEX
+        FROM 
+          INFORMATION_SCHEMA.STATISTICS 
+        WHERE 
+          ${schemaClause}
+          AND TABLE_NAME = ? 
+        ORDER BY 
+          INDEX_NAME, 
+          SEQ_IN_INDEX
+      `, queryParams);
+      const indexMap = /* @__PURE__ */ new Map();
+      for (const row of indexRows) {
+        const indexName = row.INDEX_NAME;
+        const columnName = row.COLUMN_NAME;
+        const isUnique = row.NON_UNIQUE === 0;
+        const isPrimary = indexName === "PRIMARY";
+        if (!indexMap.has(indexName)) {
+          indexMap.set(indexName, {
+            columns: [],
+            is_unique: isUnique,
+            is_primary: isPrimary
+          });
+        }
+        const indexInfo = indexMap.get(indexName);
+        indexInfo.columns.push(columnName);
+      }
+      const results = [];
+      indexMap.forEach((indexInfo, indexName) => {
+        results.push({
+          index_name: indexName,
+          column_names: indexInfo.columns,
+          is_unique: indexInfo.is_unique,
+          is_primary: indexInfo.is_primary
+        });
+      });
+      return results;
+    } catch (error) {
+      console.error("Error getting table indexes:", error);
+      throw error;
+    }
+  }
+  async getTableSchema(tableName, schema) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    try {
+      const schemaClause = schema ? "WHERE TABLE_SCHEMA = ?" : "WHERE TABLE_SCHEMA = DATABASE()";
+      const queryParams = schema ? [schema, tableName] : [tableName];
       const [rows] = await this.pool.query(`
         SELECT 
-          column_name, 
-          data_type, 
-          is_nullable,
-          column_default
-        FROM information_schema.columns
-        WHERE table_schema = DATABASE()
-        AND table_name = ?
-        ORDER BY ordinal_position
-      `, [tableName]);
+          COLUMN_NAME as column_name, 
+          DATA_TYPE as data_type, 
+          IS_NULLABLE as is_nullable,
+          COLUMN_DEFAULT as column_default
+        FROM INFORMATION_SCHEMA.COLUMNS
+        ${schemaClause}
+        AND TABLE_NAME = ?
+        ORDER BY ORDINAL_POSITION
+      `, queryParams);
       return rows;
     } catch (error) {
       console.error("Error getting table schema:", error);
       throw error;
     }
   }
+  async getStoredProcedures(schema) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    try {
+      const schemaClause = schema ? "WHERE ROUTINE_SCHEMA = ?" : "WHERE ROUTINE_SCHEMA = DATABASE()";
+      const queryParams = schema ? [schema] : [];
+      const [rows] = await this.pool.query(`
+        SELECT ROUTINE_NAME
+        FROM INFORMATION_SCHEMA.ROUTINES
+        ${schemaClause}
+        ORDER BY ROUTINE_NAME
+      `, queryParams);
+      return rows.map((row) => row.ROUTINE_NAME);
+    } catch (error) {
+      console.error("Error getting stored procedures:", error);
+      throw error;
+    }
+  }
+  async getStoredProcedureDetail(procedureName, schema) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    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(`
+        SELECT 
+          r.ROUTINE_NAME AS procedure_name,
+          CASE 
+            WHEN r.ROUTINE_TYPE = 'PROCEDURE' THEN 'procedure'
+            ELSE 'function'
+          END AS procedure_type,
+          LOWER(r.ROUTINE_TYPE) AS routine_type,
+          r.ROUTINE_DEFINITION,
+          r.DTD_IDENTIFIER AS return_type,
+          (
+            SELECT GROUP_CONCAT(
+              CONCAT(p.PARAMETER_NAME, ' ', p.PARAMETER_MODE, ' ', p.DATA_TYPE)
+              ORDER BY p.ORDINAL_POSITION
+              SEPARATOR ', '
+            )
+            FROM INFORMATION_SCHEMA.PARAMETERS p
+            WHERE p.SPECIFIC_SCHEMA = r.ROUTINE_SCHEMA
+            AND p.SPECIFIC_NAME = r.ROUTINE_NAME
+            AND p.PARAMETER_NAME IS NOT NULL
+          ) AS parameter_list
+        FROM INFORMATION_SCHEMA.ROUTINES r
+        ${schemaClause}
+        AND r.ROUTINE_NAME = ?
+      `, queryParams);
+      if (rows.length === 0) {
+        const schemaName = schema || "current schema";
+        throw new Error(`Stored procedure '${procedureName}' not found in ${schemaName}`);
+      }
+      const procedure = rows[0];
+      let definition = procedure.ROUTINE_DEFINITION;
+      try {
+        const schemaValue = schema || await this.getCurrentSchema();
+        if (procedure.procedure_type === "procedure") {
+          try {
+            const [defRows] = await this.pool.query(`
+              SHOW CREATE PROCEDURE ${schemaValue}.${procedureName}
+            `);
+            if (defRows && defRows.length > 0) {
+              definition = defRows[0]["Create Procedure"];
+            }
+          } catch (err) {
+            console.error(`Error getting procedure definition with SHOW CREATE: ${err}`);
+          }
+        } else {
+          try {
+            const [defRows] = await this.pool.query(`
+              SHOW CREATE FUNCTION ${schemaValue}.${procedureName}
+            `);
+            if (defRows && defRows.length > 0) {
+              definition = defRows[0]["Create Function"];
+            }
+          } catch (innerErr) {
+            console.error(`Error getting function definition with SHOW CREATE: ${innerErr}`);
+          }
+        }
+        if (!definition) {
+          const [bodyRows] = await this.pool.query(`
+            SELECT ROUTINE_DEFINITION, ROUTINE_BODY 
+            FROM INFORMATION_SCHEMA.ROUTINES
+            WHERE ROUTINE_SCHEMA = ? AND ROUTINE_NAME = ?
+          `, [schemaValue, procedureName]);
+          if (bodyRows && bodyRows.length > 0) {
+            if (bodyRows[0].ROUTINE_DEFINITION) {
+              definition = bodyRows[0].ROUTINE_DEFINITION;
+            } else if (bodyRows[0].ROUTINE_BODY) {
+              definition = bodyRows[0].ROUTINE_BODY;
+            }
+          }
+        }
+      } catch (error) {
+        console.error(`Error getting procedure/function details: ${error}`);
+      }
+      return {
+        procedure_name: procedure.procedure_name,
+        procedure_type: procedure.procedure_type,
+        language: "sql",
+        // MySQL procedures are generally in SQL
+        parameter_list: procedure.parameter_list || "",
+        return_type: procedure.routine_type === "function" ? procedure.return_type : void 0,
+        definition: definition || void 0
+      };
+    } catch (error) {
+      console.error("Error getting stored procedure detail:", error);
+      throw error;
+    }
+  }
+  // Helper method to get current schema (database) name
+  async getCurrentSchema() {
+    const [rows] = await this.pool.query("SELECT DATABASE() AS DB");
+    return rows[0].DB;
+  }
   async executeQuery(query) {
     if (!this.pool) {
       throw new Error("Not connected to database");
@@ -981,22 +1564,62 @@ function formatPromptErrorResponse(error, code = "ERROR") {
 }
 
 // src/resources/tables.ts
-async function tablesResourceHandler(uri, _extra) {
+async function tablesResourceHandler(uri, variables, _extra) {
   const connector = ConnectorManager.getCurrentConnector();
-  const tableNames = await connector.getTables();
-  const responseData = {
-    tables: tableNames,
-    count: tableNames.length
-  };
-  return createResourceSuccessResponse(uri.href, responseData);
+  const schemaName = variables && variables.schemaName ? Array.isArray(variables.schemaName) ? variables.schemaName[0] : variables.schemaName : void 0;
+  try {
+    if (schemaName) {
+      const availableSchemas = await connector.getSchemas();
+      if (!availableSchemas.includes(schemaName)) {
+        return createResourceErrorResponse(
+          uri.href,
+          `Schema '${schemaName}' does not exist or cannot be accessed`,
+          "SCHEMA_NOT_FOUND"
+        );
+      }
+    }
+    const tableNames = await connector.getTables(schemaName);
+    const responseData = {
+      tables: tableNames,
+      count: tableNames.length,
+      schema: schemaName
+    };
+    return createResourceSuccessResponse(uri.href, responseData);
+  } catch (error) {
+    return createResourceErrorResponse(
+      uri.href,
+      `Error retrieving tables: ${error.message}`,
+      "TABLES_RETRIEVAL_ERROR"
+    );
+  }
 }
 
 // src/resources/schema.ts
-async function schemaResourceHandler(uri, variables, _extra) {
+async function tableStructureResourceHandler(uri, variables, _extra) {
   const connector = ConnectorManager.getCurrentConnector();
   const tableName = Array.isArray(variables.tableName) ? variables.tableName[0] : variables.tableName;
+  const schemaName = variables.schemaName ? Array.isArray(variables.schemaName) ? variables.schemaName[0] : variables.schemaName : void 0;
   try {
-    const columns = await connector.getTableSchema(tableName);
+    if (schemaName) {
+      const availableSchemas = await connector.getSchemas();
+      if (!availableSchemas.includes(schemaName)) {
+        return createResourceErrorResponse(
+          uri.href,
+          `Schema '${schemaName}' does not exist or cannot be accessed`,
+          "SCHEMA_NOT_FOUND"
+        );
+      }
+    }
+    const tableExists = await connector.tableExists(tableName, schemaName);
+    if (!tableExists) {
+      const schemaInfo = schemaName ? ` in schema '${schemaName}'` : "";
+      return createResourceErrorResponse(
+        uri.href,
+        `Table '${tableName}'${schemaInfo} does not exist or cannot be accessed`,
+        "TABLE_NOT_FOUND"
+      );
+    }
+    const columns = await connector.getTableSchema(tableName, schemaName);
     const formattedColumns = columns.map((col) => ({
       name: col.column_name,
       type: col.data_type,
@@ -1005,6 +1628,7 @@ async function schemaResourceHandler(uri, variables, _extra) {
     }));
     const responseData = {
       table: tableName,
+      schema: schemaName,
       columns: formattedColumns,
       count: formattedColumns.length
     };
@@ -1012,8 +1636,147 @@ async function schemaResourceHandler(uri, variables, _extra) {
   } catch (error) {
     return createResourceErrorResponse(
       uri.href,
-      `Table '${tableName}' does not exist or cannot be accessed`,
-      "TABLE_NOT_FOUND"
+      `Error retrieving schema: ${error.message}`,
+      "SCHEMA_RETRIEVAL_ERROR"
+    );
+  }
+}
+
+// src/resources/schemas.ts
+async function schemasResourceHandler(uri, _extra) {
+  const connector = ConnectorManager.getCurrentConnector();
+  try {
+    const schemas = await connector.getSchemas();
+    const responseData = {
+      schemas,
+      count: schemas.length
+    };
+    return createResourceSuccessResponse(uri.href, responseData);
+  } catch (error) {
+    return createResourceErrorResponse(
+      uri.href,
+      `Error retrieving database schemas: ${error.message}`,
+      "SCHEMAS_RETRIEVAL_ERROR"
+    );
+  }
+}
+
+// src/resources/indexes.ts
+async function indexesResourceHandler(uri, variables, _extra) {
+  const connector = ConnectorManager.getCurrentConnector();
+  const schemaName = variables && variables.schemaName ? Array.isArray(variables.schemaName) ? variables.schemaName[0] : variables.schemaName : void 0;
+  const tableName = variables && variables.tableName ? Array.isArray(variables.tableName) ? variables.tableName[0] : variables.tableName : void 0;
+  if (!tableName) {
+    return createResourceErrorResponse(
+      uri.href,
+      "Table name is required",
+      "MISSING_TABLE_NAME"
+    );
+  }
+  try {
+    if (schemaName) {
+      const availableSchemas = await connector.getSchemas();
+      if (!availableSchemas.includes(schemaName)) {
+        return createResourceErrorResponse(
+          uri.href,
+          `Schema '${schemaName}' does not exist or cannot be accessed`,
+          "SCHEMA_NOT_FOUND"
+        );
+      }
+    }
+    const tableExists = await connector.tableExists(tableName, schemaName);
+    if (!tableExists) {
+      return createResourceErrorResponse(
+        uri.href,
+        `Table '${tableName}' does not exist in schema '${schemaName || "default"}'`,
+        "TABLE_NOT_FOUND"
+      );
+    }
+    const indexes = await connector.getTableIndexes(tableName, schemaName);
+    const responseData = {
+      table: tableName,
+      schema: schemaName,
+      indexes,
+      count: indexes.length
+    };
+    return createResourceSuccessResponse(uri.href, responseData);
+  } catch (error) {
+    return createResourceErrorResponse(
+      uri.href,
+      `Error retrieving indexes: ${error.message}`,
+      "INDEXES_RETRIEVAL_ERROR"
+    );
+  }
+}
+
+// src/resources/procedures.ts
+async function proceduresResourceHandler(uri, variables, _extra) {
+  const connector = ConnectorManager.getCurrentConnector();
+  const schemaName = variables && variables.schemaName ? Array.isArray(variables.schemaName) ? variables.schemaName[0] : variables.schemaName : void 0;
+  try {
+    if (schemaName) {
+      const availableSchemas = await connector.getSchemas();
+      if (!availableSchemas.includes(schemaName)) {
+        return createResourceErrorResponse(
+          uri.href,
+          `Schema '${schemaName}' does not exist or cannot be accessed`,
+          "SCHEMA_NOT_FOUND"
+        );
+      }
+    }
+    const procedureNames = await connector.getStoredProcedures(schemaName);
+    const responseData = {
+      procedures: procedureNames,
+      count: procedureNames.length,
+      schema: schemaName
+    };
+    return createResourceSuccessResponse(uri.href, responseData);
+  } catch (error) {
+    return createResourceErrorResponse(
+      uri.href,
+      `Error retrieving stored procedures: ${error.message}`,
+      "PROCEDURES_RETRIEVAL_ERROR"
+    );
+  }
+}
+async function procedureDetailResourceHandler(uri, variables, _extra) {
+  const connector = ConnectorManager.getCurrentConnector();
+  const schemaName = variables && variables.schemaName ? Array.isArray(variables.schemaName) ? variables.schemaName[0] : variables.schemaName : void 0;
+  const procedureName = variables && variables.procedureName ? Array.isArray(variables.procedureName) ? variables.procedureName[0] : variables.procedureName : void 0;
+  if (!procedureName) {
+    return createResourceErrorResponse(
+      uri.href,
+      "Procedure name is required",
+      "MISSING_PARAMETER"
+    );
+  }
+  try {
+    if (schemaName) {
+      const availableSchemas = await connector.getSchemas();
+      if (!availableSchemas.includes(schemaName)) {
+        return createResourceErrorResponse(
+          uri.href,
+          `Schema '${schemaName}' does not exist or cannot be accessed`,
+          "SCHEMA_NOT_FOUND"
+        );
+      }
+    }
+    const procedureDetails = await connector.getStoredProcedureDetail(procedureName, schemaName);
+    const responseData = {
+      procedureName: procedureDetails.procedure_name,
+      procedureType: procedureDetails.procedure_type,
+      language: procedureDetails.language,
+      parameters: procedureDetails.parameter_list,
+      returnType: procedureDetails.return_type,
+      definition: procedureDetails.definition,
+      schema: schemaName
+    };
+    return createResourceSuccessResponse(uri.href, responseData);
+  } catch (error) {
+    return createResourceErrorResponse(
+      uri.href,
+      `Error retrieving procedure details: ${error.message}`,
+      "PROCEDURE_DETAILS_ERROR"
     );
   }
 }
@@ -1021,14 +1784,34 @@ async function schemaResourceHandler(uri, variables, _extra) {
 // src/resources/index.ts
 function registerResources(server) {
   server.resource(
-    "tables",
-    "db://tables",
+    "schemas",
+    "db://schemas",
+    schemasResourceHandler
+  );
+  server.resource(
+    "tables_in_schema",
+    new ResourceTemplate("db://schemas/{schemaName}/tables", { list: void 0 }),
     tablesResourceHandler
   );
   server.resource(
-    "schema",
-    new ResourceTemplate("db://schema/{tableName}", { list: void 0 }),
-    schemaResourceHandler
+    "table_structure_in_schema",
+    new ResourceTemplate("db://schemas/{schemaName}/tables/{tableName}", { list: void 0 }),
+    tableStructureResourceHandler
+  );
+  server.resource(
+    "indexes_in_table",
+    new ResourceTemplate("db://schemas/{schemaName}/tables/{tableName}/indexes", { list: void 0 }),
+    indexesResourceHandler
+  );
+  server.resource(
+    "procedures_in_schema",
+    new ResourceTemplate("db://schemas/{schemaName}/procedures", { list: void 0 }),
+    proceduresResourceHandler
+  );
+  server.resource(
+    "procedure_detail_in_schema",
+    new ResourceTemplate("db://schemas/{schemaName}/procedures/{procedureName}", { list: void 0 }),
+    procedureDetailResourceHandler
   );
 }
 
@@ -1063,7 +1846,6 @@ async function runQueryToolHandler({ query }, _extra) {
 
 // src/tools/list-connectors.ts
 async function listConnectorsToolHandler(_args, _extra) {
-  const connectors = ConnectorManager.getAvailableConnectors();
   const samples = ConnectorRegistry.getAllSampleDSNs();
   let activeConnectorId = null;
   try {
@@ -1107,52 +1889,108 @@ function registerTools(server) {
 import { z as z2 } from "zod";
 var sqlGeneratorSchema = {
   description: z2.string().describe("Natural language description of the SQL query to generate"),
-  dialect: z2.enum(["postgres", "sqlite"]).optional().describe("SQL dialect to use (optional)")
+  schema: z2.string().optional().describe("Optional database schema to use")
 };
-async function sqlGeneratorPromptHandler({ description, dialect }, _extra) {
+async function sqlGeneratorPromptHandler({ description, schema }, _extra) {
   try {
     const connector = ConnectorManager.getCurrentConnector();
-    const sqlDialect = dialect || (connector.id === "postgres" ? "postgres" : connector.id === "sqlite" ? "sqlite" : "postgres");
-    const tables = await connector.getTables();
-    const tableSchemas = await Promise.all(
-      tables.map(async (table) => {
-        try {
-          const columns = await connector.getTableSchema(table);
-          return {
-            table,
-            columns: columns.map((col) => ({
-              name: col.column_name,
-              type: col.data_type
-            }))
-          };
-        } catch (error) {
-          return null;
-        }
-      })
-    );
-    const accessibleSchemas = tableSchemas.filter((schema) => schema !== null);
-    const schemaContext = accessibleSchemas.length > 0 ? `Available tables and their columns:
+    let sqlDialect;
+    switch (connector.id) {
+      case "postgres":
+        sqlDialect = "postgres";
+        break;
+      case "sqlite":
+        sqlDialect = "sqlite";
+        break;
+      case "mysql":
+        sqlDialect = "mysql";
+        break;
+      case "sqlserver":
+        sqlDialect = "mssql";
+        break;
+      default:
+        sqlDialect = "ansi";
+    }
+    if (schema) {
+      const availableSchemas = await connector.getSchemas();
+      if (!availableSchemas.includes(schema)) {
+        return formatPromptErrorResponse(
+          `Schema '${schema}' does not exist or cannot be accessed. Available schemas: ${availableSchemas.join(", ")}`,
+          "SCHEMA_NOT_FOUND"
+        );
+      }
+    }
+    try {
+      const tables = await connector.getTables(schema);
+      if (tables.length === 0) {
+        const schemaInfo2 = schema ? `in schema '${schema}'` : "in the database";
+        return formatPromptErrorResponse(
+          `No tables found ${schemaInfo2}. Please check your database connection or schema name.`,
+          "NO_TABLES_FOUND"
+        );
+      }
+      const tableSchemas = await Promise.all(
+        tables.map(async (table) => {
+          try {
+            const columns = await connector.getTableSchema(table, schema);
+            return {
+              table,
+              columns: columns.map((col) => ({
+                name: col.column_name,
+                type: col.data_type
+              }))
+            };
+          } catch (error) {
+            return null;
+          }
+        })
+      );
+      const accessibleSchemas = tableSchemas.filter((schema2) => schema2 !== null);
+      if (accessibleSchemas.length === 0) {
+        return formatPromptErrorResponse(
+          `No accessible tables found. You may not have sufficient permissions to access table schemas.`,
+          "NO_ACCESSIBLE_TABLES"
+        );
+      }
+      const schemaContext = accessibleSchemas.length > 0 ? `Available tables and their columns:
 ${accessibleSchemas.map(
-      (schema) => `- ${schema.table}: ${schema.columns.map(
-        (col) => `${col.name} (${col.type})`
-      ).join(", ")}`
-    ).join("\n")}` : "No schema information available.";
-    const dialectExamples = {
-      postgres: [
-        "SELECT * FROM users WHERE created_at > NOW() - INTERVAL '1 day'",
-        "SELECT u.name, COUNT(o.id) FROM users u JOIN orders o ON u.id = o.user_id GROUP BY u.name HAVING COUNT(o.id) > 5",
-        "SELECT product_name, price FROM products WHERE price > (SELECT AVG(price) FROM products)"
-      ],
-      sqlite: [
-        "SELECT * FROM users WHERE created_at > datetime('now', '-1 day')",
-        "SELECT u.name, COUNT(o.id) FROM users u JOIN orders o ON u.id = o.user_id GROUP BY u.name HAVING COUNT(o.id) > 5",
-        "SELECT product_name, price FROM products WHERE price > (SELECT AVG(price) FROM products)"
-      ]
-    };
-    const prompt = `
+        (schema2) => `- ${schema2.table}: ${schema2.columns.map(
+          (col) => `${col.name} (${col.type})`
+        ).join(", ")}`
+      ).join("\n")}` : "No schema information available.";
+      const dialectExamples = {
+        postgres: [
+          "SELECT * FROM users WHERE created_at > NOW() - INTERVAL '1 day'",
+          "SELECT u.name, COUNT(o.id) FROM users u JOIN orders o ON u.id = o.user_id GROUP BY u.name HAVING COUNT(o.id) > 5",
+          "SELECT product_name, price FROM products WHERE price > (SELECT AVG(price) FROM products)"
+        ],
+        sqlite: [
+          "SELECT * FROM users WHERE created_at > datetime('now', '-1 day')",
+          "SELECT u.name, COUNT(o.id) FROM users u JOIN orders o ON u.id = o.user_id GROUP BY u.name HAVING COUNT(o.id) > 5",
+          "SELECT product_name, price FROM products WHERE price > (SELECT AVG(price) FROM products)"
+        ],
+        mysql: [
+          "SELECT * FROM users WHERE created_at > NOW() - INTERVAL 1 DAY",
+          "SELECT u.name, COUNT(o.id) FROM users u JOIN orders o ON u.id = o.user_id GROUP BY u.name HAVING COUNT(o.id) > 5",
+          "SELECT product_name, price FROM products WHERE price > (SELECT AVG(price) FROM products)"
+        ],
+        mssql: [
+          "SELECT * FROM users WHERE created_at > DATEADD(day, -1, GETDATE())",
+          "SELECT u.name, COUNT(o.id) FROM users u JOIN orders o ON u.id = o.user_id GROUP BY u.name HAVING COUNT(o.id) > 5",
+          "SELECT product_name, price FROM products WHERE price > (SELECT AVG(price) FROM products)"
+        ],
+        ansi: [
+          "SELECT * FROM users WHERE created_at > CURRENT_TIMESTAMP - INTERVAL '1' DAY",
+          "SELECT u.name, COUNT(o.id) FROM users u JOIN orders o ON u.id = o.user_id GROUP BY u.name HAVING COUNT(o.id) > 5",
+          "SELECT product_name, price FROM products WHERE price > (SELECT AVG(price) FROM products)"
+        ]
+      };
+      const schemaInfo = schema ? `in schema '${schema}'` : "across all schemas";
+      const prompt = `
 Generate a ${sqlDialect} SQL query based on this description: "${description}"
 
 ${schemaContext}
+Working ${schemaInfo}
 
 The query should:
 1. Be written for ${sqlDialect} dialect
@@ -1161,35 +1999,49 @@ The query should:
 4. Include appropriate comments
 5. Be compatible with ${sqlDialect} syntax
 `;
-    let generatedSQL;
-    if (description.toLowerCase().includes("count")) {
-      generatedSQL = `-- Count query generated from: "${description}"
+      let generatedSQL;
+      if (description.toLowerCase().includes("count")) {
+        const schemaPrefix = schema ? `-- Schema: ${schema}
+` : "";
+        generatedSQL = `${schemaPrefix}-- Count query generated from: "${description}"
 SELECT COUNT(*) AS count 
 FROM ${accessibleSchemas.length > 0 ? accessibleSchemas[0].table : "table_name"};`;
-    } else if (description.toLowerCase().includes("average") || description.toLowerCase().includes("avg")) {
-      const table = accessibleSchemas.length > 0 ? accessibleSchemas[0].table : "table_name";
-      const numericColumn = accessibleSchemas.length > 0 ? accessibleSchemas[0].columns.find((col) => ["int", "numeric", "decimal", "float", "real", "double"].some((t) => col.type.includes(t)))?.name || "numeric_column" : "numeric_column";
-      generatedSQL = `-- Average query generated from: "${description}"
+      } else if (description.toLowerCase().includes("average") || description.toLowerCase().includes("avg")) {
+        const table = accessibleSchemas.length > 0 ? accessibleSchemas[0].table : "table_name";
+        const numericColumn = accessibleSchemas.length > 0 ? accessibleSchemas[0].columns.find((col) => ["int", "numeric", "decimal", "float", "real", "double"].some((t) => col.type.includes(t)))?.name || "numeric_column" : "numeric_column";
+        const schemaPrefix = schema ? `-- Schema: ${schema}
+` : "";
+        generatedSQL = `${schemaPrefix}-- Average query generated from: "${description}"
 SELECT AVG(${numericColumn}) AS average
 FROM ${table};`;
-    } else if (description.toLowerCase().includes("join")) {
-      generatedSQL = `-- Join query generated from: "${description}"
+      } else if (description.toLowerCase().includes("join")) {
+        const schemaPrefix = schema ? `-- Schema: ${schema}
+` : "";
+        generatedSQL = `${schemaPrefix}-- Join query generated from: "${description}"
 SELECT t1.*, t2.*
 FROM ${accessibleSchemas.length > 0 ? accessibleSchemas[0]?.table : "table1"} t1
 JOIN ${accessibleSchemas.length > 1 ? accessibleSchemas[1]?.table : "table2"} t2
   ON t1.id = t2.${accessibleSchemas.length > 0 ? accessibleSchemas[0]?.table : "table1"}_id;`;
-    } else {
-      const table = accessibleSchemas.length > 0 ? accessibleSchemas[0].table : "table_name";
-      generatedSQL = `-- Query generated from: "${description}"
+      } else {
+        const table = accessibleSchemas.length > 0 ? accessibleSchemas[0].table : "table_name";
+        const schemaPrefix = schema ? `-- Schema: ${schema}
+` : "";
+        generatedSQL = `${schemaPrefix}-- Query generated from: "${description}"
 SELECT * 
 FROM ${table}
 LIMIT 10;`;
+      }
+      return formatPromptSuccessResponse(
+        generatedSQL,
+        // Add references to example queries that could help
+        dialectExamples[sqlDialect]
+      );
+    } catch (error) {
+      return formatPromptErrorResponse(
+        `Error generating SQL query schema information: ${error.message}`,
+        "SCHEMA_RETRIEVAL_ERROR"
+      );
     }
-    return formatPromptSuccessResponse(
-      generatedSQL,
-      // Add references to example queries that could help
-      dialectExamples[sqlDialect]
-    );
   } catch (error) {
     return formatPromptErrorResponse(
       `Failed to generate SQL: ${error.message}`,
@@ -1201,17 +2053,35 @@ LIMIT 10;`;
 // src/prompts/db-explainer.ts
 import { z as z3 } from "zod";
 var dbExplainerSchema = {
-  target: z3.string().describe("Name of the table, column, or database to explain")
+  schema: z3.string().optional().describe("Optional database schema to use"),
+  table: z3.string().optional().describe("Optional specific table to explain")
 };
-async function dbExplainerPromptHandler({ target }, _extra) {
+async function dbExplainerPromptHandler({ schema, table }, _extra) {
   try {
     const connector = ConnectorManager.getCurrentConnector();
-    const tables = await connector.getTables();
-    const normalizedTarget = target.toLowerCase();
-    const matchingTable = tables.find((t) => t.toLowerCase() === normalizedTarget);
-    if (matchingTable) {
-      const columns = await connector.getTableSchema(matchingTable);
-      const tableDescription = `Table: ${matchingTable}
+    if (schema) {
+      const availableSchemas = await connector.getSchemas();
+      if (!availableSchemas.includes(schema)) {
+        return formatPromptErrorResponse(
+          `Schema '${schema}' does not exist or cannot be accessed. Available schemas: ${availableSchemas.join(", ")}`,
+          "SCHEMA_NOT_FOUND"
+        );
+      }
+    }
+    const tables = await connector.getTables(schema);
+    const normalizedTable = table?.toLowerCase() || "";
+    const matchingTable = tables.find((t) => t.toLowerCase() === normalizedTable);
+    if (matchingTable && table) {
+      try {
+        const columns = await connector.getTableSchema(matchingTable, schema);
+        if (columns.length === 0) {
+          return formatPromptErrorResponse(
+            `Table '${matchingTable}' exists but has no columns or cannot be accessed.`,
+            "EMPTY_TABLE_SCHEMA"
+          );
+        }
+        const schemaInfo = schema ? ` in schema '${schema}'` : "";
+        const tableDescription = `Table: ${matchingTable}${schemaInfo}
       
 Structure:
 ${columns.map((col) => `- ${col.column_name} (${col.data_type})${col.is_nullable === "YES" ? ", nullable" : ""}${col.column_default ? `, default: ${col.column_default}` : ""}`).join("\n")}
@@ -1221,12 +2091,25 @@ This table appears to store ${determineTablePurpose(matchingTable, columns)}
 
 Relationships:
 ${determineRelationships(matchingTable, columns)}`;
-      return formatPromptSuccessResponse(tableDescription);
+        return formatPromptSuccessResponse(tableDescription);
+      } catch (error) {
+        return formatPromptErrorResponse(
+          `Error retrieving schema for table '${matchingTable}': ${error.message}`,
+          "TABLE_SCHEMA_ERROR"
+        );
+      }
     }
-    if (target.includes(".")) {
-      const [tableName, columnName] = target.split(".");
-      if (tables.find((t) => t.toLowerCase() === tableName.toLowerCase())) {
-        const columns = await connector.getTableSchema(tableName);
+    if (table && table.includes(".")) {
+      const [tableName, columnName] = table.split(".");
+      const tableExists = tables.find((t) => t.toLowerCase() === tableName.toLowerCase());
+      if (!tableExists) {
+        return formatPromptErrorResponse(
+          `Table '${tableName}' does not exist in schema '${schema || "default"}'. Available tables: ${tables.slice(0, 10).join(", ")}${tables.length > 10 ? "..." : ""}`,
+          "TABLE_NOT_FOUND"
+        );
+      }
+      try {
+        const columns = await connector.getTableSchema(tableName, schema);
         const column = columns.find((c) => c.column_name.toLowerCase() === columnName.toLowerCase());
         if (column) {
           const columnDescription = `Column: ${tableName}.${column.column_name}
@@ -1238,11 +2121,22 @@ Default: ${column.column_default || "None"}
 Purpose:
 ${determineColumnPurpose(column.column_name, column.data_type)}`;
           return formatPromptSuccessResponse(columnDescription);
+        } else {
+          return formatPromptErrorResponse(
+            `Column '${columnName}' does not exist in table '${tableName}'. Available columns: ${columns.map((c) => c.column_name).join(", ")}`,
+            "COLUMN_NOT_FOUND"
+          );
         }
+      } catch (error) {
+        return formatPromptErrorResponse(
+          `Error accessing table schema: ${error.message}`,
+          "SCHEMA_ACCESS_ERROR"
+        );
       }
     }
-    if (["database", "db", "schema", "overview", "all"].includes(normalizedTarget)) {
-      let dbOverview = `Database Overview
+    if (!table || ["database", "db", "schema", "overview", "all"].includes(normalizedTable)) {
+      const schemaInfo = schema ? `in schema '${schema}'` : "across all schemas";
+      let dbOverview = `Database Overview ${schemaInfo}
 
 Tables: ${tables.length}
 ${tables.map((t) => `- ${t}`).join("\n")}
@@ -1250,26 +2144,34 @@ ${tables.map((t) => `- ${t}`).join("\n")}
 This database ${describeDatabasePurpose(tables)}`;
       return formatPromptSuccessResponse(dbOverview);
     }
-    const possibleTableMatches = tables.filter(
-      (t) => t.toLowerCase().includes(normalizedTarget) || normalizedTarget.includes(t.toLowerCase())
-    );
-    if (possibleTableMatches.length > 0) {
-      return formatPromptSuccessResponse(
-        `Could not find exact match for "${target}". Did you mean one of these tables?
+    if (table && !normalizedTable.includes(".")) {
+      const possibleTableMatches = tables.filter(
+        (t) => t.toLowerCase().includes(normalizedTable) || normalizedTable.includes(t.toLowerCase())
+      );
+      if (possibleTableMatches.length > 0) {
+        return formatPromptSuccessResponse(
+          `Table "${table}" not found. Did you mean one of these tables?
 
 ${possibleTableMatches.join("\n")}`
-      );
+        );
+      } else {
+        const schemaInfo = schema ? `in schema '${schema}'` : "in the database";
+        return formatPromptErrorResponse(
+          `Table "${table}" does not exist ${schemaInfo}. Available tables: ${tables.slice(0, 10).join(", ")}${tables.length > 10 ? "..." : ""}`,
+          "TABLE_NOT_FOUND"
+        );
+      }
     }
-    return formatPromptErrorResponse(
-      `Could not find a table, column, or database feature matching "${target}"`,
-      "NOT_FOUND"
-    );
   } catch (error) {
     return formatPromptErrorResponse(
       `Error explaining database: ${error.message}`,
       "EXPLANATION_ERROR"
     );
   }
+  return formatPromptErrorResponse(
+    `Unable to process request for schema: ${schema}, table: ${table}`,
+    "UNHANDLED_REQUEST"
+  );
 }
 function determineTablePurpose(tableName, columns) {
   const lowerTableName = tableName.toLowerCase();