@neverinfamous/mysql-mcp 2.3.1 → 3.0.1

package/src/adapters/mysql/tools/json/__tests__/core.test.ts

@@ -299,6 +299,26 @@ describe("JSON Core Tools", () => {
       const call = mockAdapter.executeReadQuery.mock.calls[0][0] as string;
       expect(call).toContain("JSON_KEYS");
     });
+
+    it("should include count in response", async () => {
+      mockAdapter.executeReadQuery.mockResolvedValue(
+        createMockQueryResult([
+          { json_keys: '["a", "b"]' },
+          { json_keys: '["c"]' },
+        ]),
+      );
+
+      const tool = createJsonKeysTool(mockAdapter as unknown as MySQLAdapter);
+      const result = (await tool.handler(
+        {
+          table: "data",
+          column: "json_col",
+        },
+        mockContext,
+      )) as { rows: unknown[]; count: number };
+
+      expect(result.count).toBe(2);
+    });
   });
 
   describe("createJsonArrayAppendTool", () => {

package/src/adapters/mysql/tools/json/__tests__/enhanced.test.ts

@@ -506,67 +506,99 @@ describe("JSON Enhanced Tools", () => {
 
       expect(result.suggestions).toHaveLength(5);
     });
-  });
 
-  describe("P154 Graceful Error Handling", () => {
-    const tableError = new Error("Table 'testdb.nonexistent' doesn't exist");
+    it("should produce valid DDL for qualified table names", async () => {
+      mockAdapter.executeQuery
+        .mockResolvedValueOnce(createMockQueryResult([{ key_name: "email" }]))
+        .mockResolvedValueOnce(
+          createMockQueryResult([{ value_type: "STRING", cardinality: 50 }]),
+        );
 
-    it("json_normalize should return exists: false for nonexistent table", async () => {
-      mockAdapter.executeQuery.mockRejectedValue(tableError);
-      const tool = createJsonNormalizeTool(
+      const tool = createJsonIndexSuggestTool(
         mockAdapter as unknown as MySQLAdapter,
       );
-      const result = await tool.handler(
-        { table: "nonexistent", column: "doc" },
+      const result = (await tool.handler(
+        {
+          table: "mydb.users",
+          column: "data",
+        },
         mockContext,
-      );
-      expect(result).toEqual({ exists: false, table: "nonexistent" });
-    });
+      )) as { suggestions: { indexDdl: string }[] };
 
-    it("json_stats should return exists: false for nonexistent table", async () => {
-      mockAdapter.executeQuery.mockRejectedValue(tableError);
-      const tool = createJsonStatsTool(mockAdapter as unknown as MySQLAdapter);
-      const result = await tool.handler(
-        { table: "nonexistent", column: "doc" },
-        mockContext,
+      expect(result.suggestions).toHaveLength(1);
+      // Table reference should be properly escaped as `mydb`.`users`
+      expect(result.suggestions[0].indexDdl).toContain(
+        "ALTER TABLE `mydb`.`users`",
       );
-      expect(result).toEqual({ exists: false, table: "nonexistent" });
+      // Index name should use only the table basename (no schema prefix)
+      expect(result.suggestions[0].indexDdl).toContain("idx_users_email");
+      expect(result.suggestions[0].indexDdl).not.toContain("idx_mydb.users");
     });
 
-    it("json_index_suggest should return exists: false for nonexistent table", async () => {
-      mockAdapter.executeQuery.mockRejectedValue(tableError);
-      const tool = createJsonIndexSuggestTool(
-        mockAdapter as unknown as MySQLAdapter,
-      );
-      const result = await tool.handler(
-        { table: "nonexistent", column: "doc" },
-        mockContext,
-      );
-      expect(result).toEqual({ exists: false, table: "nonexistent" });
-    });
+    describe("P154 Graceful Error Handling", () => {
+      const tableError = new Error("Table 'testdb.nonexistent' doesn't exist");
 
-    it("json_merge should return success: false for invalid input", async () => {
-      mockAdapter.executeReadQuery.mockRejectedValue(
-        new Error("Invalid JSON text"),
-      );
-      const tool = createJsonMergeTool(mockAdapter as unknown as MySQLAdapter);
-      const result = await tool.handler(
-        { json1: "not-json", json2: "{}" },
-        mockContext,
-      );
-      expect(result).toEqual({ success: false, error: "Invalid JSON text" });
-    });
+      it("json_normalize should return exists: false for nonexistent table", async () => {
+        mockAdapter.executeQuery.mockRejectedValue(tableError);
+        const tool = createJsonNormalizeTool(
+          mockAdapter as unknown as MySQLAdapter,
+        );
+        const result = await tool.handler(
+          { table: "nonexistent", column: "doc" },
+          mockContext,
+        );
+        expect(result).toEqual({ exists: false, table: "nonexistent" });
+      });
 
-    it("json_diff should return success: false for invalid input", async () => {
-      mockAdapter.executeReadQuery.mockRejectedValue(
-        new Error("Invalid JSON text"),
-      );
-      const tool = createJsonDiffTool(mockAdapter as unknown as MySQLAdapter);
-      const result = await tool.handler(
-        { json1: "not-json", json2: "{}" },
-        mockContext,
-      );
-      expect(result).toEqual({ success: false, error: "Invalid JSON text" });
+      it("json_stats should return exists: false for nonexistent table", async () => {
+        mockAdapter.executeQuery.mockRejectedValue(tableError);
+        const tool = createJsonStatsTool(
+          mockAdapter as unknown as MySQLAdapter,
+        );
+        const result = await tool.handler(
+          { table: "nonexistent", column: "doc" },
+          mockContext,
+        );
+        expect(result).toEqual({ exists: false, table: "nonexistent" });
+      });
+
+      it("json_index_suggest should return exists: false for nonexistent table", async () => {
+        mockAdapter.executeQuery.mockRejectedValue(tableError);
+        const tool = createJsonIndexSuggestTool(
+          mockAdapter as unknown as MySQLAdapter,
+        );
+        const result = await tool.handler(
+          { table: "nonexistent", column: "doc" },
+          mockContext,
+        );
+        expect(result).toEqual({ exists: false, table: "nonexistent" });
+      });
+
+      it("json_merge should return success: false for invalid input", async () => {
+        mockAdapter.executeReadQuery.mockRejectedValue(
+          new Error("Invalid JSON text"),
+        );
+        const tool = createJsonMergeTool(
+          mockAdapter as unknown as MySQLAdapter,
+        );
+        const result = await tool.handler(
+          { json1: "not-json", json2: "{}" },
+          mockContext,
+        );
+        expect(result).toEqual({ success: false, error: "Invalid JSON text" });
+      });
+
+      it("json_diff should return success: false for invalid input", async () => {
+        mockAdapter.executeReadQuery.mockRejectedValue(
+          new Error("Invalid JSON text"),
+        );
+        const tool = createJsonDiffTool(mockAdapter as unknown as MySQLAdapter);
+        const result = await tool.handler(
+          { json1: "not-json", json2: "{}" },
+          mockContext,
+        );
+        expect(result).toEqual({ success: false, error: "Invalid JSON text" });
+      });
     });
   });
 });

package/src/adapters/mysql/tools/json/__tests__/helpers.test.ts

@@ -52,6 +52,24 @@ describe("JSON Helper Tools", () => {
       // Value is parsed from JSON string
       expect(result.value).toEqual({ a: 1 });
     });
+
+    it("should return rowFound: false for nonexistent row", async () => {
+      mockAdapter.executeReadQuery.mockResolvedValue(createMockQueryResult([]));
+
+      const tool = createJsonGetTool(mockAdapter as unknown as MySQLAdapter);
+      const result = (await tool.handler(
+        {
+          table: "data",
+          column: "json_col",
+          path: "$.a",
+          id: 999,
+        },
+        mockContext,
+      )) as { value: null; rowFound: boolean };
+
+      expect(result.value).toBeNull();
+      expect(result.rowFound).toBe(false);
+    });
   });
 
   describe("createJsonSearchTool", () => {
@@ -72,7 +90,7 @@ describe("JSON Helper Tools", () => {
 
       const call = mockAdapter.executeReadQuery.mock.calls[0][0] as string;
       expect(call).toContain("JSON_SEARCH");
-      expect(call).toContain("SELECT id, `json_col`");
+      expect(call).toContain("SELECT id, JSON_SEARCH");
       expect(call).not.toContain("SELECT *");
     });
   });
@@ -116,10 +134,10 @@ describe("JSON Helper Tools", () => {
           id: 999,
         },
         mockContext,
-      )) as { success: boolean; reason: string };
+      )) as { success: boolean; error: string };
 
       expect(result.success).toBe(false);
