DbalReader::doCalcRowCount() - Code Metrics - ddeboer/data-import - Measure and Improve Code Quality continuously with Scrutinizer

DbalReader::doCalcRowCount() A
last analyzed 2017-08-31 09:23 UTC

↳ Parent: DbalReader

Complexity

Conditions	1
Paths	1

Size

Total Lines	7
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	7
rs	9.4285
c	0
b	0
f	0
ccs	5
cts	5
cp	1
cc	1
eloc	4
nc	1
nop	0
crap	1

<?php
namespace Ddeboer\DataImport\Reader;

use Doctrine\DBAL\Connection;
use Doctrine\DBAL\Statement;

/**
 * Reads data through the Doctrine DBAL
 */
class DbalReader implements CountableReader
{
    /**
     * @var Connection
     */
    private $connection;

    /**
     * @var array
     */
    private $data;

    /**
     * @var Statement
     */
    private $stmt;

    /**
     * @var string
     */
    private $sql;

    /**
     * @var array
     */
    private $params;

    /**
     * @var integer
     */
    private $rowCount;

    /**
     * @var boolean
     */
    private $rowCountCalculated = true;

    /**
     * @var string
     */
    private $key;

    /**
     * @param Connection $connection
     * @param string     $sql
     * @param array      $params
     */
    public function __construct(Connection $connection, $sql, array $params = [])
    {
        $this->connection = $connection;

        $this->setSql($sql, $params);
    }

    /**
     * Do calculate row count?
     *
     * @param boolean $calculate
     */
    public function setRowCountCalculated($calculate = true)
    {
        $this->rowCountCalculated = (bool) $calculate;
    }

    /**
     * Is row count calculated?
     *
     * @return boolean
     */
    public function isRowCountCalculated()
    {
        return $this->rowCountCalculated;
    }

    /**
     * {@inheritdoc}
     */
    public function getFields()
    {
        if (null === $this->data) {
            $this->rewind();
        }
        if (false === $this->data) {
            return [];
        }

        return array_keys((array) $this->data);
    }

    /**
     * Set Query string with Parameters
     *
     * @param string $sql
     * @param array  $params
     */
    public function setSql($sql, array $params = [])
    {
        $this->sql = (string) $sql;

        $this->setSqlParameters($params);
    }

    /**
     * Set SQL parameters
     *
     * @param array $params
     */
    public function setSqlParameters(array $params)
    {
        $this->params = $params;

        $this->stmt = null;
        $this->rowCount = null;
    }

    /**
     * {@inheritdoc}
     */
    public function current()
    {
        if (null === $this->data) {
            $this->rewind();
        }

        return $this->data;
    }

    /**
     * {@inheritdoc}
     */
    public function next()
    {
        $this->key++;
        $this->data = $this->stmt->fetch(\PDO::FETCH_ASSOC);

    }

    /**
     * {@inheritdoc}
     */
    public function key()
    {
        return $this->key;
    }

    /**
     * {@inheritdoc}
     */
    public function valid()
    {
        if (null === $this->data) {
            $this->rewind();
        }

        return (false !== $this->data);
    }

    /**
     * {@inheritdoc}
     */
    public function rewind()
    {
        if (null === $this->stmt) {
            $this->stmt = $this->prepare($this->sql, $this->params);
        }
        if (0 !== $this->key) {

            $this->stmt->execute();
            $this->data = $this->stmt->fetch(\PDO::FETCH_ASSOC);

            $this->key = 0;
$answer = 42;

$correct = false;

$correct = (bool) $answer;
        }
    }

    /**
     * {@inheritdoc}
     */
    public function count()
    {
        if (null === $this->rowCount) {
            if ($this->rowCountCalculated) {
                $this->doCalcRowCount();
            } else {
                if (null === $this->stmt) {
                    $this->rewind();
                }
                $this->rowCount = $this->stmt->rowCount();
            }
        }

        return $this->rowCount;
    }

    private function doCalcRowCount()
    {
        $statement = $this->prepare(sprintf('SELECT COUNT(*) FROM (%s) AS count', $this->sql), $this->params);
        $statement->execute();

        $this->rowCount = (int) $statement->fetchColumn(0);
    }

    /**
     * Prepare given statement
     *
     * @param string $sql
     * @param array  $params
     *
     * @return Statement
     */
    private function prepare($sql, array $params)
    {
        $statement = $this->connection->prepare($sql);
        foreach ($params as $key => $value) {
            $statement->bindValue($key, $value);
        }

        return $statement;
    }
}


