feat: return affected row count for INSERT/UPDATE/DELETE

- Add rowCount to all database connectors (PostgreSQL, MySQL, MariaDB, SQLite, SQL Server)
- Add extractAffectedRows utility for MySQL/MariaDB result parsing
- Update execute-sql and custom-tool-handler to use rowCount for count field
- Frontend now displays "N rows affected" for write operations instead of "No results returned"

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: tianzhou

frontend/src/api/tools.ts

@@ -75,7 +75,8 @@ export async function executeTool(
 
   const rows = toolResult.data.rows;
   if (rows.length === 0) {
-    return { columns: [], rows: [], rowCount: 0 };
+    // For INSERT/UPDATE/DELETE, rows is empty but count reflects affected rows
+    return { columns: [], rows: [], rowCount: toolResult.data.count };
   }
 
   const columns = Object.keys(rows[0]);

frontend/src/components/tool/ResultsTable.tsx

@@ -108,11 +108,15 @@ export function ResultsTable({ result, error, isLoading, executedSql, executionT
     );
   }
 
-  // No results
+  // No rows returned - could be empty SELECT or successful INSERT/UPDATE/DELETE
   if (result.rows.length === 0) {
     return (
       <div className="border border-border rounded-lg bg-card p-8 text-center">
-        <p className="text-muted-foreground text-sm">No results returned</p>
+        <p className="text-muted-foreground text-sm">
+          {result.rowCount > 0
+            ? `${result.rowCount} row${result.rowCount !== 1 ? 's' : ''} affected`
+            : 'No results returned'}
+        </p>
       </div>
     );
   }

src/connectors/mariadb/index.ts

@@ -14,7 +14,7 @@ import {
 import { SafeURL } from "../../utils/safe-url.js";
 import { obfuscateDSNPassword } from "../../utils/dsn-obfuscate.js";
 import { SQLRowLimiter } from "../../utils/sql-row-limiter.js";
-import { parseQueryResults } from "../../utils/multi-statement-result-parser.js";
+import { parseQueryResults, extractAffectedRows } from "../../utils/multi-statement-result-parser.js";
 
 /**
  * MariaDB DSN Parser
@@ -542,7 +542,8 @@ export class MariaDBConnector implements Connector {
 
       // Parse results using shared utility that handles both single and multi-statement queries
       const rows = parseQueryResults(results);
-      return { rows };
+      const rowCount = extractAffectedRows(results);
+      return { rows, rowCount };
     } catch (error) {
       console.error("Error executing query:", error);
       throw error;

src/connectors/mysql/index.ts

@@ -14,7 +14,7 @@ import {
 import { SafeURL } from "../../utils/safe-url.js";
 import { obfuscateDSNPassword } from "../../utils/dsn-obfuscate.js";
 import { SQLRowLimiter } from "../../utils/sql-row-limiter.js";
-import { parseQueryResults } from "../../utils/multi-statement-result-parser.js";
+import { parseQueryResults, extractAffectedRows } from "../../utils/multi-statement-result-parser.js";
 
 /**
  * MySQL DSN Parser
@@ -553,7 +553,8 @@ export class MySQLConnector implements Connector {
 
       // Parse results using shared utility that handles both single and multi-statement queries
       const rows = parseQueryResults(firstResult);
-      return { rows };
+      const rowCount = extractAffectedRows(firstResult);
+      return { rows, rowCount };
     } catch (error) {
       console.error("Error executing query:", error);
       throw error;

src/connectors/postgres/index.ts

@@ -444,17 +444,21 @@ export class PostgresConnector implements Connector {
         const processedStatement = SQLRowLimiter.applyMaxRows(statements[0], options.maxRows);
 
         // Use parameters if provided
+        let result;
         if (parameters && parameters.length > 0) {
           try {
-            return await client.query(processedStatement, parameters);
+            result = await client.query(processedStatement, parameters);
           } catch (error) {
             console.error(`[PostgreSQL executeSQL] ERROR: ${(error as Error).message}`);
             console.error(`[PostgreSQL executeSQL] SQL: ${processedStatement}`);
             console.error(`[PostgreSQL executeSQL] Parameters: ${JSON.stringify(parameters)}`);
             throw error;
           }
+        } else {
+          result = await client.query(processedStatement);
         }
-        return await client.query(processedStatement);
+        // Explicitly return rows and rowCount to ensure rowCount is preserved
+        return { rows: result.rows, rowCount: result.rowCount ?? result.rows.length };
       } else {
         // Multiple statements - parameters not supported for multi-statement queries
         if (parameters && parameters.length > 0) {
@@ -463,6 +467,7 @@ export class PostgresConnector implements Connector {
 
         // Execute all in same session for transaction consistency
         let allRows: any[] = [];
+        let totalRowCount = 0;
 
         // Execute within a transaction to ensure session consistency
         await client.query('BEGIN');
@@ -476,14 +481,18 @@ export class PostgresConnector implements Connector {
             if (result.rows && result.rows.length > 0) {
               allRows.push(...result.rows);
             }
+            // Accumulate rowCount for INSERT/UPDATE/DELETE statements
+            if (result.rowCount) {
+              totalRowCount += result.rowCount;
+            }
           }
           await client.query('COMMIT');
         } catch (error) {
           await client.query('ROLLBACK');
           throw error;
         }
 
-        return { rows: allRows };
+        return { rows: allRows, rowCount: totalRowCount };
       }
     } finally {
       client.release();

src/connectors/sqlite/index.ts

@@ -413,7 +413,7 @@ export class SQLiteConnector implements Connector {
           if (parameters && parameters.length > 0) {
             try {
               const rows = this.db.prepare(processedStatement).all(...parameters);
-              return { rows };
+              return { rows, rowCount: rows.length };
             } catch (error) {
               console.error(`[SQLite executeSQL] ERROR: ${(error as Error).message}`);
               console.error(`[SQLite executeSQL] SQL: ${processedStatement}`);
@@ -422,23 +422,24 @@ export class SQLiteConnector implements Connector {
             }
           } else {
             const rows = this.db.prepare(processedStatement).all();
-            return { rows };
+            return { rows, rowCount: rows.length };
           }
         } else {
           // Use run() for statements that don't return data
+          let result;
           if (parameters && parameters.length > 0) {
             try {
-              this.db.prepare(processedStatement).run(...parameters);
+              result = this.db.prepare(processedStatement).run(...parameters);
             } catch (error) {
               console.error(`[SQLite executeSQL] ERROR: ${(error as Error).message}`);
               console.error(`[SQLite executeSQL] SQL: ${processedStatement}`);
               console.error(`[SQLite executeSQL] Parameters: ${JSON.stringify(parameters)}`);
               throw error;
             }
           } else {
-            this.db.prepare(processedStatement).run();
+            result = this.db.prepare(processedStatement).run();
           }
-          return { rows: [] };
+          return { rows: [], rowCount: result.changes };
         }
       } else {
         // Multiple statements - parameters not supported for multi-statement queries
@@ -469,9 +470,11 @@ export class SQLiteConnector implements Connector {
           }
         }
 
-        // Execute write statements using native .exec() for optimal performance
-        if (writeStatements.length > 0) {
-          this.db.exec(writeStatements.join('; '));
+        // Execute write statements individually to track changes
+        let totalChanges = 0;
+        for (const statement of writeStatements) {
+          const result = this.db.prepare(statement).run();
+          totalChanges += result.changes;
         }
 
         // Execute read statements individually to collect results
@@ -483,7 +486,8 @@ export class SQLiteConnector implements Connector {
           allRows.push(...result);
         }
 
-        return { rows: allRows };
+        // rowCount is total changes for writes, plus rows returned for reads
+        return { rows: allRows, rowCount: totalChanges + allRows.length };
       }
     } catch (error) {
       throw error;

src/tools/custom-tool-handler.ts

@@ -197,9 +197,10 @@ export function createCustomToolHandler(toolConfig: ToolConfig) {
       );
 
       // 7. Build response data
+      // Use rowCount if available (for INSERT/UPDATE/DELETE), otherwise use rows.length
       const responseData = {
         rows: result.rows,
-        count: result.rows.length,
+        count: result.rowCount ?? result.rows.length,
         source_id: toolConfig.source,
       };
 

src/tools/execute-sql.ts

@@ -76,9 +76,10 @@ export function createExecuteSqlToolHandler(sourceId?: string) {
       result = await connector.executeSQL(sql, executeOptions);
 
       // Build response data
+      // Use rowCount if available (for INSERT/UPDATE/DELETE), otherwise use rows.length
       const responseData = {
         rows: result.rows,
-        count: result.rows.length,
+        count: result.rowCount ?? result.rows.length,
         source_id: effectiveSourceId,
       };
 

src/utils/multi-statement-result-parser.ts

@@ -68,6 +68,43 @@ export function extractRowsFromMultiStatement(results: any): any[] {
   return allRows;
 }
 
+/**
+ * Extracts total affected rows from query results.
+ *
+ * For INSERT/UPDATE/DELETE operations, returns the sum of affectedRows.
+ * For SELECT operations, returns the number of rows.
+ *
+ * @param results - Raw results from the database driver
+ * @returns Total number of affected/returned rows
+ */
+export function extractAffectedRows(results: any): number {
+  // Handle metadata object (single INSERT/UPDATE/DELETE)
+  if (isMetadataObject(results)) {
+    return results.affectedRows || 0;
+  }
+
+  // Handle non-array results
+  if (!Array.isArray(results)) {
+    return 0;
+  }
+
+  // Check if this is a multi-statement result
+  if (isMultiStatementResult(results)) {
+    let totalAffected = 0;
+    for (const result of results) {
+      if (isMetadataObject(result)) {
+        totalAffected += result.affectedRows || 0;
+      } else if (Array.isArray(result)) {
+        totalAffected += result.length;
+      }
+    }
+    return totalAffected;
+  }
+
+  // Single statement result - results is the rows array directly
+  return results.length;
+}
+
 /**
  * Parses database query results, handling both single and multi-statement queries.
  *