PdoDatabase - Code Metrics - Inspection of "Add support for partial templates and expose outpu..." - webservco/framework - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — 9.0-dev ( d6cf5f...d73e4e )

by Radu

created 2018-01-21 21:46 UTC

PdoDatabase B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	163
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes	3
Bugs	0	Features	0

Metric	Value
wmc	37
lcom	1
cbo	3
dl	0
loc	163
rs	8.6
c	3
b	0
f	0

12 Methods

Rating	Name	Size	Complexity
B	__construct()	24	2
A	escape()	4	1
A	numRows()	11	4
A	affectedRows()	7	2
A	getRows()	6	1
A	getRow()	5	1
A	getColumn()	5	1
B	bindParams()	20	5
C	getDataType()	25	11
A	setLastInsertId()	4	1
A	query()	16	3
B	transaction()	18	5

<?php
namespace WebServCo\Framework\Libraries;

final class PdoDatabase extends \WebServCo\Framework\AbstractDatabase implements
    \WebServCo\Framework\Interfaces\DatabaseInterface
{
    use \WebServCo\Framework\Traits\DatabaseTrait;
    use \WebServCo\Framework\Traits\MysqlDatabaseTrait;
    
    public function __construct($config)
    {
        parent::__construct($config);
        
        try {
            $this->db = new \PDO(
                $this->setting('driver', 'mysql') .
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                ':host=' . $this->setting('connection/host', '127.0.0.1') .
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                ';dbname=' . $this->setting('connection/dbname', 'test') .
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                ';port=' . $this->setting('connection/port', 3306) .
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                ';charset=utf8mb4',
                $this->setting('connection/username', 'root'),
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                $this->setting('connection/passwd', ''),
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                [
                    \PDO::ATTR_ERRMODE => \PDO::ERRMODE_EXCEPTION,
                    \PDO::ATTR_DEFAULT_FETCH_MODE => \PDO::FETCH_ASSOC,
                    \PDO::ATTR_EMULATE_PREPARES => false,
                    \PDO::ATTR_PERSISTENT => false
                ]
            );
        } catch (\Exception $e) {
            throw new \ErrorException($e->getMessage());
        }
    }
    
    public function escape($string)
    {
        return $this->db->quote($string);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
    }
    
    public function query($query, $params = [])
    {
        if (empty($query)) {
            throw new \ErrorException('No query specified');
        }
        
        if (!empty($params)) {
            $this->stmt = $this->db->prepare($query);
            $this->bindParams($params);
            $this->stmt->execute();
        } else {
            $this->stmt = $this->db->query($query);
        }
        $this->setLastInsertId();
        return $this->stmt;
    }
    
    public function transaction($queries)
    {
        try {
            $this->db->beginTransaction();
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            foreach ($queries as $item) {
                if (!isset($item[0])) {
                    throw new \ErrorException('No query specified');
                }
                $params = isset($item[1]) ? $item[1] : [];
                $this->query($item[0], $params);
            }
            $this->db->commit();
            return true;
        } catch (\Exception $e) {
            $this->db->rollBack();
            throw new \ErrorException($e->getMessage());
        }
    }
    
    public function numRows()
    {
        if (!is_object($this->stmt)) {
            throw new \ErrorException('No Statement object available.');
        }
        if ('mysql' == $this->setting('driver')) {
            return $this->stmt->rowCount();
        }
        $rows = $this->rows ?: $this->stmt->fetchAll(\PDO::FETCH_ASSOC);
        return count($rows);
    }
    
    public function affectedRows()
    {
        if (!is_object($this->stmt)) {
            throw new \ErrorException('No Statement object available.');
        }
        return $this->stmt->rowCount();
    }
    
    public function getRows($query, $params = [])
    {
        $this->query($query, $params);
        $this->rows = $this->stmt->fetchAll(\PDO::FETCH_ASSOC);
        return $this->rows;
    }
    
    public function getRow($query, $params = [])
    {
        $this->query($query, $params);
        return $this->stmt->fetch(\PDO::FETCH_ASSOC);
    }
    
    public function getColumn($query, $params = [], $columnNumber = 0)
    {
        $this->query($query, $params);
        return $this->stmt->fetchColumn($columnNumber);
    }
        
    protected function bindParams($data)
    {
        if (empty($data)) {
            return false;
        }
        
        $i = 1;
        foreach ($data as $item) {
            if (is_array($item)) {
                foreach ($item as $v) {
                    $this->stmt->bindValue($i, $v, $this->getDataType($v));
                    $i++;
                }
            } else {
                $this->stmt->bindValue($i, $item, $this->getDataType($item));
                $i++;
            }
        }
        return true;
    }
    
    protected function getDataType($variable)
    {
        $type = gettype($variable);
        
        switch ($type) {
            case 'NULL':
                return PDO::PARAM_NULL;
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case 'boolean':
                return \PDO::PARAM_BOOL;
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case 'integer':
                return \PDO::PARAM_INT;
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case 'string':
            case 'double':
            case 'array':
            case 'object':
            case 'resource':
            case 'resource (closed)':
            case 'unknown type':
                return \PDO::PARAM_STR;
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
        }
    }
    
    protected function setLastInsertId()
    {
        $this->lastInsertId = $this->db->lastInsertId();
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
    }
}


