Query::lastAutoIncrementId() - Code Metrics - Inspection of "Fixed errors revealed by Scrutinizer." - lagdo/dbadmin-driver - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — main ( 40936e...9d67f9 )

by Thierry

created 2021-10-26 11:20 UTC

Query::lastAutoIncrementId() A

↳ Parent: Query

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

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

<?php

namespace Lagdo\DbAdmin\Driver\Db;

use Lagdo\DbAdmin\Driver\Entity\TableFieldEntity;
use Lagdo\DbAdmin\Driver\Entity\TableEntity;

use Lagdo\DbAdmin\Driver\DriverInterface;
use Lagdo\DbAdmin\Driver\UtilInterface;
use Lagdo\DbAdmin\Driver\TranslatorInterface;
use Lagdo\DbAdmin\Driver\Db\ConnectionInterface;

abstract class Query implements QueryInterface
{
    /**
     * @var DriverInterface
     */
    protected $driver;

    /**
     * @var UtilInterface
     */
    protected $util;

    /**
     * @var TranslatorInterface
     */
    protected $trans;

    /**
     * @var ConnectionInterface
     */
    protected $connection;

    /**
     * The last error code
     *
     * @var int
     */
    protected $errno = 0;

    /**
     * The last error message
     *
     * @var string
     */
    protected $error = '';

    /**
     * The number of rows affected by the last query
     *
     * @var int
     */
    protected $affectedRows;

    /**
     * The constructor
     *
     * @param DriverInterface $driver
     * @param UtilInterface $util
     * @param TranslatorInterface $trans
     * @param ConnectionInterface $connection
     */
    public function __construct(DriverInterface $driver, UtilInterface $util, TranslatorInterface $trans, ConnectionInterface $connection)
    {
        $this->driver = $driver;
        $this->util = $util;
        $this->trans = $trans;
        $this->connection = $connection;
    }

    /**
     * @inheritDoc
     */
    public function schema()
    {
        return "";
    }

    /**
     * @inheritDoc
     */
    public function select(string $table, array $select, array $where,
        array $group, array $order = [], int $limit = 1, int $page = 0)
    {
        $query = $this->driver->buildSelectQuery($table, $select, $where, $group, $order, $limit, $page);
        // $start = microtime(true);
        return $this->connection->query($query);
    }

    /**
     * @inheritDoc
     */
    public function insert(string $table, array $values)
    {
        $table = $this->driver->table($table);
        if (!empty($values)) {
            return $this->driver->queries("INSERT INTO $table DEFAULT VALUES");
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
        }
        return $this->driver->queries("INSERT INTO $table (" .
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
            implode(", ", array_keys($values)) . ") VALUES (" . implode(", ", $values) . ")");
    }

    /**
     * @inheritDoc
     */
    public function update(string $table, array $values, string $queryWhere, int $limit = 0, string $separator = "\n")
    {
        $assignments = [];
        foreach ($values as $name => $value) {
            $assignments[] = "$name = $value";
        }
        $query = $this->driver->table($table) . " SET$separator" . implode(",$separator", $assignments);
        if (!$limit) {
            return $this->driver->queries('UPDATE ' . $query . $queryWhere);
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
        }
        return $this->driver->queries('UPDATE' . $this->driver->limitToOne($table, $query, $queryWhere, $separator));
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
    }

    /**
     * @inheritDoc
     */
    public function delete(string $table, string $queryWhere, int $limit = 0)
    {
        $query = 'FROM ' . $this->driver->table($table);
        if (!$limit) {
            return $this->driver->queries("DELETE $query $queryWhere");
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
        }
        return $this->driver->queries('DELETE' . $this->driver->limitToOne($table, $query, $queryWhere));
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
    }

    /**
     * @inheritDoc
     */
    public function explain(ConnectionInterface $connection, string $query)
    {
        return null;
    }

    /**
     * @inheritDoc
     */
    public function slowQuery(string $query, int $timeout)
    {
    }

    /**
     * @inheritDoc
     */
    public function setError(string $error = '')
    {
        $this->error = $error;
    }

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

    /**
     * @inheritDoc
     */
    public function hasError()
    {
        return $this->error !== '';
    }

    /**
     * @inheritDoc
     */
    public function setErrno($errno)
    {
        $this->errno = $errno;
    }

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

    /**
     * @inheritDoc
     */
    public function hasErrno()
    {
        return $this->errno !== 0;
    }

