@neverinfamous/mysql-mcp 2.2.0 → 2.3.1

package/src/adapters/mysql/tools/performance/__tests__/analysis.test.ts

@@ -61,7 +61,7 @@ describe("Performance Analysis Tools", () => {
       );
 
       expect(mockAdapter.executeReadQuery).toHaveBeenCalledWith(
-        "EXPLAIN SELECT * FROM users",
+        "EXPLAIN FORMAT=TRADITIONAL SELECT * FROM users",
       );
       expect(result).toHaveProperty("plan");
     });
@@ -243,6 +243,30 @@ describe("Performance Analysis Tools", () => {
       expect(result.success).toBe(false);
       expect(result.error).toContain("SQL syntax");
     });
+
+    it("should accept sql alias for query", async () => {
+      mockAdapter.executeReadQuery.mockResolvedValue(
+        createMockQueryResult([
+          {
+            EXPLAIN:
+              "-> Table scan on users  (actual time=0.05..0.10 rows=100 loops=1)",
+          },
+        ]),
+      );
+
+      const tool = createExplainAnalyzeTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = await tool.handler(
+        { sql: "SELECT * FROM users" },
+        mockContext,
+      );
+
+      expect(mockAdapter.executeReadQuery).toHaveBeenCalledWith(
+        "EXPLAIN ANALYZE FORMAT=TREE SELECT * FROM users",
+      );
+      expect(result).toHaveProperty("analysis");
+    });
   });
 
   describe("createSlowQueriesTool", () => {
@@ -284,6 +308,112 @@ describe("Performance Analysis Tools", () => {
       // Code: AVG_TIMER_WAIT > ${minTime * 1000000000}
       expect(call).toContain("AVG_TIMER_WAIT > 500000000");
     });
+
+    it("should clamp overflowed timer values to -1 with overflow flag", async () => {
+      mockAdapter.executeReadQuery.mockResolvedValue(
+        createMockQueryResult([
+          {
+            query: "DROP TABLE IF EXISTS `t`",
+            executions: 3,
+            avg_time_ms: 18446743555252.1,
+            total_time_ms: 55340230665756.3,
+            rows_examined: 0,
+            rows_sent: 0,
+          },
+        ]),
+      );
+
+      const tool = createSlowQueriesTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = (await tool.handler({ limit: 10 }, mockContext)) as {
+        slowQueries: Record<string, unknown>[];
+      };
+
+      expect(result.slowQueries[0]["avg_time_ms"]).toBe(-1);
+      expect(result.slowQueries[0]["total_time_ms"]).toBe(-1);
+      expect(result.slowQueries[0]["overflow"]).toBe(true);
+    });
+
+    it("should clamp string-typed overflowed values (MySQL DECIMAL)", async () => {
+      mockAdapter.executeReadQuery.mockResolvedValue(
+        createMockQueryResult([
+          {
+            query: "DROP TABLE IF EXISTS `t`",
+            executions: 2,
+            avg_time_ms: "18446743555.2521",
+            total_time_ms: "18446743036.7947",
+            rows_examined: 0,
+            rows_sent: 0,
+          },
+        ]),
+      );
+
+      const tool = createSlowQueriesTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = (await tool.handler({ limit: 10 }, mockContext)) as {
+        slowQueries: Record<string, unknown>[];
+      };
+
+      expect(result.slowQueries[0]["avg_time_ms"]).toBe(-1);
+      expect(result.slowQueries[0]["total_time_ms"]).toBe(-1);
+      expect(result.slowQueries[0]["overflow"]).toBe(true);
+    });
+
+    it("should not add overflow flag for normal timer values", async () => {
+      mockAdapter.executeReadQuery.mockResolvedValue(
+        createMockQueryResult([
+          {
+            query: "SELECT 1",
+            executions: 10,
+            avg_time_ms: 500,
+            total_time_ms: 5000,
+            rows_examined: 0,
+            rows_sent: 10,
+          },
+        ]),
+      );
+
+      const tool = createSlowQueriesTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = (await tool.handler({ limit: 10 }, mockContext)) as {
+        slowQueries: Record<string, unknown>[];
+      };
+
+      expect(result.slowQueries[0]["avg_time_ms"]).toBe(500);
+      expect(result.slowQueries[0]["total_time_ms"]).toBe(5000);
+      expect(result.slowQueries[0]["overflow"]).toBeUndefined();
+    });
+
+    it("should convert string-typed timer values to numbers", async () => {
+      mockAdapter.executeReadQuery.mockResolvedValue(
+        createMockQueryResult([
+          {
+            query: "SELECT * FROM users",
+            executions: 5,
+            avg_time_ms: "209241.7573",
+            total_time_ms: "1046208.7865",
+            rows_examined: 100,
+            rows_sent: 10,
+          },
+        ]),
+      );
+
+      const tool = createSlowQueriesTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = (await tool.handler({ limit: 10 }, mockContext)) as {
+        slowQueries: Record<string, unknown>[];
+      };
+
+      expect(result.slowQueries[0]["avg_time_ms"]).toBe(209241.7573);
+      expect(typeof result.slowQueries[0]["avg_time_ms"]).toBe("number");
+      expect(result.slowQueries[0]["total_time_ms"]).toBe(1046208.7865);
+      expect(typeof result.slowQueries[0]["total_time_ms"]).toBe("number");
+      expect(result.slowQueries[0]["overflow"]).toBeUndefined();
+    });
   });
 
   describe("createQueryStatsTool", () => {
@@ -323,6 +453,96 @@ describe("Performance Analysis Tools", () => {
       const call = mockAdapter.executeReadQuery.mock.calls[0][0] as string;
       expect(call).toContain("ORDER BY AVG_TIMER_WAIT DESC");
     });
+
+    it("should clamp overflowed timer values to -1 with overflow flag", async () => {
+      mockAdapter.executeReadQuery.mockResolvedValue(
+        createMockQueryResult([
+          {
+            database_name: "testdb",
+            query_text: "DROP TABLE IF EXISTS `t`",
+            execution_count: 3,
+            avg_time_ms: 18446743555252.1,
+            max_time_ms: 99999999999,
+            total_time_ms: 55340230665756.3,
+            total_rows_examined: 0,
+            total_rows_sent: 0,
+            first_seen: "2026-01-01",
+            last_seen: "2026-02-16",
+          },
+        ]),
+      );
+
+      const tool = createQueryStatsTool(mockAdapter as unknown as MySQLAdapter);
+      const result = (await tool.handler({}, mockContext)) as {
+        queries: Record<string, unknown>[];
+      };
+
+      expect(result.queries[0]["avg_time_ms"]).toBe(-1);
+      expect(result.queries[0]["max_time_ms"]).toBe(-1);
+      expect(result.queries[0]["total_time_ms"]).toBe(-1);
+      expect(result.queries[0]["overflow"]).toBe(true);
+    });
+
+    it("should not add overflow flag for normal timer values", async () => {
+      mockAdapter.executeReadQuery.mockResolvedValue(
+        createMockQueryResult([
+          {
+            database_name: "testdb",
+            query_text: "SELECT 1",
+            execution_count: 10,
+            avg_time_ms: 250,
+            max_time_ms: 800,
+            total_time_ms: 2500,
+            total_rows_examined: 0,
+            total_rows_sent: 10,
+            first_seen: "2026-01-01",
+            last_seen: "2026-02-16",
+          },
+        ]),
+      );
+
+      const tool = createQueryStatsTool(mockAdapter as unknown as MySQLAdapter);
+      const result = (await tool.handler({}, mockContext)) as {
+        queries: Record<string, unknown>[];
+      };
+
+      expect(result.queries[0]["avg_time_ms"]).toBe(250);
+      expect(result.queries[0]["max_time_ms"]).toBe(800);
+      expect(result.queries[0]["total_time_ms"]).toBe(2500);
+      expect(result.queries[0]["overflow"]).toBeUndefined();
+    });
+
+    it("should convert string-typed timer values to numbers", async () => {
+      mockAdapter.executeReadQuery.mockResolvedValue(
+        createMockQueryResult([
+          {
+            database_name: "testdb",
+            query_text: "SELECT * FROM users",
+            execution_count: 5,
+            avg_time_ms: "209241.7573",
+            max_time_ms: "412000.5000",
+            total_time_ms: "1046208.7865",
+            total_rows_examined: 100,
+            total_rows_sent: 10,
+            first_seen: "2026-01-01",
+            last_seen: "2026-02-16",
+          },
+        ]),
+      );
+
+      const tool = createQueryStatsTool(mockAdapter as unknown as MySQLAdapter);
+      const result = (await tool.handler({}, mockContext)) as {
+        queries: Record<string, unknown>[];
+      };
+
+      expect(result.queries[0]["avg_time_ms"]).toBe(209241.7573);
+      expect(typeof result.queries[0]["avg_time_ms"]).toBe("number");
+      expect(result.queries[0]["max_time_ms"]).toBe(412000.5);
+      expect(typeof result.queries[0]["max_time_ms"]).toBe("number");
+      expect(result.queries[0]["total_time_ms"]).toBe(1046208.7865);
+      expect(typeof result.queries[0]["total_time_ms"]).toBe("number");
+      expect(result.queries[0]["overflow"]).toBeUndefined();
+    });
   });
 
   describe("createIndexUsageTool", () => {
@@ -455,9 +675,12 @@ describe("Performance Analysis Tools", () => {
       );
       const result = await tool.handler({}, mockContext);
 
-      expect(mockAdapter.executeReadQuery).toHaveBeenCalledWith(
-        "SELECT * FROM information_schema.INNODB_BUFFER_POOL_STATS",
-      );
+      expect(mockAdapter.executeReadQuery).toHaveBeenCalled();
+      const call = mockAdapter.executeReadQuery.mock.calls[0][0] as string;
+      expect(call).toContain("INNODB_BUFFER_POOL_STATS");
+      expect(call).toContain("POOL_SIZE");
+      expect(call).toContain("HIT_RATE");
+      expect(call).not.toContain("SELECT *");
       expect(result).toHaveProperty("bufferPoolStats");
     });
   });

