Wrap pdo instances

lib/Doctrine/DBAL/Connection.php

@@ -13,6 +13,7 @@
 use Doctrine\DBAL\Driver\ResultStatement;
 use Doctrine\DBAL\Driver\ServerInfoAwareConnection;
 use Doctrine\DBAL\Driver\Statement as DriverStatement;
+use Doctrine\DBAL\Driver\WrappedPDOConnection;
 use Doctrine\DBAL\Exception\InvalidArgumentException;
 use Doctrine\DBAL\Platforms\AbstractPlatform;
 use Doctrine\DBAL\Query\Expression\ExpressionBuilder;
@@ -189,7 +190,7 @@ public function __construct(
         $this->params  = $params;
 
         if (isset($params['pdo'])) {
-            $this->_conn       = $params['pdo'];
+            $this->_conn       = WrappedPDOConnection::fromInstance($params['pdo']);
             $this->isConnected = true;
             unset($this->params['pdo']);
         }

lib/Doctrine/DBAL/Driver/WrappedPDOConnection.php

@@ -0,0 +1,161 @@
+<?php
+declare(strict_types=1);
+
+namespace Doctrine\DBAL\Driver;
+
+use Doctrine\DBAL\ParameterType;
+use PDO;
+use function assert;
+use function func_get_args;
+
+final class WrappedPDOConnection implements Connection, ServerInfoAwareConnection
+{
+    /** @var PDO */
+    private $connection;
+
+    private function __construct(PDO $connection)
+    {
+        $this->connection = $connection;
+    }
+
+    public static function fromInstance(PDO $connection) : self
+    {
+        try {
+            $connection->setAttribute(PDO::ATTR_STATEMENT_CLASS, [PDOStatement::class, []]);
+            $connection->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
+
+            return new self($connection);
+        } catch (\PDOException $exception) {
+            throw new PDOException($exception);
+        }
+    }
+
+    public function setAttribute(int $attribute, $value) : bool
+    {
+        return $this->connection->setAttribute($attribute, $value);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function prepare($prepareString)
+    {
+        try {
+            $stmt = $this->connection->prepare($prepareString);
+            assert($stmt instanceof PDOStatement);
+
+            return $stmt;
+        } catch (\PDOException $exception) {
+            throw new PDOException($exception);
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function query()
+    {
+        $args = func_get_args();
+
+        try {
+            $stmt = $this->connection->query(...$args);
+            assert($stmt instanceof PDOStatement);
+
+            return $stmt;
+        } catch (\PDOException $exception) {
+            throw new PDOException($exception);
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function quote($input, $type = ParameterType::STRING)
+    {
+        return $this->connection->quote($input, $type);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function exec($statement)
+    {
+        try {
+            return $this->connection->exec($statement);
+        } catch (\PDOException $exception) {
+            throw new PDOException($exception);
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function lastInsertId($name = null)
+    {
+        try {
+            if ($name === null) {
+                return $this->connection->lastInsertId();
+            }
+
+            return $this->connection->lastInsertId($name);
+        } catch (\PDOException $exception) {
+            throw new PDOException($exception);
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function beginTransaction()
+    {
+        return $this->connection->beginTransaction();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function commit()
+    {
+        return $this->connection->commit();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function rollBack()
+    {
+        return $this->connection->rollBack();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function errorCode()
+    {
+        return $this->connection->errorCode();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function errorInfo()
+    {
+        return $this->connection->errorInfo();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getServerVersion()
+    {
+        return $this->connection->getAttribute(PDO::ATTR_SERVER_VERSION);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function requiresQueryForServerVersion()
+    {
+        return false;
+    }
+}

lib/Doctrine/DBAL/Portability/Connection.php

@@ -5,6 +5,7 @@
 use Doctrine\DBAL\Cache\QueryCacheProfile;
 use Doctrine\DBAL\ColumnCase;
 use Doctrine\DBAL\Driver\PDOConnection;
+use Doctrine\DBAL\Driver\WrappedPDOConnection;
 use PDO;
 use const CASE_LOWER;
 use const CASE_UPPER;
@@ -66,7 +67,7 @@ public function connect()
             }
 
             if (isset($params['fetch_case']) && $this->portability & self::PORTABILITY_FIX_CASE) {
-                if ($this->_conn instanceof PDOConnection) {
+                if ($this->_conn instanceof PDOConnection || $this->_conn instanceof WrappedPDOConnection) {
                     // make use of c-level support for case handling
                     $this->_conn->setAttribute(PDO::ATTR_CASE, $params['fetch_case']);
                 } else {

tests/Doctrine/Tests/DBAL/ConnectionTest.php

@@ -12,7 +12,6 @@
 use Doctrine\DBAL\DBALException;
 use Doctrine\DBAL\Driver;
 use Doctrine\DBAL\Driver\Connection as DriverConnection;
-use Doctrine\DBAL\Driver\Statement;
 use Doctrine\DBAL\DriverManager;
 use Doctrine\DBAL\Events;
 use Doctrine\DBAL\Exception\InvalidArgumentException;
@@ -26,6 +25,7 @@
 use Doctrine\Tests\Mocks\ServerInfoAwareConnectionMock;
 use Doctrine\Tests\Mocks\VersionAwarePlatformDriverMock;
 use Exception;
+use PDO;
 use PHPUnit\Framework\MockObject\MockObject;
 use stdClass;
 use function call_user_func_array;
@@ -656,7 +656,7 @@ public function testFetchAll()
 
     public function testConnectionDoesNotMaintainTwoReferencesToExternalPDO()
     {
-        $params['pdo'] = new stdClass();
+        $params['pdo'] = new PDO('sqlite::memory:');
 
         $driverMock = $this->createMock(Driver::class);
 
@@ -667,7 +667,7 @@ public function testConnectionDoesNotMaintainTwoReferencesToExternalPDO()
 
     public function testPassingExternalPDOMeansConnectionIsConnected()
     {
-        $params['pdo'] = new stdClass();
+        $params['pdo'] = new PDO('sqlite::memory:');
 
         $driverMock = $this->createMock(Driver::class);
 
@@ -680,7 +680,7 @@ public function testCallingDeleteWithNoDeletionCriteriaResultsInInvalidArgumentE
     {
         /** @var Driver $driver */
         $driver  = $this->createMock(Driver::class);
-        $pdoMock = $this->createMock(\Doctrine\DBAL\Driver\Connection::class);
+        $pdoMock = $this->createMock(PDO::class);
 
         // should never execute queries with invalid arguments
         $pdoMock->expects($this->never())->method('exec');
@@ -709,9 +709,9 @@ public function dataCallConnectOnce()
     public function testCallConnectOnce($method, $params)
     {
         $driverMock   = $this->createMock(Driver::class);
-        $pdoMock      = $this->createMock(Connection::class);
+        $pdoMock      = $this->createMock(PDO::class);
         $platformMock = $this->createMock(AbstractPlatform::class);
-        $stmtMock     = $this->createMock(Statement::class);
+        $stmtMock     = $this->createMock(Driver\PDOStatement::class);
 
         $pdoMock->expects($this->any())
             ->method('prepare')

tests/Doctrine/Tests/DBAL/DriverManagerTest.php

@@ -38,11 +38,10 @@ public function testInvalidPdoInstance()
      */
     public function testValidPdoInstance()
     {
-        $conn = DriverManager::getConnection([
-            'pdo' => new PDO('sqlite::memory:'),
-        ]);
+        $conn = DriverManager::getConnection(['pdo' => new PDO('sqlite::memory:')]);
 
         self::assertEquals('sqlite', $conn->getDatabasePlatform()->getName());
+        self::assertInstanceOf(Driver\WrappedPDOConnection::class, $conn->getWrappedConnection());
     }
 
     /**

tests/Doctrine/Tests/DBAL/Functional/WrappedPDOConnectionTest.php

@@ -0,0 +1,71 @@
+<?php
+declare(strict_types=1);
+
+namespace Doctrine\Tests\DBAL\Functional;
+
+use Doctrine\DBAL\DriverManager;
+use PDO;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * @group GH-3487
+ */
+final class WrappedPDOConnectionTest extends TestCase
+{
+    /** @var PDO */
+    private $pdo;
+
+    /**
+     * @before
+     */
+    public function createInMemoryConnection() : void
+    {
+        $this->pdo = new PDO('sqlite::memory:');
+    }
+
+    /**
+     * @test
+     */
+    public function queriesAndPreparedStatementsShouldWork() : void
+    {
+        $connection = DriverManager::getConnection(['pdo' => $this->pdo]);
+
+        self::assertTrue($connection->ping());
+
+        $connection->query('CREATE TABLE testing (id INTEGER NOT NULL PRIMARY KEY)');
+        $connection->query('INSERT INTO testing VALUES (1), (2), (3)');
+
+        $statement = $connection->prepare('SELECT id FROM testing WHERE id >= ?');
+        $statement->execute([2]);
+
+        self::assertSame([['id' => '2'], ['id' => '3']], $statement->fetchAll(PDO::FETCH_ASSOC));
+    }
+
+    /**
+     * @test
+     */
+    public function autoIncrementIdsShouldBeFetched() : void
+    {
+        $connection = DriverManager::getConnection(['pdo' => $this->pdo]);
+
+        $connection->query('CREATE TABLE testing (id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, name VARCHAR(10) NOT NULL)');
+        $connection->query('INSERT INTO testing (name) VALUES ("Testing")');
+
+        self::assertSame('1', $connection->lastInsertId());
+    }
+
+    /**
+     * @test
+     */
+    public function transactionControlShouldHappenNormally() : void
+    {
+        $connection = DriverManager::getConnection(['pdo' => $this->pdo]);
+        $connection->query('CREATE TABLE testing (id INTEGER NOT NULL PRIMARY KEY)');
+
+        $connection->beginTransaction();
+        $connection->query('INSERT INTO testing VALUES (1), (2), (3)');
+        $connection->rollBack();
+
+        self::assertSame([], $connection->fetchAll('SELECT * FROM testing'));
+    }
+}