fix(mariadb): surface the error of a later statement in a multi-statement string

MySQL and MariaDB run each statement of a ';'-joined string, but
execute() reports only the first one's error; a later statement's error
waits in its result. The adapter joins statements this way for a
relationship's columns and a collection's permissions table, so a
two-column relationship rename whose second ALTER failed reported
success and stored the new keys over a column that was never renamed.
executeStatement() now reaches every result, so such a failure fails the
call. PostgreSQL already failed the call, and SQLite runs its statements
one by one.

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

Author: abnegate

src/Database/Adapter/MariaDB.php

@@ -1055,6 +1055,23 @@ protected function decodePolygon(string $wkb): array
      */
     private int $appliedRound = 0;
 
+    /**
+     * MySQL and MariaDB run every statement of a multi-statement string, but report only the first one's error from
+     * execute(); a later statement's error surfaces when its result is reached. Each result is reached here, so a
+     * statement that fails after another succeeded fails the call instead of being lost.
+     */
+    #[\Override]
+    protected function executeStatement(string $sql, Event $event): bool
+    {
+        $statement = $this->prepareStatement($sql, $event);
+        $executed = $this->execute($statement);
+
+        while ($statement->nextRowset()) {
+        }
+
+        return $executed;
+    }
+
     /**
      * @param  PDOStatement|DatabasePDOStatement|PDOStatementProxy  $statement
      */

tests/e2e/Adapter/Scopes/SchemaReconciliationTests.php

@@ -3,6 +3,7 @@
 namespace Tests\E2E\Adapter\Scopes;
 
 use Throwable;
+use Utopia\Database\Adapter\Feature;
 use Utopia\Database\Attribute;
 use Utopia\Database\Capability;
 use Utopia\Database\Collection;
@@ -11,6 +12,8 @@
 use Utopia\Database\Exception\Duplicate as DuplicateException;
 use Utopia\Database\Index;
 use Utopia\Database\Permission;
+use Utopia\Database\Relationship;
+use Utopia\Database\RelationshipUpdate;
 use Utopia\Database\Role;
 use Utopia\Database\Schema\Index as SchemaIndex;
 use Utopia\Database\Storage;
@@ -94,6 +97,59 @@ public function testAnOrphanColumnOfTheRequestedTypeIsReused(): void
         }
     }
 
+    public function testARelationshipRenameThatFailsPartWayConvergesOnRetry(): void
+    {
+        $database = $this->getDatabase();
+        $adapter = $database->getAdapter();
+
+        if (! $adapter->supports(Capability::SchemaIntrospection) || ! $adapter->hasFeature(Feature\Relationships::class)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $books = 'halfRenamedBooks';
+        $authors = 'halfRenamedAuthors';
+        foreach ([$books, $authors] as $collection) {
+            $database->createCollection(Collection::create(id: $collection, attributes: [
+                Attribute::string(key: 'name', size: 64),
+            ], permissions: [
+                Permission::create(Role::any()),
+                Permission::read(Role::any()),
+                Permission::update(Role::any()),
+                Permission::delete(Role::any()),
+            ], documentSecurity: false));
+        }
+
+        try {
+            $database->createRelationship($books, Relationship::oneToOne(relatedCollection: $authors, twoWay: true, key: 'author', twoWayKey: 'book'));
+            $database->createDocument($authors, new Document([Document::ID => 'herbert', 'name' => 'Herbert']));
+            $database->createDocument($books, new Document([Document::ID => 'dune', 'name' => 'Dune', 'author' => 'herbert']));
+            $adapter->createAttribute($authors, Attribute::string(key: 'novel', size: 64));
+            $update = new RelationshipUpdate(key: 'writer', twoWayKey: 'novel');
+
+            try {
+                $database->updateRelationship($books, 'author', $update);
+                $this->fail('A rename whose second column the engine refuses must fail');
+            } catch (Throwable $error) {
+                $this->assertNotInstanceOf(\PHPUnit\Framework\AssertionFailedError::class, $error);
+            }
+
+            $adapter->deleteAttribute($authors, 'novel');
+            $database->updateRelationship($books, 'author', $update);
+
+            $writer = $database->getDocument($books, 'dune')->getAttribute('writer');
+            $this->assertInstanceOf(Document::class, $writer);
+            $this->assertSame('herbert', $writer->getId());
+            $novel = $database->getDocument($authors, 'herbert')->getAttribute('novel');
+            $this->assertInstanceOf(Document::class, $novel);
+            $this->assertSame('dune', $novel->getId());
+        } finally {
+            $database->deleteCollection($books);
+            $database->deleteCollection($authors);
+        }
+    }
+
     public function testAnOrphanColumnOfAnotherTypeIsReplacedOrRefusedUnderSharedTables(): void
     {
         $database = $this->getDatabase();