vendor/doctrine/dbal/src/Driver/PDO/Statement.php line 92

Open in your IDE?
  1. <?php
  3. namespace Doctrine\DBAL\Driver\PDO;
  5. use Doctrine\DBAL\Driver\Exception as ExceptionInterface;
  6. use Doctrine\DBAL\Driver\Exception\UnknownParameterType;
  7. use Doctrine\DBAL\Driver\Result as ResultInterface;
  8. use Doctrine\DBAL\Driver\Statement as StatementInterface;
  9. use Doctrine\DBAL\ParameterType;
  10. use Doctrine\Deprecations\Deprecation;
  11. use PDO;
  12. use PDOException;
  13. use PDOStatement;
  15. use function array_slice;
  16. use function func_get_args;
  17. use function func_num_args;
  19. final class Statement implements StatementInterface
  20. {
  21.     private const PARAM_TYPE_MAP = [
  22.         ParameterType::NULL => PDO::PARAM_NULL,
  23.         ParameterType::INTEGER => PDO::PARAM_INT,
  24.         ParameterType::STRING => PDO::PARAM_STR,
  25.         ParameterType::ASCII => PDO::PARAM_STR,
  26.         ParameterType::BINARY => PDO::PARAM_LOB,
  27.         ParameterType::LARGE_OBJECT => PDO::PARAM_LOB,
  28.         ParameterType::BOOLEAN => PDO::PARAM_BOOL,
  29.     ];
  31.     /** @var PDOStatement */
  32.     private $stmt;
  34.     /**
  35.      * @internal The statement can be only instantiated by its driver connection.
  36.      */
  37.     public function __construct(PDOStatement $stmt)
  38.     {
  39.         $this->stmt = $stmt;
  40.     }
  42.     /**
  43.      * {@inheritdoc}
  44.      */
  45.     public function bindValue($param, $value, $type = ParameterType::STRING)
  46.     {
  47.         $type = $this->convertParamType($type);
  49.         try {
  50.             return $this->stmt->bindValue($param, $value, $type);
  51.         } catch (PDOException $exception) {
  52.             throw Exception::new($exception);
  53.         }
  54.     }
  56.     /**
  57.      * {@inheritDoc}
  58.      *
  59.      * @param mixed    $param
  60.      * @param mixed    $variable
  61.      * @param int      $type
  62.      * @param int|null $length
  63.      * @param mixed    $driverOptions The usage of the argument is deprecated.
  64.      *
  65.      * @return bool
  66.      */
  67.     public function bindParam($param, &$variable, $type = ParameterType::STRING, $length = null, $driverOptions = null)
  68.     {
  69.         if (func_num_args() > 4) {
  70.             Deprecation::triggerIfCalledFromOutside(
  71.                 'doctrine/dbal',
  72.                 'https://github.com/doctrine/dbal/issues/4533',
  73.                 'The $driverOptions argument of Statement::bindParam() is deprecated.'
  74.             );
  75.         }
  77.         $type = $this->convertParamType($type);
  79.         try {
  80.             return $this->stmt->bindParam($param, $variable, $type, ...array_slice(func_get_args(), 3));
  81.         } catch (PDOException $exception) {
  82.             throw Exception::new($exception);
  83.         }
  84.     }
  86.     /**
  87.      * {@inheritdoc}
  88.      */
  89.     public function execute($params = null): ResultInterface
  90.     {
  91.         try {
  92.             $this->stmt->execute($params);
  93.         } catch (PDOException $exception) {
  94.             throw Exception::new($exception);
  95.         }
  97.         return new Result($this->stmt);
  98.     }
  100.     /**
  101.      * Converts DBAL parameter type to PDO parameter type
  102.      *
  103.      * @param int $type Parameter type
  104.      *
  105.      * @throws ExceptionInterface
  106.      */
  107.     private function convertParamType(int $type): int
  108.     {
  109.         if (! isset(self::PARAM_TYPE_MAP[$type])) {
  110.             throw UnknownParameterType::new($type);
  111.         }
  113.         return self::PARAM_TYPE_MAP[$type];
  114.     }
  115. }