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

Open in your IDE?
  1. <?php
  3. namespace Doctrine\DBAL\Driver\PDO;
  5. use Doctrine\DBAL\Driver\Exception\UnknownParameterType;
  6. use Doctrine\DBAL\Driver\Result as ResultInterface;
  7. use Doctrine\DBAL\Driver\Statement as StatementInterface;
  8. use Doctrine\DBAL\ParameterType;
  9. use Doctrine\Deprecations\Deprecation;
  10. use PDOException;
  11. use PDOStatement;
  13. use function array_slice;
  14. use function func_get_args;
  15. use function func_num_args;
  17. final class Statement implements StatementInterface
  18. {
  19.     private PDOStatement $stmt;
  21.     /** @internal The statement can be only instantiated by its driver connection. */
  22.     public function __construct(PDOStatement $stmt)
  23.     {
  24.         $this->stmt = $stmt;
  25.     }
  27.     /**
  28.      * {@inheritDoc}
  29.      *
  30.      * @throws UnknownParameterType
  31.      *
  32.      * @psalm-assert ParameterType::* $type
  33.      */
  34.     public function bindValue($param, $value, $type = ParameterType::STRING)
  35.     {
  36.         if (func_num_args() < 3) {
  37.             Deprecation::trigger(
  38.                 'doctrine/dbal',
  39.                 'https://github.com/doctrine/dbal/pull/5558',
  40.                 'Not passing $type to Statement::bindValue() is deprecated.'
  41.                     . ' Pass the type corresponding to the parameter being bound.',
  42.             );
  43.         }
  45.         $pdoType = ParameterTypeMap::convertParamType($type);
  47.         try {
  48.             return $this->stmt->bindValue($param, $value, $pdoType);
  49.         } catch (PDOException $exception) {
  50.             throw Exception::new($exception);
  51.         }
  52.     }
  54.     /**
  55.      * {@inheritDoc}
  56.      *
  57.      * @deprecated Use {@see bindValue()} instead.
  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.      * @throws UnknownParameterType
  66.      *
  67.      * @psalm-assert ParameterType::* $type
  68.      */
  69.     public function bindParam(
  70.         $param,
  71.         &$variable,
  72.         $type = ParameterType::STRING,
  73.         $length = null,
  74.         $driverOptions = null
  75.     ): bool {
  76.         Deprecation::trigger(
  77.             'doctrine/dbal',
  78.             'https://github.com/doctrine/dbal/pull/5563',
  79.             '%s is deprecated. Use bindValue() instead.',
  80.             __METHOD__,
  81.         );
  83.         if (func_num_args() < 3) {
  84.             Deprecation::trigger(
  85.                 'doctrine/dbal',
  86.                 'https://github.com/doctrine/dbal/pull/5558',
  87.                 'Not passing $type to Statement::bindParam() is deprecated.'
  88.                     . ' Pass the type corresponding to the parameter being bound.',
  89.             );
  90.         }
  92.         if (func_num_args() > 4) {
  93.             Deprecation::triggerIfCalledFromOutside(
  94.                 'doctrine/dbal',
  95.                 'https://github.com/doctrine/dbal/issues/4533',
  96.                 'The $driverOptions argument of Statement::bindParam() is deprecated.',
  97.             );
  98.         }
  100.         $pdoType = ParameterTypeMap::convertParamType($type);
  102.         try {
  103.             return $this->stmt->bindParam(
  104.                 $param,
  105.                 $variable,
  106.                 $pdoType,
  107.                 $length ?? 0,
  108.                 ...array_slice(func_get_args(), 4),
  109.             );
  110.         } catch (PDOException $exception) {
  111.             throw Exception::new($exception);
  112.         }
  113.     }
  115.     /**
  116.      * {@inheritDoc}
  117.      */
  118.     public function execute($params = null): ResultInterface
  119.     {
  120.         if ($params !== null) {
  121.             Deprecation::trigger(
  122.                 'doctrine/dbal',
  123.                 'https://github.com/doctrine/dbal/pull/5556',
  124.                 'Passing $params to Statement::execute() is deprecated. Bind parameters using'
  125.                     . ' Statement::bindParam() or Statement::bindValue() instead.',
  126.             );
  127.         }
  129.         try {
  130.             $this->stmt->execute($params);
  131.         } catch (PDOException $exception) {
  132.             throw Exception::new($exception);
  133.         }
  135.         return new Result($this->stmt);
  136.     }
  137. }