PDOStatement - Code Metrics - Inspection of "fixup! replaced buildout with venv" - crate/crate-pdo - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — b/formatting_error ( 13186c...5fe1d8 )

unknown

created 2017-04-06 10:09 UTC

PDOStatement D

↳ Parent: Project

Complexity

Total Complexity

100

Size/Duplication

Total Lines	606
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

96.6%

Importance

Changes

Metric	Value
wmc	100
lcom	1
cbo	6
dl	0
loc	606
ccs	227
cts	235
cp	0.966
rs	4.848
c	0
b	0
f	0

27 Methods

Rating	Name	Size	Complexity
A	__construct()	7	1
A	replaceNamedParametersWithPositionals()	20	3
A	hasExecuted()	4	2
A	isSuccessful()	10	2
A	getFetchStyle()	4	2
A	updateBoundColumns()	17	3
A	getIterator()	4	1
A	bindColumn()	11	2
A	bindValue()	5	1
B	execute()	26	5
D	fetch()	42	10
C	bindParam()	27	7
A	rowCount()	12	3
B	fetchColumn()	29	6
A	fetchObject()	4	1
A	errorCode()	4	1
A	setAttribute()	4	1
A	getAttribute()	4	1
A	getColumnMeta()	4	1
A	closeCursor()	6	1
A	debugDumpParams()	4	1
C	fetchAll()	62	14
A	errorInfo()	23	3
A	columnCount()	8	2
D	setFetchMode()	36	10
A	nextRowset()	13	3
C	typedValue()	37	13

How to fix Complexity

<?php
/**
 * Licensed to CRATE Technology GmbH("Crate") under one or more contributor
 * license agreements.  See the NOTICE file distributed with this work for
 * additional information regarding copyright ownership.  Crate licenses
 * this file to you under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.  You may
 * obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
 * License for the specific language governing permissions and limitations
 * under the License.
 *
 * However, if you have executed another commercial license agreement
 * with Crate these terms will supersede the license and you may use the
 * software solely pursuant to the terms of the relevant commercial agreement.
 */

namespace Crate\PDO;

use ArrayIterator;
use Closure;
use Crate\Stdlib\ArrayUtils;
use Crate\Stdlib\CollectionInterface;
use Crate\Stdlib\CrateConst;
use InvalidArgumentException;
use IteratorAggregate;
use PDOStatement as BasePDOStatement;

class PDOStatement extends BasePDOStatement implements IteratorAggregate
{
    /**
     * @var array
     */
    private $parameters = [];

    /**
     * @var string|null
     */
    private $errorCode;

    /**
     * @var string|null
     */
    private $errorMessage;

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

    /**
     * @var array
     */
    private $options = [
        'fetchMode'          => null,
        'fetchColumn'        => 0,
        'fetchClass'         => 'array',
        'fetchClassCtorArgs' => null,
    ];

    /**
     * Used for the {@see PDO::FETCH_BOUND}
     *
     * @var array
     */
    private $columnBinding = [];

    /**
     * @var CollectionInterface|null
     */
    private $collection;

    /**
     * @var PDOInterface
     */
    private $pdo;

    /**
     * @var Closure
     */
    private $request;

    private $namedToPositionalMap = array();

    /**
     * @param PDOInterface $pdo
     * @param Closure      $request
     * @param string       $sql
     * @param array        $options
     */
    public function __construct(PDOInterface $pdo, Closure $request, $sql, array $options)
    {
        $this->sql     = $this->replaceNamedParametersWithPositionals($sql);
        $this->pdo     = $pdo;
        $this->options = array_merge($this->options, $options);
        $this->request = $request;
    }

    private function replaceNamedParametersWithPositionals($sql)
    {
        if (strpos($sql, ':') === false) {
            return $sql;
        }
        $pattern = '/:((?:[\w|\d|_](?=([^\'\\\]*(\\\.|\'([^\'\\\]*\\\.)*[^\'\\\]*\'))*[^\']*$))*)/';

        $idx = 1;
        $callback = function ($matches) use (&$idx) {
            $value = $matches[1];
            if (empty($value)) {
                return $matches[0];
            }
            $this->namedToPositionalMap[$idx] = $value;
            $idx++;
            return '?';
        };

        return preg_replace_callback($pattern, $callback, $sql);
    }

    /**
     * Determines if the statement has been executed
     *
     * @internal
     *
     * @return bool
     */
    private function hasExecuted()
    {
        return ($this->collection !== null || $this->errorCode !== null);
    }

