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

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\DBALException;
  16. use Doctrine\DBAL\Driver\ServerInfoAwareConnection;
  17. use Doctrine\DBAL\DriverManager;
  18. use Doctrine\DBAL\Exception;
  19. use Doctrine\DBAL\Exception\TableNotFoundException;
  20. use Doctrine\DBAL\ParameterType;
  21. use Doctrine\DBAL\Schema\Schema;
  22. use Doctrine\DBAL\Statement;
  23. use Symfony\Component\Cache\Exception\InvalidArgumentException;
  24. use Symfony\Component\Cache\Marshaller\DefaultMarshaller;
  25. use Symfony\Component\Cache\Marshaller\MarshallerInterface;
  26. use Symfony\Component\Cache\PruneableInterface;
  28. class PdoAdapter extends AbstractAdapter implements PruneableInterface
  29. {
  30.     protected $maxIdLength = 255;
  32.     private $marshaller;
  33.     private $conn;
  34.     private $dsn;
  35.     private $driver;
  36.     private $serverVersion;
  37.     private $table = 'cache_items';
  38.     private $idCol = 'item_id';
  39.     private $dataCol = 'item_data';
  40.     private $lifetimeCol = 'item_lifetime';
  41.     private $timeCol = 'item_time';
  42.     private $username = '';
  43.     private $password = '';
  44.     private $connectionOptions = [];
  45.     private $namespace;
  47.     /**
  48.      * You can either pass an existing database connection as PDO instance or
  49.      * a Doctrine DBAL Connection or a DSN string that will be used to
  50.      * lazy-connect to the database when the cache is actually used.
  51.      *
  52.      * When a Doctrine DBAL Connection is passed, the cache table is created
  53.      * automatically when possible. Otherwise, use the createTable() method.
  54.      *
  55.      * List of available options:
  56.      *  * db_table: The name of the table [default: cache_items]
  57.      *  * db_id_col: The column where to store the cache id [default: item_id]
  58.      *  * db_data_col: The column where to store the cache data [default: item_data]
  59.      *  * db_lifetime_col: The column where to store the lifetime [default: item_lifetime]
  60.      *  * db_time_col: The column where to store the timestamp [default: item_time]
  61.      *  * db_username: The username when lazy-connect [default: '']
  62.      *  * db_password: The password when lazy-connect [default: '']
  63.      *  * db_connection_options: An array of driver-specific connection options [default: []]
  64.      *
  65.      * @param \PDO|Connection|string $connOrDsn a \PDO or Connection instance or DSN string or null
  66.      *
  67.      * @throws InvalidArgumentException When first argument is not PDO nor Connection nor string
  68.      * @throws InvalidArgumentException When PDO error mode is not PDO::ERRMODE_EXCEPTION
  69.      * @throws InvalidArgumentException When namespace contains invalid characters
  70.      */
  71.     public function __construct($connOrDsn, string $namespace = '', int $defaultLifetime = 0, array $options = [], MarshallerInterface $marshaller = null)
  72.     {
  73.         if (isset($namespace[0]) && preg_match('#[^-+.A-Za-z0-9]#', $namespace, $match)) {
  74.             throw new InvalidArgumentException(sprintf('Namespace contains "%s" but only characters in [-+.A-Za-z0-9] are allowed.', $match[0]));
  75.         }
  77.         if ($connOrDsn instanceof \PDO) {
  78.             if (\PDO::ERRMODE_EXCEPTION !== $connOrDsn->getAttribute(\PDO::ATTR_ERRMODE)) {
  79.                 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__));
  80.             }
  82.             $this->conn = $connOrDsn;
  83.         } elseif ($connOrDsn instanceof Connection) {
  84.             $this->conn = $connOrDsn;
  85.         } elseif (\is_string($connOrDsn)) {
  86.             $this->dsn = $connOrDsn;
  87.         } else {
  88.             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)));
  89.         }
  91.         $this->table = $options['db_table'] ?? $this->table;
  92.         $this->idCol = $options['db_id_col'] ?? $this->idCol;
  93.         $this->dataCol = $options['db_data_col'] ?? $this->dataCol;
  94.         $this->lifetimeCol = $options['db_lifetime_col'] ?? $this->lifetimeCol;
  95.         $this->timeCol = $options['db_time_col'] ?? $this->timeCol;
  96.         $this->username = $options['db_username'] ?? $this->username;
  97.         $this->password = $options['db_password'] ?? $this->password;
  98.         $this->connectionOptions = $options['db_connection_options'] ?? $this->connectionOptions;
  99.         $this->namespace = $namespace;
  100.         $this->marshaller = $marshaller ?? new DefaultMarshaller();
  102.         parent::__construct($namespace, $defaultLifetime);
  103.     }
  105.     /**
  106.      * Creates the table to store cache items which can be called once for setup.
  107.      *
  108.      * Cache ID are saved in a column of maximum length 255. Cache data is
  109.      * saved in a BLOB.
  110.      *
  111.      * @throws \PDOException    When the table already exists
  112.      * @throws DBALException    When the table already exists
  113.      * @throws Exception        When the table already exists
  114.      * @throws \DomainException When an unsupported PDO driver is used
  115.      */
  116.     public function createTable()
  117.     {
  118.         // connect if we are not yet
  119.         $conn = $this->getConnection();
  121.         if ($conn instanceof Connection) {
  122.             $schema = new Schema();
  123.             $this->addTableToSchema($schema);
  125.             foreach ($schema->toSql($conn->getDatabasePlatform()) as $sql) {
  126.                 if ($conn instanceof Connection && method_exists($conn, 'executeStatement')) {
  127.                     $conn->executeStatement($sql);
  128.                 } else {
  129.                     $conn->exec($sql);
  130.                 }
  131.             }
  133.             return;
  134.         }
  136.         switch ($this->driver) {
  137.             case 'mysql':
  138.                 // We use varbinary for the ID column because it prevents unwanted conversions:
  139.                 // - character set conversions between server and client
  140.                 // - trailing space removal
  141.                 // - case-insensitivity
  142.                 // - language processing like é == e
  143.                 $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";
  144.                 break;
  145.             case 'sqlite':
  146.                 $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)";
  147.                 break;
  148.             case 'pgsql':
  149.                 $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)";
  150.                 break;
  151.             case 'oci':
  152.                 $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)";
  153.                 break;
  154.             case 'sqlsrv':
  155.                 $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)";
  156.                 break;
  157.             default:
  158.                 throw new \DomainException(sprintf('Creating the cache table is currently not implemented for PDO driver "%s".', $this->driver));
  159.         }
  161.         if ($conn instanceof Connection && method_exists($conn, 'executeStatement')) {
  162.             $conn->executeStatement($sql);
  163.         } else {
  164.             $conn->exec($sql);
  165.         }
  166.     }
  168.     /**
  169.      * Adds the Table to the Schema if the adapter uses this Connection.
  170.      */
  171.     public function configureSchema(Schema $schema, Connection $forConnection): void
  172.     {
  173.         // only update the schema for this connection
  174.         if ($forConnection !== $this->getConnection()) {
  175.             return;
  176.         }
  178.         if ($schema->hasTable($this->table)) {
  179.             return;
  180.         }
  182.         $this->addTableToSchema($schema);
  183.     }
  185.     /**
  186.      * {@inheritdoc}
  187.      */
  188.     public function prune()
  189.     {
  190.         $deleteSql = "DELETE FROM $this->table WHERE $this->lifetimeCol + $this->timeCol <= :time";
  192.         if ('' !== $this->namespace) {
  193.             $deleteSql .= " AND $this->idCol LIKE :namespace";
  194.         }
  196.         $connection = $this->getConnection();
  197.         $useDbalConstants = $connection instanceof Connection;
  199.         try {
  200.             $delete = $connection->prepare($deleteSql);
  201.         } catch (TableNotFoundException $e) {
  202.             return true;
  203.         } catch (\PDOException $e) {
  204.             return true;
  205.         }
  206.         $delete->bindValue(':time', time(), $useDbalConstants ? ParameterType::INTEGER : \PDO::PARAM_INT);
  208.         if ('' !== $this->namespace) {
  209.             $delete->bindValue(':namespace', sprintf('%s%%', $this->namespace), $useDbalConstants ? ParameterType::STRING : \PDO::PARAM_STR);
  210.         }
  211.         try {
  212.             // Doctrine DBAL ^2.13 || >= 3.1
  213.             if ($delete instanceof Statement && method_exists($delete, 'executeStatement')) {
  214.                 $delete->executeStatement();
  216.                 return true;
  217.             }
  219.             return $delete->execute();
  220.         } catch (TableNotFoundException $e) {
  221.             return true;
  222.         } catch (\PDOException $e) {
  223.             return true;
  224.         }
  225.     }
  227.     /**
  228.      * {@inheritdoc}
  229.      */
  230.     protected function doFetch(array $ids)
  231.     {
  232.         $connection = $this->getConnection();
  233.         $useDbalConstants = $connection instanceof Connection;
  235.         $now = time();
  236.         $expired = [];
  238.         $sql = str_pad('', (\count($ids) << 1) - 1, '?,');
  239.         $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)";
  240.         $stmt = $connection->prepare($sql);
  241.         $stmt->bindValue($i = 1, $now, $useDbalConstants ? ParameterType::INTEGER : \PDO::PARAM_INT);
  242.         foreach ($ids as $id) {
  243.             $stmt->bindValue(++$i, $id);
  244.         }
  245.         $result = $stmt->execute();
  247.         if (\is_object($result)) {
  248.             $result = $result->iterateNumeric();
  249.         } else {
  250.             $stmt->setFetchMode(\PDO::FETCH_NUM);
  251.             $result = $stmt;
  252.         }
  254.         foreach ($result as $row) {
  255.             if (null === $row[1]) {
  256.                 $expired[] = $row[0];
  257.             } else {
  258.                 yield $row[0] => $this->marshaller->unmarshall(\is_resource($row[1]) ? stream_get_contents($row[1]) : $row[1]);
  259.             }
  260.         }
  262.         if ($expired) {
  263.             $sql = str_pad('', (\count($expired) << 1) - 1, '?,');
  264.             $sql = "DELETE FROM $this->table WHERE $this->lifetimeCol + $this->timeCol <= ? AND $this->idCol IN ($sql)";
  265.             $stmt = $connection->prepare($sql);
  266.             $stmt->bindValue($i = 1, $now, $useDbalConstants ? ParameterType::INTEGER : \PDO::PARAM_INT);
  267.             foreach ($expired as $id) {
  268.                 $stmt->bindValue(++$i, $id);
  269.             }
  270.             $stmt->execute();
  271.         }
  272.     }
  274.     /**
  275.      * {@inheritdoc}
  276.      */
  277.     protected function doHave(string $id)
  278.     {
  279.         $connection = $this->getConnection();
  280.         $useDbalConstants = $connection instanceof Connection;
  282.         $sql = "SELECT 1 FROM $this->table WHERE $this->idCol = :id AND ($this->lifetimeCol IS NULL OR $this->lifetimeCol + $this->timeCol > :time)";
  283.         $stmt = $connection->prepare($sql);
  285.         $stmt->bindValue(':id', $id);
  286.         $stmt->bindValue(':time', time(), $useDbalConstants ? ParameterType::INTEGER : \PDO::PARAM_INT);
  287.         $result = $stmt->execute();
  289.         return (bool) (\is_object($result) ? $result->fetchOne() : $stmt->fetchColumn());
  290.     }
  292.     /**
  293.      * {@inheritdoc}
  294.      */
  295.     protected function doClear(string $namespace)
  296.     {
  297.         $conn = $this->getConnection();
  299.         if ('' === $namespace) {
  300.             if ('sqlite' === $this->driver) {
  301.                 $sql = "DELETE FROM $this->table";
  302.             } else {
  303.                 $sql = "TRUNCATE TABLE $this->table";
  304.             }
  305.         } else {
  306.             $sql = "DELETE FROM $this->table WHERE $this->idCol LIKE '$namespace%'";
  307.         }
  309.         try {
  310.             if ($conn instanceof Connection && method_exists($conn, 'executeStatement')) {
  311.                 $conn->executeStatement($sql);
  312.             } else {
  313.                 $conn->exec($sql);
  314.             }
  315.         } catch (TableNotFoundException $e) {
  316.         } catch (\PDOException $e) {
  317.         }
  319.         return true;
  320.     }
  322.     /**
  323.      * {@inheritdoc}
  324.      */
  325.     protected function doDelete(array $ids)
  326.     {
  327.         $sql = str_pad('', (\count($ids) << 1) - 1, '?,');
  328.         $sql = "DELETE FROM $this->table WHERE $this->idCol IN ($sql)";
  329.         try {
  330.             $stmt = $this->getConnection()->prepare($sql);
  331.             $stmt->execute(array_values($ids));
  332.         } catch (TableNotFoundException $e) {
  333.         } catch (\PDOException $e) {
  334.         }
  336.         return true;
  337.     }
  339.     /**
  340.      * {@inheritdoc}
  341.      */
  342.     protected function doSave(array $values, int $lifetime)
  343.     {
  344.         if (!$values = $this->marshaller->marshall($values, $failed)) {
  345.             return $failed;
  346.         }
  348.         $conn = $this->getConnection();
  349.         $useDbalConstants = $conn instanceof Connection;
  351.         $driver = $this->driver;
  352.         $insertSql = "INSERT INTO $this->table ($this->idCol, $this->dataCol, $this->lifetimeCol, $this->timeCol) VALUES (:id, :data, :lifetime, :time)";
  354.         switch (true) {
  355.             case 'mysql' === $driver:
  356.                 $sql = $insertSql." ON DUPLICATE KEY UPDATE $this->dataCol = VALUES($this->dataCol), $this->lifetimeCol = VALUES($this->lifetimeCol), $this->timeCol = VALUES($this->timeCol)";
  357.                 break;
  358.             case 'oci' === $driver:
  359.                 // DUAL is Oracle specific dummy table
  360.                 $sql = "MERGE INTO $this->table USING DUAL ON ($this->idCol = ?) ".
  361.                     "WHEN NOT MATCHED THEN INSERT ($this->idCol, $this->dataCol, $this->lifetimeCol, $this->timeCol) VALUES (?, ?, ?, ?) ".
  362.                     "WHEN MATCHED THEN UPDATE SET $this->dataCol = ?, $this->lifetimeCol = ?, $this->timeCol = ?";
  363.                 break;
  364.             case 'sqlsrv' === $driver && version_compare($this->getServerVersion(), '10', '>='):
  365.                 // MERGE is only available since SQL Server 2008 and must be terminated by semicolon
  366.                 // It also requires HOLDLOCK according to http://weblogs.sqlteam.com/dang/archive/2009/01/31/UPSERT-Race-Condition-With-MERGE.aspx
  367.                 $sql = "MERGE INTO $this->table WITH (HOLDLOCK) USING (SELECT 1 AS dummy) AS src ON ($this->idCol = ?) ".
  368.                     "WHEN NOT MATCHED THEN INSERT ($this->idCol, $this->dataCol, $this->lifetimeCol, $this->timeCol) VALUES (?, ?, ?, ?) ".
  369.                     "WHEN MATCHED THEN UPDATE SET $this->dataCol = ?, $this->lifetimeCol = ?, $this->timeCol = ?;";
  370.                 break;
  371.             case 'sqlite' === $driver:
  372.                 $sql = 'INSERT OR REPLACE'.substr($insertSql, 6);
  373.                 break;
  374.             case 'pgsql' === $driver && version_compare($this->getServerVersion(), '9.5', '>='):
  375.                 $sql = $insertSql." ON CONFLICT ($this->idCol) DO UPDATE SET ($this->dataCol, $this->lifetimeCol, $this->timeCol) = (EXCLUDED.$this->dataCol, EXCLUDED.$this->lifetimeCol, EXCLUDED.$this->timeCol)";
  376.                 break;
  377.             default:
  378.                 $driver = null;
  379.                 $sql = "UPDATE $this->table SET $this->dataCol = :data, $this->lifetimeCol = :lifetime, $this->timeCol = :time WHERE $this->idCol = :id";
  380.                 break;
  381.         }
  383.         $now = time();
  384.         $lifetime = $lifetime ?: null;
  385.         try {
  386.             $stmt = $conn->prepare($sql);
  387.         } catch (TableNotFoundException $e) {
  388.             if (!$conn->isTransactionActive() || \in_array($this->driver, ['pgsql', 'sqlite', 'sqlsrv'], true)) {
  389.                 $this->createTable();
  390.             }
  391.             $stmt = $conn->prepare($sql);
  392.         } catch (\PDOException $e) {
  393.             if (!$conn->inTransaction() || \in_array($this->driver, ['pgsql', 'sqlite', 'sqlsrv'], true)) {
  394.                 $this->createTable();
  395.             }
  396.             $stmt = $conn->prepare($sql);
  397.         }
  399.         if ('sqlsrv' === $driver || 'oci' === $driver) {
  400.             $stmt->bindParam(1, $id);
  401.             $stmt->bindParam(2, $id);
  402.             $stmt->bindParam(3, $data, $useDbalConstants ? ParameterType::LARGE_OBJECT : \PDO::PARAM_LOB);
  403.             $stmt->bindValue(4, $lifetime, $useDbalConstants ? ParameterType::INTEGER : \PDO::PARAM_INT);
  404.             $stmt->bindValue(5, $now, $useDbalConstants ? ParameterType::INTEGER : \PDO::PARAM_INT);
  405.             $stmt->bindParam(6, $data, $useDbalConstants ? ParameterType::LARGE_OBJECT : \PDO::PARAM_LOB);
  406.             $stmt->bindValue(7, $lifetime, $useDbalConstants ? ParameterType::INTEGER : \PDO::PARAM_INT);
  407.             $stmt->bindValue(8, $now, $useDbalConstants ? ParameterType::INTEGER : \PDO::PARAM_INT);
  408.         } else {
  409.             $stmt->bindParam(':id', $id);
  410.             $stmt->bindParam(':data', $data, $useDbalConstants ? ParameterType::LARGE_OBJECT : \PDO::PARAM_LOB);
  411.             $stmt->bindValue(':lifetime', $lifetime, $useDbalConstants ? ParameterType::INTEGER : \PDO::PARAM_INT);
  412.             $stmt->bindValue(':time', $now, $useDbalConstants ? ParameterType::INTEGER : \PDO::PARAM_INT);
  413.         }
  414.         if (null === $driver) {
  415.             $insertStmt = $conn->prepare($insertSql);
  417.             $insertStmt->bindParam(':id', $id);
  418.             $insertStmt->bindParam(':data', $data, $useDbalConstants ? ParameterType::LARGE_OBJECT : \PDO::PARAM_LOB);
  419.             $insertStmt->bindValue(':lifetime', $lifetime, $useDbalConstants ? ParameterType::INTEGER : \PDO::PARAM_INT);
  420.             $insertStmt->bindValue(':time', $now, $useDbalConstants ? ParameterType::INTEGER : \PDO::PARAM_INT);
  421.         }
  423.         foreach ($values as $id => $data) {
  424.             try {
  425.                 $result = $stmt->execute();
  426.             } catch (TableNotFoundException $e) {
  427.                 if (!$conn->isTransactionActive() || \in_array($this->driver, ['pgsql', 'sqlite', 'sqlsrv'], true)) {
  428.                     $this->createTable();
  429.                 }
  430.                 $result = $stmt->execute();
  431.             } catch (\PDOException $e) {
  432.                 if (!$conn->inTransaction() || \in_array($this->driver, ['pgsql', 'sqlite', 'sqlsrv'], true)) {
  433.                     $this->createTable();
  434.                 }
  435.                 $result = $stmt->execute();
  436.             }
  437.             if (null === $driver && !(\is_object($result) ? $result->rowCount() : $stmt->rowCount())) {
  438.                 try {
  439.                     $insertStmt->execute();
  440.                 } catch (DBALException | Exception $e) {
  441.                 } catch (\PDOException $e) {
  442.                     // A concurrent write won, let it be
  443.                 }
  444.             }
  445.         }
  447.         return $failed;
  448.     }
  450.     /**
  451.      * @return \PDO|Connection
  452.      */
  453.     private function getConnection(): object
  454.     {
  455.         if (null === $this->conn) {
  456.             if (strpos($this->dsn, '://')) {
  457.                 if (!class_exists(DriverManager::class)) {
  458.                     throw new InvalidArgumentException(sprintf('Failed to parse the DSN "%s". Try running "composer require doctrine/dbal".', $this->dsn));
  459.                 }
  460.                 $this->conn = DriverManager::getConnection(['url' => $this->dsn]);
  461.             } else {
  462.                 $this->conn = new \PDO($this->dsn, $this->username, $this->password, $this->connectionOptions);
  463.                 $this->conn->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION);
  464.             }
  465.         }
  466.         if (null === $this->driver) {
  467.             if ($this->conn instanceof \PDO) {
  468.                 $this->driver = $this->conn->getAttribute(\PDO::ATTR_DRIVER_NAME);
  469.             } else {
  470.                 $driver = $this->conn->getDriver();
  472.                 switch (true) {
  473.                     case $driver instanceof \Doctrine\DBAL\Driver\Mysqli\Driver:
  474.                         throw new \LogicException(sprintf('The adapter "%s" does not support the mysqli driver, use pdo_mysql instead.', static::class));
  475.                     case $driver instanceof \Doctrine\DBAL\Driver\AbstractMySQLDriver:
  476.                         $this->driver = 'mysql';
  477.                         break;
  478.                     case $driver instanceof \Doctrine\DBAL\Driver\PDOSqlite\Driver:
  479.                     case $driver instanceof \Doctrine\DBAL\Driver\PDO\SQLite\Driver:
  480.                         $this->driver = 'sqlite';
  481.                         break;
  482.                     case $driver instanceof \Doctrine\DBAL\Driver\PDOPgSql\Driver:
  483.                     case $driver instanceof \Doctrine\DBAL\Driver\PDO\PgSQL\Driver:
  484.                         $this->driver = 'pgsql';
  485.                         break;
  486.                     case $driver instanceof \Doctrine\DBAL\Driver\OCI8\Driver:
  487.                     case $driver instanceof \Doctrine\DBAL\Driver\PDOOracle\Driver:
  488.                     case $driver instanceof \Doctrine\DBAL\Driver\PDO\OCI\Driver:
  489.                         $this->driver = 'oci';
  490.                         break;
  491.                     case $driver instanceof \Doctrine\DBAL\Driver\SQLSrv\Driver:
  492.                     case $driver instanceof \Doctrine\DBAL\Driver\PDOSqlsrv\Driver:
  493.                     case $driver instanceof \Doctrine\DBAL\Driver\PDO\SQLSrv\Driver:
  494.                         $this->driver = 'sqlsrv';
  495.                         break;
  496.                     case $driver instanceof \Doctrine\DBAL\Driver:
  497.                         $this->driver = [
  498.                                 'mssql' => 'sqlsrv',
  499.                                 'oracle' => 'oci',
  500.                                 'postgresql' => 'pgsql',
  501.                                 'sqlite' => 'sqlite',
  502.                                 'mysql' => 'mysql',
  503.                             ][$driver->getDatabasePlatform()->getName()] ?? \get_class($driver);
  504.                         break;
  505.                     default:
  506.                         $this->driver = \get_class($driver);
  507.                         break;
  508.                 }
  509.             }
  510.         }
  512.         return $this->conn;
  513.     }
  515.     private function getServerVersion(): string
  516.     {
  517.         if (null === $this->serverVersion) {
  518.             $conn = $this->conn instanceof \PDO ? $this->conn : $this->conn->getWrappedConnection();
  519.             if ($conn instanceof \PDO) {
  520.                 $this->serverVersion = $conn->getAttribute(\PDO::ATTR_SERVER_VERSION);
  521.             } elseif ($conn instanceof ServerInfoAwareConnection) {
  522.                 $this->serverVersion = $conn->getServerVersion();
  523.             } else {
  524.                 $this->serverVersion = '0';
  525.             }
  526.         }
  528.         return $this->serverVersion;
  529.     }
  531.     private function addTableToSchema(Schema $schema): void
  532.     {
  533.         $types = [
  534.             'mysql' => 'binary',
  535.             'sqlite' => 'text',
  536.             'pgsql' => 'string',
  537.             'oci' => 'string',
  538.             'sqlsrv' => 'string',
  539.         ];
  540.         if (!isset($types[$this->driver])) {
  541.             throw new \DomainException(sprintf('Creating the cache table is currently not implemented for PDO driver "%s".', $this->driver));
  542.         }
  544.         $table = $schema->createTable($this->table);
  545.         $table->addColumn($this->idCol, $types[$this->driver], ['length' => 255]);
  546.         $table->addColumn($this->dataCol, 'blob', ['length' => 16777215]);
  547.         $table->addColumn($this->lifetimeCol, 'integer', ['unsigned' => true, 'notnull' => false]);
  548.         $table->addColumn($this->timeCol, 'integer', ['unsigned' => true]);
  549.         $table->setPrimaryKey([$this->idCol]);
  550.     }
  551. }