vendor/doctrine/dbal/src/Driver/PDO/Connection.php line 89

Open in your IDE?
  1. <?php
  3. namespace Doctrine\DBAL\Driver\PDO;
  5. use Doctrine\DBAL\Driver\Exception\UnknownParameterType;
  6. use Doctrine\DBAL\Driver\PDO\PDOException as DriverPDOException;
  7. use Doctrine\DBAL\Driver\Result as ResultInterface;
  8. use Doctrine\DBAL\Driver\ServerInfoAwareConnection;
  9. use Doctrine\DBAL\Driver\Statement as StatementInterface;
  10. use Doctrine\DBAL\ParameterType;
  11. use Doctrine\Deprecations\Deprecation;
  12. use PDO;
  13. use PDOException;
  14. use PDOStatement;
  16. use function assert;
  18. final class Connection implements ServerInfoAwareConnection
  19. {
  20.     private PDO $connection;
  22.     /** @internal The connection can be only instantiated by its driver. */
  23.     public function __construct(PDO $connection)
  24.     {
  25.         $connection->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
  27.         $this->connection = $connection;
  28.     }
  30.     public function exec(string $sql): int
  31.     {
  32.         try {
  33.             $result = $this->connection->exec($sql);
  35.             assert($result !== false);
  37.             return $result;
  38.         } catch (PDOException $exception) {
  39.             throw Exception::new($exception);
  40.         }
  41.     }
  43.     /**
  44.      * {@inheritDoc}
  45.      */
  46.     public function getServerVersion()
  47.     {
  48.         return $this->connection->getAttribute(PDO::ATTR_SERVER_VERSION);
  49.     }
  51.     /**
  52.      * {@inheritDoc}
  53.      *
  54.      * @return Statement
  55.      */
  56.     public function prepare(string $sql): StatementInterface
  57.     {
  58.         try {
  59.             $stmt = $this->connection->prepare($sql);
  60.             assert($stmt instanceof PDOStatement);
  62.             return new Statement($stmt);
  63.         } catch (PDOException $exception) {
  64.             throw Exception::new($exception);
  65.         }
  66.     }
  68.     public function query(string $sql): ResultInterface
  69.     {
  70.         try {
  71.             $stmt = $this->connection->query($sql);
  72.             assert($stmt instanceof PDOStatement);
  74.             return new Result($stmt);
  75.         } catch (PDOException $exception) {
  76.             throw Exception::new($exception);
  77.         }
  78.     }
  80.     /**
  81.      * {@inheritDoc}
  82.      *
  83.      * @throws UnknownParameterType
  84.      *
  85.      * @psalm-assert ParameterType::* $type
  86.      */
  87.     public function quote($value, $type = ParameterType::STRING)
  88.     {
  89.         return $this->connection->quote($value, ParameterTypeMap::convertParamType($type));
  90.     }
  92.     /**
  93.      * {@inheritDoc}
  94.      */
  95.     public function lastInsertId($name = null)
  96.     {
  97.         try {
  98.             if ($name === null) {
  99.                 return $this->connection->lastInsertId();
  100.             }
  102.             Deprecation::triggerIfCalledFromOutside(
  103.                 'doctrine/dbal',
  104.                 'https://github.com/doctrine/dbal/issues/4687',
  105.                 'The usage of Connection::lastInsertId() with a sequence name is deprecated.',
  106.             );
  108.             return $this->connection->lastInsertId($name);
  109.         } catch (PDOException $exception) {
  110.             throw Exception::new($exception);
  111.         }
  112.     }
  114.     public function beginTransaction(): bool
  115.     {
  116.         try {
  117.             return $this->connection->beginTransaction();
  118.         } catch (PDOException $exception) {
  119.             throw DriverPDOException::new($exception);
  120.         }
  121.     }
  123.     public function commit(): bool
  124.     {
  125.         try {
  126.             return $this->connection->commit();
  127.         } catch (PDOException $exception) {
  128.             throw DriverPDOException::new($exception);
  129.         }
  130.     }
  132.     public function rollBack(): bool
  133.     {
  134.         try {
  135.             return $this->connection->rollBack();
  136.         } catch (PDOException $exception) {
  137.             throw DriverPDOException::new($exception);
  138.         }
  139.     }
  141.     public function getNativeConnection(): PDO
  142.     {
  143.         return $this->connection;
  144.     }
  146.     /** @deprecated Call {@see getNativeConnection()} instead. */
  147.     public function getWrappedConnection(): PDO
  148.     {
  149.         Deprecation::triggerIfCalledFromOutside(
  150.             'doctrine/dbal',
  151.             'https://github.com/doctrine/dbal/pull/5037',
  152.             '%s is deprecated, call getNativeConnection() instead.',
  153.             __METHOD__,
  154.         );
  156.         return $this->getNativeConnection();
  157.     }
  158. }