    /**
     * Internal pointer to mark the state of the current query
     *
     * @internal
     *
     * @return bool
     */
    private function isSuccessful()
    {
        if (!$this->hasExecuted()) {
            // @codeCoverageIgnoreStart
            throw new Exception\LogicException('The statement has not been executed yet');
            // @codeCoverageIgnoreEnd
        }

        return $this->collection !== null;
    }

    /**
     * Get the fetch style to be used
     *
     * @internal
     *
     * @return int
     */
    private function getFetchStyle()
    {
        return $this->options['fetchMode'] ?: $this->pdo->getAttribute(PDO::ATTR_DEFAULT_FETCH_MODE);
    }

    /**
     * Update all the bound column references
     *
     * @internal
     *
     * @param array $row
     *
     * @return void
     */
    private function updateBoundColumns(array $row)
    {
        foreach ($this->columnBinding as $column => &$metadata) {


            $index = $this->collection->getColumnIndex($column);
            if ($index === null) {
                // todo: I would like to throw an exception and tell someone they screwed up
                // but i think that would violate the PDO api
                continue;
            }

            // Update by reference
            $value = $this->typedValue($row[$index], $metadata['type']);
            $metadata['ref'] = $value;
        }

    }

    /**
     * {@inheritDoc}
     */
    public function execute($input_parameters = null)
    {
        $input_parameters_array = ArrayUtils::toArray($input_parameters);
        $zero_based = isset($input_parameters_array[0]);
        foreach ($input_parameters_array as $parameter => $value) {
            if (is_int($parameter) && $zero_based) {
                $parameter++;
            }
            $this->bindValue($parameter, $value);
        }

        // parameter binding might be unordered, so sort it before execute
        ksort($this->parameters);

        $result = $this->request->__invoke($this, $this->sql, array_values($this->parameters));

        if (is_array($result)) {
            $this->errorCode    = $result['code'];
            $this->errorMessage = $result['message'];

            return false;
        }

        $this->collection = $result;
        return true;
    }

    /**
     * {@inheritDoc}
     */
    public function fetch($fetch_style = null, $cursor_orientation = PDO::FETCH_ORI_NEXT, $cursor_offset = 0)
    {
        if (!$this->hasExecuted()) {
            $this->execute();
        }

        if (!$this->isSuccessful()) {
            return false;
        }

        if (!$this->collection->valid()) {
            return false;
        }

        // Get the current row
        $row = $this->collection->current();

        // Traverse
        $this->collection->next();

        $fetch_style = $fetch_style ?: $this->getFetchStyle();

        switch ($fetch_style)
        {
            case PDO::FETCH_NAMED:
            case PDO::FETCH_ASSOC:
                return array_combine($this->collection->getColumns(false), $row);

            case PDO::FETCH_BOTH:
                return array_merge($row, array_combine($this->collection->getColumns(false), $row));

            case PDO::FETCH_BOUND:
                $this->updateBoundColumns($row);
                return true;

            case PDO::FETCH_NUM:
                return $row;

            default:
                throw new Exception\UnsupportedException('Unsupported fetch style');
        }
    }

    /**
     * {@inheritDoc}
     */
    public function bindParam(
        $parameter,
        & $variable,
        $data_type = PDO::PARAM_STR,
        $length = null,
        $driver_options = null
    ) {
        if (is_numeric($parameter)) {
            if ($parameter == 0) {
                throw new Exception\UnsupportedException("0-based parameter binding not supported, use 1-based");
            }
            $this->parameters[$parameter-1] = &$variable;
        } else {
            $namedParameterKey = substr($parameter, 0, 1) === ':' ? substr($parameter, 1) : $parameter;
            if (in_array($namedParameterKey, $this->namedToPositionalMap, true)) {
                foreach ($this->namedToPositionalMap as $key => $value) {
                    if ($value == $namedParameterKey) {
                        $this->parameters[$key] = &$variable;
                    }
                }
            } else {
                throw new Exception\OutOfBoundsException(
                    sprintf('The named parameter "%s" does not exist', $parameter)
                );
            }
        }
    }

    /**
     * {@inheritDoc}
     */
    public function bindColumn($column, &$param, $type = null, $maxlen = null, $driverdata = null)
    {
        $type = $type ?: PDO::PARAM_STR;

        $this->columnBinding[$column] = [
            'ref'        => &$param,
            'type'       => $type,
            'maxlen'     => $maxlen,
            'driverdata' => $driverdata
        ];
    }