-      expect(result.reason).toContain("999");
+      expect(result.error).toContain("999");
     });
   });
 
@@ -165,6 +183,27 @@ describe("JSON Helper Tools", () => {
       expect(sqlParam[0]).toBe("hello");
       expect(result.valid).toBe(false);
     });
+
+    it("should strip Query failed and Execute failed prefixes from errors", async () => {
+      mockAdapter.executeReadQuery.mockRejectedValue(
+        new Error(
+          'Query failed: Execute failed: Invalid JSON text in argument 1 to function cast_as_json: "Missing a name" at position 1.',
+        ),
+      );
+
+      const tool = createJsonValidateTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = (await tool.handler({ value: "{bad" }, mockContext)) as {
+        valid: boolean;
+        error: string;
+      };
+
+      expect(result.valid).toBe(false);
+      expect(result.error).not.toContain("Query failed");
+      expect(result.error).not.toContain("Execute failed");
+      expect(result.error).toContain("Invalid JSON text");
+    });
   });
 
   describe("P154 Graceful Error Handling", () => {

package/src/adapters/mysql/tools/json/core.ts

@@ -15,12 +15,19 @@ import {
   JsonExtractSchemaBase,
   JsonSetSchema,
   JsonSetSchemaBase,
+  JsonInsertSchema,
+  JsonInsertSchemaBase,
+  JsonReplaceSchema,
+  JsonReplaceSchemaBase,
+  JsonRemoveSchema,
+  JsonRemoveSchemaBase,
   JsonContainsSchema,
   JsonContainsSchemaBase,
   JsonKeysSchema,
   JsonKeysSchemaBase,
+  JsonArrayAppendSchema,
+  JsonArrayAppendSchemaBase,
 } from "../../types.js";
-import { z } from "zod";
 import {
   validateIdentifier,
   validateQualifiedIdentifier,
@@ -136,27 +143,20 @@ export function createJsonSetTool(adapter: MySQLAdapter): ToolDefinition {
 }
 
 export function createJsonInsertTool(adapter: MySQLAdapter): ToolDefinition {
-  const schema = z.object({
-    table: z.string(),
-    column: z.string(),
-    path: z.string(),
-    value: z.unknown(),
-    where: z.string(),
-  });
-
   return {
     name: "mysql_json_insert",
     title: "MySQL JSON Insert",
     description:
       "Insert values into JSON columns only if the path does not exist.",
     group: "json",
-    inputSchema: schema,
+    inputSchema: JsonInsertSchemaBase,
     requiredScopes: ["write"],
     annotations: {
       readOnlyHint: false,
     },
     handler: async (params: unknown, _context: RequestContext) => {
-      const { table, column, path, value, where } = schema.parse(params);
+      const { table, column, path, value, where } =
+        JsonInsertSchema.parse(params);
 
       // Validate inputs
       validateQualifiedIdentifier(table, "table");
@@ -197,26 +197,19 @@ export function createJsonInsertTool(adapter: MySQLAdapter): ToolDefinition {
 }
 
 export function createJsonReplaceTool(adapter: MySQLAdapter): ToolDefinition {
-  const schema = z.object({
-    table: z.string(),
-    column: z.string(),
-    path: z.string(),
-    value: z.unknown(),
-    where: z.string(),
-  });
-
   return {
     name: "mysql_json_replace",
     title: "MySQL JSON Replace",
     description: "Replace values in JSON columns only if the path exists.",
     group: "json",
-    inputSchema: schema,
+    inputSchema: JsonReplaceSchemaBase,
     requiredScopes: ["write"],
     annotations: {
       readOnlyHint: false,
     },
     handler: async (params: unknown, _context: RequestContext) => {
-      const { table, column, path, value, where } = schema.parse(params);
+      const { table, column, path, value, where } =
+        JsonReplaceSchema.parse(params);
 
       // Validate inputs
       validateQualifiedIdentifier(table, "table");
@@ -242,25 +235,18 @@ export function createJsonReplaceTool(adapter: MySQLAdapter): ToolDefinition {
 }
 
 export function createJsonRemoveTool(adapter: MySQLAdapter): ToolDefinition {
-  const schema = z.object({
-    table: z.string(),
-    column: z.string(),
-    paths: z.array(z.string()),
-    where: z.string(),
-  });
-
   return {
     name: "mysql_json_remove",
     title: "MySQL JSON Remove",
     description: "Remove values from JSON columns at specified paths.",
     group: "json",
-    inputSchema: schema,
+    inputSchema: JsonRemoveSchemaBase,
     requiredScopes: ["write"],
     annotations: {
       readOnlyHint: false,
     },
     handler: async (params: unknown, _context: RequestContext) => {
-      const { table, column, paths, where } = schema.parse(params);
+      const { table, column, paths, where } = JsonRemoveSchema.parse(params);
 
       // Validate inputs
       validateQualifiedIdentifier(table, "table");
@@ -351,10 +337,10 @@ export function createJsonKeysTool(adapter: MySQLAdapter): ToolDefinition {
 
       try {
         const jsonPath = path ?? "$";
-        const sql = `SELECT JSON_KEYS(\`${column}\`, ?) as json_keys FROM ${escapeQualifiedTable(table)}`;
+        const sql = `SELECT JSON_KEYS(\`${column}\`, ?) as json_keys FROM ${escapeQualifiedTable(table)} HAVING json_keys IS NOT NULL`;
 
         const result = await adapter.executeReadQuery(sql, [jsonPath]);
-        return { rows: result.rows };
+        return { rows: result.rows, count: result.rows?.length ?? 0 };
       } catch (error) {
         const msg = error instanceof Error ? error.message : String(error);
         if (msg.includes("doesn't exist")) {
@@ -369,26 +355,19 @@ export function createJsonKeysTool(adapter: MySQLAdapter): ToolDefinition {
 export function createJsonArrayAppendTool(
   adapter: MySQLAdapter,
 ): ToolDefinition {
-  const schema = z.object({
-    table: z.string(),
-    column: z.string(),
-    path: z.string(),
-    value: z.unknown(),
-    where: z.string(),
-  });
-
   return {
     name: "mysql_json_array_append",
     title: "MySQL JSON Array Append",
     description: "Append a value to a JSON array at the specified path.",
     group: "json",
-    inputSchema: schema,
+    inputSchema: JsonArrayAppendSchemaBase,
     requiredScopes: ["write"],
     annotations: {
       readOnlyHint: false,
     },
     handler: async (params: unknown, _context: RequestContext) => {
-      const { table, column, path, value, where } = schema.parse(params);
+      const { table, column, path, value, where } =
+        JsonArrayAppendSchema.parse(params);
 
       // Validate inputs
       validateQualifiedIdentifier(table, "table");

package/src/adapters/mysql/tools/json/enhanced.ts

@@ -11,16 +11,21 @@ import type {
   RequestContext,
 } from "../../../../types/index.js";
 import { z } from "zod";
+import {
+  JsonNormalizeSchema,
+  JsonNormalizeSchemaBase,
+  JsonStatsSchema,
+  JsonStatsSchemaBase,
+  JsonIndexSuggestSchema,
+  JsonIndexSuggestSchemaBase,
+} from "../../types.js";
 import {
   validateQualifiedIdentifier,
   escapeQualifiedTable,
   validateIdentifier,
 } from "../../../../utils/validators.js";
 
-// =============================================================================
-// Schemas
-// =============================================================================
-
+// Schemas for json_merge and json_diff (no table/column — no aliases needed)
 const JsonMergeSchema = z.object({
   json1: z.string().describe("First JSON document"),
   json2: z.string().describe("Second JSON document"),
@@ -35,26 +40,6 @@ const JsonDiffSchema = z.object({
   json2: z.string().describe("Second JSON document"),
 });
 
-const JsonNormalizeSchema = z.object({
-  table: z.string().describe("Table name"),
-  column: z.string().describe("JSON column name"),
-  where: z.string().optional().describe("WHERE clause"),
-  limit: z.number().default(100).describe("Maximum rows to process"),
-});
-
-const JsonStatsSchema = z.object({
-  table: z.string().describe("Table name"),
-  column: z.string().describe("JSON column name"),
-  where: z.string().optional().describe("Optional WHERE clause"),
-  sampleSize: z.number().default(1000).describe("Sample size for statistics"),
-});
-
-const JsonIndexSuggestSchema = z.object({
-  table: z.string().describe("Table name"),
-  column: z.string().describe("JSON column name"),
-  sampleSize: z.number().default(100).describe("Sample size to analyze"),
-});
-
 // =============================================================================
 // Tool Creation Functions
 // =============================================================================
@@ -232,7 +217,7 @@ export function createJsonNormalizeTool(adapter: MySQLAdapter): ToolDefinition {
     description:
       "Normalize JSON column structure by extracting all unique keys across documents.",
     group: "json",
-    inputSchema: JsonNormalizeSchema,
+    inputSchema: JsonNormalizeSchemaBase,
     requiredScopes: ["read"],
     annotations: {
       readOnlyHint: true,
@@ -306,7 +291,7 @@ export function createJsonStatsTool(adapter: MySQLAdapter): ToolDefinition {
     description:
       "Analyze statistics for a JSON column including depth, size, and key frequency.",
     group: "json",
-    inputSchema: JsonStatsSchema,
+    inputSchema: JsonStatsSchemaBase,
     requiredScopes: ["read"],
     annotations: {
       readOnlyHint: true,
@@ -341,20 +326,20 @@ export function createJsonStatsTool(adapter: MySQLAdapter): ToolDefinition {
         const row = result.rows?.[0];
 
         return {
-          totalSampled: row?.["total_rows"],
-          nullCount: row?.["null_count"],
+          totalSampled: Number(row?.["total_rows"] ?? 0),
+          nullCount: Number(row?.["null_count"] ?? 0),
           length: {
-            avg: row?.["avg_length"],
-            max: row?.["max_length"],
-            min: row?.["min_length"],
+            avg: Number(row?.["avg_length"] ?? 0),
+            max: Number(row?.["max_length"] ?? 0),
+            min: Number(row?.["min_length"] ?? 0),
           },
           depth: {
-            avg: row?.["avg_depth"],
-            max: row?.["max_depth"],
+            avg: Number(row?.["avg_depth"] ?? 0),
+            max: Number(row?.["max_depth"] ?? 0),
           },
           sizeBytes: {
-            avg: row?.["avg_size_bytes"],
-            max: row?.["max_size_bytes"],
+            avg: Number(row?.["avg_size_bytes"] ?? 0),
+            max: Number(row?.["max_size_bytes"] ?? 0),
           },
           sampleSize,
         };
@@ -378,7 +363,7 @@ export function createJsonIndexSuggestTool(
     description:
       "Suggest functional indexes for frequently accessed JSON paths.",
     group: "json",
-    inputSchema: JsonIndexSuggestSchema,
+    inputSchema: JsonIndexSuggestSchemaBase,
     requiredScopes: ["read"],
     annotations: {
       readOnlyHint: true,
@@ -459,7 +444,7 @@ export function createJsonIndexSuggestTool(
               path: `$.${key}`,
               type: valueType ?? "UNKNOWN",
               cardinality,
-              indexDdl: `ALTER TABLE \`${table}\` ADD INDEX idx_${table}_${key} ((CAST(JSON_EXTRACT(\`${column}\`, '$.${key}') AS ${dataType})));`,
+              indexDdl: `ALTER TABLE ${escapeQualifiedTable(table)} ADD INDEX idx_${table.split(".").pop()}_${key} ((CAST(JSON_EXTRACT(\`${column}\`, '$.${key}') AS ${dataType})));`,
             });
           }
         }

package/src/adapters/mysql/tools/json/helpers.ts

@@ -14,8 +14,11 @@ import {
   JsonSearchSchema,
   JsonSearchSchemaBase,
   JsonValidateSchema,
+  JsonGetSchema,
+  JsonGetSchemaBase,
+  JsonUpdateSchema,
+  JsonUpdateSchemaBase,
 } from "../../types.js";
-import { z } from "zod";
 import {
   validateQualifiedIdentifier,
   escapeQualifiedTable,
@@ -26,27 +29,19 @@ import {
  * Export all JSON helper tool creation functions
  */
 export function createJsonGetTool(adapter: MySQLAdapter): ToolDefinition {
-  const schema = z.object({
-    table: z.string(),
-    column: z.string(),
-    path: z.string(),
-    id: z.union([z.string(), z.number()]),
-    idColumn: z.string().default("id"),
-  });
-
   return {
     name: "mysql_json_get",
     title: "MySQL JSON Get",
     description: "Simple JSON value extraction by row ID.",
     group: "json",
-    inputSchema: schema,
+    inputSchema: JsonGetSchemaBase,
     requiredScopes: ["read"],
     annotations: {
       readOnlyHint: true,
       idempotentHint: true,
     },
     handler: async (params: unknown, _context: RequestContext) => {
-      const { table, column, path, id, idColumn } = schema.parse(params);
+      const { table, column, path, id, idColumn } = JsonGetSchema.parse(params);
 
       validateQualifiedIdentifier(table, "table");
       validateIdentifier(column, "column");
@@ -56,6 +51,11 @@ export function createJsonGetTool(adapter: MySQLAdapter): ToolDefinition {
         const sql = `SELECT JSON_EXTRACT(\`${column}\`, ?) as value FROM ${escapeQualifiedTable(table)} WHERE \`${idColumn}\` = ?`;
         const result = await adapter.executeReadQuery(sql, [path, id]);
 
+        // No rows = row ID doesn't exist (distinct from null JSON path)
+        if (!result.rows || result.rows.length === 0) {
+          return { value: null, rowFound: false };
+        }
+
         const rawValue = result.rows?.[0]?.["value"];
         // Parse JSON value for consistency with mysql_json_extract
         // Return null for missing paths, parse objects/arrays, return primitives as-is
@@ -88,27 +88,19 @@ export function createJsonGetTool(adapter: MySQLAdapter): ToolDefinition {
 }
 
 export function createJsonUpdateTool(adapter: MySQLAdapter): ToolDefinition {
-  const schema = z.object({
-    table: z.string(),
-    column: z.string(),
-    path: z.string(),
-    value: z.unknown(),
-    id: z.union([z.string(), z.number()]),
-    idColumn: z.string().default("id"),
-  });
-
   return {
     name: "mysql_json_update",
     title: "MySQL JSON Update",
     description: "Simple JSON value update by row ID.",
     group: "json",
-    inputSchema: schema,
+    inputSchema: JsonUpdateSchemaBase,
     requiredScopes: ["write"],
     annotations: {
       readOnlyHint: false,
     },
     handler: async (params: unknown, _context: RequestContext) => {
-      const { table, column, path, value, id, idColumn } = schema.parse(params);
+      const { table, column, path, value, id, idColumn } =
+        JsonUpdateSchema.parse(params);
 
       validateQualifiedIdentifier(table, "table");
       validateIdentifier(column, "column");
@@ -140,7 +132,7 @@ export function createJsonUpdateTool(adapter: MySQLAdapter): ToolDefinition {
         if (result.rowsAffected === 0) {
           return {
             success: false,
-            reason: `No row found with ${idColumn} = ${id}`,
+            error: `No row found with ${idColumn} = ${id}`,
           };
         }
         return { success: true };
@@ -176,7 +168,7 @@ export function createJsonSearchTool(adapter: MySQLAdapter): ToolDefinition {
       validateIdentifier(column, "column");
 
       try {
-        const sql = `SELECT id, \`${column}\`, JSON_SEARCH(\`${column}\`, ?, ?) as match_path FROM ${escapeQualifiedTable(table)} WHERE JSON_SEARCH(\`${column}\`, ?, ?) IS NOT NULL`;
+        const sql = `SELECT id, JSON_SEARCH(\`${column}\`, ?, ?) as match_path FROM ${escapeQualifiedTable(table)} WHERE JSON_SEARCH(\`${column}\`, ?, ?) IS NOT NULL`;
 
         const result = await adapter.executeReadQuery(sql, [
           mode,
@@ -220,8 +212,12 @@ export function createJsonValidateTool(adapter: MySQLAdapter): ToolDefinition {
       } catch (error) {
         // MySQL may throw an error for severely malformed input
         // Return a structured error response instead of propagating
-        const message =
+        let message =
           error instanceof Error ? error.message : "Unknown validation error";
+        message = message.replace(
+          /^(Query failed:\s*|Execute failed:\s*)+/i,
+          "",
+        );
         return { valid: false, error: message };
       }
     },

package/src/adapters/mysql/tools/partitioning.ts

@@ -146,6 +146,7 @@ function createAddPartitionTool(adapter: MySQLAdapter): ToolDefinition {
 
       try {
         await adapter.executeQuery(sql);
+        adapter.clearSchemaCache();
         return { success: true, table, partitionName };
       } catch (error) {
         const msg = error instanceof Error ? error.message : String(error);
@@ -210,6 +211,7 @@ function createDropPartitionTool(adapter: MySQLAdapter): ToolDefinition {
           `ALTER TABLE \`${table}\` DROP PARTITION \`${partitionName}\``,
         );
 
+        adapter.clearSchemaCache();
         return {
           success: true,
           table,
@@ -296,6 +298,7 @@ function createReorganizePartitionTool(adapter: MySQLAdapter): ToolDefinition {
 
       try {
         await adapter.executeQuery(sql);
+        adapter.clearSchemaCache();
         return {
           success: true,
           table,