updated-packages

vendor/doctrine/dbal/lib/Doctrine/DBAL/Cache/ArrayStatement.php

@@ -3,17 +3,24 @@
 namespace Doctrine\DBAL\Cache;
 
 use ArrayIterator;
+use Doctrine\DBAL\Driver\FetchUtils;
+use Doctrine\DBAL\Driver\Result;
 use Doctrine\DBAL\Driver\ResultStatement;
 use Doctrine\DBAL\FetchMode;
 use InvalidArgumentException;
 use IteratorAggregate;
 use PDO;
+use ReturnTypeWillChange;
+
 use function array_merge;
 use function array_values;
 use function count;
 use function reset;
 
-class ArrayStatement implements IteratorAggregate, ResultStatement
+/**
+ * @deprecated
+ */
+class ArrayStatement implements IteratorAggregate, ResultStatement, Result
 {
     /** @var mixed[] */
     private $data;
@@ -42,10 +49,22 @@ class ArrayStatement implements IteratorAggregate, ResultStatement
 
     /**
      * {@inheritdoc}
+     *
+     * @deprecated Use free() instead.
      */
     public function closeCursor()
     {
-        unset($this->data);
+        $this->free();
+
+        return true;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function rowCount()
+    {
+        return count($this->data);
     }
 
     /**
@@ -58,6 +77,8 @@ class ArrayStatement implements IteratorAggregate, ResultStatement
 
     /**
      * {@inheritdoc}
+     *
+     * @deprecated Use one of the fetch- or iterate-related methods.
      */
     public function setFetchMode($fetchMode, $arg2 = null, $arg3 = null)
     {
@@ -72,7 +93,10 @@ class ArrayStatement implements IteratorAggregate, ResultStatement
 
     /**
      * {@inheritdoc}
+     *
+     * @deprecated Use iterateNumeric(), iterateAssociative() or iterateColumn() instead.
      */
+    #[ReturnTypeWillChange]
     public function getIterator()
     {
         $data = $this->fetchAll();
@@ -82,6 +106,8 @@ class ArrayStatement implements IteratorAggregate, ResultStatement
 
     /**
      * {@inheritdoc}
+     *
+     * @deprecated Use fetchNumeric(), fetchAssociative() or fetchOne() instead.
      */
     public function fetch($fetchMode = null, $cursorOrientation = PDO::FETCH_ORI_NEXT, $cursorOffset = 0)
     {
@@ -113,6 +139,8 @@ class ArrayStatement implements IteratorAggregate, ResultStatement
 
     /**
      * {@inheritdoc}
+     *
+     * @deprecated Use fetchAllNumeric(), fetchAllAssociative() or fetchFirstColumn() instead.
      */
     public function fetchAll($fetchMode = null, $fetchArgument = null, $ctorArgs = null)
     {
@@ -126,6 +154,8 @@ class ArrayStatement implements IteratorAggregate, ResultStatement
 
     /**
      * {@inheritdoc}
+     *
+     * @deprecated Use fetchOne() instead.
      */
     public function fetchColumn($columnIndex = 0)
     {
@@ -134,4 +164,81 @@ class ArrayStatement implements IteratorAggregate, ResultStatement
         // TODO: verify that return false is the correct behavior
         return $row[$columnIndex] ?? false;
     }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function fetchNumeric()
+    {
+        $row = $this->doFetch();
+
+        if ($row === false) {
+            return false;
+        }
+
+        return array_values($row);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function fetchAssociative()
+    {
+        return $this->doFetch();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function fetchOne()
+    {
+        $row = $this->doFetch();
+
+        if ($row === false) {
+            return false;
+        }
+
+        return reset($row);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function fetchAllNumeric(): array
+    {
+        return FetchUtils::fetchAllNumeric($this);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function fetchAllAssociative(): array
+    {
+        return FetchUtils::fetchAllAssociative($this);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function fetchFirstColumn(): array
+    {
+        return FetchUtils::fetchFirstColumn($this);
+    }
+
+    public function free(): void
+    {
+        $this->data = [];
+    }
+
+    /**
+     * @return mixed|false
+     */
+    private function doFetch()
+    {
+        if (! isset($this->data[$this->num])) {
+            return false;
+        }
+
+        return $this->data[$this->num++];
+    }
 }

vendor/doctrine/dbal/lib/Doctrine/DBAL/Cache/CacheException.php

@@ -2,12 +2,15 @@
 
 namespace Doctrine\DBAL\Cache;
 
-use Doctrine\DBAL\DBALException;
+use Doctrine\DBAL\Exception;
 
-class CacheException extends DBALException
+/**
+ * @psalm-immutable
+ */
+class CacheException extends Exception
 {
     /**
-     * @return \Doctrine\DBAL\Cache\CacheException
+     * @return CacheException
      */
     public static function noCacheKey()
     {
@@ -15,7 +18,7 @@ class CacheException extends DBALException
     }
 
     /**
-     * @return \Doctrine\DBAL\Cache\CacheException
+     * @return CacheException
      */
     public static function noResultDriverConfigured()
     {

vendor/doctrine/dbal/lib/Doctrine/DBAL/Cache/QueryCacheProfile.php

@@ -3,6 +3,8 @@
 namespace Doctrine\DBAL\Cache;
 
 use Doctrine\Common\Cache\Cache;
+use Doctrine\DBAL\Types\Type;
+
 use function hash;
 use function serialize;
 use function sha1;
@@ -67,16 +69,16 @@ class QueryCacheProfile
     /**
      * Generates the real cache key from query, params, types and connection parameters.
      *
-     * @param string         $query
-     * @param mixed[]        $params
-     * @param int[]|string[] $types
-     * @param mixed[]        $connectionParams
+     * @param string                                                               $sql
+     * @param array<int, mixed>|array<string, mixed>                               $params
+     * @param array<int, Type|int|string|null>|array<string, Type|int|string|null> $types
+     * @param array<string, mixed>                                                 $connectionParams
      *
      * @return string[]
      */
-    public function generateCacheKeys($query, $params, $types, array $connectionParams = [])
+    public function generateCacheKeys($sql, $params, $types, array $connectionParams = [])
     {
-        $realCacheKey = 'query=' . $query .
+        $realCacheKey = 'query=' . $sql .
             '&params=' . serialize($params) .
             '&types=' . serialize($types) .
             '&connectionParams=' . hash('sha256', serialize($connectionParams));
@@ -92,7 +94,7 @@ class QueryCacheProfile
     }
 
     /**
-     * @return \Doctrine\DBAL\Cache\QueryCacheProfile
+     * @return QueryCacheProfile
      */
     public function setResultCacheDriver(Cache $cache)
     {
@@ -102,7 +104,7 @@ class QueryCacheProfile
     /**
      * @param string|null $cacheKey
      *
-     * @return \Doctrine\DBAL\Cache\QueryCacheProfile
+     * @return QueryCacheProfile
      */
     public function setCacheKey($cacheKey)
     {
@@ -112,7 +114,7 @@ class QueryCacheProfile
     /**
      * @param int $lifetime
      *
-     * @return \Doctrine\DBAL\Cache\QueryCacheProfile
+     * @return QueryCacheProfile
      */
     public function setLifetime($lifetime)
     {

vendor/doctrine/dbal/lib/Doctrine/DBAL/Cache/ResultCacheStatement.php

@@ -4,14 +4,21 @@ namespace Doctrine\DBAL\Cache;
 
 use ArrayIterator;
 use Doctrine\Common\Cache\Cache;
+use Doctrine\DBAL\Driver\Exception;
+use Doctrine\DBAL\Driver\FetchUtils;
+use Doctrine\DBAL\Driver\Result;
 use Doctrine\DBAL\Driver\ResultStatement;
 use Doctrine\DBAL\Driver\Statement;
 use Doctrine\DBAL\FetchMode;
 use InvalidArgumentException;
 use IteratorAggregate;
 use PDO;
+use ReturnTypeWillChange;
+
+use function array_map;
 use function array_merge;
 use function array_values;
+use function assert;
 use function reset;
 
 /**
@@ -26,8 +33,10 @@ use function reset;
  *
  * Also you have to realize that the cache will load the whole result into memory at once to ensure 2.
  * This means that the memory usage for cached results might increase by using this feature.
+ *
+ * @deprecated
  */
-class ResultCacheStatement implements IteratorAggregate, ResultStatement
+class ResultCacheStatement implements IteratorAggregate, ResultStatement, Result
 {
     /** @var Cache */
     private $resultCache;
@@ -41,17 +50,10 @@ class ResultCacheStatement implements IteratorAggregate, ResultStatement
     /** @var int */
     private $lifetime;
 
-    /** @var Statement */
+    /** @var ResultStatement */
     private $statement;
 
-    /**
-     * Did we reach the end of the statement?
-     *
-     * @var bool
-     */
-    private $emptied = false;
-
-    /** @var mixed[] */
+    /** @var array<int,array<string,mixed>>|null */
     private $data;
 
     /** @var int */
@@ -62,7 +64,7 @@ class ResultCacheStatement implements IteratorAggregate, ResultStatement
      * @param string $realKey
      * @param int    $lifetime
      */
-    public function __construct(Statement $stmt, Cache $resultCache, $cacheKey, $realKey, $lifetime)
+    public function __construct(ResultStatement $stmt, Cache $resultCache, $cacheKey, $realKey, $lifetime)
     {
         $this->statement   = $stmt;
         $this->resultCache = $resultCache;
@@ -73,22 +75,12 @@ class ResultCacheStatement implements IteratorAggregate, ResultStatement
 
     /**
      * {@inheritdoc}
+     *
+     * @deprecated Use free() instead.
      */
     public function closeCursor()
     {
-        $this->statement->closeCursor();
-        if (! $this->emptied || $this->data === null) {
-            return true;
-        }
-
-        $data = $this->resultCache->fetch($this->cacheKey);
-        if (! $data) {
-            $data = [];
-        }
-        $data[$this->realKey] = $this->data;
-
-        $this->resultCache->save($this->cacheKey, $data, $this->lifetime);
-        unset($this->data);
+        $this->free();
 
         return true;
     }
@@ -103,6 +95,8 @@ class ResultCacheStatement implements IteratorAggregate, ResultStatement
 
     /**
      * {@inheritdoc}
+     *
+     * @deprecated Use one of the fetch- or iterate-related methods.
      */
     public function setFetchMode($fetchMode, $arg2 = null, $arg3 = null)
     {
@@ -113,7 +107,10 @@ class ResultCacheStatement implements IteratorAggregate, ResultStatement
 
     /**
      * {@inheritdoc}
+     *
+     * @deprecated Use iterateNumeric(), iterateAssociative() or iterateColumn() instead.
      */
+    #[ReturnTypeWillChange]
     public function getIterator()
     {
         $data = $this->fetchAll();
@@ -122,7 +119,12 @@ class ResultCacheStatement implements IteratorAggregate, ResultStatement
     }
 
     /**
+     * Be warned that you will need to call this method until no rows are
+     * available for caching to happen.
+     *
      * {@inheritdoc}
+     *
+     * @deprecated Use fetchNumeric(), fetchAssociative() or fetchOne() instead.
      */
     public function fetch($fetchMode = null, $cursorOrientation = PDO::FETCH_ORI_NEXT, $cursorOffset = 0)
     {
@@ -156,21 +158,48 @@ class ResultCacheStatement implements IteratorAggregate, ResultStatement
             throw new InvalidArgumentException('Invalid fetch-style given for caching result.');
         }
 
-        $this->emptied = true;
+        $this->saveToCache();
 
         return false;
     }
 
     /**
      * {@inheritdoc}
+     *
+     * @deprecated Use fetchAllNumeric(), fetchAllAssociative() or fetchFirstColumn() instead.
      */
     public function fetchAll($fetchMode = null, $fetchArgument = null, $ctorArgs = null)
     {
-        return $this->statement->fetchAll($fetchMode, $fetchArgument, $ctorArgs);
+        $data = $this->statement->fetchAll(FetchMode::ASSOCIATIVE, $fetchArgument, $ctorArgs);
+
+        $this->data = $data;
+
+        $this->saveToCache();
+
+        if ($fetchMode === FetchMode::NUMERIC) {
+            foreach ($data as $i => $row) {
+                $data[$i] = array_values($row);
+            }
+        } elseif ($fetchMode === FetchMode::MIXED) {
+            foreach ($data as $i => $row) {
+                $data[$i] = array_merge($row, array_values($row));
+            }
+        } elseif ($fetchMode === FetchMode::COLUMN) {
+            foreach ($data as $i => $row) {
+                $data[$i] = reset($row);
+            }
+        }
+
+        return $data;
     }
 
     /**
+     * Be warned that you will need to call this method until no rows are
+     * available for caching to happen.
+     *
      * {@inheritdoc}
+     *
+     * @deprecated Use fetchOne() instead.
      */
     public function fetchColumn($columnIndex = 0)
     {
@@ -180,6 +209,89 @@ class ResultCacheStatement implements IteratorAggregate, ResultStatement
         return $row[$columnIndex] ?? false;
     }
 
+    /**
+     * Be warned that you will need to call this method until no rows are
+     * available for caching to happen.
+     *
+     * {@inheritdoc}
+     */
+    public function fetchNumeric()
+    {
+        $row = $this->doFetch();
+
+        if ($row === false) {
+            return false;
+        }
+
+        return array_values($row);
+    }
+
+    /**
+     * Be warned that you will need to call this method until no rows are
+     * available for caching to happen.
+     *
+     * {@inheritdoc}
+     */
+    public function fetchAssociative()
+    {
+        return $this->doFetch();
+    }
+
+    /**
+     * Be warned that you will need to call this method until no rows are
+     * available for caching to happen.
+     *
+     * {@inheritdoc}
+     */
+    public function fetchOne()
+    {
+        return FetchUtils::fetchOne($this);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function fetchAllNumeric(): array
+    {
+        if ($this->statement instanceof Result) {
+            $data = $this->statement->fetchAllAssociative();
+        } else {
+            $data = $this->statement->fetchAll(FetchMode::ASSOCIATIVE);
+        }
+
+        $this->data = $data;
+
+        $this->saveToCache();
+
+        return array_map('array_values', $data);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function fetchAllAssociative(): array
+    {
+        if ($this->statement instanceof Result) {
+            $data = $this->statement->fetchAllAssociative();
+        } else {
+            $data = $this->statement->fetchAll(FetchMode::ASSOCIATIVE);
+        }
+
+        $this->data = $data;
+
+        $this->saveToCache();
+
+        return $data;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function fetchFirstColumn(): array
+    {
+        return FetchUtils::fetchFirstColumn($this);
+    }
+
     /**
      * Returns the number of rows affected by the last DELETE, INSERT, or UPDATE statement
      * executed by the corresponding object.
@@ -189,10 +301,61 @@ class ResultCacheStatement implements IteratorAggregate, ResultStatement
      * this behaviour is not guaranteed for all databases and should not be
      * relied on for portable applications.
      *
-     * @return int The number of rows.
+     * @return int|string The number of rows.
      */
     public function rowCount()
     {
+        assert($this->statement instanceof Statement);
+
         return $this->statement->rowCount();
     }
+
+    public function free(): void
+    {
+        $this->data = null;
+    }
+
+    /**
+     * @return array<string,mixed>|false
+     *
+     * @throws Exception
+     */
+    private function doFetch()
+    {
+        if ($this->data === null) {
+            $this->data = [];
+        }
+
+        if ($this->statement instanceof Result) {
+            $row = $this->statement->fetchAssociative();
+        } else {
+            $row = $this->statement->fetch(FetchMode::ASSOCIATIVE);
+        }
+
+        if ($row !== false) {
+            $this->data[] = $row;
+
+            return $row;
+        }
+
+        $this->saveToCache();
+
+        return false;
+    }
+
+    private function saveToCache(): void
+    {
+        if ($this->data === null) {
+            return;
+        }
+
+        $data = $this->resultCache->fetch($this->cacheKey);
+        if (! $data) {
+            $data = [];
+        }
+
+        $data[$this->realKey] = $this->data;
+
+        $this->resultCache->save($this->cacheKey, $data, $this->lifetime);
+    }
 }