1			<?php
2			namespace WebServCo\Framework\Libraries;
3
4			final class PdoDatabase extends \WebServCo\Framework\AbstractDatabase implements
5			\WebServCo\Framework\Interfaces\DatabaseInterface
6			{
7			use \WebServCo\Framework\Traits\DatabaseTrait;
8			use \WebServCo\Framework\Traits\MysqlDatabaseTrait;
9
10			public function __construct($config)
11			{
12			parent::__construct($config);
13
14			try {
15			$this->db = new \PDO(
16			$this->setting('driver', 'mysql') .
			0 ignored issues – show Documentation introduced 2018-01-21 20:26 UTC by Report Bug Copy Issue Report `'mysql'` is of type `string`, but the function expects a `boolean`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
17			':host=' . $this->setting('connection/host', '127.0.0.1') .
			0 ignored issues – show Documentation introduced 2018-01-21 20:26 UTC by Report Bug Copy Issue Report `'127.0.0.1'` is of type `string`, but the function expects a `boolean`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
18			';dbname=' . $this->setting('connection/dbname', 'test') .
			0 ignored issues – show Documentation introduced 2018-01-21 20:26 UTC by Report Bug Copy Issue Report `'test'` is of type `string`, but the function expects a `boolean`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
19			';port=' . $this->setting('connection/port', 3306) .
			0 ignored issues – show Documentation introduced 2018-01-21 20:26 UTC by Report Bug Copy Issue Report `3306` is of type `integer`, but the function expects a `boolean`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
20			';charset=utf8mb4',
21			$this->setting('connection/username', 'root'),
			0 ignored issues – show Documentation introduced 2018-01-21 20:26 UTC by Report Bug Copy Issue Report `'root'` is of type `string`, but the function expects a `boolean`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
22			$this->setting('connection/passwd', ''),
			0 ignored issues – show Documentation introduced 2018-01-21 20:26 UTC by Report Bug Copy Issue Report `''` is of type `string`, but the function expects a `boolean`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
23			[
24			\PDO::ATTR_ERRMODE => \PDO::ERRMODE_EXCEPTION,
25			\PDO::ATTR_DEFAULT_FETCH_MODE => \PDO::FETCH_ASSOC,
26			\PDO::ATTR_EMULATE_PREPARES => false,
27			\PDO::ATTR_PERSISTENT => false
28			]
29			);
30			} catch (\Exception $e) {
31			throw new \ErrorException($e->getMessage());
32			}
33			}
34
35			public function escape($string)
36			{
37			return $this->db->quote($string);
			0 ignored issues – show Bug introduced 2018-01-21 20:26 UTC by Report Bug Copy Issue Report The method `quote` does only exist in `PDO`, but not in `mysqli`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
38			}
39
40			public function query($query, $params = [])
41			{
42			if (empty($query)) {
43			throw new \ErrorException('No query specified');
44			}
45
46			if (!empty($params)) {
47			$this->stmt = $this->db->prepare($query);
48			$this->bindParams($params);
49			$this->stmt->execute();
50			} else {
51			$this->stmt = $this->db->query($query);
52			}
53			$this->setLastInsertId();
54			return $this->stmt;
55			}
56
57			public function transaction($queries)
58			{
59			try {
60			$this->db->beginTransaction();
			0 ignored issues – show Bug introduced 2018-01-21 20:26 UTC by Report Bug Copy Issue Report The method `beginTransaction` does only exist in `PDO`, but not in `mysqli`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
61			foreach ($queries as $item) {
62			if (!isset($item[0])) {
63			throw new \ErrorException('No query specified');
64			}
65			$params = isset($item[1]) ? $item[1] : [];
66			$this->query($item[0], $params);
67			}
68			$this->db->commit();
69			return true;
70			} catch (\Exception $e) {
71			$this->db->rollBack();
72			throw new \ErrorException($e->getMessage());
73			}
74			}
75
76			public function numRows()
77			{
78			if (!is_object($this->stmt)) {
79			throw new \ErrorException('No Statement object available.');
80			}
81			if ('mysql' == $this->setting('driver')) {
82			return $this->stmt->rowCount();
83			}
84			$rows = $this->rows ?: $this->stmt->fetchAll(\PDO::FETCH_ASSOC);
85			return count($rows);
86			}
87
88			public function affectedRows()
89			{
90			if (!is_object($this->stmt)) {
91			throw new \ErrorException('No Statement object available.');
92			}
93			return $this->stmt->rowCount();
94			}
95
96			public function getRows($query, $params = [])
97			{
98			$this->query($query, $params);
99			$this->rows = $this->stmt->fetchAll(\PDO::FETCH_ASSOC);
100			return $this->rows;
101			}
102
103			public function getRow($query, $params = [])
104			{
105			$this->query($query, $params);
106			return $this->stmt->fetch(\PDO::FETCH_ASSOC);
107			}
108
109			public function getColumn($query, $params = [], $columnNumber = 0)
110			{
111			$this->query($query, $params);
112			return $this->stmt->fetchColumn($columnNumber);
113			}
114
115			protected function bindParams($data)
116			{
117			if (empty($data)) {
118			return false;
119			}
120
121			$i = 1;
122			foreach ($data as $item) {
123			if (is_array($item)) {
124			foreach ($item as $v) {
125			$this->stmt->bindValue($i, $v, $this->getDataType($v));
126			$i++;
127			}
128			} else {
129			$this->stmt->bindValue($i, $item, $this->getDataType($item));
130			$i++;
131			}
132			}
133			return true;
134			}
135
136			protected function getDataType($variable)
137			{
138			$type = gettype($variable);
139
140			switch ($type) {
141			case 'NULL':
142			return PDO::PARAM_NULL;
143			break;
			0 ignored issues – show Unused Code introduced 2018-01-21 20:26 UTC by Report Bug Copy Issue Report `break` is not strictly necessary here and could be removed. The `break` statement is not necessary if it is preceded for example by a `return` statement: switch ($x) { case 1: return 'foo'; break; // This break is not necessary and can be left off. } If you would like to keep this construct to be consistent with other `case` statements, you can safely mark this issue as a false-positive. Loading history...
144			case 'boolean':
145			return \PDO::PARAM_BOOL;
146			break;
			0 ignored issues – show Unused Code introduced 2018-01-21 20:26 UTC by Report Bug Copy Issue Report `break` is not strictly necessary here and could be removed. The `break` statement is not necessary if it is preceded for example by a `return` statement: switch ($x) { case 1: return 'foo'; break; // This break is not necessary and can be left off. } If you would like to keep this construct to be consistent with other `case` statements, you can safely mark this issue as a false-positive. Loading history...
147			case 'integer':
148			return \PDO::PARAM_INT;
149			break;
			0 ignored issues – show Unused Code introduced 2018-01-21 20:26 UTC by Report Bug Copy Issue Report `break` is not strictly necessary here and could be removed. The `break` statement is not necessary if it is preceded for example by a `return` statement: switch ($x) { case 1: return 'foo'; break; // This break is not necessary and can be left off. } If you would like to keep this construct to be consistent with other `case` statements, you can safely mark this issue as a false-positive. Loading history...
150			case 'string':
151			case 'double':
152			case 'array':
153			case 'object':
154			case 'resource':
155			case 'resource (closed)':
156			case 'unknown type':
157			return \PDO::PARAM_STR;
158			break;
			0 ignored issues – show Unused Code introduced 2018-01-21 20:26 UTC by Report Bug Copy Issue Report `break` is not strictly necessary here and could be removed. The `break` statement is not necessary if it is preceded for example by a `return` statement: switch ($x) { case 1: return 'foo'; break; // This break is not necessary and can be left off. } If you would like to keep this construct to be consistent with other `case` statements, you can safely mark this issue as a false-positive. Loading history...
159			}
160			}
161
162			protected function setLastInsertId()
163			{
164			$this->lastInsertId = $this->db->lastInsertId();
			0 ignored issues – show Bug introduced 2018-01-21 20:26 UTC by Report Bug Copy Issue Report The method `lastInsertId` does only exist in `PDO`, but not in `mysqli`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
165			}
166			}
167

webservco / framework

Push — 9.0-dev ( d6cf5f...d73e4e )

PdoDatabase B

Complexity

Size/Duplication

Coupling/Cohesion

Importance

12 Methods

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like