1		<?php
2		namespace Ddeboer\DataImport\Reader;
3
4		use Doctrine\DBAL\Connection;
5		use Doctrine\DBAL\Statement;
6
7		/**
8		* Reads data through the Doctrine DBAL
9		*/
10		class DbalReader implements CountableReader
11		{
12		/**
13		* @var Connection
14		*/
15		private $connection;
16
17		/**
18		* @var array
19		*/
20		private $data;
21
22		/**
23		* @var Statement
24		*/
25		private $stmt;
26
27		/**
28		* @var string
29		*/
30		private $sql;
31
32		/**
33		* @var array
34		*/
35		private $params;
36
37		/**
38		* @var integer
39		*/
40		private $rowCount;
41
42		/**
43		* @var boolean
44		*/
45		private $rowCountCalculated = true;
46
47		/**
48		* @var string
49		*/
50		private $key;
51
52		/**
53		* @param Connection $connection
54		* @param string $sql
55		* @param array $params
56		*/
57	11	public function __construct(Connection $connection, $sql, array $params = [])
58		{
59	11	$this->connection = $connection;
60
61	11	$this->setSql($sql, $params);
62	11	}
63
64		/**
65		* Do calculate row count?
66		*
67		* @param boolean $calculate
68		*/
69	2	public function setRowCountCalculated($calculate = true)
70		{
71	2	$this->rowCountCalculated = (bool) $calculate;
72	2	}
73
74		/**
75		* Is row count calculated?
76		*
77		* @return boolean
78		*/
79	1	public function isRowCountCalculated()
80		{
81	1	return $this->rowCountCalculated;
82		}
83
84		/**
85		* {@inheritdoc}
86		*/
87	3	public function getFields()
88		{
89	3	if (null === $this->data) {
90	3	$this->rewind();
91	3	}
92	3	if (false === $this->data) {
93	1	return [];
94		}
95
96	2	return array_keys((array) $this->data);
97		}
98
99		/**
100		* Set Query string with Parameters
101		*
102		* @param string $sql
103		* @param array $params
104		*/
105	11	public function setSql($sql, array $params = [])
106		{
107	11	$this->sql = (string) $sql;
108
109	11	$this->setSqlParameters($params);
110	11	}
111
112		/**
113		* Set SQL parameters
114		*
115		* @param array $params
116		*/
117	11	public function setSqlParameters(array $params)
118		{
119	11	$this->params = $params;
120
121	11	$this->stmt = null;
122	11	$this->rowCount = null;
123	11	}
124
125		/**
126		* {@inheritdoc}
127		*/
128	3	public function current()
129		{
130	3	if (null === $this->data) {
131	1	$this->rewind();
132	1	}
133
134	3	return $this->data;
135		}
136
137		/**
138		* {@inheritdoc}
139		*/
140	2	public function next()
141		{
142	2	$this->key++;
143	2	$this->data = $this->stmt->fetch(\PDO::FETCH_ASSOC);
		0 ignored issues – show Documentation Bug introduced 2015-12-09 23:34 UTC by Report Bug Copy Issue Report It seems like `$this->stmt->fetch(\PDO::FETCH_ASSOC)` of type `*` is incompatible with the declared type `array` of property `$data`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
144	2	}
145
146		/**
147		* {@inheritdoc}
148		*/
149	1	public function key()
150		{
151	1	return $this->key;
152		}
153
154		/**
155		* {@inheritdoc}
156		*/
157	3	public function valid()
158		{
159	3	if (null === $this->data) {
160	1	$this->rewind();
161	1	}
162
163	3	return (false !== $this->data);
164		}
165
166		/**
167		* {@inheritdoc}
168		*/
169	8	public function rewind()
170		{
171	8	if (null === $this->stmt) {
172	8	$this->stmt = $this->prepare($this->sql, $this->params);
173	8	}
174	8	if (0 !== $this->key) {
		0 ignored issues – show Unused Code Bug introduced 2016-02-16 14:37 UTC by Report Bug Copy Issue Report The strict comparison `!==` seems to always evaluate to `true` as the types of `0` (`integer`) and `$this->key` (`string`) can never be identical. Maybe you want to use a loose comparison `!=` instead? Loading history...
175	8	$this->stmt->execute();
176	8	$this->data = $this->stmt->fetch(\PDO::FETCH_ASSOC);
		0 ignored issues – show Documentation Bug introduced 2015-12-09 23:34 UTC by Report Bug Copy Issue Report It seems like `$this->stmt->fetch(\PDO::FETCH_ASSOC)` of type `*` is incompatible with the declared type `array` of property `$data`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
177	8	$this->key = 0;
		0 ignored issues – show Documentation Bug introduced 2016-02-16 14:37 UTC by Report Bug Copy Issue Report The property `$key` was declared of type `string`, but `0` is of type `integer`. Maybe add a type cast? This check looks for assignments to scalar types that may be of the wrong type. To ensure the code behaves as expected, it may be a good idea to add an explicit type cast. $answer = 42; $correct = false; $correct = (bool) $answer; Loading history...
178	8	}
179	8	}
180
181		/**
182		* {@inheritdoc}
183		*/
184	3	public function count()
185		{
186	3	if (null === $this->rowCount) {
187	3	if ($this->rowCountCalculated) {
188	2	$this->doCalcRowCount();
189	2	} else {
190	1	if (null === $this->stmt) {
191	1	$this->rewind();
192	1	}
193	1	$this->rowCount = $this->stmt->rowCount();
194		}
195	3	}
196
197	3	return $this->rowCount;
198		}
199
200	2	private function doCalcRowCount()
201		{
202	2	$statement = $this->prepare(sprintf('SELECT COUNT(*) FROM (%s) AS count', $this->sql), $this->params);
203	2	$statement->execute();
204
205	2	$this->rowCount = (int) $statement->fetchColumn(0);
206	2	}
207
208		/**
209		* Prepare given statement
210		*
211		* @param string $sql
212		* @param array $params
213		*
214		* @return Statement
215		*/
216	9	private function prepare($sql, array $params)
217		{
218	9	$statement = $this->connection->prepare($sql);
219	9	foreach ($params as $key => $value) {
220	9	$statement->bindValue($key, $value);
221	9	}
222
223	9	return $statement;
224		}
225		}
226

ddeboer / data-import

DbalReader::doCalcRowCount() A last analyzed 2017-08-31 09:23 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

DbalReader::doCalcRowCount() A
last analyzed 2017-08-31 09:23 UTC