    /**
     * @inheritDoc
     */
    public function setAffectedRows($affectedRows)
    {
        $this->affectedRows = $affectedRows;
    }

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

    /**
     * @inheritDoc
     */
    public function queries(string $query = '')
    {
        static $queries = [];
        static $start;
        if (!$start) {
            $start = microtime(true);
        }
        if ($query === '') {
            // return executed queries
            return [implode("\n", $queries), $this->trans->formatTime($start)];
        }
        $queries[] = (preg_match('~;$~', $query) ? "DELIMITER ;;\n$query;\nDELIMITER " : $query) . ";";
        return $this->connection->query($query);
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
    }

    /**
     * @inheritDoc
     */
    public function applyQueries(string $query, array $tables, $escape = null)
    {
        if (!$escape) {
            $escape = function ($table) {
                return $this->driver->table($table);
            };
        }
        foreach ($tables as $table) {
            if (!$this->queries("$query " . $escape($table))) {
                return false;
            }
        }
        return true;
    }

    /**
     * @inheritDoc
     */
    public function values(string $query, $column = 0)
    {
        $values = [];
        $statement = $this->connection->query($query);
        if (is_object($statement)) {
            while ($row = $statement->fetchRow()) {
                $values[] = $row[$column];
            }
        }
        return $values;
    }

    /**
     * @inheritDoc
     */
    public function keyValues(string $query, ConnectionInterface $connection = null, bool $setKeys = true)
    {
        if (!is_object($connection)) {
            $connection = $this->connection;
        }
        $values = [];
        $statement = $connection->query($query);
        if (is_object($statement)) {
            while ($row = $statement->fetchRow()) {
                if ($setKeys) {
                    $values[$row[0]] = $row[1];
                } else {
                    $values[] = $row[0];
                }
            }
        }
        return $values;
    }

    /**
     * @inheritDoc
     */
    public function rows(string $query, ConnectionInterface $connection = null)
    {
        if (!$connection) {
            $connection = $this->connection;
        }
        $statement = $connection->query($query);
        if (!is_object($statement)) { // can return true
            return [];
        }
        $rows = [];
        while ($row = $statement->fetchAssoc()) {
            $rows[] = $row;
        }
        return $rows;
    }

    /**
     * @inheritDoc
     */
    public function removeDefiner(string $query)
    {
        return preg_replace('~^([A-Z =]+) DEFINER=`' .
            preg_replace('~@(.*)~', '`@`(%|\1)', $this->user()) .
            '`~', '\1', $query); //! proper escaping of user
    }

    /**
     * @inheritDoc
     */
    public function begin()
    {
        return $this->connection->query("BEGIN");
    }

    /**
     * @inheritDoc
     */
    public function commit()
    {
        return $this->connection->query("COMMIT");
    }

    /**
     * @inheritDoc
     */
    public function rollback()
    {
        return $this->connection->query("ROLLBACK");
    }

    /**
     * @inheritDoc
     */
    public function countRows(TableEntity $tableStatus, array $where)
    {
        return null;
    }

    /**
     * @inheritDoc
     */
    public function convertSearch(string $idf, array $val, TableFieldEntity $field)
    {
        return $idf;
    }

    /**
     * @inheritDoc
     */
    public function view(string $name)
    {
        return [];
    }
}


