Exclude trigger rows from SQL Server update and delete counts

The affected count from updateRows() and deleteFrom() was the sum of the
row counts reported by the batch, which with SQL Server includes rows
changed by triggers. The count is now selected from @@rowcount in the
same batch, like for inserts, which only includes the rows changed by
the statement itself (even with an INSTEAD OF trigger). MySQL and
PostgreSQL row counts already exclude rows changed by triggers.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: theodorejb

CHANGELOG.md

@@ -16,8 +16,8 @@
 - With SQL Server, `insertRow()` and `insertRows()` returned the wrong ID when an insert trigger
   inserted into another table with an identity column. The IDs now come from `SCOPE_IDENTITY()`
   rather than `@@IDENTITY` (like before v7.0).
-- With SQL Server, the affected count from `insertRow()` and `insertRows()` no longer includes
-  rows inserted by triggers.
+- With SQL Server, the affected count from `insertRow()`, `insertRows()`, `updateRows()`, and
+  `deleteFrom()` no longer includes rows changed by triggers.
 - An error while fetching a row (e.g. a conversion error in a SQL Server result that's sent as it's
   computed) threw a `PDOException` rather than a `SqlException`. Without the exception error mode,
   the error was ignored and the results ended early.

src/PeachySql.php

@@ -297,7 +297,7 @@ private function runInBatches(array $where, Closure $buildQuery, array $setColum
         $maxParams = $this->options->maxBoundParams;
 
         if ($maxParams <= 0 || $paramCount <= $maxParams) {
-            return $this->query($sqlParams->sql, $sqlParams->params)->getAffected();
+            return $this->runAffectingRows($sqlParams);
         }
 
         $batches = Query::batchWhere($where, $paramCount, $maxParams, $setColumns);
@@ -306,14 +306,28 @@ private function runInBatches(array $where, Closure $buildQuery, array $setColum
             $affected = 0;
 
             foreach ($batches as $batchWhere) {
-                $batchParams = $buildQuery($batchWhere);
-                $affected += $this->query($batchParams->sql, $batchParams->params)->getAffected();
+                $affected += $this->runAffectingRows($buildQuery($batchWhere));
             }
 
             return $affected;
         });
     }
 
+    /**
+     * Runs an update or delete query, and returns the number of affected rows. With SQL Server, the count is
+     * selected from @@ROWCOUNT, since the query's row count would otherwise include rows changed by triggers.
+     */
+    private function runAffectingRows(SqlParams $sqlParams): int
+    {
+        if ($this->options->driver === 'sqlsrv') {
+            /** @var array{affected: int|string} $row */
+            $row = $this->query($sqlParams->sql . '; SELECT @@ROWCOUNT AS affected', $sqlParams->params)->getFirst();
+            return (int) $row['affected'];
+        }
+
+        return $this->query($sqlParams->sql, $sqlParams->params)->getAffected();
+    }
+
     /**
      * Runs the function in a transaction (unless one has already been started), so that if it runs multiple
      * queries, a failure doesn't leave the changes from some of them committed.

tests/MssqlDbTest.php

@@ -99,6 +99,43 @@ public function testExplicitIdentityValues(): void
         }
     }
 
+    /**
+     * The affected count from updateRows() and deleteFrom() shouldn't include rows changed by triggers.
+     */
+    public function testAffectedCountWithTrigger(): void
+    {
+        $db = static::dbProvider();
+        $db->query('DROP TABLE IF EXISTS AffectedTest');
+        $db->query('DROP TABLE IF EXISTS AffectedAudit');
+        $db->query('CREATE TABLE AffectedAudit (id INT IDENTITY PRIMARY KEY, note INT NOT NULL)');
+        $db->query('CREATE TABLE AffectedTest (id INT PRIMARY KEY, name NVARCHAR(50) NOT NULL)');
+        $db->query('CREATE TRIGGER AffectedTestAudit ON AffectedTest AFTER UPDATE, DELETE AS
+            INSERT INTO AffectedAudit (note) SELECT id FROM deleted;
+            INSERT INTO AffectedAudit (note) SELECT id FROM deleted');
+
+        $options = $db->options;
+        $maxBoundParams = $options->maxBoundParams;
+        $ids = [1, 2, 3];
+
+        try {
+            // with a max of 3 bound parameters, the updates and deletes are split into multiple queries
+            foreach ([$maxBoundParams, 3] as $maxParams) {
+                $options->maxBoundParams = $maxParams;
+                $db->insertRows('AffectedTest', array_map(fn($id) => ['id' => $id, 'name' => 'a'], $ids));
+
+                $this->assertSame(3, $db->updateRows('AffectedTest', ['name' => 'b'], ['id' => $ids]));
+                $this->assertSame(2, $db->updateRows('AffectedTest', ['name' => 'c'], ['id' => ['eq' => $ids, 'ne' => 1]]));
+                $this->assertSame(3, $db->deleteFrom('AffectedTest', ['id' => $ids]));
+            }
+        } finally {
+            $options->maxBoundParams = $maxBoundParams;
+        }
+
+        // the trigger added 2 audit rows for each updated or deleted row
+        $audit = $db->query('SELECT COUNT(*) AS audit_count FROM AffectedAudit')->getFirst();
+        $this->assertSame(['audit_count' => 2 * (3 + 2 + 3) * 2], $audit);
+    }
+
     public function testFetchErrorThrowsSqlException(): void
     {
         // without ORDER BY, rows are sent as they're computed, so the error on the last row occurs while fetching