    /**
     * {@inheritDoc}
     */
    public function bindValue($parameter, $value, $data_type = PDO::PARAM_STR)
    {
        $value = $this->typedValue($value, $data_type);
        $this->bindParam($parameter, $value, $data_type);
    }

    /**
     * {@inheritDoc}
     */
    public function rowCount()
    {
        if (!$this->hasExecuted()) {
            $this->execute();
        }

        if (!$this->isSuccessful()) {
            return 0;
        }

        return $this->collection->count();
    }

    /**
     * {@inheritDoc}
     */
    public function fetchColumn($column_number = 0)
    {
        if (!is_int($column_number)) {
            throw new Exception\InvalidArgumentException('column_number must be a valid integer');
        }

        if (!$this->hasExecuted()) {
            $this->execute();
        }

        if (!$this->isSuccessful()) {
            return false;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
        }

        if (!$this->collection->valid()) {
            return false;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
        }

        $row = $this->collection->current();
        $this->collection->next();

        if ($column_number >= count($row)) {
            throw new Exception\OutOfBoundsException(
                sprintf('The column "%d" with the zero-based does not exist', $column_number)
            );
        }

        return $row[$column_number];
    }

    /**
     * {@inheritDoc}
     */
    public function fetchAll($fetch_style = null, $fetch_argument = null, $ctor_args = [])
    {
        if (!$this->hasExecuted()) {
            $this->execute();
        }

        if (!$this->isSuccessful()) {
            return false;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
        }

        $fetch_style = $fetch_style ?: $this->getFetchStyle();

        switch ($fetch_style)
        {
            case PDO::FETCH_NUM:
                return $this->collection->getRows();

            case PDO::FETCH_NAMED:
            case PDO::FETCH_ASSOC:
                $columns = $this->collection->getColumns(false);
                return $this->collection->map(function (array $row) use ($columns) {
                    return array_combine($columns, $row);
                });

            case PDO::FETCH_BOTH:
                $columns = $this->collection->getColumns(false);

                return $this->collection->map(function (array $row) use ($columns) {
                    return array_merge($row, array_combine($columns, $row));
                });

            case PDO::FETCH_FUNC:
                if (!is_callable($fetch_argument)) {
                    throw new Exception\InvalidArgumentException('Second argument must be callable');
                }

                return $this->collection->map(function (array $row) use ($fetch_argument) {
                    return call_user_func_array($fetch_argument, $row);
                });

            case PDO::FETCH_COLUMN:
                $columnIndex = $fetch_argument ?: $this->options['fetchColumn'];

                if (!is_int($columnIndex)) {
                    throw new Exception\InvalidArgumentException('Second argument must be a integer');
                }

                $columns = $this->collection->getColumns(false);
                if (!isset($columns[$columnIndex])) {
                    throw new Exception\OutOfBoundsException(
                        sprintf('Column with the index %d does not exist.', $columnIndex)
                    );
                }

                return $this->collection->map(function (array $row) use ($columnIndex) {
                    return $row[$columnIndex];
                });

            default:
                throw new Exception\UnsupportedException('Unsupported fetch style');
        }
    }

    /**
     * {@inheritDoc}
     */
    public function fetchObject($class_name = null, $ctor_args = null)
    {
        throw new Exception\UnsupportedException;
    }

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

    /**
     * {@inheritDoc}
     */
    public function errorInfo()
    {
        if ($this->errorCode === null) {
            return null;
        }

        switch ($this->errorCode)
        {
            case CrateConst::ERR_INVALID_SQL:
                $ansiErrorCode = 42000;
                break;

            default:
                $ansiErrorCode = 'Not available';
                break;
        }

        return [
            $ansiErrorCode,
            $this->errorCode,
            $this->errorMessage
        ];
    }

    /**
     * {@inheritDoc}
     */
    public function setAttribute($attribute, $value)
    {
        throw new Exception\UnsupportedException('This driver doesn\'t support setting attributes');
    }

    /**
     * {@inheritDoc}
     */
    public function getAttribute($attribute)
    {
        throw new Exception\UnsupportedException('This driver doesn\'t support getting attributes');
    }

    /**
     * {@inheritDoc}
     */
    public function columnCount()
    {
        if (!$this->hasExecuted()) {
            $this->execute();
        }

        return count($this->collection->getColumns(false));
    }