package/src/adapters/mysql/tools/performance/__tests__/optimization.test.ts

@@ -222,6 +222,21 @@ describe("Performance Optimization Tools", () => {
         "Table 'testdb.nonexistent' doesn't exist",
       );
     });
+
+    it("should accept sql alias for query parameter", async () => {
+      const tool = createQueryRewriteTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = (await tool.handler(
+        { sql: "SELECT * FROM users" },
+        mockContext,
+      )) as { originalQuery: string; suggestions: string[] };
+
+      expect(result.originalQuery).toBe("SELECT * FROM users");
+      expect(result.suggestions).toContain(
+        "Consider selecting only needed columns instead of SELECT *",
+      );
+    });
   });
 
   describe("createForceIndexTool", () => {
@@ -419,5 +434,25 @@ describe("Performance Optimization Tools", () => {
         'SET optimizer_trace="enabled=off"',
       );
     });
+
+    it("should accept sql alias for query parameter", async () => {
+      mockAdapter.executeReadQuery
+        .mockResolvedValueOnce(createMockQueryResult([])) // The query
+        .mockResolvedValueOnce(createMockQueryResult([{ TRACE: "{}" }])); // The trace
+
+      const tool = createOptimizerTraceTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = await tool.handler(
+        { sql: "SELECT * FROM users" },
+        mockContext,
+      );
+
+      expect(mockAdapter.executeReadQuery).toHaveBeenNthCalledWith(
+        1,
+        "SELECT * FROM users",
+      );
+      expect(result).toHaveProperty("trace");
+    });
   });
 });

