updated-packages

vendor/doctrine/dbal/lib/Doctrine/DBAL/Portability/Connection.php

@@ -4,16 +4,20 @@ namespace Doctrine\DBAL\Portability;
 
 use Doctrine\DBAL\Cache\QueryCacheProfile;
 use Doctrine\DBAL\ColumnCase;
-use Doctrine\DBAL\Driver\PDOConnection;
+use Doctrine\DBAL\Connection as BaseConnection;
+use Doctrine\DBAL\Driver\PDO\Connection as PDOConnection;
+use Doctrine\DBAL\ForwardCompatibility;
 use PDO;
+
+use function func_get_args;
+
 use const CASE_LOWER;
 use const CASE_UPPER;
-use function func_get_args;
 
 /**
  * Portability wrapper for a Connection.
  */
-class Connection extends \Doctrine\DBAL\Connection
+class Connection extends BaseConnection
 {
     public const PORTABILITY_ALL           = 255;
     public const PORTABILITY_NONE          = 0;
@@ -21,6 +25,10 @@ class Connection extends \Doctrine\DBAL\Connection
     public const PORTABILITY_EMPTY_TO_NULL = 4;
     public const PORTABILITY_FIX_CASE      = 8;
 
+    /**#@+
+     *
+     * @deprecated Will be removed as internal implementation details.
+     */
     public const PORTABILITY_DB2          = 13;
     public const PORTABILITY_ORACLE       = 9;
     public const PORTABILITY_POSTGRESQL   = 13;
@@ -29,11 +37,12 @@ class Connection extends \Doctrine\DBAL\Connection
     public const PORTABILITY_DRIZZLE      = 13;
     public const PORTABILITY_SQLANYWHERE  = 13;
     public const PORTABILITY_SQLSRV       = 13;
+    /**#@-*/
 
     /** @var int */
     private $portability = self::PORTABILITY_NONE;
 
-    /** @var int */
+    /** @var int|null */
     private $case;
 
     /**
@@ -45,24 +54,10 @@ class Connection extends \Doctrine\DBAL\Connection
         if ($ret) {
             $params = $this->getParams();
             if (isset($params['portability'])) {
-                if ($this->getDatabasePlatform()->getName() === 'oracle') {
-                    $params['portability'] &= self::PORTABILITY_ORACLE;
-                } elseif ($this->getDatabasePlatform()->getName() === 'postgresql') {
-                    $params['portability'] &= self::PORTABILITY_POSTGRESQL;
-                } elseif ($this->getDatabasePlatform()->getName() === 'sqlite') {
-                    $params['portability'] &= self::PORTABILITY_SQLITE;
-                } elseif ($this->getDatabasePlatform()->getName() === 'drizzle') {
-                    $params['portability'] &= self::PORTABILITY_DRIZZLE;
-                } elseif ($this->getDatabasePlatform()->getName() === 'sqlanywhere') {
-                    $params['portability'] &= self::PORTABILITY_SQLANYWHERE;
-                } elseif ($this->getDatabasePlatform()->getName() === 'db2') {
-                    $params['portability'] &= self::PORTABILITY_DB2;
-                } elseif ($this->getDatabasePlatform()->getName() === 'mssql') {
-                    $params['portability'] &= self::PORTABILITY_SQLSRV;
-                } else {
-                    $params['portability'] &= self::PORTABILITY_OTHERVENDORS;
-                }
-                $this->portability = $params['portability'];
+                $this->portability = $params['portability'] = (new OptimizeFlags())(
+                    $this->getDatabasePlatform(),
+                    $params['portability']
+                );
             }
 
             if (isset($params['fetch_case']) && $this->portability & self::PORTABILITY_FIX_CASE) {
@@ -87,7 +82,7 @@ class Connection extends \Doctrine\DBAL\Connection
     }
 
     /**
-     * @return int
+     * @return int|null
      */
     public function getFetchCase()
     {
@@ -97,20 +92,24 @@ class Connection extends \Doctrine\DBAL\Connection
     /**
      * {@inheritdoc}
      */
-    public function executeQuery($query, array $params = [], $types = [], ?QueryCacheProfile $qcp = null)
+    public function executeQuery($sql, array $params = [], $types = [], ?QueryCacheProfile $qcp = null)
     {
-        $stmt = new Statement(parent::executeQuery($query, $params, $types, $qcp), $this);
+        $stmt = new Statement(parent::executeQuery($sql, $params, $types, $qcp), $this);
         $stmt->setFetchMode($this->defaultFetchMode);
 
-        return $stmt;
+        return new ForwardCompatibility\Result($stmt);
     }
 
     /**
      * {@inheritdoc}
+     *
+     * @param string $sql
+     *
+     * @return Statement
      */
-    public function prepare($statement)
+    public function prepare($sql)
     {
-        $stmt = new Statement(parent::prepare($statement), $this);
+        $stmt = new Statement(parent::prepare($sql), $this);
         $stmt->setFetchMode($this->defaultFetchMode);
 
         return $stmt;
@@ -121,9 +120,9 @@ class Connection extends \Doctrine\DBAL\Connection
      */
     public function query()
     {
-        $this->connect();
+        $connection = $this->getWrappedConnection();
 
-        $stmt = $this->_conn->query(...func_get_args());
+        $stmt = $connection->query(...func_get_args());
         $stmt = new Statement($stmt, $this);
         $stmt->setFetchMode($this->defaultFetchMode);
 

vendor/doctrine/dbal/lib/Doctrine/DBAL/Portability/OptimizeFlags.php

@@ -0,0 +1,44 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\DBAL\Portability;
+
+use Doctrine\DBAL\Platforms\AbstractPlatform;
+use Doctrine\DBAL\Platforms\DB2Platform;
+use Doctrine\DBAL\Platforms\OraclePlatform;
+use Doctrine\DBAL\Platforms\PostgreSQL94Platform;
+use Doctrine\DBAL\Platforms\SQLAnywhere16Platform;
+use Doctrine\DBAL\Platforms\SqlitePlatform;
+use Doctrine\DBAL\Platforms\SQLServer2012Platform;
+
+final class OptimizeFlags
+{
+    /**
+     * Platform-specific portability flags that need to be excluded from the user-provided mode
+     * since the platform already operates in this mode to avoid unnecessary conversion overhead.
+     *
+     * @var array<string,int>
+     */
+    private static $platforms = [
+        DB2Platform::class           => 0,
+        OraclePlatform::class        => Connection::PORTABILITY_EMPTY_TO_NULL,
+        PostgreSQL94Platform::class  => 0,
+        SQLAnywhere16Platform::class => 0,
+        SqlitePlatform::class        => 0,
+        SQLServer2012Platform::class => 0,
+    ];
+
+    public function __invoke(AbstractPlatform $platform, int $flags): int
+    {
+        foreach (self::$platforms as $class => $mask) {
+            if ($platform instanceof $class) {
+                $flags &= ~$mask;
+
+                break;
+            }
+        }
+
+        return $flags;
+    }
+}

vendor/doctrine/dbal/lib/Doctrine/DBAL/Portability/Statement.php

@@ -2,28 +2,33 @@
 
 namespace Doctrine\DBAL\Portability;
 
+use Doctrine\DBAL\Driver\Result;
+use Doctrine\DBAL\Driver\ResultStatement;
 use Doctrine\DBAL\Driver\Statement as DriverStatement;
 use Doctrine\DBAL\Driver\StatementIterator;
 use Doctrine\DBAL\FetchMode;
 use Doctrine\DBAL\ParameterType;
 use IteratorAggregate;
 use PDO;
+use ReturnTypeWillChange;
+
 use function array_change_key_case;
+use function assert;
 use function is_string;
 use function rtrim;
 
 /**
  * Portability wrapper for a Statement.
  */
-class Statement implements IteratorAggregate, DriverStatement
+class Statement implements IteratorAggregate, DriverStatement, Result
 {
     /** @var int */
     private $portability;
 
-    /** @var DriverStatement */
+    /** @var DriverStatement|ResultStatement */
     private $stmt;
 
-    /** @var int */
+    /** @var int|null */
     private $case;
 
     /** @var int */
@@ -32,7 +37,7 @@ class Statement implements IteratorAggregate, DriverStatement
     /**
      * Wraps <tt>Statement</tt> and applies portability measures.
      *
-     * @param DriverStatement $stmt
+     * @param DriverStatement|ResultStatement $stmt
      */
     public function __construct($stmt, Connection $conn)
     {
@@ -44,9 +49,11 @@ class Statement implements IteratorAggregate, DriverStatement
     /**
      * {@inheritdoc}
      */
-    public function bindParam($column, &$variable, $type = ParameterType::STRING, $length = null)
+    public function bindParam($param, &$variable, $type = ParameterType::STRING, $length = null)
     {
-        return $this->stmt->bindParam($column, $variable, $type, $length);
+        assert($this->stmt instanceof DriverStatement);
+
+        return $this->stmt->bindParam($param, $variable, $type, $length);
     }
 
     /**
@@ -54,11 +61,15 @@ class Statement implements IteratorAggregate, DriverStatement
      */
     public function bindValue($param, $value, $type = ParameterType::STRING)
     {
+        assert($this->stmt instanceof DriverStatement);
+
         return $this->stmt->bindValue($param, $value, $type);
     }
 
     /**
      * {@inheritdoc}
+     *
+     * @deprecated Use free() instead.
      */
     public function closeCursor()
     {
@@ -75,17 +86,25 @@ class Statement implements IteratorAggregate, DriverStatement
 
     /**
      * {@inheritdoc}
+     *
+     * @deprecated The error information is available via exceptions.
      */
     public function errorCode()
     {
+        assert($this->stmt instanceof DriverStatement);
+
         return $this->stmt->errorCode();
     }
 
     /**
      * {@inheritdoc}
+     *
+     * @deprecated The error information is available via exceptions.
      */
     public function errorInfo()
     {
+        assert($this->stmt instanceof DriverStatement);
+
         return $this->stmt->errorInfo();
     }
 
@@ -94,22 +113,29 @@ class Statement implements IteratorAggregate, DriverStatement
      */
     public function execute($params = null)
     {
+        assert($this->stmt instanceof DriverStatement);
+
         return $this->stmt->execute($params);
     }
 
     /**
      * {@inheritdoc}
+     *
+     * @deprecated Use one of the fetch- or iterate-related methods.
      */
-    public function setFetchMode($fetchMode, $arg1 = null, $arg2 = null)
+    public function setFetchMode($fetchMode, $arg2 = null, $arg3 = null)
     {
         $this->defaultFetchMode = $fetchMode;
 
-        return $this->stmt->setFetchMode($fetchMode, $arg1, $arg2);
+        return $this->stmt->setFetchMode($fetchMode, $arg2, $arg3);
     }
 
     /**
      * {@inheritdoc}
+     *
+     * @deprecated Use iterateNumeric(), iterateAssociative() or iterateColumn() instead.
      */
+    #[ReturnTypeWillChange]
     public function getIterator()
     {
         return new StatementIterator($this);
@@ -117,6 +143,8 @@ class Statement implements IteratorAggregate, DriverStatement
 
     /**
      * {@inheritdoc}
+     *
+     * @deprecated Use fetchNumeric(), fetchAssociative() or fetchOne() instead.
      */
     public function fetch($fetchMode = null, $cursorOrientation = PDO::FETCH_ORI_NEXT, $cursorOffset = 0)
     {
@@ -124,8 +152,11 @@ class Statement implements IteratorAggregate, DriverStatement
 
         $row = $this->stmt->fetch($fetchMode);
 
-        $iterateRow = $this->portability & (Connection::PORTABILITY_EMPTY_TO_NULL|Connection::PORTABILITY_RTRIM);
-        $fixCase    = $this->case !== null
+        $iterateRow = (
+            $this->portability & (Connection::PORTABILITY_EMPTY_TO_NULL | Connection::PORTABILITY_RTRIM)
+        ) !== 0;
+
+        $fixCase = $this->case !== null
             && ($fetchMode === FetchMode::ASSOCIATIVE || $fetchMode === FetchMode::MIXED)
             && ($this->portability & Connection::PORTABILITY_FIX_CASE);
 
@@ -136,6 +167,8 @@ class Statement implements IteratorAggregate, DriverStatement
 
     /**
      * {@inheritdoc}
+     *
+     * @deprecated Use fetchAllNumeric(), fetchAllAssociative() or fetchFirstColumn() instead.
      */
     public function fetchAll($fetchMode = null, $fetchArgument = null, $ctorArgs = null)
     {
@@ -147,37 +180,169 @@ class Statement implements IteratorAggregate, DriverStatement
             $rows = $this->stmt->fetchAll($fetchMode);
         }
 
-        $iterateRow = $this->portability & (Connection::PORTABILITY_EMPTY_TO_NULL|Connection::PORTABILITY_RTRIM);
-        $fixCase    = $this->case !== null
+        $fixCase = $this->case !== null
             && ($fetchMode === FetchMode::ASSOCIATIVE || $fetchMode === FetchMode::MIXED)
             && ($this->portability & Connection::PORTABILITY_FIX_CASE);
 
+        return $this->fixResultSet($rows, $fixCase, $fetchMode !== FetchMode::COLUMN);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function fetchNumeric()
+    {
+        if ($this->stmt instanceof Result) {
+            $row = $this->stmt->fetchNumeric();
+        } else {
+            $row = $this->stmt->fetch(FetchMode::NUMERIC);
+        }
+
+        return $this->fixResult($row, false);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function fetchAssociative()
+    {
+        if ($this->stmt instanceof Result) {
+            $row = $this->stmt->fetchAssociative();
+        } else {
+            $row = $this->stmt->fetch(FetchMode::ASSOCIATIVE);
+        }
+
+        return $this->fixResult($row, true);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function fetchOne()
+    {
+        if ($this->stmt instanceof Result) {
+            $value = $this->stmt->fetchOne();
+        } else {
+            $value = $this->stmt->fetch(FetchMode::COLUMN);
+        }
+
+        if (($this->portability & Connection::PORTABILITY_EMPTY_TO_NULL) !== 0 && $value === '') {
+            $value = null;
+        } elseif (($this->portability & Connection::PORTABILITY_RTRIM) !== 0 && is_string($value)) {
+            $value = rtrim($value);
+        }
+
+        return $value;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function fetchAllNumeric(): array
+    {
+        if ($this->stmt instanceof Result) {
+            $data = $this->stmt->fetchAllNumeric();
+        } else {
+            $data = $this->stmt->fetchAll(FetchMode::NUMERIC);
+        }
+
+        return $this->fixResultSet($data, false, true);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function fetchAllAssociative(): array
+    {
+        if ($this->stmt instanceof Result) {
+            $data = $this->stmt->fetchAllAssociative();
+        } else {
+            $data = $this->stmt->fetchAll(FetchMode::ASSOCIATIVE);
+        }
+
+        return $this->fixResultSet($data, true, true);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function fetchFirstColumn(): array
+    {
+        if ($this->stmt instanceof Result) {
+            $data = $this->stmt->fetchFirstColumn();
+        } else {
+            $data = $this->stmt->fetchAll(FetchMode::COLUMN);
+        }
+
+        return $this->fixResultSet($data, true, false);
+    }
+
+    public function free(): void
+    {
+        if ($this->stmt instanceof Result) {
+            $this->stmt->free();
+
+            return;
+        }
+
+        $this->stmt->closeCursor();
+    }
+
+    /**
+     * @param mixed $result
+     *
+     * @return mixed
+     */
+    private function fixResult($result, bool $fixCase)
+    {
+        $iterateRow = (
+            $this->portability & (Connection::PORTABILITY_EMPTY_TO_NULL | Connection::PORTABILITY_RTRIM)
+        ) !== 0;
+
+        $fixCase = $fixCase && $this->case !== null && ($this->portability & Connection::PORTABILITY_FIX_CASE) !== 0;
+
+        return $this->fixRow($result, $iterateRow, $fixCase);
+    }
+
+    /**
+     * @param array<int,mixed> $resultSet
+     *
+     * @return array<int,mixed>
+     */
+    private function fixResultSet(array $resultSet, bool $fixCase, bool $isArray): array
+    {
+        $iterateRow = (
+            $this->portability & (Connection::PORTABILITY_EMPTY_TO_NULL | Connection::PORTABILITY_RTRIM)
+        ) !== 0;
+
+        $fixCase = $fixCase && $this->case !== null && ($this->portability & Connection::PORTABILITY_FIX_CASE) !== 0;
+
         if (! $iterateRow && ! $fixCase) {
-            return $rows;
+            return $resultSet;
         }
 
-        if ($fetchMode === FetchMode::COLUMN) {
-            foreach ($rows as $num => $row) {
-                $rows[$num] = [$row];
+        if (! $isArray) {
+            foreach ($resultSet as $num => $value) {
+                $resultSet[$num] = [$value];
             }
         }
 
-        foreach ($rows as $num => $row) {
-            $rows[$num] = $this->fixRow($row, $iterateRow, $fixCase);
+        foreach ($resultSet as $num => $row) {
+            $resultSet[$num] = $this->fixRow($row, $iterateRow, $fixCase);
         }
 
-        if ($fetchMode === FetchMode::COLUMN) {
-            foreach ($rows as $num => $row) {
-                $rows[$num] = $row[0];
+        if (! $isArray) {
+            foreach ($resultSet as $num => $row) {
+                $resultSet[$num] = $row[0];
             }
         }
 
-        return $rows;
+        return $resultSet;
     }
 
     /**
      * @param mixed $row
-     * @param int   $iterateRow
+     * @param bool  $iterateRow
      * @param bool  $fixCase
      *
      * @return mixed
@@ -189,6 +354,7 @@ class Statement implements IteratorAggregate, DriverStatement
         }
 
         if ($fixCase) {
+            assert($this->case !== null);
             $row = array_change_key_case($row, $this->case);
         }
 
@@ -207,12 +373,14 @@ class Statement implements IteratorAggregate, DriverStatement
 
     /**
      * {@inheritdoc}
+     *
+     * @deprecated Use fetchOne() instead.
      */
     public function fetchColumn($columnIndex = 0)
     {
         $value = $this->stmt->fetchColumn($columnIndex);
 
-        if ($this->portability & (Connection::PORTABILITY_EMPTY_TO_NULL|Connection::PORTABILITY_RTRIM)) {
+        if ($this->portability & (Connection::PORTABILITY_EMPTY_TO_NULL | Connection::PORTABILITY_RTRIM)) {
             if (($this->portability & Connection::PORTABILITY_EMPTY_TO_NULL) && $value === '') {
                 $value = null;
             } elseif (($this->portability & Connection::PORTABILITY_RTRIM) && is_string($value)) {
@@ -228,6 +396,8 @@ class Statement implements IteratorAggregate, DriverStatement
      */
     public function rowCount()
     {
+        assert($this->stmt instanceof DriverStatement);
+
         return $this->stmt->rowCount();
     }
 }