vendor/symfony/cache/Adapter/PdoAdapter.php line 68

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\Cache\Adapter;
  14. use Doctrine\DBAL\Connection;
  15. use Doctrine\DBAL\Schema\Schema;
  16. use Psr\Cache\CacheItemInterface;
  17. use Psr\Log\LoggerInterface;
  18. use Symfony\Component\Cache\Exception\InvalidArgumentException;
  19. use Symfony\Component\Cache\Marshaller\DefaultMarshaller;
  20. use Symfony\Component\Cache\Marshaller\MarshallerInterface;
  21. use Symfony\Component\Cache\PruneableInterface;
  23. class PdoAdapter extends AbstractAdapter implements PruneableInterface
  24. {
  25.     protected $maxIdLength = 255;
  27.     private $marshaller;
  28.     private $conn;
  29.     private $dsn;
  30.     private $driver;
  31.     private $serverVersion;
  32.     private $table = 'cache_items';
  33.     private $idCol = 'item_id';
  34.     private $dataCol = 'item_data';
  35.     private $lifetimeCol = 'item_lifetime';
  36.     private $timeCol = 'item_time';
  37.     private $username = '';
  38.     private $password = '';
  39.     private $connectionOptions = [];
  40.     private $namespace;
  42.     private $dbalAdapter;
  44.     /**
  45.      * You can either pass an existing database connection as PDO instance or
  46.      * a DSN string that will be used to lazy-connect to the database when the
  47.      * cache is actually used.
  48.      *
  49.      * List of available options:
  50.      *  * db_table: The name of the table [default: cache_items]
  51.      *  * db_id_col: The column where to store the cache id [default: item_id]
  52.      *  * db_data_col: The column where to store the cache data [default: item_data]
  53.      *  * db_lifetime_col: The column where to store the lifetime [default: item_lifetime]
  54.      *  * db_time_col: The column where to store the timestamp [default: item_time]
  55.      *  * db_username: The username when lazy-connect [default: '']
  56.      *  * db_password: The password when lazy-connect [default: '']
  57.      *  * db_connection_options: An array of driver-specific connection options [default: []]
  58.      *
  59.      * @param \PDO|string $connOrDsn
  60.      *
  61.      * @throws InvalidArgumentException When first argument is not PDO nor Connection nor string
  62.      * @throws InvalidArgumentException When PDO error mode is not PDO::ERRMODE_EXCEPTION
  63.      * @throws InvalidArgumentException When namespace contains invalid characters
  64.      */
  65.     public function __construct($connOrDsn, string $namespace = '', int $defaultLifetime = 0, array $options = [], MarshallerInterface $marshaller = null)
  66.     {
  67.         if ($connOrDsn instanceof Connection || (\is_string($connOrDsn) && str_contains($connOrDsn, '://'))) {
  68.             trigger_deprecation('symfony/cache', '5.4', 'Usage of a DBAL Connection with "%s" is deprecated and will be removed in symfony 6.0. Use "%s" instead.', __CLASS__, DoctrineDbalAdapter::class);
  69.             $this->dbalAdapter = new DoctrineDbalAdapter($connOrDsn, $namespace, $defaultLifetime, $options, $marshaller);
  71.             return;
  72.         }
  74.         if (isset($namespace[0]) && preg_match('#[^-+.A-Za-z0-9]#', $namespace, $match)) {
  75.             throw new InvalidArgumentException(sprintf('Namespace contains "%s" but only characters in [-+.A-Za-z0-9] are allowed.', $match[0]));
  76.         }
  78.         if ($connOrDsn instanceof \PDO) {
  79.             if (\PDO::ERRMODE_EXCEPTION !== $connOrDsn->getAttribute(\PDO::ATTR_ERRMODE)) {
  80.                 throw new InvalidArgumentException(sprintf('"%s" requires PDO error mode attribute be set to throw Exceptions (i.e. $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION)).', __CLASS__));
  81.             }
  83.             $this->conn = $connOrDsn;
  84.         } elseif (\is_string($connOrDsn)) {
  85.             $this->dsn = $connOrDsn;
  86.         } else {
  87.             throw new InvalidArgumentException(sprintf('"%s" requires PDO or Doctrine\DBAL\Connection instance or DSN string as first argument, "%s" given.', __CLASS__, get_debug_type($connOrDsn)));
  88.         }
  90.         $this->table = $options['db_table'] ?? $this->table;
  91.         $this->idCol = $options['db_id_col'] ?? $this->idCol;
  92.         $this->dataCol = $options['db_data_col'] ?? $this->dataCol;
  93.         $this->lifetimeCol = $options['db_lifetime_col'] ?? $this->lifetimeCol;
  94.         $this->timeCol = $options['db_time_col'] ?? $this->timeCol;
  95.         $this->username = $options['db_username'] ?? $this->username;
  96.         $this->password = $options['db_password'] ?? $this->password;
  97.         $this->connectionOptions = $options['db_connection_options'] ?? $this->connectionOptions;
  98.         $this->namespace = $namespace;
  99.         $this->marshaller = $marshaller ?? new DefaultMarshaller();
  101.         parent::__construct($namespace, $defaultLifetime);
  102.     }
  104.     /**
  105.      * {@inheritDoc}
  106.      */
  107.     public function getItem($key)
  108.     {
  109.         if (isset($this->dbalAdapter)) {
  110.             return $this->dbalAdapter->getItem($key);
  111.         }
  113.         return parent::getItem($key);
  114.     }
  116.     /**
  117.      * {@inheritDoc}
  118.      */
  119.     public function getItems(array $keys = [])
  120.     {
  121.         if (isset($this->dbalAdapter)) {
  122.             return $this->dbalAdapter->getItems($keys);
  123.         }
  125.         return parent::getItems($keys);
  126.     }
  128.     /**
  129.      * {@inheritDoc}
  130.      */
  131.     public function hasItem($key)
  132.     {
  133.         if (isset($this->dbalAdapter)) {
  134.             return $this->dbalAdapter->hasItem($key);
  135.         }
  137.         return parent::hasItem($key);
  138.     }
  140.     /**
  141.      * {@inheritDoc}
  142.      */
  143.     public function deleteItem($key)
  144.     {
  145.         if (isset($this->dbalAdapter)) {
  146.             return $this->dbalAdapter->deleteItem($key);
  147.         }
  149.         return parent::deleteItem($key);
  150.     }
  152.     /**
  153.      * {@inheritDoc}
  154.      */
  155.     public function deleteItems(array $keys)
  156.     {
  157.         if (isset($this->dbalAdapter)) {
  158.             return $this->dbalAdapter->deleteItems($keys);
  159.         }
  161.         return parent::deleteItems($keys);
  162.     }
  164.     /**
  165.      * {@inheritDoc}
  166.      */
  167.     public function clear(string $prefix = '')
  168.     {
  169.         if (isset($this->dbalAdapter)) {
  170.             return $this->dbalAdapter->clear($prefix);
  171.         }
  173.         return parent::clear($prefix);
  174.     }
  176.     /**
  177.      * {@inheritDoc}
  178.      */
  179.     public function get(string $key, callable $callback, float $beta = null, array &$metadata = null)
  180.     {
  181.         if (isset($this->dbalAdapter)) {
  182.             return $this->dbalAdapter->get($key, $callback, $beta, $metadata);
  183.         }
  185.         return parent::get($key, $callback, $beta, $metadata);
  186.     }
  188.     /**
  189.      * {@inheritDoc}
  190.      */
  191.     public function delete(string $key): bool
  192.     {
  193.         if (isset($this->dbalAdapter)) {
  194.             return $this->dbalAdapter->delete($key);
  195.         }
  197.         return parent::delete($key);
  198.     }
  200.     /**
  201.      * {@inheritDoc}
  202.      */
  203.     public function save(CacheItemInterface $item)
  204.     {
  205.         if (isset($this->dbalAdapter)) {
  206.             return $this->dbalAdapter->save($item);
  207.         }
  209.         return parent::save($item);
  210.     }
  212.     /**
  213.      * {@inheritDoc}
  214.      */
  215.     public function saveDeferred(CacheItemInterface $item)
  216.     {
  217.         if (isset($this->dbalAdapter)) {
  218.             return $this->dbalAdapter->saveDeferred($item);
  219.         }
  221.         return parent::saveDeferred($item);
  222.     }
  224.     /**
  225.      * {@inheritDoc}
  226.      */
  227.     public function setLogger(LoggerInterface $logger): void
  228.     {
  229.         if (isset($this->dbalAdapter)) {
  230.             $this->dbalAdapter->setLogger($logger);
  232.             return;
  233.         }
  235.         parent::setLogger($logger);
  236.     }
  238.     /**
  239.      * {@inheritDoc}
  240.      */
  241.     public function commit()
  242.     {
  243.         if (isset($this->dbalAdapter)) {
  244.             return $this->dbalAdapter->commit();
  245.         }
  247.         return parent::commit();
  248.     }
  250.     /**
  251.      * {@inheritDoc}
  252.      */
  253.     public function reset()
  254.     {
  255.         if (isset($this->dbalAdapter)) {
  256.             $this->dbalAdapter->reset();
  258.             return;
  259.         }
  261.         parent::reset();
  262.     }
  264.     /**
  265.      * Creates the table to store cache items which can be called once for setup.
  266.      *
  267.      * Cache ID are saved in a column of maximum length 255. Cache data is
  268.      * saved in a BLOB.
  269.      *
  270.      * @throws \PDOException    When the table already exists
  271.      * @throws \DomainException When an unsupported PDO driver is used
  272.      */
  273.     public function createTable()
  274.     {
  275.         if (isset($this->dbalAdapter)) {
  276.             $this->dbalAdapter->createTable();
  278.             return;
  279.         }
  281.         // connect if we are not yet
  282.         $conn = $this->getConnection();
  284.         switch ($this->driver) {
  285.             case 'mysql':
  286.                 // We use varbinary for the ID column because it prevents unwanted conversions:
  287.                 // - character set conversions between server and client
  288.                 // - trailing space removal
  289.                 // - case-insensitivity
  290.                 // - language processing like é == e
  291.                 $sql = "CREATE TABLE $this->table ($this->idCol VARBINARY(255) NOT NULL PRIMARY KEY, $this->dataCol MEDIUMBLOB NOT NULL, $this->lifetimeCol INTEGER UNSIGNED, $this->timeCol INTEGER UNSIGNED NOT NULL) COLLATE utf8mb4_bin, ENGINE = InnoDB";
  292.                 break;
  293.             case 'sqlite':
  294.                 $sql = "CREATE TABLE $this->table ($this->idCol TEXT NOT NULL PRIMARY KEY, $this->dataCol BLOB NOT NULL, $this->lifetimeCol INTEGER, $this->timeCol INTEGER NOT NULL)";
  295.                 break;
  296.             case 'pgsql':
  297.                 $sql = "CREATE TABLE $this->table ($this->idCol VARCHAR(255) NOT NULL PRIMARY KEY, $this->dataCol BYTEA NOT NULL, $this->lifetimeCol INTEGER, $this->timeCol INTEGER NOT NULL)";
  298.                 break;
  299.             case 'oci':
  300.                 $sql = "CREATE TABLE $this->table ($this->idCol VARCHAR2(255) NOT NULL PRIMARY KEY, $this->dataCol BLOB NOT NULL, $this->lifetimeCol INTEGER, $this->timeCol INTEGER NOT NULL)";
  301.                 break;
  302.             case 'sqlsrv':
  303.                 $sql = "CREATE TABLE $this->table ($this->idCol VARCHAR(255) NOT NULL PRIMARY KEY, $this->dataCol VARBINARY(MAX) NOT NULL, $this->lifetimeCol INTEGER, $this->timeCol INTEGER NOT NULL)";
  304.                 break;
  305.             default:
  306.                 throw new \DomainException(sprintf('Creating the cache table is currently not implemented for PDO driver "%s".', $this->driver));
  307.         }
  309.         $conn->exec($sql);
  310.     }
  312.     /**
  313.      * Adds the Table to the Schema if the adapter uses this Connection.
  314.      *
  315.      * @deprecated since symfony/cache 5.4 use DoctrineDbalAdapter instead
  316.      */
  317.     public function configureSchema(Schema $schema, Connection $forConnection): void
  318.     {
  319.         if (isset($this->dbalAdapter)) {
  320.             $this->dbalAdapter->configureSchema($schema, $forConnection);
  321.         }
  322.     }
  324.     /**
  325.      * {@inheritdoc}
  326.      */
  327.     public function prune()
  328.     {
  329.         if (isset($this->dbalAdapter)) {
  330.             return $this->dbalAdapter->prune();
  331.         }
  333.         $deleteSql = "DELETE FROM $this->table WHERE $this->lifetimeCol + $this->timeCol <= :time";
  335.         if ('' !== $this->namespace) {
  336.             $deleteSql .= " AND $this->idCol LIKE :namespace";
  337.         }
  339.         $connection = $this->getConnection();
  341.         try {
  342.             $delete = $connection->prepare($deleteSql);
  343.         } catch (\PDOException $e) {
  344.             return true;
  345.         }
  346.         $delete->bindValue(':time', time(), \PDO::PARAM_INT);
  348.         if ('' !== $this->namespace) {
  349.             $delete->bindValue(':namespace', sprintf('%s%%', $this->namespace), \PDO::PARAM_STR);
  350.         }
  351.         try {
  352.             return $delete->execute();
  353.         } catch (\PDOException $e) {
  354.             return true;
  355.         }
  356.     }
  358.     /**
  359.      * {@inheritdoc}
  360.      */
  361.     protected function doFetch(array $ids)
  362.     {
  363.         $connection = $this->getConnection();
  365.         $now = time();
  366.         $expired = [];
  368.         $sql = str_pad('', (\count($ids) << 1) - 1, '?,');
  369.         $sql = "SELECT $this->idCol, CASE WHEN $this->lifetimeCol IS NULL OR $this->lifetimeCol + $this->timeCol > ? THEN $this->dataCol ELSE NULL END FROM $this->table WHERE $this->idCol IN ($sql)";
  370.         $stmt = $connection->prepare($sql);
  371.         $stmt->bindValue($i = 1, $now, \PDO::PARAM_INT);
  372.         foreach ($ids as $id) {
  373.             $stmt->bindValue(++$i, $id);
  374.         }
  375.         $result = $stmt->execute();
  377.         if (\is_object($result)) {
  378.             $result = $result->iterateNumeric();
  379.         } else {
  380.             $stmt->setFetchMode(\PDO::FETCH_NUM);
  381.             $result = $stmt;
  382.         }
  384.         foreach ($result as $row) {
  385.             if (null === $row[1]) {
  386.                 $expired[] = $row[0];
  387.             } else {
  388.                 yield $row[0] => $this->marshaller->unmarshall(\is_resource($row[1]) ? stream_get_contents($row[1]) : $row[1]);
  389.             }
  390.         }
  392.         if ($expired) {
  393.             $sql = str_pad('', (\count($expired) << 1) - 1, '?,');
  394.             $sql = "DELETE FROM $this->table WHERE $this->lifetimeCol + $this->timeCol <= ? AND $this->idCol IN ($sql)";
  395.             $stmt = $connection->prepare($sql);
  396.             $stmt->bindValue($i = 1, $now, \PDO::PARAM_INT);
  397.             foreach ($expired as $id) {
  398.                 $stmt->bindValue(++$i, $id);
  399.             }
  400.             $stmt->execute();
  401.         }
  402.     }
  404.     /**
  405.      * {@inheritdoc}
  406.      */
  407.     protected function doHave(string $id)
  408.     {
  409.         $connection = $this->getConnection();
  411.         $sql = "SELECT 1 FROM $this->table WHERE $this->idCol = :id AND ($this->lifetimeCol IS NULL OR $this->lifetimeCol + $this->timeCol > :time)";
  412.         $stmt = $connection->prepare($sql);
  414.         $stmt->bindValue(':id', $id);
  415.         $stmt->bindValue(':time', time(), \PDO::PARAM_INT);
  416.         $stmt->execute();
  418.         return (bool) $stmt->fetchColumn();
  419.     }
  421.     /**
  422.      * {@inheritdoc}
  423.      */
  424.     protected function doClear(string $namespace)
  425.     {
  426.         $conn = $this->getConnection();
  428.         if ('' === $namespace) {
  429.             if ('sqlite' === $this->driver) {
  430.                 $sql = "DELETE FROM $this->table";
  431.             } else {
  432.                 $sql = "TRUNCATE TABLE $this->table";
  433.             }
  434.         } else {
  435.             $sql = "DELETE FROM $this->table WHERE $this->idCol LIKE '$namespace%'";
  436.         }
  438.         try {
  439.             $conn->exec($sql);
  440.         } catch (\PDOException $e) {
  441.         }
  443.         return true;
  444.     }
  446.     /**
  447.      * {@inheritdoc}
  448.      */
  449.     protected function doDelete(array $ids)
  450.     {
  451.         $sql = str_pad('', (\count($ids) << 1) - 1, '?,');
  452.         $sql = "DELETE FROM $this->table WHERE $this->idCol IN ($sql)";
  453.         try {
  454.             $stmt = $this->getConnection()->prepare($sql);
  455.             $stmt->execute(array_values($ids));
  456.         } catch (\PDOException $e) {
  457.         }
  459.         return true;
  460.     }
  462.     /**
  463.      * {@inheritdoc}
  464.      */
  465.     protected function doSave(array $values, int $lifetime)
  466.     {
  467.         if (!$values = $this->marshaller->marshall($values, $failed)) {
  468.             return $failed;
  469.         }
  471.         $conn = $this->getConnection();
  473.         $driver = $this->driver;
  474.         $insertSql = "INSERT INTO $this->table ($this->idCol, $this->dataCol, $this->lifetimeCol, $this->timeCol) VALUES (:id, :data, :lifetime, :time)";
  476.         switch (true) {
  477.             case 'mysql' === $driver:
  478.                 $sql = $insertSql." ON DUPLICATE KEY UPDATE $this->dataCol = VALUES($this->dataCol), $this->lifetimeCol = VALUES($this->lifetimeCol), $this->timeCol = VALUES($this->timeCol)";
  479.                 break;
  480.             case 'oci' === $driver:
  481.                 // DUAL is Oracle specific dummy table
  482.                 $sql = "MERGE INTO $this->table USING DUAL ON ($this->idCol = ?) ".
  483.                     "WHEN NOT MATCHED THEN INSERT ($this->idCol, $this->dataCol, $this->lifetimeCol, $this->timeCol) VALUES (?, ?, ?, ?) ".
  484.                     "WHEN MATCHED THEN UPDATE SET $this->dataCol = ?, $this->lifetimeCol = ?, $this->timeCol = ?";
  485.                 break;
  486.             case 'sqlsrv' === $driver && version_compare($this->getServerVersion(), '10', '>='):
  487.                 // MERGE is only available since SQL Server 2008 and must be terminated by semicolon
  488.                 // It also requires HOLDLOCK according to http://weblogs.sqlteam.com/dang/archive/2009/01/31/UPSERT-Race-Condition-With-MERGE.aspx
  489.                 $sql = "MERGE INTO $this->table WITH (HOLDLOCK) USING (SELECT 1 AS dummy) AS src ON ($this->idCol = ?) ".
  490.                     "WHEN NOT MATCHED THEN INSERT ($this->idCol, $this->dataCol, $this->lifetimeCol, $this->timeCol) VALUES (?, ?, ?, ?) ".
  491.                     "WHEN MATCHED THEN UPDATE SET $this->dataCol = ?, $this->lifetimeCol = ?, $this->timeCol = ?;";
  492.                 break;
  493.             case 'sqlite' === $driver:
  494.                 $sql = 'INSERT OR REPLACE'.substr($insertSql, 6);
  495.                 break;
  496.             case 'pgsql' === $driver && version_compare($this->getServerVersion(), '9.5', '>='):
  497.                 $sql = $insertSql." ON CONFLICT ($this->idCol) DO UPDATE SET ($this->dataCol, $this->lifetimeCol, $this->timeCol) = (EXCLUDED.$this->dataCol, EXCLUDED.$this->lifetimeCol, EXCLUDED.$this->timeCol)";
  498.                 break;
  499.             default:
  500.                 $driver = null;
  501.                 $sql = "UPDATE $this->table SET $this->dataCol = :data, $this->lifetimeCol = :lifetime, $this->timeCol = :time WHERE $this->idCol = :id";
  502.                 break;
  503.         }
  505.         $now = time();
  506.         $lifetime = $lifetime ?: null;
  507.         try {
  508.             $stmt = $conn->prepare($sql);
  509.         } catch (\PDOException $e) {
  510.             if (!$conn->inTransaction() || \in_array($this->driver, ['pgsql', 'sqlite', 'sqlsrv'], true)) {
  511.                 $this->createTable();
  512.             }
  513.             $stmt = $conn->prepare($sql);
  514.         }
  516.         // $id and $data are defined later in the loop. Binding is done by reference, values are read on execution.
  517.         if ('sqlsrv' === $driver || 'oci' === $driver) {
  518.             $stmt->bindParam(1, $id);
  519.             $stmt->bindParam(2, $id);
  520.             $stmt->bindParam(3, $data, \PDO::PARAM_LOB);
  521.             $stmt->bindValue(4, $lifetime, \PDO::PARAM_INT);
  522.             $stmt->bindValue(5, $now, \PDO::PARAM_INT);
  523.             $stmt->bindParam(6, $data, \PDO::PARAM_LOB);
  524.             $stmt->bindValue(7, $lifetime, \PDO::PARAM_INT);
  525.             $stmt->bindValue(8, $now, \PDO::PARAM_INT);
  526.         } else {
  527.             $stmt->bindParam(':id', $id);
  528.             $stmt->bindParam(':data', $data, \PDO::PARAM_LOB);
  529.             $stmt->bindValue(':lifetime', $lifetime, \PDO::PARAM_INT);
  530.             $stmt->bindValue(':time', $now, \PDO::PARAM_INT);
  531.         }
  532.         if (null === $driver) {
  533.             $insertStmt = $conn->prepare($insertSql);
  535.             $insertStmt->bindParam(':id', $id);
  536.             $insertStmt->bindParam(':data', $data, \PDO::PARAM_LOB);
  537.             $insertStmt->bindValue(':lifetime', $lifetime, \PDO::PARAM_INT);
  538.             $insertStmt->bindValue(':time', $now, \PDO::PARAM_INT);
  539.         }
  541.         foreach ($values as $id => $data) {
  542.             try {
  543.                 $stmt->execute();
  544.             } catch (\PDOException $e) {
  545.                 if (!$conn->inTransaction() || \in_array($this->driver, ['pgsql', 'sqlite', 'sqlsrv'], true)) {
  546.                     $this->createTable();
  547.                 }
  548.                 $stmt->execute();
  549.             }
  550.             if (null === $driver && !$stmt->rowCount()) {
  551.                 try {
  552.                     $insertStmt->execute();
  553.                 } catch (\PDOException $e) {
  554.                     // A concurrent write won, let it be
  555.                 }
  556.             }
  557.         }
  559.         return $failed;
  560.     }
  562.     /**
  563.      * @internal
  564.      */
  565.     protected function getId($key)
  566.     {
  567.         if ('pgsql' !== $this->driver ?? ($this->getConnection() ? $this->driver : null)) {
  568.             return parent::getId($key);
  569.         }
  571.         if (str_contains($key, "\0") || str_contains($key, '%') || !preg_match('//u', $key)) {
  572.             $key = rawurlencode($key);
  573.         }
  575.         return parent::getId($key);
  576.     }
  578.     private function getConnection(): \PDO
  579.     {
  580.         if (null === $this->conn) {
  581.             $this->conn = new \PDO($this->dsn, $this->username, $this->password, $this->connectionOptions);
  582.             $this->conn->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION);
  583.         }
  584.         if (null === $this->driver) {
  585.             $this->driver = $this->conn->getAttribute(\PDO::ATTR_DRIVER_NAME);
  586.         }
  588.         return $this->conn;
  589.     }
  591.     private function getServerVersion(): string
  592.     {
  593.         if (null === $this->serverVersion) {
  594.             $this->serverVersion = $this->conn->getAttribute(\PDO::ATTR_SERVER_VERSION);
  595.         }
  597.         return $this->serverVersion;
  598.     }
  599. }