Statement::getIterator() - Code Metrics - Inspection of "Manually merge 3.0.x into master" - doctrine/dbal - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Pull Request — master (#3945)

by Sergei

created 2020-04-12 18:38 UTC

Statement::getIterator() A

↳ Parent: Statement

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	3
rs	10
c	0
b	0
f	0
cc	1
eloc	1
nc	1
nop	0

<?php

declare(strict_types=1);

namespace Doctrine\DBAL\Portability;

use Doctrine\DBAL\Driver\ResultStatement;
use Doctrine\DBAL\Driver\Statement as DriverStatement;
use Doctrine\DBAL\Driver\StatementIterator;
use Doctrine\DBAL\FetchMode;
use Doctrine\DBAL\ParameterType;
use IteratorAggregate;
use function array_change_key_case;
use function assert;
use function is_string;
use function rtrim;

/**
 * Portability wrapper for a Statement.
 */
final class Statement implements IteratorAggregate, DriverStatement
{
    /** @var int */
    private $portability;

    /** @var DriverStatement|ResultStatement */
    private $stmt;

    /** @var int|null */
    private $case;

    /** @var int */
    private $defaultFetchMode = FetchMode::MIXED;

    /**
     * Wraps <tt>Statement</tt> and applies portability measures.
     *
     * @param DriverStatement|ResultStatement $stmt
     */
    public function __construct($stmt, Connection $conn)
    {
        $this->stmt        = $stmt;
        $this->portability = $conn->getPortability();
        $this->case        = $conn->getFetchCase();
    }

    /**
     * {@inheritdoc}
     */
    public function bindParam($param, &$variable, int $type = ParameterType::STRING, ?int $length = null) : void
    {
        assert($this->stmt instanceof DriverStatement);

        $this->stmt->bindParam($param, $variable, $type, $length);
    }

    /**
     * {@inheritdoc}
     */
    public function bindValue($param, $value, int $type = ParameterType::STRING) : void
    {
        assert($this->stmt instanceof DriverStatement);

        $this->stmt->bindValue($param, $value, $type);
    }

    public function closeCursor() : void
    {
        $this->stmt->closeCursor();
    }

    public function columnCount() : int
    {
        return $this->stmt->columnCount();
    }

    /**
     * {@inheritdoc}
     */
    public function execute(?array $params = null) : void
    {
        assert($this->stmt instanceof DriverStatement);

        $this->stmt->execute($params);
    }

    /**
     * {@inheritdoc}
     */
    public function setFetchMode(int $fetchMode, ...$args) : void
    {
        $this->defaultFetchMode = $fetchMode;

        $this->stmt->setFetchMode($fetchMode, ...$args);
    }

    /**
     * {@inheritdoc}
     */
    public function getIterator()
    {
        return new StatementIterator($this);
    }

    /**
     * {@inheritdoc}
     */
    public function fetch(?int $fetchMode = null, ...$args)
    {
        $fetchMode = $fetchMode ?? $this->defaultFetchMode;

        $row = $this->stmt->fetch($fetchMode, ...$args);

        $iterateRow = ($this->portability & (Connection::PORTABILITY_EMPTY_TO_NULL|Connection::PORTABILITY_RTRIM)) !== 0;
        $fixCase    = $this->case !== null
            && ($fetchMode === FetchMode::ASSOCIATIVE || $fetchMode === FetchMode::MIXED)
            && ($this->portability & Connection::PORTABILITY_FIX_CASE) !== 0;

        $row = $this->fixRow($row, $iterateRow, $fixCase);

        return $row;
    }

    /**
     * {@inheritdoc}
     */
    public function fetchAll(?int $fetchMode = null, ...$args) : array
    {
        $fetchMode = $fetchMode ?? $this->defaultFetchMode;

        $rows = $this->stmt->fetchAll($fetchMode, ...$args);

        $iterateRow = ($this->portability & (Connection::PORTABILITY_EMPTY_TO_NULL|Connection::PORTABILITY_RTRIM)) !== 0;
        $fixCase    = $this->case !== null
            && ($fetchMode === FetchMode::ASSOCIATIVE || $fetchMode === FetchMode::MIXED)
            && ($this->portability & Connection::PORTABILITY_FIX_CASE) !== 0;

        if (! $iterateRow && ! $fixCase) {
            return $rows;
        }

        if ($fetchMode === FetchMode::COLUMN) {
            foreach ($rows as $num => $row) {
                $rows[$num] = [$row];
            }
        }

        foreach ($rows as $num => $row) {
            $rows[$num] = $this->fixRow($row, $iterateRow, $fixCase);
        }

        if ($fetchMode === FetchMode::COLUMN) {
            foreach ($rows as $num => $row) {
                $rows[$num] = $row[0];
            }
        }

        return $rows;
    }

    /**
     * {@inheritdoc}
     */
    public function fetchColumn(int $columnIndex = 0)
    {
        $value = $this->stmt->fetchColumn($columnIndex);

        if (($this->portability & Connection::PORTABILITY_EMPTY_TO_NULL) !== 0 && $value === '') {
            $value = null;
        } elseif (($this->portability & Connection::PORTABILITY_RTRIM) !== 0 && is_string($value)) {
            $value = rtrim($value);
        }

        return $value;
    }

    public function rowCount() : int
    {
        assert($this->stmt instanceof DriverStatement);

        return $this->stmt->rowCount();
    }

    /**
     * @param mixed $row
     *
     * @return mixed
     */
    private function fixRow($row, bool $iterateRow, bool $fixCase)
    {
        if ($row === false) {
            return $row;
        }

        if ($fixCase) {
            assert($this->case !== null);
            $row = array_change_key_case($row, $this->case);
        }

        if ($iterateRow) {
            foreach ($row as $k => $v) {
                if (($this->portability & Connection::PORTABILITY_EMPTY_TO_NULL) !== 0 && $v === '') {
                    $row[$k] = null;
                } elseif (($this->portability & Connection::PORTABILITY_RTRIM) !== 0 && is_string($v)) {
                    $row[$k] = rtrim($v);
                }
            }
        }

        return $row;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Doctrine\DBAL\Portability;
6
7			use Doctrine\DBAL\Driver\ResultStatement;
8			use Doctrine\DBAL\Driver\Statement as DriverStatement;
9			use Doctrine\DBAL\Driver\StatementIterator;
10			use Doctrine\DBAL\FetchMode;
11			use Doctrine\DBAL\ParameterType;
12			use IteratorAggregate;
13			use function array_change_key_case;
14			use function assert;
15			use function is_string;
16			use function rtrim;
17
18			/**
19			* Portability wrapper for a Statement.
20			*/
21			final class Statement implements IteratorAggregate, DriverStatement
22			{
23			/** @var int */
24			private $portability;
25
26			/** @var DriverStatement\|ResultStatement */
27			private $stmt;
28
29			/** @var int\|null */
30			private $case;
31
32			/** @var int */
33			private $defaultFetchMode = FetchMode::MIXED;
34
35			/**
36			* Wraps <tt>Statement</tt> and applies portability measures.
37			*
38			* @param DriverStatement\|ResultStatement $stmt
39			*/
40			public function __construct($stmt, Connection $conn)
41			{
42			$this->stmt = $stmt;
43			$this->portability = $conn->getPortability();
44			$this->case = $conn->getFetchCase();
45			}
46
47			/**
48			* {@inheritdoc}
49			*/
50			public function bindParam($param, &$variable, int $type = ParameterType::STRING, ?int $length = null) : void
51			{
52			assert($this->stmt instanceof DriverStatement);
53
54			$this->stmt->bindParam($param, $variable, $type, $length);
55			}
56
57			/**
58			* {@inheritdoc}
59			*/
60			public function bindValue($param, $value, int $type = ParameterType::STRING) : void
61			{
62			assert($this->stmt instanceof DriverStatement);
63
64			$this->stmt->bindValue($param, $value, $type);
65			}
66
67			public function closeCursor() : void
68			{
69			$this->stmt->closeCursor();
70			}
71
72			public function columnCount() : int
73			{
74			return $this->stmt->columnCount();
75			}
76
77			/**
78			* {@inheritdoc}
79			*/
80			public function execute(?array $params = null) : void
81			{
82			assert($this->stmt instanceof DriverStatement);
83
84			$this->stmt->execute($params);
85			}
86
87			/**
88			* {@inheritdoc}
89			*/
90			public function setFetchMode(int $fetchMode, ...$args) : void
91			{
92			$this->defaultFetchMode = $fetchMode;
93
94			$this->stmt->setFetchMode($fetchMode, ...$args);
95			}
96
97			/**
98			* {@inheritdoc}
99			*/
100			public function getIterator()
101			{
102			return new StatementIterator($this);
103			}
104
105			/**
106			* {@inheritdoc}
107			*/
108			public function fetch(?int $fetchMode = null, ...$args)
109			{
110			$fetchMode = $fetchMode ?? $this->defaultFetchMode;
111
112			$row = $this->stmt->fetch($fetchMode, ...$args);
113
114			$iterateRow = ($this->portability & (Connection::PORTABILITY_EMPTY_TO_NULL\|Connection::PORTABILITY_RTRIM)) !== 0;
115			$fixCase = $this->case !== null
116			&& ($fetchMode === FetchMode::ASSOCIATIVE \|\| $fetchMode === FetchMode::MIXED)
117			&& ($this->portability & Connection::PORTABILITY_FIX_CASE) !== 0;
118
119			$row = $this->fixRow($row, $iterateRow, $fixCase);
120
121			return $row;
122			}
123
124			/**
125			* {@inheritdoc}
126			*/
127			public function fetchAll(?int $fetchMode = null, ...$args) : array
128			{
129			$fetchMode = $fetchMode ?? $this->defaultFetchMode;
130
131			$rows = $this->stmt->fetchAll($fetchMode, ...$args);
132
133			$iterateRow = ($this->portability & (Connection::PORTABILITY_EMPTY_TO_NULL\|Connection::PORTABILITY_RTRIM)) !== 0;
134			$fixCase = $this->case !== null
135			&& ($fetchMode === FetchMode::ASSOCIATIVE \|\| $fetchMode === FetchMode::MIXED)
136			&& ($this->portability & Connection::PORTABILITY_FIX_CASE) !== 0;
137
138			if (! $iterateRow && ! $fixCase) {
139			return $rows;
140			}
141
142			if ($fetchMode === FetchMode::COLUMN) {
143			foreach ($rows as $num => $row) {
144			$rows[$num] = [$row];
145			}
146			}
147
148			foreach ($rows as $num => $row) {
149			$rows[$num] = $this->fixRow($row, $iterateRow, $fixCase);
150			}
151
152			if ($fetchMode === FetchMode::COLUMN) {
153			foreach ($rows as $num => $row) {
154			$rows[$num] = $row[0];
155			}
156			}
157
158			return $rows;
159			}
160
161			/**
162			* {@inheritdoc}
163			*/
164			public function fetchColumn(int $columnIndex = 0)
165			{
166			$value = $this->stmt->fetchColumn($columnIndex);
167
168			if (($this->portability & Connection::PORTABILITY_EMPTY_TO_NULL) !== 0 && $value === '') {
169			$value = null;
170			} elseif (($this->portability & Connection::PORTABILITY_RTRIM) !== 0 && is_string($value)) {
171			$value = rtrim($value);
172			}
173
174			return $value;
175			}
176
177			public function rowCount() : int
178			{
179			assert($this->stmt instanceof DriverStatement);
180
181			return $this->stmt->rowCount();
182			}
183
184			/**
185			* @param mixed $row
186			*
187			* @return mixed
188			*/
189			private function fixRow($row, bool $iterateRow, bool $fixCase)
190			{
191			if ($row === false) {
192			return $row;
193			}
194
195			if ($fixCase) {
196			assert($this->case !== null);
197			$row = array_change_key_case($row, $this->case);
198			}
199
200			if ($iterateRow) {
201			foreach ($row as $k => $v) {
202			if (($this->portability & Connection::PORTABILITY_EMPTY_TO_NULL) !== 0 && $v === '') {
203			$row[$k] = null;
204			} elseif (($this->portability & Connection::PORTABILITY_RTRIM) !== 0 && is_string($v)) {
205			$row[$k] = rtrim($v);
206			}
207			}
208			}
209
210			return $row;
211			}
212			}
213

doctrine / dbal

Pull Request — master (#3945)

Statement::getIterator() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like