Issues in MysqliStatement.php - All Issues - Inspection of "Merge pull request #2855 from lcobucci/bc-break/fi..." - doctrine/dbal - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( c7757e...39cb21 )

by Luís

created 2017-11-18 21:31 UTC

Doctrine/DBAL/Driver/Mysqli/MysqliStatement.php (1 issue)

Labels

Duplication 1

Severity

Informational 1

Benjamin Eberlei 1

<?php
/*
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * This software consists of voluntary contributions made by many individuals
 * and is licensed under the MIT license. For more information, see
 * <http://www.doctrine-project.org>.
 */

namespace Doctrine\DBAL\Driver\Mysqli;

use Doctrine\DBAL\Driver\Statement;
use Doctrine\DBAL\Driver\StatementIterator;
use PDO;

/**
 * @author Kim Hemsø Rasmussen <[email protected]>
 */
class MysqliStatement implements \IteratorAggregate, Statement
{
    /**
     * @var array
     */
    protected static $_paramTypeMap = [
        PDO::PARAM_STR => 's',
        PDO::PARAM_BOOL => 'i',
        PDO::PARAM_NULL => 's',
        PDO::PARAM_INT => 'i',
        PDO::PARAM_LOB => 's' // TODO Support LOB bigger then max package size.
    ];

    /**
     * @var \mysqli
     */
    protected $_conn;

    /**
     * @var \mysqli_stmt
     */
    protected $_stmt;

    /**
     * @var null|boolean|array
     */
    protected $_columnNames;

    /**
     * @var null|array
     */
    protected $_rowBindedValues;

    /**
     * @var array
     */
    protected $_bindedValues;

    /**
     * @var string
     */
    protected $types;

    /**
     * Contains ref values for bindValue().
     *
     * @var array
     */
    protected $_values = [];

    /**
     * @var integer
     */
    protected $_defaultFetchMode = PDO::FETCH_BOTH;

    /**
     * Indicates whether the statement is in the state when fetching results is possible
     *
     * @var bool
     */
    private $result = false;

