list_tables

Instructions

Implementation Reference

• src/index.ts:151-168 (handler)

  The 'list_tables' tool handler that executes SHOW FULL TABLES query and returns results as JSON.

  case "list_tables": {
    console.error('[Tool] Executing list_tables');
    
    const database = request.params.arguments?.database as string | undefined;
    
    const { rows } = await executeQuery(
      pool,
      'SHOW FULL TABLES',
      [],
      database
    );
    
    return {
      content: [{
        type: "text",
        text: JSON.stringify(rows, null, 2)
      }]
    };

• src/index.ts:75-87 (schema)

  Input schema for the 'list_tables' tool, defining the optional 'database' parameter.

  {
    name: "list_tables",
    description: "List all tables in a specified database",
    inputSchema: {
      type: "object",
      properties: {
        database: {
          type: "string",
          description: "Database name (optional, uses default if not specified)"
        }
      },
      required: []
    }

• src/index.ts:63-127 (registration)

  Tool registration via ListToolsRequestSchema, listing all available tools including 'list_tables'.

  server.setRequestHandler(ListToolsRequestSchema, async () => {
    return {
      tools: [
        {
          name: "list_databases",
          description: "List all accessible databases on the MySQL server",
          inputSchema: {
            type: "object",
            properties: {},
            required: []
          }
        },
        {
          name: "list_tables",
          description: "List all tables in a specified database",
          inputSchema: {
            type: "object",
            properties: {
              database: {
                type: "string",
                description: "Database name (optional, uses default if not specified)"
              }
            },
            required: []
          }
        },
        {
          name: "describe_table",
          description: "Show the schema for a specific table",
          inputSchema: {
            type: "object",
            properties: {
              database: {
                type: "string",
                description: "Database name (optional, uses default if not specified)"
              },
              table: {
                type: "string",
                description: "Table name"
              }
            },
            required: ["table"]
          }
        },
        {
          name: "execute_query",
          description: "Execute a read-only SQL query",
          inputSchema: {
            type: "object",
            properties: {
              query: {
                type: "string",
                description: "SQL query (only SELECT, SHOW, DESCRIBE, and EXPLAIN statements are allowed)"
              },
              database: {
                type: "string",
                description: "Database name (optional, uses default if not specified)"
              }
            },
            required: ["query"]
          }
        }
      ]
    };
  });

• src/connection.ts:63-109 (helper)

  The executeQuery helper function used by list_tables to run the SQL query with optional database context.

  export async function executeQuery(
    pool: mysql.Pool,
    sql: string,
    params: any[] = [],
    database?: string
  ): Promise<{ rows: any; fields: mysql.FieldPacket[] }> {
    console.error(`[Query] Executing: ${sql}`);
    
    let connection: mysql.PoolConnection | null = null;
    
    try {
      // Get connection from pool
      connection = await pool.getConnection();
      
      // Use specific database if provided
      if (database) {
        console.error(`[Query] Using database: ${database}`);
        await connection.query(`USE \`${database}\``);
      }
      
      // Execute query with timeout
      const [rows, fields] = await Promise.race([
        connection.query(sql, params),
        new Promise<never>((_, reject) => {
          setTimeout(() => reject(new Error('Query timeout')), DEFAULT_TIMEOUT);
        }),
      ]);
      
      // Apply row limit if result is an array
      const limitedRows = Array.isArray(rows) && rows.length > DEFAULT_ROW_LIMIT
        ? rows.slice(0, DEFAULT_ROW_LIMIT)
        : rows;
      
      // Log result summary
      console.error(`[Query] Success: ${Array.isArray(rows) ? rows.length : 1} rows returned`);
      
      return { rows: limitedRows, fields };
    } catch (error) {
      console.error('[Error] Query execution failed:', error);
      throw error;
    } finally {
      // Release connection back to pool
      if (connection) {
        connection.release();
      }
    }
  }

• src/types.ts:19-27 (helper)

  The TableInfo interface used to describe table result types.

  }
  
  // Database information
  export interface DatabaseInfo {
    name: string;
  }
  
  // Table information
  export interface TableInfo {