    /**
     * {@inheritDoc}
     */
    public function getColumnMeta($column)
    {
        throw new Exception\UnsupportedException;
    }

    /**
     * {@inheritDoc}
     */
    public function setFetchMode($mode, $params = null)
    {
        $args     = func_get_args();
        $argCount = count($args);

        switch ($mode)
        {
            case PDO::FETCH_COLUMN:
                if ($argCount != 2) {
                    throw new Exception\InvalidArgumentException('fetch mode requires the colno argument');
                }

                if (!is_int($params)) {
                    throw new Exception\InvalidArgumentException('colno must be an integer');
                }

                $this->options['fetchMode']   = $mode;
                $this->options['fetchColumn'] = $params;
                break;

            case PDO::FETCH_ASSOC:
            case PDO::FETCH_NUM:
            case PDO::FETCH_BOTH:
            case PDO::FETCH_BOUND:
            case PDO::FETCH_NAMED:
                if ($params !== null) {
                    throw new Exception\InvalidArgumentException('fetch mode doesn\'t allow any extra arguments');
                }

                $this->options['fetchMode'] = $mode;
                break;

            default:
                throw new Exception\UnsupportedException('Invalid fetch mode specified');
        }
    }

    /**
     * {@inheritDoc}
     */
    public function nextRowset()
    {
        if (!$this->hasExecuted()) {
            $this->execute();
        }

        if (!$this->isSuccessful()) {
            return false;
        }

        $this->collection->next();
        return $this->collection->valid();
    }

    /**
     * {@inheritDoc}
     */
    public function closeCursor()
    {
        $this->errorCode = 0;

        $this->collection = null;
        return true;
    }

    /**
     * {@inheritDoc}
     */
    public function debugDumpParams()
    {
        throw new Exception\UnsupportedException('Not supported, use var_dump($stmt) instead');
    }

    /**
     * {@Inheritdoc}
     */
    public function getIterator()
    {
        return new ArrayIterator($this->fetchAll());
    }

    private function typedValue($value, $data_type)
    {
        switch ($data_type)
        {
            case PDO::PARAM_FLOAT:
            case PDO::PARAM_DOUBLE:
                return (float) $value;

            case PDO::PARAM_INT:
            case PDO::PARAM_LONG:
                return (int) $value;

            case PDO::PARAM_NULL:
                return null;

            case PDO::PARAM_BOOL:
                return (bool) $value;

            case PDO::PARAM_STR:
            case PDO::PARAM_IP:
                return (string) $value;

            case PDO::PARAM_OBJECT:
            case PDO::PARAM_ARRAY:
                return (array) $value;

            case PDO::PARAM_TIMESTAMP:
                if (is_numeric($value)) {
                    return (int) $value;
                }
                return (string) $value;

            default:
                throw new Exception\InvalidArgumentException(sprintf('Parameter type %s not supported', $data_type));
        }

    }
}


