list_tables

Instructions

Implementation Reference

• src/index.ts:130-136 (handler)

  Handler for the list_tables tool: extracts database from args, runs SHOW FULL TABLES query via executeQuery helper, returns JSON stringified rows.

  case "list_tables": {
    const db = args.database as string | undefined;
    const { rows } = await executeQuery("SHOW FULL TABLES", [], db);
    return {
      content: [{ type: "text", text: JSON.stringify(rows, null, 2) }],
    };
  }

• src/index.ts:90-93 (schema)

  Input schema for list_tables tool: object with optional 'database' string property.

  inputSchema: {
    type: "object",
    properties: { database: { type: "string" } },
  },

• src/index.ts:80-114 (registration)

  Registration of list_tables tool in the ListToolsRequestSchema handler, defining name, description, and schema.

  mcpServer.setRequestHandler(ListToolsRequestSchema, async () => ({
    tools: [
      {
        name: "list_databases",
        description: "List all databases",
        inputSchema: { type: "object" },
      },
      {
        name: "list_tables",
        description: "List tables in a database",
        inputSchema: {
          type: "object",
          properties: { database: { type: "string" } },
        },
      },
      {
        name: "describe_table",
        description: "Show schema of a table",
        inputSchema: {
          type: "object",
          properties: { database: { type: "string" }, table: { type: "string" } },
          required: ["table"],
        },
      },
      {
        name: "execute_query",
        description: "Run an arbitrary SQL query",
        inputSchema: {
          type: "object",
          properties: { query: { type: "string" }, database: { type: "string" } },
          required: ["query"],
        },
      },
    ],
  }));

• src/connection.ts:49-114 (helper)

  Supporting executeQuery function called by list_tables handler to perform the SQL query on the database.

  export async function executeQuery(
    sql: string,
    params: any[] = [],
    database?: string
  ): Promise<{ rows: any; fields: mariadb.FieldInfo[] }> {
    console.error(`[Query] Executing: ${sql}`);
    // Create connection pool if not already created
    if (!pool) {
      console.error("[Setup] Connection pool not found, creating a new one");
      pool = createConnectionPool();
    }
    try {
      // Get connection from pool
      if (connection) {
        console.error("[Query] Reusing existing connection");
      } else {
        console.error("[Query] Creating new connection");
        connection = await pool.getConnection();
      }
  
      // Use specific database if provided
      if (database) {
        console.error(`[Query] Using database: ${database}`);
        await connection.query(`USE \`${database}\``);
      }
      if (!isAlloowedQuery(sql)) {
        throw new Error("Query not allowed");
      }
      // Execute query with timeout
      const [rows, fields] = await connection.query({
        metaAsArray: true,
        namedPlaceholders: true,
        sql,
        ...params,
        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 with ${JSON.stringify(params)}`
      );
  
      return { rows: limitedRows, fields };
    } catch (error) {
      if (connection) {
        connection.release();
        console.error("[Query] Connection released with error");
      }
      console.error("[Error] Query execution failed:", error);
      throw error;
    } finally {
      // Release connection back to pool
      if (connection) {
        connection.release();
        console.error("[Query] Connection released");
      }
    }
  }