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

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.     public function bindParam(
  66.         $param,
  67.         &$variable,
  68.         $type = ParameterType::STRING,
  69.         $length = null,
  70.         $driverOptions = null
  71.     ): bool {
  72.         if (func_num_args() > 4) {
  73.             Deprecation::triggerIfCalledFromOutside(
  74.                 'doctrine/dbal',
  75.                 'https://github.com/doctrine/dbal/issues/4533',
  76.                 'The $driverOptions argument of Statement::bindParam() is deprecated.'
  77.             );
  78.         }
  80.         $type = $this->convertParamType($type);
  82.         try {
  83.             return $this->stmt->bindParam(
  84.                 $param,
  85.                 $variable,
  86.                 $type,
  87.                 $length ?? 0,
  88.                 ...array_slice(func_get_args(), 4)
  89.             );
  90.         } catch (PDOException $exception) {
  91.             throw Exception::new($exception);
  92.         }
  93.     }
  95.     /**
  96.      * {@inheritdoc}
  97.      */
  98.     public function execute($params = null): ResultInterface
  99.     {
  100.         try {
  101.             $this->stmt->execute($params);
  102.         } catch (PDOException $exception) {
  103.             throw Exception::new($exception);
  104.         }
  106.         return new Result($this->stmt);
  107.     }
  109.     /**
  110.      * Converts DBAL parameter type to PDO parameter type
  111.      *
  112.      * @param int $type Parameter type
  113.      *
  114.      * @throws ExceptionInterface
  115.      */
  116.     private function convertParamType(int $type): int
  117.     {
  118.         if (! isset(self::PARAM_TYPE_MAP[$type])) {
  119.             throw UnknownParameterType::new($type);
  120.         }
  122.         return self::PARAM_TYPE_MAP[$type];
  123.     }
  124. }