1		<?php
2		/**
3		* Licensed to CRATE Technology GmbH("Crate") under one or more contributor
4		* license agreements. See the NOTICE file distributed with this work for
5		* additional information regarding copyright ownership. Crate licenses
6		* this file to you under the Apache License, Version 2.0 (the "License");
7		* you may not use this file except in compliance with the License. You may
8		* obtain a copy of the License at
9		*
10		* http://www.apache.org/licenses/LICENSE-2.0
11		*
12		* Unless required by applicable law or agreed to in writing, software
13		* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
14		* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
15		* License for the specific language governing permissions and limitations
16		* under the License.
17		*
18		* However, if you have executed another commercial license agreement
19		* with Crate these terms will supersede the license and you may use the
20		* software solely pursuant to the terms of the relevant commercial agreement.
21		*/
22
23		namespace Crate\PDO;
24
25		use ArrayIterator;
26		use Closure;
27		use Crate\Stdlib\ArrayUtils;
28		use Crate\Stdlib\CollectionInterface;
29		use Crate\Stdlib\CrateConst;
30		use InvalidArgumentException;
31		use IteratorAggregate;
32		use PDOStatement as BasePDOStatement;
33
34		class PDOStatement extends BasePDOStatement implements IteratorAggregate
35		{
36		/**
37		* @var array
38		*/
39		private $parameters = [];
40
41		/**
42		* @var string\|null
43		*/
44		private $errorCode;
45
46		/**
47		* @var string\|null
48		*/
49		private $errorMessage;
50
51		/**
52		* @var string
53		*/
54		private $sql;
55
56		/**
57		* @var array
58		*/
59		private $options = [
60		'fetchMode' => null,
61		'fetchColumn' => 0,
62		'fetchClass' => 'array',
63		'fetchClassCtorArgs' => null,
64		];
65
66		/**
67		* Used for the {@see PDO::FETCH_BOUND}
68		*
69		* @var array
70		*/
71		private $columnBinding = [];
72
73		/**
74		* @var CollectionInterface\|null
75		*/
76		private $collection;
77
78		/**
79		* @var PDOInterface
80		*/
81		private $pdo;
82
83		/**
84		* @var Closure
85		*/
86		private $request;
87
88		private $namedToPositionalMap = array();
89
90		/**
91		* @param PDOInterface $pdo
92		* @param Closure $request
93		* @param string $sql
94		* @param array $options
95		*/
96	1	public function __construct(PDOInterface $pdo, Closure $request, $sql, array $options)
97		{
98	1	$this->sql = $this->replaceNamedParametersWithPositionals($sql);
99	1	$this->pdo = $pdo;
100	1	$this->options = array_merge($this->options, $options);
101	1	$this->request = $request;
102	1	}
103
104	70	private function replaceNamedParametersWithPositionals($sql)
105		{
106	70	if (strpos($sql, ':') === false) {
107	70	return $sql;
108		}
109	2	$pattern = '/:((?:[\w\|\d\|_](?=([^\'\\\](\\\.\|\'([^\'\\\]\\\.)[^\'\\\]\'))[^\']$))*)/';
110
111	2	$idx = 1;
112		$callback = function ($matches) use (&$idx) {
113	2	$value = $matches[1];
114	2	if (empty($value)) {
115	1	return $matches[0];
116		}
117	2	$this->namedToPositionalMap[$idx] = $value;
118	2	$idx++;
119	2	return '?';
120	2	};
121
122	2	return preg_replace_callback($pattern, $callback, $sql);
123		}
124
125		/**
126		* Determines if the statement has been executed
127		*
128		* @internal
129		*
130		* @return bool
131		*/
132	32	private function hasExecuted()
133		{
134	32	return ($this->collection !== null \|\| $this->errorCode !== null);
135		}
136
137		/**
138		* Internal pointer to mark the state of the current query
139		*
140		* @internal
141		*
142		* @return bool
143		*/
144	30	private function isSuccessful()
145		{
146	30	if (!$this->hasExecuted()) {
147		// @codeCoverageIgnoreStart
148		throw new Exception\LogicException('The statement has not been executed yet');
149		// @codeCoverageIgnoreEnd
150		}
151
152	30	return $this->collection !== null;
153		}
154
155		/**
156		* Get the fetch style to be used
157		*
158		* @internal
159		*
160		* @return int
161		*/
162	2	private function getFetchStyle()
163		{
164	2	return $this->options['fetchMode'] ?: $this->pdo->getAttribute(PDO::ATTR_DEFAULT_FETCH_MODE);
165		}
166
167		/**
168		* Update all the bound column references
169		*
170		* @internal
171		*
172		* @param array $row
173		*
174		* @return void
175		*/
176	1	private function updateBoundColumns(array $row)
177		{
178	1	foreach ($this->columnBinding as $column => &$metadata) {
		0 ignored issues – show Coding Style introduced 2016-04-08 20:27 UTC by Report Bug Copy Issue Report Blank line found at start of control structure Loading history...
179
180	1	$index = $this->collection->getColumnIndex($column);
181	1	if ($index === null) {
182		// todo: I would like to throw an exception and tell someone they screwed up
183		// but i think that would violate the PDO api
184		continue;
185		}
186
187		// Update by reference
188	1	$value = $this->typedValue($row[$index], $metadata['type']);
189	1	$metadata['ref'] = $value;
190		}
191
192	1	}
193
194		/**
195		* {@inheritDoc}
196		*/
197	2	public function execute($input_parameters = null)
198		{
199	2	$input_parameters_array = ArrayUtils::toArray($input_parameters);
200	2	$zero_based = isset($input_parameters_array[0]);
201	2	foreach ($input_parameters_array as $parameter => $value) {
202	1	if (is_int($parameter) && $zero_based) {
203	1	$parameter++;
204		}
205	1	$this->bindValue($parameter, $value);
206		}
207
208		// parameter binding might be unordered, so sort it before execute
209	2	ksort($this->parameters);
210
211	2	$result = $this->request->__invoke($this, $this->sql, array_values($this->parameters));
212
213	2	if (is_array($result)) {
214	1	$this->errorCode = $result['code'];
215	1	$this->errorMessage = $result['message'];
216
217	1	return false;
218		}
219
220	1	$this->collection = $result;
221	1	return true;
222		}
223
224		/**
225		* {@inheritDoc}
226		*/
227	8	public function fetch($fetch_style = null, $cursor_orientation = PDO::FETCH_ORI_NEXT, $cursor_offset = 0)
228		{
229	8	if (!$this->hasExecuted()) {
230	8	$this->execute();
231		}
232
233	8	if (!$this->isSuccessful()) {
234	1	return false;
235		}
236
237	7	if (!$this->collection->valid()) {
238	1	return false;
239		}
240
241		// Get the current row
242	6	$row = $this->collection->current();
243
244		// Traverse
245	6	$this->collection->next();
246
247	6	$fetch_style = $fetch_style ?: $this->getFetchStyle();
248
249		switch ($fetch_style)
250		{
251	6	case PDO::FETCH_NAMED:
252	5	case PDO::FETCH_ASSOC:
253	2	return array_combine($this->collection->getColumns(false), $row);
254
255	4	case PDO::FETCH_BOTH:
256	1	return array_merge($row, array_combine($this->collection->getColumns(false), $row));
257
258	3	case PDO::FETCH_BOUND:
259	1	$this->updateBoundColumns($row);
260	1	return true;
261
262	2	case PDO::FETCH_NUM:
263	1	return $row;
264
265		default:
266	1	throw new Exception\UnsupportedException('Unsupported fetch style');
267		}
268		}
269
270		/**
271		* {@inheritDoc}
272		*/
273	2	public function bindParam(
274		$parameter,
275		& $variable,
276		$data_type = PDO::PARAM_STR,
277		$length = null,
278		$driver_options = null
279		) {
280	2	if (is_numeric($parameter)) {
281	2	if ($parameter == 0) {
282	1	throw new Exception\UnsupportedException("0-based parameter binding not supported, use 1-based");
283		}
284	1	$this->parameters[$parameter-1] = &$variable;
285		} else {
286		$namedParameterKey = substr($parameter, 0, 1) === ':' ? substr($parameter, 1) : $parameter;
287		if (in_array($namedParameterKey, $this->namedToPositionalMap, true)) {
288		foreach ($this->namedToPositionalMap as $key => $value) {
289		if ($value == $namedParameterKey) {
290		$this->parameters[$key] = &$variable;
291		}
292		}
293		} else {
294		throw new Exception\OutOfBoundsException(
295		sprintf('The named parameter "%s" does not exist', $parameter)
296		);
297		}
298		}
299	1	}
300
301		/**
302		* {@inheritDoc}
303		*/
304	1	public function bindColumn($column, &$param, $type = null, $maxlen = null, $driverdata = null)
305		{
306	1	$type = $type ?: PDO::PARAM_STR;
307
308	1	$this->columnBinding[$column] = [
309	1	'ref' => &$param,
310	1	'type' => $type,
311	1	'maxlen' => $maxlen,
312	1	'driverdata' => $driverdata
313		];
314	1	}
315
316		/**
317		* {@inheritDoc}
318		*/
319	4	public function bindValue($parameter, $value, $data_type = PDO::PARAM_STR)
320		{
321	4	$value = $this->typedValue($value, $data_type);
322	4	$this->bindParam($parameter, $value, $data_type);
323	4	}
324
325		/**
326		* {@inheritDoc}
327		*/
328	2	public function rowCount()
329		{
330	2	if (!$this->hasExecuted()) {
331	2	$this->execute();
332		}
333
334	2	if (!$this->isSuccessful()) {
335	1	return 0;
336		}
337
338	1	return $this->collection->count();
339		}
340
341		/**
342		* {@inheritDoc}
343		*/
344	5	public function fetchColumn($column_number = 0)
345		{
346	5	if (!is_int($column_number)) {
347	1	throw new Exception\InvalidArgumentException('column_number must be a valid integer');
348		}
349
350	4	if (!$this->hasExecuted()) {
351	4	$this->execute();
352		}
353
354	4	if (!$this->isSuccessful()) {
355	1	return false;
		0 ignored issues – show Bug Best Practice introduced 2015-12-07 07:15 UTC by Report Bug Copy Issue Report The return type of `return false;` (`false`) is incompatible with the return type of the parent method `PDOStatement::fetchColumn` of type `string`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
356		}
357
358	3	if (!$this->collection->valid()) {
359	2	return false;
		0 ignored issues – show Bug Best Practice introduced 2015-12-07 07:15 UTC by Report Bug Copy Issue Report The return type of `return false;` (`false`) is incompatible with the return type of the parent method `PDOStatement::fetchColumn` of type `string`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
360		}
361
362	2	$row = $this->collection->current();
363	2	$this->collection->next();
364
365	2	if ($column_number >= count($row)) {
366	1	throw new Exception\OutOfBoundsException(
367	1	sprintf('The column "%d" with the zero-based does not exist', $column_number)
368		);
369		}
370
371	1	return $row[$column_number];
372		}
373
374		/**
375		* {@inheritDoc}
376		*/
377	13	public function fetchAll($fetch_style = null, $fetch_argument = null, $ctor_args = [])
378		{
379	13	if (!$this->hasExecuted()) {
380	13	$this->execute();
381		}
382
383	13	if (!$this->isSuccessful()) {
384	1	return false;
		0 ignored issues – show Bug Best Practice introduced 2015-12-07 07:15 UTC by Report Bug Copy Issue Report The return type of `return false;` (`false`) is incompatible with the return type of the parent method `PDOStatement::fetchAll` of type `array`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
385		}
386
387	12	$fetch_style = $fetch_style ?: $this->getFetchStyle();
388
389		switch ($fetch_style)
390		{
391	12	case PDO::FETCH_NUM:
392	1	return $this->collection->getRows();
393
394	11	case PDO::FETCH_NAMED:
395	10	case PDO::FETCH_ASSOC:
396	2	$columns = $this->collection->getColumns(false);
397		return $this->collection->map(function (array $row) use ($columns) {
398	2	return array_combine($columns, $row);
399	2	});
400
401	9	case PDO::FETCH_BOTH:
402	3	$columns = $this->collection->getColumns(false);
403
404		return $this->collection->map(function (array $row) use ($columns) {
405	3	return array_merge($row, array_combine($columns, $row));
406	3	});
407
408	6	case PDO::FETCH_FUNC:
409	2	if (!is_callable($fetch_argument)) {
410	1	throw new Exception\InvalidArgumentException('Second argument must be callable');
411		}
412
413		return $this->collection->map(function (array $row) use ($fetch_argument) {
414	1	return call_user_func_array($fetch_argument, $row);
415	1	});
416
417	4	case PDO::FETCH_COLUMN:
418	3	$columnIndex = $fetch_argument ?: $this->options['fetchColumn'];
419
420	3	if (!is_int($columnIndex)) {
421	1	throw new Exception\InvalidArgumentException('Second argument must be a integer');
422		}
423
424	2	$columns = $this->collection->getColumns(false);
425	2	if (!isset($columns[$columnIndex])) {
426	1	throw new Exception\OutOfBoundsException(
427	1	sprintf('Column with the index %d does not exist.', $columnIndex)
428		);
429		}
430
431	1	return $this->collection->map(function (array $row) use ($columnIndex) {
432	1	return $row[$columnIndex];
433	1	});
434
435		default:
436	1	throw new Exception\UnsupportedException('Unsupported fetch style');
437		}
438		}
439
440		/**
441		* {@inheritDoc}
442		*/
443	1	public function fetchObject($class_name = null, $ctor_args = null)
444		{
445	1	throw new Exception\UnsupportedException;
446		}
447
448		/**
449		* {@inheritDoc}
450		*/
451	1	public function errorCode()
452		{
453	1	return $this->errorCode;
454		}
455
456		/**
457		* {@inheritDoc}
458		*/
459	2	public function errorInfo()
460		{
461	2	if ($this->errorCode === null) {
462	2	return null;
463		}
464
465	2	switch ($this->errorCode)
466		{
467	2	case CrateConst::ERR_INVALID_SQL:
468	1	$ansiErrorCode = 42000;
469	1	break;
470
471		default:
472	1	$ansiErrorCode = 'Not available';
473	1	break;
474		}
475
476		return [
477	2	$ansiErrorCode,
478	2	$this->errorCode,
479	2	$this->errorMessage
480		];
481		}
482
483		/**
484		* {@inheritDoc}
485		*/
486	1	public function setAttribute($attribute, $value)
487		{
488	1	throw new Exception\UnsupportedException('This driver doesn\'t support setting attributes');
489		}
490
491		/**
492		* {@inheritDoc}
493		*/
494	1	public function getAttribute($attribute)
495		{
496	1	throw new Exception\UnsupportedException('This driver doesn\'t support getting attributes');
497		}
498
499		/**
500		* {@inheritDoc}
501		*/
502	2	public function columnCount()
503		{
504	2	if (!$this->hasExecuted()) {
505	2	$this->execute();
506		}
507
508	2	return count($this->collection->getColumns(false));
509		}
510
511		/**
512		* {@inheritDoc}
513		*/
514	1	public function getColumnMeta($column)
515		{
516	1	throw new Exception\UnsupportedException;
517		}
518
519		/**
520		* {@inheritDoc}
521		*/
522	14	public function setFetchMode($mode, $params = null)
523		{
524	14	$args = func_get_args();
525	14	$argCount = count($args);
526
527		switch ($mode)
528		{
529	14	case PDO::FETCH_COLUMN:
530	3	if ($argCount != 2) {
531	1	throw new Exception\InvalidArgumentException('fetch mode requires the colno argument');
532		}
533
534	2	if (!is_int($params)) {
535	1	throw new Exception\InvalidArgumentException('colno must be an integer');
536		}
537
538	1	$this->options['fetchMode'] = $mode;
539	1	$this->options['fetchColumn'] = $params;
540	1	break;
541
542	11	case PDO::FETCH_ASSOC:
543	9	case PDO::FETCH_NUM:
544	7	case PDO::FETCH_BOTH:
545	5	case PDO::FETCH_BOUND:
546	3	case PDO::FETCH_NAMED:
547	10	if ($params !== null) {
548	5	throw new Exception\InvalidArgumentException('fetch mode doesn\'t allow any extra arguments');
549		}
550
551	5	$this->options['fetchMode'] = $mode;
552	5	break;
553
554		default:
555	1	throw new Exception\UnsupportedException('Invalid fetch mode specified');
556		}
557	6	}
558
559		/**
560		* {@inheritDoc}
561		*/
562	2	public function nextRowset()
563		{
564	2	if (!$this->hasExecuted()) {
565	2	$this->execute();
566		}
567
568	2	if (!$this->isSuccessful()) {
569	1	return false;
570		}
571
572	1	$this->collection->next();
573	1	return $this->collection->valid();
574		}
575
576		/**
577		* {@inheritDoc}
578		*/
579	1	public function closeCursor()
580		{
581	1	$this->errorCode = 0;
		0 ignored issues – show Documentation Bug introduced 2016-02-16 14:55 UTC by Report Bug Copy Issue Report It seems like `0` of type `integer` is incompatible with the declared type `string\|null` of property `$errorCode`. 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...
582	1	$this->collection = null;
583	1	return true;
584		}
585
586		/**
587		* {@inheritDoc}
588		*/
589	1	public function debugDumpParams()
590		{
591	1	throw new Exception\UnsupportedException('Not supported, use var_dump($stmt) instead');
592		}
593
594		/**
595		* {@Inheritdoc}
596		*/
597	1	public function getIterator()
598		{
599	1	return new ArrayIterator($this->fetchAll());
600		}
601
602	8	private function typedValue($value, $data_type)
603		{
604		switch ($data_type)
605		{
606	8	case PDO::PARAM_FLOAT:
607	8	case PDO::PARAM_DOUBLE:
608	1	return (float) $value;
609
610	8	case PDO::PARAM_INT:
611	7	case PDO::PARAM_LONG:
612	3	return (int) $value;
613
614	7	case PDO::PARAM_NULL:
615	2	return null;
616
617	6	case PDO::PARAM_BOOL:
618	2	return (bool) $value;
619
620	5	case PDO::PARAM_STR:
621	2	case PDO::PARAM_IP:
622	4	return (string) $value;
623
624	2	case PDO::PARAM_OBJECT:
625	2	case PDO::PARAM_ARRAY:
626	1	return (array) $value;
627
628	2	case PDO::PARAM_TIMESTAMP:
629	1	if (is_numeric($value)) {
630	1	return (int) $value;
631		}
632	1	return (string) $value;
633
634		default:
635	1	throw new Exception\InvalidArgumentException(sprintf('Parameter type %s not supported', $data_type));
636		}
637
638		}
639		}
640

crate / crate-pdo

Push — b/formatting_error ( 13186c...5fe1d8 )

PDOStatement D

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

27 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like