    /**
     * @param \mysqli $conn
     * @param string  $prepareString
     *
     * @throws \Doctrine\DBAL\Driver\Mysqli\MysqliException
     */
    public function __construct(\mysqli $conn, $prepareString)
    {
        $this->_conn = $conn;
        $this->_stmt = $conn->prepare($prepareString);
        if (false === $this->_stmt) {
            throw new MysqliException($this->_conn->error, $this->_conn->sqlstate, $this->_conn->errno);
        }

        $paramCount = $this->_stmt->param_count;
        if (0 < $paramCount) {
            $this->types = str_repeat('s', $paramCount);
            $this->_bindedValues = array_fill(1, $paramCount, null);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function bindParam($column, &$variable, $type = null, $length = null)
    {
        if (null === $type) {
            $type = 's';
        } else {
            if (isset(self::$_paramTypeMap[$type])) {
                $type = self::$_paramTypeMap[$type];
            } else {
                throw new MysqliException("Unknown type: '{$type}'");
            }
        }

        $this->_bindedValues[$column] =& $variable;
        $this->types[$column - 1] = $type;

        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function bindValue($param, $value, $type = null)
    {
        if (null === $type) {
            $type = 's';
        } else {
            if (isset(self::$_paramTypeMap[$type])) {
                $type = self::$_paramTypeMap[$type];
            } else {
                throw new MysqliException("Unknown type: '{$type}'");
            }
        }

        $this->_values[$param] = $value;
        $this->_bindedValues[$param] =& $this->_values[$param];
        $this->types[$param - 1] = $type;

        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function execute($params = null)
    {
        if (null !== $this->_bindedValues) {
            if (null !== $params) {
                if ( ! $this->_bindValues($params)) {
                    throw new MysqliException($this->_stmt->error, $this->_stmt->errno);
                }
            } else {
                if (!call_user_func_array([$this->_stmt, 'bind_param'], [$this->types] + $this->_bindedValues)) {
                    throw new MysqliException($this->_stmt->error, $this->_stmt->sqlstate, $this->_stmt->errno);
                }
            }
        }

        if ( ! $this->_stmt->execute()) {

            throw new MysqliException($this->_stmt->error, $this->_stmt->sqlstate, $this->_stmt->errno);
        }

        if (null === $this->_columnNames) {
            $meta = $this->_stmt->result_metadata();
            if (false !== $meta) {
                $columnNames = [];
                foreach ($meta->fetch_fields() as $col) {
                    $columnNames[] = $col->name;
                }
                $meta->free();

                $this->_columnNames = $columnNames;
            } else {
                $this->_columnNames = false;
            }
        }

        if (false !== $this->_columnNames) {
            // Store result of every execution which has it. Otherwise it will be impossible
            // to execute a new statement in case if the previous one has non-fetched rows
            // @link http://dev.mysql.com/doc/refman/5.7/en/commands-out-of-sync.html
            $this->_stmt->store_result();

            // Bind row values _after_ storing the result. Otherwise, if mysqli is compiled with libmysql,
            // it will have to allocate as much memory as it may be needed for the given column type
            // (e.g. for a LONGBLOB field it's 4 gigabytes)
            // @link https://bugs.php.net/bug.php?id=51386#1270673122
            //
            // Make sure that the values are bound after each execution. Otherwise, if closeCursor() has been
            // previously called on the statement, the values are unbound making the statement unusable.
            //
            // It's also important that row values are bound after _each_ call to store_result(). Otherwise,
            // if mysqli is compiled with libmysql, subsequently fetched string values will get truncated
            // to the length of the ones fetched during the previous execution.
            $this->_rowBindedValues = array_fill(0, count($this->_columnNames), null);

            $refs = [];
            foreach ($this->_rowBindedValues as $key => &$value) {
                $refs[$key] =& $value;
            }

            if (!call_user_func_array([$this->_stmt, 'bind_result'], $refs)) {
                throw new MysqliException($this->_stmt->error, $this->_stmt->sqlstate, $this->_stmt->errno);
            }
        }

        $this->result = true;

        return true;
    }

    /**
     * Binds a array of values to bound parameters.
     *
     * @param array $values
     *
     * @return boolean
     */
    private function _bindValues($values)
    {
        $params = [];
        $types = str_repeat('s', count($values));
        $params[0] = $types;

        foreach ($values as &$v) {
            $params[] =& $v;
        }

        return call_user_func_array([$this->_stmt, 'bind_param'], $params);
    }

    /**
     * @return boolean|array
     */
    private function _fetch()
    {
        $ret = $this->_stmt->fetch();

        if (true === $ret) {
            $values = [];
            foreach ($this->_rowBindedValues as $v) {
                $values[] = $v;
            }

            return $values;
        }

        return $ret;
    }

    /**
     * {@inheritdoc}
     */
    public function fetch($fetchMode = null, $cursorOrientation = \PDO::FETCH_ORI_NEXT, $cursorOffset = 0)
    {
        // do not try fetching from the statement if it's not expected to contain result
        // in order to prevent exceptional situation
        if (!$this->result) {
            return false;
        }

        $values = $this->_fetch();
        if (null === $values) {
            return false;
        }

        if (false === $values) {
            throw new MysqliException($this->_stmt->error, $this->_stmt->sqlstate, $this->_stmt->errno);
        }

        $fetchMode = $fetchMode ?: $this->_defaultFetchMode;

        switch ($fetchMode) {
            case PDO::FETCH_NUM:
                return $values;

            case PDO::FETCH_ASSOC:
                return array_combine($this->_columnNames, $values);

            case PDO::FETCH_BOTH:
                $ret = array_combine($this->_columnNames, $values);
                $ret += $values;

                return $ret;

            case PDO::FETCH_OBJ:
                $assoc = array_combine($this->_columnNames, $values);
                $ret = new \stdClass();

                foreach ($assoc as $column => $value) {
                    $ret->$column = $value;
                }

                return $ret;

            default:
                throw new MysqliException("Unknown fetch type '{$fetchMode}'");
        }
    }

    /**
     * {@inheritdoc}
     */
    public function fetchAll($fetchMode = null, $fetchArgument = null, $ctorArgs = null)
    {
        $fetchMode = $fetchMode ?: $this->_defaultFetchMode;

        $rows = [];
        if (PDO::FETCH_COLUMN == $fetchMode) {
            while (($row = $this->fetchColumn()) !== false) {
                $rows[] = $row;
            }
        } else {
            while (($row = $this->fetch($fetchMode)) !== false) {
                $rows[] = $row;
            }
        }

        return $rows;
    }

    /**
     * {@inheritdoc}
     */
    public function fetchColumn($columnIndex = 0)
    {
        $row = $this->fetch(PDO::FETCH_NUM);
        if (false === $row) {
            return false;
        }

        return isset($row[$columnIndex]) ? $row[$columnIndex] : null;
    }

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

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

    /**
     * {@inheritdoc}
     */
    public function closeCursor()
    {
        $this->_stmt->free_result();
        $this->result = false;

        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function rowCount()
    {
        if (false === $this->_columnNames) {
            return $this->_stmt->affected_rows;
        }

        return $this->_stmt->num_rows;
    }

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

    /**
     * {@inheritdoc}
     */
    public function setFetchMode($fetchMode, $arg2 = null, $arg3 = null)
    {
        $this->_defaultFetchMode = $fetchMode;

        return true;
    }

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


1		<?php
2		/*
3		* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
4		* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
5		* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
6		* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
7		* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
8		* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
9		* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
10		* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
11		* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
12		* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
13		* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
14		*
15		* This software consists of voluntary contributions made by many individuals
16		* and is licensed under the MIT license. For more information, see
17		* <http://www.doctrine-project.org>.
18		*/
19
20		namespace Doctrine\DBAL\Driver\Mysqli;
21
22		use Doctrine\DBAL\Driver\Statement;
23		use Doctrine\DBAL\Driver\StatementIterator;
24		use PDO;
25
26		/**
27		* @author Kim Hemsø Rasmussen <[email protected]>
28		*/
29		class MysqliStatement implements \IteratorAggregate, Statement
30		{
31		/**
32		* @var array
33		*/
34		protected static $_paramTypeMap = [
35		PDO::PARAM_STR => 's',
36		PDO::PARAM_BOOL => 'i',
37		PDO::PARAM_NULL => 's',
38		PDO::PARAM_INT => 'i',
39		PDO::PARAM_LOB => 's' // TODO Support LOB bigger then max package size.
40		];
41
42		/**
43		* @var \mysqli
44		*/
45		protected $_conn;
46
47		/**
48		* @var \mysqli_stmt
49		*/
50		protected $_stmt;
51
52		/**
53		* @var null\|boolean\|array
54		*/
55		protected $_columnNames;
56
57		/**
58		* @var null\|array
59		*/
60		protected $_rowBindedValues;
61
62		/**
63		* @var array
64		*/
65		protected $_bindedValues;
66
67		/**
68		* @var string
69		*/
70		protected $types;
71
72		/**
73		* Contains ref values for bindValue().
74		*
75		* @var array
76		*/
77		protected $_values = [];
78
79		/**
80		* @var integer
81		*/
82		protected $_defaultFetchMode = PDO::FETCH_BOTH;
83
84		/**
85		* Indicates whether the statement is in the state when fetching results is possible
86		*
87		* @var bool
88		*/
89		private $result = false;
90
91		/**
92		* @param \mysqli $conn
93		* @param string $prepareString
94		*
95		* @throws \Doctrine\DBAL\Driver\Mysqli\MysqliException
96		*/
97		public function __construct(\mysqli $conn, $prepareString)
98		{
99		$this->_conn = $conn;
100		$this->_stmt = $conn->prepare($prepareString);
101	View Code Duplication	if (false === $this->_stmt) {
102		throw new MysqliException($this->_conn->error, $this->_conn->sqlstate, $this->_conn->errno);
103		}
104
105		$paramCount = $this->_stmt->param_count;
106		if (0 < $paramCount) {
107		$this->types = str_repeat('s', $paramCount);
108		$this->_bindedValues = array_fill(1, $paramCount, null);
109		}
110		}
111
112		/**
113		* {@inheritdoc}
114		*/
115		public function bindParam($column, &$variable, $type = null, $length = null)
116		{
117	View Code Duplication	if (null === $type) {
118		$type = 's';
119		} else {
120		if (isset(self::$_paramTypeMap[$type])) {
121		$type = self::$_paramTypeMap[$type];
122		} else {
123		throw new MysqliException("Unknown type: '{$type}'");
124		}
125		}
126
127		$this->_bindedValues[$column] =& $variable;
128		$this->types[$column - 1] = $type;
129
130		return true;
131		}
132
133		/**
134		* {@inheritdoc}
135		*/
136		public function bindValue($param, $value, $type = null)
137		{
138	View Code Duplication	if (null === $type) {
139		$type = 's';
140		} else {
141		if (isset(self::$_paramTypeMap[$type])) {
142		$type = self::$_paramTypeMap[$type];
143		} else {
144		throw new MysqliException("Unknown type: '{$type}'");
145		}
146		}
147
148		$this->_values[$param] = $value;
149		$this->_bindedValues[$param] =& $this->_values[$param];
150		$this->types[$param - 1] = $type;
151
152		return true;
153		}
154
155		/**
156		* {@inheritdoc}
157		*/
158		public function execute($params = null)
159		{
160		if (null !== $this->_bindedValues) {
161		if (null !== $params) {
162		if ( ! $this->_bindValues($params)) {
163		throw new MysqliException($this->_stmt->error, $this->_stmt->errno);
164		}
165		} else {
166		if (!call_user_func_array([$this->_stmt, 'bind_param'], [$this->types] + $this->_bindedValues)) {
167		throw new MysqliException($this->_stmt->error, $this->_stmt->sqlstate, $this->_stmt->errno);
168		}
169		}
170		}
171
172	View Code Duplication	if ( ! $this->_stmt->execute()) {
		0 ignored issues – show Duplication introduced 2017-06-29 19:35 UTC by Report Bug Copy Issue Report Show Similar Issues like this This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
173		throw new MysqliException($this->_stmt->error, $this->_stmt->sqlstate, $this->_stmt->errno);
174		}
175
176		if (null === $this->_columnNames) {
177		$meta = $this->_stmt->result_metadata();
178		if (false !== $meta) {
179		$columnNames = [];
180		foreach ($meta->fetch_fields() as $col) {
181		$columnNames[] = $col->name;
182		}
183		$meta->free();
184
185		$this->_columnNames = $columnNames;
186		} else {
187		$this->_columnNames = false;
188		}
189		}
190
191		if (false !== $this->_columnNames) {
192		// Store result of every execution which has it. Otherwise it will be impossible
193		// to execute a new statement in case if the previous one has non-fetched rows
194		// @link http://dev.mysql.com/doc/refman/5.7/en/commands-out-of-sync.html
195		$this->_stmt->store_result();
196
197		// Bind row values _after_ storing the result. Otherwise, if mysqli is compiled with libmysql,
198		// it will have to allocate as much memory as it may be needed for the given column type
199		// (e.g. for a LONGBLOB field it's 4 gigabytes)
200		// @link https://bugs.php.net/bug.php?id=51386#1270673122
201		//
202		// Make sure that the values are bound after each execution. Otherwise, if closeCursor() has been
203		// previously called on the statement, the values are unbound making the statement unusable.
204		//
205		// It's also important that row values are bound after _each_ call to store_result(). Otherwise,
206		// if mysqli is compiled with libmysql, subsequently fetched string values will get truncated
207		// to the length of the ones fetched during the previous execution.
208		$this->_rowBindedValues = array_fill(0, count($this->_columnNames), null);
209
210		$refs = [];
211		foreach ($this->_rowBindedValues as $key => &$value) {
212		$refs[$key] =& $value;
213		}
214
215		if (!call_user_func_array([$this->_stmt, 'bind_result'], $refs)) {
216		throw new MysqliException($this->_stmt->error, $this->_stmt->sqlstate, $this->_stmt->errno);
217		}
218		}
219
220		$this->result = true;
221
222		return true;
223		}
224
225		/**
226		* Binds a array of values to bound parameters.
227		*
228		* @param array $values
229		*
230		* @return boolean
231		*/
232		private function _bindValues($values)
233		{
234		$params = [];
235		$types = str_repeat('s', count($values));
236		$params[0] = $types;
237
238		foreach ($values as &$v) {
239		$params[] =& $v;
240		}
241
242		return call_user_func_array([$this->_stmt, 'bind_param'], $params);
243		}
244
245		/**
246		* @return boolean\|array
247		*/
248		private function _fetch()
249		{
250		$ret = $this->_stmt->fetch();
251
252		if (true === $ret) {
253		$values = [];
254		foreach ($this->_rowBindedValues as $v) {
255		$values[] = $v;
256		}
257
258		return $values;
259		}
260
261		return $ret;
262		}
263
264		/**
265		* {@inheritdoc}
266		*/
267		public function fetch($fetchMode = null, $cursorOrientation = \PDO::FETCH_ORI_NEXT, $cursorOffset = 0)
268		{
269		// do not try fetching from the statement if it's not expected to contain result
270		// in order to prevent exceptional situation
271		if (!$this->result) {
272		return false;
273		}
274
275		$values = $this->_fetch();
276		if (null === $values) {
277		return false;
278		}
279
280	View Code Duplication	if (false === $values) {
281		throw new MysqliException($this->_stmt->error, $this->_stmt->sqlstate, $this->_stmt->errno);
282		}
283
284		$fetchMode = $fetchMode ?: $this->_defaultFetchMode;
285
286		switch ($fetchMode) {
287		case PDO::FETCH_NUM:
288		return $values;
289
290		case PDO::FETCH_ASSOC:
291		return array_combine($this->_columnNames, $values);
292
293		case PDO::FETCH_BOTH:
294		$ret = array_combine($this->_columnNames, $values);
295		$ret += $values;
296
297		return $ret;
298
299		case PDO::FETCH_OBJ:
300		$assoc = array_combine($this->_columnNames, $values);
301		$ret = new \stdClass();
302
303		foreach ($assoc as $column => $value) {
304		$ret->$column = $value;
305		}
306
307		return $ret;
308
309		default:
310		throw new MysqliException("Unknown fetch type '{$fetchMode}'");
311		}
312		}
313
314		/**
315		* {@inheritdoc}
316		*/
317		public function fetchAll($fetchMode = null, $fetchArgument = null, $ctorArgs = null)
318		{
319		$fetchMode = $fetchMode ?: $this->_defaultFetchMode;
320
321		$rows = [];
322		if (PDO::FETCH_COLUMN == $fetchMode) {
323		while (($row = $this->fetchColumn()) !== false) {
324		$rows[] = $row;
325		}
326		} else {
327		while (($row = $this->fetch($fetchMode)) !== false) {
328		$rows[] = $row;
329		}
330		}
331
332		return $rows;
333		}
334
335		/**
336		* {@inheritdoc}
337		*/
338	View Code Duplication	public function fetchColumn($columnIndex = 0)
339		{
340		$row = $this->fetch(PDO::FETCH_NUM);
341		if (false === $row) {
342		return false;
343		}
344
345		return isset($row[$columnIndex]) ? $row[$columnIndex] : null;
346		}
347
348		/**
349		* {@inheritdoc}
350		*/
351		public function errorCode()
352		{
353		return $this->_stmt->errno;
354		}
355
356		/**
357		* {@inheritdoc}
358		*/
359		public function errorInfo()
360		{
361		return $this->_stmt->error;
362		}
363
364		/**
365		* {@inheritdoc}
366		*/
367		public function closeCursor()
368		{
369		$this->_stmt->free_result();
370		$this->result = false;
371
372		return true;
373		}
374
375		/**
376		* {@inheritdoc}
377		*/
378		public function rowCount()
379		{
380		if (false === $this->_columnNames) {
381		return $this->_stmt->affected_rows;
382		}
383
384		return $this->_stmt->num_rows;
385		}
386
387		/**
388		* {@inheritdoc}
389		*/
390		public function columnCount()
391		{
392		return $this->_stmt->field_count;
393		}
394
395		/**
396		* {@inheritdoc}
397		*/
398		public function setFetchMode($fetchMode, $arg2 = null, $arg3 = null)
399		{
400		$this->_defaultFetchMode = $fetchMode;
401
402		return true;
403		}
404
405		/**
406		* {@inheritdoc}
407		*/
408		public function getIterator()
409		{
410		return new StatementIterator($this);
411		}
412		}
413

doctrine / dbal

Push — master ( c7757e...39cb21 )

Doctrine/DBAL/Driver/Mysqli/MysqliStatement.php (1 issue)

Labels

Severity

Introduced By

Duplication Side-by-Side

Filter issues like