1			<?php
2
3			namespace Lagdo\DbAdmin\Driver\Db;
4
5			use Lagdo\DbAdmin\Driver\Entity\TableFieldEntity;
6			use Lagdo\DbAdmin\Driver\Entity\TableEntity;
7
8			use Lagdo\DbAdmin\Driver\DriverInterface;
9			use Lagdo\DbAdmin\Driver\UtilInterface;
10			use Lagdo\DbAdmin\Driver\TranslatorInterface;
11			use Lagdo\DbAdmin\Driver\Db\ConnectionInterface;
12
13			abstract class Query implements QueryInterface
14			{
15			/**
16			* @var DriverInterface
17			*/
18			protected $driver;
19
20			/**
21			* @var UtilInterface
22			*/
23			protected $util;
24
25			/**
26			* @var TranslatorInterface
27			*/
28			protected $trans;
29
30			/**
31			* @var ConnectionInterface
32			*/
33			protected $connection;
34
35			/**
36			* The last error code
37			*
38			* @var int
39			*/
40			protected $errno = 0;
41
42			/**
43			* The last error message
44			*
45			* @var string
46			*/
47			protected $error = '';
48
49			/**
50			* The number of rows affected by the last query
51			*
52			* @var int
53			*/
54			protected $affectedRows;
55
56			/**
57			* The constructor
58			*
59			* @param DriverInterface $driver
60			* @param UtilInterface $util
61			* @param TranslatorInterface $trans
62			* @param ConnectionInterface $connection
63			*/
64			public function __construct(DriverInterface $driver, UtilInterface $util, TranslatorInterface $trans, ConnectionInterface $connection)
65			{
66			$this->driver = $driver;
67			$this->util = $util;
68			$this->trans = $trans;
69			$this->connection = $connection;
70			}
71
72			/**
73			* @inheritDoc
74			*/
75			public function schema()
76			{
77			return "";
78			}
79
80			/**
81			* @inheritDoc
82			*/
83			public function select(string $table, array $select, array $where,
84			array $group, array $order = [], int $limit = 1, int $page = 0)
85			{
86			$query = $this->driver->buildSelectQuery($table, $select, $where, $group, $order, $limit, $page);
87			// $start = microtime(true);
88			return $this->connection->query($query);
89			}
90
91			/**
92			* @inheritDoc
93			*/
94			public function insert(string $table, array $values)
95			{
96			$table = $this->driver->table($table);
97			if (!empty($values)) {
98			return $this->driver->queries("INSERT INTO $table DEFAULT VALUES");
			0 ignored issues – show Bug Best Practice introduced 2021-10-26 11:21 UTC by Report Bug Copy Issue Report The expression `return $this->driver->qu...able.' DEFAULT VALUES')` returns the type `Lagdo\DbAdmin\Driver\Db\Statement\|array` which is incompatible with the return type mandated by `Lagdo\DbAdmin\Driver\Db\QueryInterface::insert()` of `boolean`. In the issue above, the returned value is violating the contract defined by the mentioned interface. Let's take a look at an example: interface HasName { /** @return string / public function getName(); } class Name { public $name; } class User implements HasName { /* @return string\|Name */ public function getName() { return new Name('foo'); // This is a violation of the ``HasName`` interface // which only allows a string value to be returned. } } Loading history...
99			}
100			return $this->driver->queries("INSERT INTO $table (" .
			0 ignored issues – show Bug Best Practice introduced 2021-10-26 11:21 UTC by Report Bug Copy Issue Report The expression `return $this->driver->qu...e(', ', $values) . ')')` returns the type `Lagdo\DbAdmin\Driver\Db\Statement\|array` which is incompatible with the return type mandated by `Lagdo\DbAdmin\Driver\Db\QueryInterface::insert()` of `boolean`. In the issue above, the returned value is violating the contract defined by the mentioned interface. Let's take a look at an example: interface HasName { /** @return string / public function getName(); } class Name { public $name; } class User implements HasName { /* @return string\|Name */ public function getName() { return new Name('foo'); // This is a violation of the ``HasName`` interface // which only allows a string value to be returned. } } Loading history...
101			implode(", ", array_keys($values)) . ") VALUES (" . implode(", ", $values) . ")");
102			}
103
104			/**
105			* @inheritDoc
106			*/
107			public function update(string $table, array $values, string $queryWhere, int $limit = 0, string $separator = "\n")
108			{
109			$assignments = [];
110			foreach ($values as $name => $value) {
111			$assignments[] = "$name = $value";
112			}
113			$query = $this->driver->table($table) . " SET$separator" . implode(",$separator", $assignments);
114			if (!$limit) {
115			return $this->driver->queries('UPDATE ' . $query . $queryWhere);
			0 ignored issues – show Bug Best Practice introduced 2021-10-26 11:21 UTC by Report Bug Copy Issue Report The expression `return $this->driver->qu.... $query . $queryWhere)` returns the type `Lagdo\DbAdmin\Driver\Db\Statement\|array` which is incompatible with the return type mandated by `Lagdo\DbAdmin\Driver\Db\QueryInterface::update()` of `boolean`. In the issue above, the returned value is violating the contract defined by the mentioned interface. Let's take a look at an example: interface HasName { /** @return string / public function getName(); } class Name { public $name; } class User implements HasName { /* @return string\|Name */ public function getName() { return new Name('foo'); // This is a violation of the ``HasName`` interface // which only allows a string value to be returned. } } Loading history...
116			}
117			return $this->driver->queries('UPDATE' . $this->driver->limitToOne($table, $query, $queryWhere, $separator));
			0 ignored issues – show Bug Best Practice introduced 2021-10-26 11:21 UTC by Report Bug Copy Issue Report The expression `return $this->driver->qu...ueryWhere, $separator))` returns the type `Lagdo\DbAdmin\Driver\Db\Statement\|array` which is incompatible with the return type mandated by `Lagdo\DbAdmin\Driver\Db\QueryInterface::update()` of `boolean`. In the issue above, the returned value is violating the contract defined by the mentioned interface. Let's take a look at an example: interface HasName { /** @return string / public function getName(); } class Name { public $name; } class User implements HasName { /* @return string\|Name */ public function getName() { return new Name('foo'); // This is a violation of the ``HasName`` interface // which only allows a string value to be returned. } } Loading history...
118			}
119
120			/**
121			* @inheritDoc
122			*/
123			public function delete(string $table, string $queryWhere, int $limit = 0)
124			{
125			$query = 'FROM ' . $this->driver->table($table);
126			if (!$limit) {
127			return $this->driver->queries("DELETE $query $queryWhere");
			0 ignored issues – show Bug Best Practice introduced 2021-10-26 11:21 UTC by Report Bug Copy Issue Report The expression `return $this->driver->qu...$query.' '.$queryWhere)` returns the type `Lagdo\DbAdmin\Driver\Db\Statement\|array` which is incompatible with the return type mandated by `Lagdo\DbAdmin\Driver\Db\QueryInterface::delete()` of `boolean`. In the issue above, the returned value is violating the contract defined by the mentioned interface. Let's take a look at an example: interface HasName { /** @return string / public function getName(); } class Name { public $name; } class User implements HasName { /* @return string\|Name */ public function getName() { return new Name('foo'); // This is a violation of the ``HasName`` interface // which only allows a string value to be returned. } } Loading history...
128			}
129			return $this->driver->queries('DELETE' . $this->driver->limitToOne($table, $query, $queryWhere));
			0 ignored issues – show Bug Best Practice introduced 2021-10-26 11:21 UTC by Report Bug Copy Issue Report The expression `return $this->driver->qu..., $query, $queryWhere))` returns the type `Lagdo\DbAdmin\Driver\Db\Statement\|array` which is incompatible with the return type mandated by `Lagdo\DbAdmin\Driver\Db\QueryInterface::delete()` of `boolean`. In the issue above, the returned value is violating the contract defined by the mentioned interface. Let's take a look at an example: interface HasName { /** @return string / public function getName(); } class Name { public $name; } class User implements HasName { /* @return string\|Name */ public function getName() { return new Name('foo'); // This is a violation of the ``HasName`` interface // which only allows a string value to be returned. } } Loading history...
130			}
131
132			/**
133			* @inheritDoc
134			*/
135			public function explain(ConnectionInterface $connection, string $query)
136			{
137			return null;
138			}
139
140			/**
141			* @inheritDoc
142			*/
143			public function slowQuery(string $query, int $timeout)
144			{
145			}
146
147			/**
148			* @inheritDoc
149			*/
150			public function setError(string $error = '')
151			{
152			$this->error = $error;
153			}
154
155			/**
156			* @inheritDoc
157			*/
158			public function error()
159			{
160			return $this->error;
161			}
162
163			/**
164			* @inheritDoc
165			*/
166			public function hasError()
167			{
168			return $this->error !== '';
169			}
170
171			/**
172			* @inheritDoc
173			*/
174			public function setErrno($errno)
175			{
176			$this->errno = $errno;
177			}
178
179			/**
180			* @inheritDoc
181			*/
182			public function errno()
183			{
184			return $this->errno;
185			}
186
187			/**
188			* @inheritDoc
189			*/
190			public function hasErrno()
191			{
192			return $this->errno !== 0;
193			}
194
195			/**
196			* @inheritDoc
197			*/
198			public function setAffectedRows($affectedRows)
199			{
200			$this->affectedRows = $affectedRows;
201			}
202
203			/**
204			* @inheritDoc
205			*/
206			public function affectedRows()
207			{
208			return $this->affectedRows;
209			}
210
211			/**
212			* @inheritDoc
213			*/
214			public function queries(string $query = '')
215			{
216			static $queries = [];
217			static $start;
218			if (!$start) {
219			$start = microtime(true);
220			}
221			if ($query === '') {
222			// return executed queries
223			return [implode("\n", $queries), $this->trans->formatTime($start)];
224			}
225			$queries[] = (preg_match('~;$~', $query) ? "DELIMITER ;;\n$query;\nDELIMITER " : $query) . ";";
226			return $this->connection->query($query);
			0 ignored issues – show Bug Best Practice introduced 2021-10-26 11:21 UTC by Report Bug Copy Issue Report The expression `return $this->connection->query($query)` returns the type `Lagdo\DbAdmin\Driver\Db\StatementInterface\|boolean` which is incompatible with the return type mandated by `Lagdo\DbAdmin\Driver\Db\QueryInterface::queries()` of `Lagdo\DbAdmin\Driver\Db\Statement\|array`. In the issue above, the returned value is violating the contract defined by the mentioned interface. Let's take a look at an example: interface HasName { /** @return string / public function getName(); } class Name { public $name; } class User implements HasName { /* @return string\|Name */ public function getName() { return new Name('foo'); // This is a violation of the ``HasName`` interface // which only allows a string value to be returned. } } Loading history...
227			}
228
229			/**
230			* @inheritDoc
231			*/
232			public function applyQueries(string $query, array $tables, $escape = null)
233			{
234			if (!$escape) {
235			$escape = function ($table) {
236			return $this->driver->table($table);
237			};
238			}
239			foreach ($tables as $table) {
240			if (!$this->queries("$query " . $escape($table))) {
241			return false;
242			}
243			}
244			return true;
245			}
246
247			/**
248			* @inheritDoc
249			*/
250			public function values(string $query, $column = 0)
251			{
252			$values = [];
253			$statement = $this->connection->query($query);
254			if (is_object($statement)) {
255			while ($row = $statement->fetchRow()) {
256			$values[] = $row[$column];
257			}
258			}
259			return $values;
260			}
261
262			/**
263			* @inheritDoc
264			*/
265			public function keyValues(string $query, ConnectionInterface $connection = null, bool $setKeys = true)
266			{
267			if (!is_object($connection)) {
268			$connection = $this->connection;
269			}
270			$values = [];
271			$statement = $connection->query($query);
272			if (is_object($statement)) {
273			while ($row = $statement->fetchRow()) {
274			if ($setKeys) {
275			$values[$row[0]] = $row[1];
276			} else {
277			$values[] = $row[0];
278			}
279			}
280			}
281			return $values;
282			}
283
284			/**
285			* @inheritDoc
286			*/
287			public function rows(string $query, ConnectionInterface $connection = null)
288			{
289			if (!$connection) {
290			$connection = $this->connection;
291			}
292			$statement = $connection->query($query);
293			if (!is_object($statement)) { // can return true
294			return [];
295			}
296			$rows = [];
297			while ($row = $statement->fetchAssoc()) {
298			$rows[] = $row;
299			}
300			return $rows;
301			}
302
303			/**
304			* @inheritDoc
305			*/
306			public function removeDefiner(string $query)
307			{
308			return preg_replace('~^([A-Z =]+) DEFINER=`' .
309			preg_replace('~@(.*)~', '`@`(%\|\1)', $this->user()) .
310			'`~', '\1', $query); //! proper escaping of user
311			}
312
313			/**
314			* @inheritDoc
315			*/
316			public function begin()
317			{
318			return $this->connection->query("BEGIN");
319			}
320
321			/**
322			* @inheritDoc
323			*/
324			public function commit()
325			{
326			return $this->connection->query("COMMIT");
327			}
328
329			/**
330			* @inheritDoc
331			*/
332			public function rollback()
333			{
334			return $this->connection->query("ROLLBACK");
335			}
336
337			/**
338			* @inheritDoc
339			*/
340			public function countRows(TableEntity $tableStatus, array $where)
341			{
342			return null;
343			}
344
345			/**
346			* @inheritDoc
347			*/
348			public function convertSearch(string $idf, array $val, TableFieldEntity $field)
349			{
350			return $idf;
351			}
352
353			/**
354			* @inheritDoc
355			*/
356			public function view(string $name)
357			{
358			return [];
359			}
360			}
361

lagdo / dbadmin-driver

Push — main ( 40936e...9d67f9 )

Query::lastAutoIncrementId() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like