vendor/doctrine/dbal/lib/Doctrine/DBAL/Statement.php line 161

Open in your IDE?
  1. <?php
  3. namespace Doctrine\DBAL;
  5. use Doctrine\DBAL\Abstraction\Result;
  6. use Doctrine\DBAL\Driver\Exception;
  7. use Doctrine\DBAL\Driver\Statement as DriverStatement;
  8. use Doctrine\DBAL\Exception\NoKeyValue;
  9. use Doctrine\DBAL\Platforms\AbstractPlatform;
  10. use Doctrine\DBAL\Result as BaseResult;
  11. use Doctrine\DBAL\Types\Type;
  12. use Doctrine\Deprecations\Deprecation;
  13. use IteratorAggregate;
  14. use PDO;
  15. use PDOStatement;
  16. use ReturnTypeWillChange;
  17. use Throwable;
  18. use Traversable;
  20. use function array_shift;
  21. use function func_get_args;
  22. use function is_array;
  23. use function is_string;
  25. /**
  26.  * A thin wrapper around a Doctrine\DBAL\Driver\Statement that adds support
  27.  * for logging, DBAL mapping types, etc.
  28.  */
  29. class Statement implements IteratorAggregate, DriverStatement, Result
  30. {
  31.     /**
  32.      * The SQL statement.
  33.      *
  34.      * @var string
  35.      */
  36.     protected $sql;
  38.     /**
  39.      * The bound parameters.
  40.      *
  41.      * @var mixed[]
  42.      */
  43.     protected $params = [];
  45.     /**
  46.      * The parameter types.
  47.      *
  48.      * @var int[]|string[]
  49.      */
  50.     protected $types = [];
  52.     /**
  53.      * The underlying driver statement.
  54.      *
  55.      * @var \Doctrine\DBAL\Driver\Statement
  56.      */
  57.     protected $stmt;
  59.     /**
  60.      * The underlying database platform.
  61.      *
  62.      * @var AbstractPlatform
  63.      */
  64.     protected $platform;
  66.     /**
  67.      * The connection this statement is bound to and executed on.
  68.      *
  69.      * @var Connection
  70.      */
  71.     protected $conn;
  73.     /**
  74.      * Creates a new <tt>Statement</tt> for the given SQL and <tt>Connection</tt>.
  75.      *
  76.      * @internal The statement can be only instantiated by {@link Connection}.
  77.      *
  78.      * @param string     $sql  The SQL of the statement.
  79.      * @param Connection $conn The connection on which the statement should be executed.
  80.      */
  81.     public function __construct($sql, Connection $conn)
  82.     {
  83.         $this->sql      = $sql;
  84.         $this->stmt     = $conn->getWrappedConnection()->prepare($sql);
  85.         $this->conn     = $conn;
  86.         $this->platform = $conn->getDatabasePlatform();
  87.     }
  89.     /**
  90.      * Binds a parameter value to the statement.
  91.      *
  92.      * The value can optionally be bound with a PDO binding type or a DBAL mapping type.
  93.      * If bound with a DBAL mapping type, the binding type is derived from the mapping
  94.      * type and the value undergoes the conversion routines of the mapping type before
  95.      * being bound.
  96.      *
  97.      * @param string|int $param The name or position of the parameter.
  98.      * @param mixed      $value The value of the parameter.
  99.      * @param mixed      $type  Either a PDO binding type or a DBAL mapping type name or instance.
  100.      *
  101.      * @return bool TRUE on success, FALSE on failure.
  102.      */
  103.     public function bindValue($param, $value, $type = ParameterType::STRING)
  104.     {
  105.         $this->params[$param] = $value;
  106.         $this->types[$param]  = $type;
  107.         if ($type !== null) {
  108.             if (is_string($type)) {
  109.                 $type = Type::getType($type);
  110.             }
  112.             if ($type instanceof Type) {
  113.                 $value       = $type->convertToDatabaseValue($value, $this->platform);
  114.                 $bindingType = $type->getBindingType();
  115.             } else {
  116.                 $bindingType = $type;
  117.             }
  119.             return $this->stmt->bindValue($param, $value, $bindingType);
  120.         }
  122.         return $this->stmt->bindValue($param, $value);
  123.     }
  125.     /**
  126.      * Binds a parameter to a value by reference.
  127.      *
  128.      * Binding a parameter by reference does not support DBAL mapping types.
  129.      *
  130.      * @param string|int $param    The name or position of the parameter.
  131.      * @param mixed      $variable The reference to the variable to bind.
  132.      * @param int        $type     The PDO binding type.
  133.      * @param int|null   $length   Must be specified when using an OUT bind
  134.      *                             so that PHP allocates enough memory to hold the returned value.
  135.      *
  136.      * @return bool TRUE on success, FALSE on failure.
  137.      */
  138.     public function bindParam($param, &$variable, $type = ParameterType::STRING, $length = null)
  139.     {
  140.         $this->params[$param] = $variable;
  141.         $this->types[$param]  = $type;
  143.         if ($this->stmt instanceof PDOStatement) {
  144.             $length = $length ?? 0;
  145.         }
  147.         return $this->stmt->bindParam($param, $variable, $type, $length);
  148.     }
  150.     /**
  151.      * Executes the statement with the currently bound parameters.
  152.      *
  153.      * @deprecated Statement::execute() is deprecated, use Statement::executeQuery() or executeStatement() instead
  154.      *
  155.      * @param mixed[]|null $params
  156.      *
  157.      * @return bool TRUE on success, FALSE on failure.
  158.      *
  159.      * @throws Exception
  160.      */
  161.     public function execute($params = null)
  162.     {
  163.         Deprecation::triggerIfCalledFromOutside(
  164.             'doctrine/dbal',
  165.             'https://github.com/doctrine/dbal/pull/4580',
  166.             'Statement::execute() is deprecated, use Statement::executeQuery() or Statement::executeStatement() instead'
  167.         );
  169.         if (is_array($params)) {
  170.             $this->params = $params;
  171.         }
  173.         $logger = $this->conn->getConfiguration()->getSQLLogger();
  174.         if ($logger) {
  175.             $logger->startQuery($this->sql, $this->params, $this->types);
  176.         }
  178.         try {
  179.             $stmt = $this->stmt->execute($params);
  180.         } catch (Throwable $ex) {
  181.             if ($logger) {
  182.                 $logger->stopQuery();
  183.             }
  185.             $this->conn->handleExceptionDuringQuery($ex, $this->sql, $this->params, $this->types);
  186.         }
  188.         if ($logger) {
  189.             $logger->stopQuery();
  190.         }
  192.         return $stmt;
  193.     }
  195.     /**
  196.      * Executes the statement with the currently bound parameters and return result.
  197.      *
  198.      * @param mixed[] $params
  199.      *
  200.      * @throws Exception
  201.      */
  202.     public function executeQuery(array $params = []): BaseResult
  203.     {
  204.         if ($params === []) {
  205.             $params = null; // Workaround as long execute() exists and used internally.
  206.         }
  208.         $this->execute($params);
  210.         return new ForwardCompatibility\Result($this);
  211.     }
  213.     /**
  214.      * Executes the statement with the currently bound parameters and return affected rows.
  215.      *
  216.      * @param mixed[] $params
  217.      *
  218.      * @throws Exception
  219.      */
  220.     public function executeStatement(array $params = []): int
  221.     {
  222.         if ($params === []) {
  223.             $params = null; // Workaround as long execute() exists and used internally.
  224.         }
  226.         $this->execute($params);
  228.         return $this->rowCount();
  229.     }
  231.     /**
  232.      * Closes the cursor, freeing the database resources used by this statement.
  233.      *
  234.      * @deprecated Use Result::free() instead.
  235.      *
  236.      * @return bool TRUE on success, FALSE on failure.
  237.      */
  238.     public function closeCursor()
  239.     {
  240.         Deprecation::triggerIfCalledFromOutside(
  241.             'doctrine/dbal',
  242.             'https://github.com/doctrine/dbal/pull/4049',
  243.             'Statement::closeCursor() is deprecated, use Result::free() instead.'
  244.         );
  246.         return $this->stmt->closeCursor();
  247.     }
  249.     /**
  250.      * Returns the number of columns in the result set.
  251.      *
  252.      * @return int
  253.      */
  254.     public function columnCount()
  255.     {
  256.         return $this->stmt->columnCount();
  257.     }
  259.     /**
  260.      * Fetches the SQLSTATE associated with the last operation on the statement.
  261.      *
  262.      * @deprecated The error information is available via exceptions.
  263.      *
  264.      * @return string|int|bool
  265.      */
  266.     public function errorCode()
  267.     {
  268.         Deprecation::triggerIfCalledFromOutside(
  269.             'doctrine/dbal',
  270.             'https://github.com/doctrine/dbal/pull/3507',
  271.             'Connection::errorCode() is deprecated, use getCode() or getSQLState() on Exception instead.'
  272.         );
  274.         return $this->stmt->errorCode();
  275.     }
  277.     /**
  278.      * {@inheritDoc}
  279.      *
  280.      * @deprecated The error information is available via exceptions.
  281.      */
  282.     public function errorInfo()
  283.     {
  284.         Deprecation::triggerIfCalledFromOutside(
  285.             'doctrine/dbal',
  286.             'https://github.com/doctrine/dbal/pull/3507',
  287.             'Connection::errorInfo() is deprecated, use getCode() or getSQLState() on Exception instead.'
  288.         );
  290.         return $this->stmt->errorInfo();
  291.     }
  293.     /**
  294.      * {@inheritdoc}
  295.      *
  296.      * @deprecated Use one of the fetch- or iterate-related methods.
  297.      */
  298.     public function setFetchMode($fetchMode, $arg2 = null, $arg3 = null)
  299.     {
  300.         Deprecation::triggerIfCalledFromOutside(
  301.             'doctrine/dbal',
  302.             'https://github.com/doctrine/dbal/pull/4019',
  303.             'Statement::setFetchMode() is deprecated, use explicit Result::fetch*() APIs instead.'
  304.         );
  306.         if ($arg2 === null) {
  307.             return $this->stmt->setFetchMode($fetchMode);
  308.         }
  310.         if ($arg3 === null) {
  311.             return $this->stmt->setFetchMode($fetchMode, $arg2);
  312.         }
  314.         return $this->stmt->setFetchMode($fetchMode, $arg2, $arg3);
  315.     }
  317.     /**
  318.      * Required by interface IteratorAggregate.
  319.      *
  320.      * @deprecated Use iterateNumeric(), iterateAssociative() or iterateColumn() instead.
  321.      *
  322.      * {@inheritdoc}
  323.      */
  324.     #[ReturnTypeWillChange]
  325.     public function getIterator()
  326.     {
  327.         Deprecation::trigger(
  328.             'doctrine/dbal',
  329.             'https://github.com/doctrine/dbal/pull/4019',
  330.             'Statement::getIterator() is deprecated, use Result::iterateNumeric(), iterateAssociative() ' .
  331.             'or iterateColumn() instead.'
  332.         );
  334.         return $this->stmt;
  335.     }
  337.     /**
  338.      * {@inheritdoc}
  339.      *
  340.      * @deprecated Use fetchNumeric(), fetchAssociative() or fetchOne() instead.
  341.      */
  342.     public function fetch($fetchMode = null, $cursorOrientation = PDO::FETCH_ORI_NEXT, $cursorOffset = 0)
  343.     {
  344.         Deprecation::triggerIfCalledFromOutside(
  345.             'doctrine/dbal',
  346.             'https://github.com/doctrine/dbal/pull/4019',
  347.             'Statement::fetch() is deprecated, use Result::fetchNumeric(), fetchAssociative() or fetchOne() instead.'
  348.         );
  350.         return $this->stmt->fetch(...func_get_args());
  351.     }
  353.     /**
  354.      * {@inheritdoc}
  355.      *
  356.      * @deprecated Use fetchAllNumeric(), fetchAllAssociative() or fetchFirstColumn() instead.
  357.      */
  358.     public function fetchAll($fetchMode = null, $fetchArgument = null, $ctorArgs = null)
  359.     {
  360.         Deprecation::triggerIfCalledFromOutside(
  361.             'doctrine/dbal',
  362.             'https://github.com/doctrine/dbal/pull/4019',
  363.             'Statement::fetchAll() is deprecated, use Result::fetchAllNumeric(), fetchAllAssociative() or ' .
  364.             'fetchFirstColumn() instead.'
  365.         );
  367.         if ($ctorArgs !== null) {
  368.             return $this->stmt->fetchAll($fetchMode, $fetchArgument, $ctorArgs);
  369.         }
  371.         if ($fetchArgument !== null) {
  372.             return $this->stmt->fetchAll($fetchMode, $fetchArgument);
  373.         }
  375.         return $this->stmt->fetchAll($fetchMode);
  376.     }
  378.     /**
  379.      * {@inheritDoc}
  380.      *
  381.      * @deprecated Use fetchOne() instead.
  382.      */
  383.     public function fetchColumn($columnIndex = 0)
  384.     {
  385.         Deprecation::triggerIfCalledFromOutside(
  386.             'doctrine/dbal',
  387.             'https://github.com/doctrine/dbal/pull/4019',
  388.             'Statement::fetchColumn() is deprecated, use Result::fetchOne() instead.'
  389.         );
  391.         return $this->stmt->fetchColumn($columnIndex);
  392.     }
  394.     /**
  395.      * {@inheritdoc}
  396.      *
  397.      * @deprecated Use Result::fetchNumeric() instead
  398.      *
  399.      * @throws Exception
  400.      */
  401.     public function fetchNumeric()
  402.     {
  403.         Deprecation::triggerIfCalledFromOutside(
  404.             'doctrine/dbal',
  405.             'https://github.com/doctrine/dbal/issues/4554',
  406.             'Statement::%s() is deprecated, use Result::%s() instead.',
  407.             __FUNCTION__,
  408.             __FUNCTION__
  409.         );
  411.         try {
  412.             if ($this->stmt instanceof Result) {
  413.                 return $this->stmt->fetchNumeric();
  414.             }
  416.             return $this->stmt->fetch(FetchMode::NUMERIC);
  417.         } catch (Exception $e) {
  418.             $this->conn->handleDriverException($e);
  419.         }
  420.     }
  422.     /**
  423.      * {@inheritdoc}
  424.      *
  425.      * @deprecated Use Result::fetchAssociative() instead
  426.      *
  427.      * @throws Exception
  428.      */
  429.     public function fetchAssociative()
  430.     {
  431.         Deprecation::triggerIfCalledFromOutside(
  432.             'doctrine/dbal',
  433.             'https://github.com/doctrine/dbal/issues/4554',
  434.             'Statement::%s() is deprecated, use Result::%s() instead.',
  435.             __FUNCTION__,
  436.             __FUNCTION__
  437.         );
  439.         try {
  440.             if ($this->stmt instanceof Result) {
  441.                 return $this->stmt->fetchAssociative();
  442.             }
  444.             return $this->stmt->fetch(FetchMode::ASSOCIATIVE);
  445.         } catch (Exception $e) {
  446.             $this->conn->handleDriverException($e);
  447.         }
  448.     }
  450.     /**
  451.      * {@inheritDoc}
  452.      *
  453.      * @deprecated Use Result::fetchOne() instead
  454.      *
  455.      * @throws Exception
  456.      */
  457.     public function fetchOne()
  458.     {
  459.         Deprecation::triggerIfCalledFromOutside(
  460.             'doctrine/dbal',
  461.             'https://github.com/doctrine/dbal/issues/4554',
  462.             'Statement::%s() is deprecated, use Result::%s() instead.',
  463.             __FUNCTION__,
  464.             __FUNCTION__
  465.         );
  467.         try {
  468.             if ($this->stmt instanceof Result) {
  469.                 return $this->stmt->fetchOne();
  470.             }
  472.             return $this->stmt->fetch(FetchMode::COLUMN);
  473.         } catch (Exception $e) {
  474.             $this->conn->handleDriverException($e);
  475.         }
  476.     }
  478.     /**
  479.      * {@inheritdoc}
  480.      *
  481.      * @deprecated Use Result::fetchAllNumeric() instead
  482.      *
  483.      * @throws Exception
  484.      */
  485.     public function fetchAllNumeric(): array
  486.     {
  487.         Deprecation::triggerIfCalledFromOutside(
  488.             'doctrine/dbal',
  489.             'https://github.com/doctrine/dbal/issues/4554',
  490.             'Statement::%s() is deprecated, use Result::%s() instead.',
  491.             __FUNCTION__,
  492.             __FUNCTION__
  493.         );
  495.         try {
  496.             if ($this->stmt instanceof Result) {
  497.                 return $this->stmt->fetchAllNumeric();
  498.             }
  500.             return $this->stmt->fetchAll(FetchMode::NUMERIC);
  501.         } catch (Exception $e) {
  502.             $this->conn->handleDriverException($e);
  503.         }
  504.     }
  506.     /**
  507.      * {@inheritdoc}
  508.      *
  509.      * @deprecated Use Result::fetchAllAssociative() instead
  510.      *
  511.      * @throws Exception
  512.      */
  513.     public function fetchAllAssociative(): array
  514.     {
  515.         Deprecation::triggerIfCalledFromOutside(
  516.             'doctrine/dbal',
  517.             'https://github.com/doctrine/dbal/issues/4554',
  518.             'Statement::%s() is deprecated, use Result::%s() instead.',
  519.             __FUNCTION__,
  520.             __FUNCTION__
  521.         );
  523.         try {
  524.             if ($this->stmt instanceof Result) {
  525.                 return $this->stmt->fetchAllAssociative();
  526.             }
  528.             return $this->stmt->fetchAll(FetchMode::ASSOCIATIVE);
  529.         } catch (Exception $e) {
  530.             $this->conn->handleDriverException($e);
  531.         }
  532.     }
  534.     /**
  535.      * Returns an associative array with the keys mapped to the first column and the values mapped to the second column.
  536.      *
  537.      * The result must contain at least two columns.
  538.      *
  539.      * @deprecated Use Result::fetchAllKeyValue() instead
  540.      *
  541.      * @return array<mixed,mixed>
  542.      *
  543.      * @throws Exception
  544.      */
  545.     public function fetchAllKeyValue(): array
  546.     {
  547.         Deprecation::triggerIfCalledFromOutside(
  548.             'doctrine/dbal',
  549.             'https://github.com/doctrine/dbal/issues/4554',
  550.             'Statement::%s() is deprecated, use Result::%s() instead.',
  551.             __FUNCTION__,
  552.             __FUNCTION__
  553.         );
  555.         $this->ensureHasKeyValue();
  557.         $data = [];
  559.         foreach ($this->fetchAllNumeric() as [$key, $value]) {
  560.             $data[$key] = $value;
  561.         }
  563.         return $data;
  564.     }
  566.     /**
  567.      * Returns an associative array with the keys mapped to the first column and the values being
  568.      * an associative array representing the rest of the columns and their values.
  569.      *
  570.      * @deprecated Use Result::fetchAllAssociativeIndexed() instead
  571.      *
  572.      * @return array<mixed,array<string,mixed>>
  573.      *
  574.      * @throws Exception
  575.      */
  576.     public function fetchAllAssociativeIndexed(): array
  577.     {
  578.         Deprecation::triggerIfCalledFromOutside(
  579.             'doctrine/dbal',
  580.             'https://github.com/doctrine/dbal/issues/4554',
  581.             'Statement::%s() is deprecated, use Result::%s() instead.',
  582.             __FUNCTION__,
  583.             __FUNCTION__
  584.         );
  586.         $data = [];
  588.         foreach ($this->fetchAll(FetchMode::ASSOCIATIVE) as $row) {
  589.             $data[array_shift($row)] = $row;
  590.         }
  592.         return $data;
  593.     }
  595.     /**
  596.      * {@inheritdoc}
  597.      *
  598.      * @deprecated Use Result::fetchFirstColumn() instead
  599.      *
  600.      * @throws Exception
  601.      */
  602.     public function fetchFirstColumn(): array
  603.     {
  604.         Deprecation::triggerIfCalledFromOutside(
  605.             'doctrine/dbal',
  606.             'https://github.com/doctrine/dbal/issues/4554',
  607.             'Statement::%s() is deprecated, use Result::%s() instead.',
  608.             __FUNCTION__,
  609.             __FUNCTION__
  610.         );
  612.         try {
  613.             if ($this->stmt instanceof Result) {
  614.                 return $this->stmt->fetchFirstColumn();
  615.             }
  617.             return $this->stmt->fetchAll(FetchMode::COLUMN);
  618.         } catch (Exception $e) {
  619.             $this->conn->handleDriverException($e);
  620.         }
  621.     }
  623.     /**
  624.      * {@inheritDoc}
  625.      *
  626.      * @deprecated Use Result::iterateNumeric() instead
  627.      *
  628.      * @return Traversable<int,array<int,mixed>>
  629.      *
  630.      * @throws Exception
  631.      */
  632.     public function iterateNumeric(): Traversable
  633.     {
  634.         Deprecation::triggerIfCalledFromOutside(
  635.             'doctrine/dbal',
  636.             'https://github.com/doctrine/dbal/issues/4554',
  637.             'Statement::%s() is deprecated, use Result::%s() instead.',
  638.             __FUNCTION__,
  639.             __FUNCTION__
  640.         );
  642.         try {
  643.             if ($this->stmt instanceof Result) {
  644.                 while (($row = $this->stmt->fetchNumeric()) !== false) {
  645.                     yield $row;
  646.                 }
  647.             } else {
  648.                 while (($row = $this->stmt->fetch(FetchMode::NUMERIC)) !== false) {
  649.                     yield $row;
  650.                 }
  651.             }
  652.         } catch (Exception $e) {
  653.             $this->conn->handleDriverException($e);
  654.         }
  655.     }
  657.     /**
  658.      * {@inheritDoc}
  659.      *
  660.      * @deprecated Use Result::iterateAssociative() instead
  661.      *
  662.      * @return Traversable<int,array<string,mixed>>
  663.      *
  664.      * @throws Exception
  665.      */
  666.     public function iterateAssociative(): Traversable
  667.     {
  668.         Deprecation::triggerIfCalledFromOutside(
  669.             'doctrine/dbal',
  670.             'https://github.com/doctrine/dbal/issues/4554',
  671.             'Statement::%s() is deprecated, use Result::%s() instead.',
  672.             __FUNCTION__,
  673.             __FUNCTION__
  674.         );
  676.         try {
  677.             if ($this->stmt instanceof Result) {
  678.                 while (($row = $this->stmt->fetchAssociative()) !== false) {
  679.                     yield $row;
  680.                 }
  681.             } else {
  682.                 while (($row = $this->stmt->fetch(FetchMode::ASSOCIATIVE)) !== false) {
  683.                     yield $row;
  684.                 }
  685.             }
  686.         } catch (Exception $e) {
  687.             $this->conn->handleDriverException($e);
  688.         }
  689.     }
  691.     /**
  692.      * Returns an iterator over the result set with the keys mapped to the first column
  693.      * and the values mapped to the second column.
  694.      *
  695.      * The result must contain at least two columns.
  696.      *
  697.      * @deprecated Use Result::iterateKeyValue() instead
  698.      *
  699.      * @return Traversable<mixed,mixed>
  700.      *
  701.      * @throws Exception
  702.      */
  703.     public function iterateKeyValue(): Traversable
  704.     {
  705.         Deprecation::triggerIfCalledFromOutside(
  706.             'doctrine/dbal',
  707.             'https://github.com/doctrine/dbal/issues/4554',
  708.             'Statement::%s() is deprecated, use Result::%s() instead.',
  709.             __FUNCTION__,
  710.             __FUNCTION__
  711.         );
  713.         $this->ensureHasKeyValue();
  715.         foreach ($this->iterateNumeric() as [$key, $value]) {
  716.             yield $key => $value;
  717.         }
  718.     }
  720.     /**
  721.      * Returns an iterator over the result set with the keys mapped to the first column and the values being
  722.      * an associative array representing the rest of the columns and their values.
  723.      *
  724.      * @deprecated Use Result::iterateAssociativeIndexed() instead
  725.      *
  726.      * @return Traversable<mixed,array<string,mixed>>
  727.      *
  728.      * @throws Exception
  729.      */
  730.     public function iterateAssociativeIndexed(): Traversable
  731.     {
  732.         Deprecation::triggerIfCalledFromOutside(
  733.             'doctrine/dbal',
  734.             'https://github.com/doctrine/dbal/issues/4554',
  735.             'Statement::%s() is deprecated, use Result::%s() instead.',
  736.             __FUNCTION__,
  737.             __FUNCTION__
  738.         );
  740.         while (($row = $this->stmt->fetch(FetchMode::ASSOCIATIVE)) !== false) {
  741.             yield array_shift($row) => $row;
  742.         }
  743.     }
  745.     /**
  746.      * {@inheritDoc}
  747.      *
  748.      * @deprecated Use Result::iterateColumn() instead
  749.      *
  750.      * @return Traversable<int,mixed>
  751.      *
  752.      * @throws Exception
  753.      */
  754.     public function iterateColumn(): Traversable
  755.     {
  756.         Deprecation::triggerIfCalledFromOutside(
  757.             'doctrine/dbal',
  758.             'https://github.com/doctrine/dbal/issues/4554',
  759.             'Statement::%s() is deprecated, use Result::%s() instead.',
  760.             __FUNCTION__,
  761.             __FUNCTION__
  762.         );
  764.         try {
  765.             if ($this->stmt instanceof Result) {
  766.                 while (($value = $this->stmt->fetchOne()) !== false) {
  767.                     yield $value;
  768.                 }
  769.             } else {
  770.                 while (($value = $this->stmt->fetch(FetchMode::COLUMN)) !== false) {
  771.                     yield $value;
  772.                 }
  773.             }
  774.         } catch (Exception $e) {
  775.             $this->conn->handleDriverException($e);
  776.         }
  777.     }
  779.     /**
  780.      * Returns the number of rows affected by the last execution of this statement.
  781.      *
  782.      * @return int|string The number of affected rows.
  783.      */
  784.     public function rowCount()
  785.     {
  786.         return $this->stmt->rowCount();
  787.     }
  789.     public function free(): void
  790.     {
  791.         if ($this->stmt instanceof Result) {
  792.             $this->stmt->free();
  794.             return;
  795.         }
  797.         $this->stmt->closeCursor();
  798.     }
  800.     /**
  801.      * Gets the wrapped driver statement.
  802.      *
  803.      * @return \Doctrine\DBAL\Driver\Statement
  804.      */
  805.     public function getWrappedStatement()
  806.     {
  807.         return $this->stmt;
  808.     }
  810.     private function ensureHasKeyValue(): void
  811.     {
  812.         $columnCount = $this->columnCount();
  814.         if ($columnCount < 2) {
  815.             throw NoKeyValue::fromColumnCount($columnCount);
  816.         }
  817.     }
  818. }