package/src/adapters/mysql/tools/performance/analysis.ts

@@ -12,19 +12,65 @@ import type {
 } from "../../../../types/index.js";
 import {
   ExplainSchema,
+  ExplainSchemaBase,
+  ExplainAnalyzeSchema,
+  ExplainAnalyzeSchemaBase,
   SlowQuerySchema,
   IndexUsageSchema,
+  IndexUsageSchemaBase,
   TableStatsSchema,
+  TableStatsSchemaBase,
 } from "../../types.js";
 import { z } from "zod";
 
+/**
+ * Maximum reasonable timer value in milliseconds (24 hours).
+ * Values exceeding this threshold are timer overflow artifacts from
+ * performance_schema's unsigned 64-bit picosecond counters wrapping.
+ */
+const MAX_TIMER_MS = 86_400_000;
+
+/**
+ * Sanitize timer fields in query result rows.
+ * Overflowed values (> 24 hours) are clamped to -1 with an `overflow: true` flag.
+ */
+function sanitizeTimerRows(
+  rows: Record<string, unknown>[] | undefined,
+  timerFields: string[],
+): Record<string, unknown>[] {
+  if (!rows) return [];
+  return rows.map((row) => {
+    let hasOverflow = false;
+    const sanitized = { ...row };
+    for (const field of timerFields) {
+      const value = sanitized[field];
+      const numValue =
+        typeof value === "number"
+          ? value
+          : typeof value === "string"
+            ? parseFloat(value)
+            : NaN;
+      if (!isNaN(numValue) && numValue > MAX_TIMER_MS) {
+        sanitized[field] = -1;
+        hasOverflow = true;
+      } else if (!isNaN(numValue)) {
+        sanitized[field] = numValue;
+      }
+    }
+    if (hasOverflow) {
+      sanitized["overflow"] = true;
+    }
+    return sanitized;
+  });
+}
+
 export function createExplainTool(adapter: MySQLAdapter): ToolDefinition {
   return {
     name: "mysql_explain",
     title: "MySQL EXPLAIN",
     description: "Get query execution plan using EXPLAIN.",
     group: "performance",
-    inputSchema: ExplainSchema,
+    inputSchema: ExplainSchemaBase,
     requiredScopes: ["read"],
     annotations: {
       readOnlyHint: true,
@@ -33,12 +79,7 @@ export function createExplainTool(adapter: MySQLAdapter): ToolDefinition {
     handler: async (params: unknown, _context: RequestContext) => {
       const { query, format } = ExplainSchema.parse(params);
 
-      const sql =
-        format === "JSON"
-          ? `EXPLAIN FORMAT=JSON ${query}`
-          : format === "TREE"
-            ? `EXPLAIN FORMAT=TREE ${query}`
-            : `EXPLAIN ${query}`;
+      const sql = `EXPLAIN FORMAT=${format} ${query}`;
 
       try {
         const result = await adapter.executeReadQuery(sql);
@@ -66,24 +107,19 @@ export function createExplainTool(adapter: MySQLAdapter): ToolDefinition {
 export function createExplainAnalyzeTool(
   adapter: MySQLAdapter,
 ): ToolDefinition {
-  const schema = z.object({
-    query: z.string().describe("SQL query to analyze"),
-    format: z.enum(["JSON", "TREE"]).optional().default("TREE"),
-  });
-
   return {
     name: "mysql_explain_analyze",
     title: "MySQL EXPLAIN ANALYZE",
     description:
       "Get query execution plan with actual timing using EXPLAIN ANALYZE (MySQL 8.0+). Only TREE format is supported.",
     group: "performance",
-    inputSchema: schema,
+    inputSchema: ExplainAnalyzeSchemaBase,
     requiredScopes: ["read"],
     annotations: {
       readOnlyHint: true,
     },
     handler: async (params: unknown, _context: RequestContext) => {
-      const { query, format } = schema.parse(params);
+      const { query, format } = ExplainAnalyzeSchema.parse(params);
 
       // MySQL does not support EXPLAIN ANALYZE with FORMAT=JSON
       // (requires explain_json_format_version=2 which is not widely available).
@@ -145,7 +181,12 @@ export function createSlowQueriesTool(adapter: MySQLAdapter): ToolDefinition {
       sql += ` ORDER BY AVG_TIMER_WAIT DESC LIMIT ${limit}`;
 
       const result = await adapter.executeReadQuery(sql);
-      return { slowQueries: result.rows };
+      return {
+        slowQueries: sanitizeTimerRows(result.rows, [
+          "avg_time_ms",
+          "total_time_ms",
+        ]),
+      };
     },
   };
 }
@@ -198,7 +239,13 @@ export function createQueryStatsTool(adapter: MySQLAdapter): ToolDefinition {
             `;
 
       const result = await adapter.executeReadQuery(sql);
-      return { queries: result.rows };
+      return {
+        queries: sanitizeTimerRows(result.rows, [
+          "avg_time_ms",
+          "max_time_ms",
+          "total_time_ms",
+        ]),
+      };
     },
   };
 }
@@ -209,7 +256,7 @@ export function createIndexUsageTool(adapter: MySQLAdapter): ToolDefinition {
     title: "MySQL Index Usage",
     description: "Get index usage statistics from performance_schema.",
     group: "performance",
-    inputSchema: IndexUsageSchema,
+    inputSchema: IndexUsageSchemaBase,
     requiredScopes: ["read"],
     annotations: {
       readOnlyHint: true,
@@ -266,7 +313,7 @@ export function createTableStatsTool(adapter: MySQLAdapter): ToolDefinition {
     description:
       "Get detailed table statistics including size, rows, and engine info.",
     group: "performance",
-    inputSchema: TableStatsSchema,
+    inputSchema: TableStatsSchemaBase,
     requiredScopes: ["read"],
     annotations: {
       readOnlyHint: true,
@@ -322,10 +369,17 @@ export function createBufferPoolStatsTool(
       idempotentHint: true,
     },
     handler: async (_params: unknown, _context: RequestContext) => {
-      // Use SELECT * for compatibility across MySQL versions
-      // Different MySQL versions have different column sets
       const result = await adapter.executeReadQuery(
-        `SELECT * FROM information_schema.INNODB_BUFFER_POOL_STATS`,
+        `SELECT POOL_ID, POOL_SIZE, FREE_BUFFERS, DATABASE_PAGES,
+                OLD_DATABASE_PAGES, MODIFIED_DATABASE_PAGES, PENDING_DECOMPRESS,
+                PENDING_READS, PENDING_FLUSH_LRU, PENDING_FLUSH_LIST,
+                PAGES_MADE_YOUNG, PAGES_NOT_MADE_YOUNG,
+                PAGES_MADE_YOUNG_RATE, PAGES_MADE_NOT_YOUNG_RATE,
+                NUMBER_PAGES_READ, NUMBER_PAGES_CREATED, NUMBER_PAGES_WRITTEN,
+                PAGES_READ_RATE, PAGES_CREATE_RATE, PAGES_WRITTEN_RATE,
+                HIT_RATE, YOUNG_MAKE_PER_THOUSAND_GETS,
+                NOT_YOUNG_MAKE_PER_THOUSAND_GETS
+         FROM information_schema.INNODB_BUFFER_POOL_STATS`,
       );
 
       return { bufferPoolStats: result.rows };

package/src/adapters/mysql/tools/performance/optimization.ts

@@ -11,6 +11,7 @@ import type {
   RequestContext,
 } from "../../../../types/index.js";
 import { z } from "zod";
+import { preprocessQueryOnlyParams } from "../../types.js";
 
 /** Trace summary decision type */
 interface TraceSummaryDecision {
@@ -230,16 +231,35 @@ export function createIndexRecommendationTool(
 }
 
 export function createQueryRewriteTool(adapter: MySQLAdapter): ToolDefinition {
-  const schema = z.object({
-    query: z.string().describe("SQL query to analyze for optimization"),
+  const schemaBase = z.object({
+    query: z
+      .string()
+      .optional()
+      .describe("SQL query to analyze for optimization"),
+    sql: z.string().optional().describe("Alias for query"),
   });
 
+  const schema = z
+    .preprocess(
+      preprocessQueryOnlyParams,
+      z.object({
+        query: z.string().optional(),
+        sql: z.string().optional(),
+      }),
+    )
+    .transform((data) => ({
+      query: data.query ?? data.sql ?? "",
+    }))
+    .refine((data) => data.query !== "", {
+      message: "query (or sql alias) is required",
+    });
+
   return {
     name: "mysql_query_rewrite",
     title: "MySQL Query Rewrite",
     description: "Analyze a query and suggest optimizations.",
     group: "optimization",
-    inputSchema: schema,
+    inputSchema: schemaBase,
     requiredScopes: ["read"],
     annotations: {
       readOnlyHint: true,
@@ -376,8 +396,9 @@ export function createForceIndexTool(adapter: MySQLAdapter): ToolDefinition {
 export function createOptimizerTraceTool(
   adapter: MySQLAdapter,
 ): ToolDefinition {
-  const schema = z.object({
-    query: z.string().describe("Query to trace"),
+  const schemaBase = z.object({
+    query: z.string().optional().describe("Query to trace"),
+    sql: z.string().optional().describe("Alias for query"),
     summary: z
       .boolean()
       .optional()
@@ -386,12 +407,29 @@ export function createOptimizerTraceTool(
       ),
   });
 
+  const schema = z
+    .preprocess(
+      preprocessQueryOnlyParams,
+      z.object({
+        query: z.string().optional(),
+        sql: z.string().optional(),
+        summary: z.boolean().optional(),
+      }),
+    )
+    .transform((data) => ({
+      query: data.query ?? data.sql ?? "",
+      summary: data.summary,
+    }))
+    .refine((data) => data.query !== "", {
+      message: "query (or sql alias) is required",
+    });
+
   return {
     name: "mysql_optimizer_trace",
     title: "MySQL Optimizer Trace",
     description: "Get detailed optimizer trace for a query.",
     group: "optimization",
-    inputSchema: schema,
+    inputSchema: schemaBase,
     requiredScopes: ["read"],
     annotations: {
       readOnlyHint: true,

package/src/adapters/mysql/tools/security/data-protection.ts

@@ -124,13 +124,13 @@ export function createSecurityMaskDataTool(
         case "credit_card": {
           // Show first 4 and last 4
           const ccDigits = value.replace(/\D/g, "");
-          if (ccDigits.length < 8) {
+          if (ccDigits.length <= 8) {
             return Promise.resolve({
               original: value,
               masked: maskChar.repeat(value.length),
               type,
               warning:
-                "Value too short for credit_card format (expected at least 8 digits); fully masked instead",
+                "Value too short for credit_card format (expected more than 8 digits); fully masked instead",
             });
           }
           maskedValue =
@@ -140,9 +140,15 @@ export function createSecurityMaskDataTool(
           break;
         }
         case "partial": {
-          // When keepFirst + keepLast covers the entire value, return unchanged
+          // When keepFirst + keepLast covers the entire value, return unchanged with warning
           if (keepFirst + keepLast >= value.length) {
-            maskedValue = value;
+            return Promise.resolve({
+              original: value,
+              masked: value,
+              type,
+              warning:
+                "Masking ineffective: keepFirst + keepLast covers entire value length; returned unchanged",
+            });
           } else {
             const maskLength = value.length - keepFirst - keepLast;
             maskedValue =

package/src/adapters/mysql/tools/shell/__tests__/common.test.ts

@@ -184,4 +184,50 @@ describe("execShellJS", () => {
 
     await expect(promise).rejects.toThrow("Fatal Error");
   });
+
+  it("should extract specific ERROR lines from Fatal error during dump stderr", async () => {
+    const promise = execShellJS("bad");
+
+    mockChild.stderr.emit(
+      "data",
+      Buffer.from(
+        "ERROR: Unknown column 'invalid_col' in 'where clause'\nWhile 'Dumping data': Fatal error during dump",
+      ),
+    );
+    mockChild.emit("close", 1);
+
+    await expect(promise).rejects.toThrow(
+      "Unknown column 'invalid_col' in 'where clause'",
+    );
+  });
+
+  it("should fall back to generic message when Fatal error during dump has no ERROR lines", async () => {
+    const promise = execShellJS("bad");
+
+    mockChild.stderr.emit("data", Buffer.from("Fatal error during dump"));
+    mockChild.emit("close", 1);
+
+    await expect(promise).rejects.toThrow(
+      "MySQL Shell dump failed: Fatal error during dump",
+    );
+  });
+
+  it("should extract specific ERROR lines from stderr when JSON reports Fatal error during dump", async () => {
+    const promise = execShellJS("bad");
+
+    const jsonOutput = JSON.stringify({
+      success: false,
+      error: "While 'Dumping data': Fatal error during dump",
+    });
+    mockChild.stderr.emit(
+      "data",
+      Buffer.from("ERROR: Unknown column 'bad_col' in 'where clause'"),
+    );
+    mockChild.stdout.emit("data", Buffer.from(jsonOutput));
+    mockChild.emit("close", 0);
+
+    await expect(promise).rejects.toThrow(
+      "Unknown column 'bad_col' in 'where clause'",
+    );
+  });
 });