Driver::executeQuery() - Code Metrics - Inspection of "New methods from the Admin class in the jaxon-dbad..." - lagdo/dbadmin-driver - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — main ( 317226...e95517 )

by Thierry

created 2024-01-24 18:19 UTC

Driver::executeQuery() A

↳ Parent: Driver

Complexity

Conditions	4
Paths	6

Size

Total Lines	16
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	4
eloc	8
nc	6
nop	3
dl	0
loc	16
rs	10
c	0
b	0
f	0

<?php

namespace Lagdo\DbAdmin\Driver;

use Exception;
use Lagdo\DbAdmin\Driver\Db\ConnectionInterface;
use Lagdo\DbAdmin\Driver\Db\ServerInterface;
use Lagdo\DbAdmin\Driver\Db\DatabaseInterface;
use Lagdo\DbAdmin\Driver\Db\TableInterface;
use Lagdo\DbAdmin\Driver\Db\QueryInterface;
use Lagdo\DbAdmin\Driver\Db\GrammarInterface;
use Lagdo\DbAdmin\Driver\Entity\ConfigEntity;
use Lagdo\DbAdmin\Driver\Exception\AuthException;

use function is_object;
use function preg_match;
use function preg_replace;
use function substr;
use function strlen;
use function version_compare;

abstract class Driver implements DriverInterface
{
    use ErrorTrait;
    use ConfigTrait;

    use ConnectionTrait;
    use ServerTrait;
    use TableTrait;
    use DatabaseTrait;
    use QueryTrait;
    use GrammarTrait;

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

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

    /**
     * @var ServerInterface
     */
    protected $server;

    /**
     * @var DatabaseInterface
     */
    protected $database;

    /**
     * @var TableInterface
     */
    protected $table;

    /**
     * @var QueryInterface
     */
    protected $query;

    /**
     * @var GrammarInterface
     */
    protected $grammar;

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

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

    /**
     * @var ConfigEntity
     */
    protected $config;

    /**
     * @var History
     */
    protected $history;

    /**
     * The constructor
     *
     * @param UtilInterface $util
     * @param TranslatorInterface $trans
     * @param array $options
     */
    public function __construct(UtilInterface $util, TranslatorInterface $trans, array $options)
    {
        $this->util = $util;
        $this->util->setDriver($this);
        $this->trans = $trans;
        $this->config = new ConfigEntity($options);
        $this->history = new History($trans);
        $this->initConfig();
        $this->createConnection();
        // Set the current connection as the main connection.
        $this->mainConnection = $this->connection;
    }

    /**
     * @param ConnectionInterface $connection
     *
     * @return Driver
     */
    public function useConnection(ConnectionInterface $connection)
    {
        $this->connection = $connection;
        return $this;
    }

    /**
     * @return Driver
     */
    public function useMainConnection()
    {
        $this->connection = $this->mainConnection;
        return $this;
    }

    /**
     * Set driver config
     *
     * @return void
     */
    abstract protected function initConfig();

    /**
     * @inheritDoc
     * @throws AuthException
     */
    public function connect(string $database, string $schema)
    {
        if (!$this->connection->open($database, $schema)) {
            throw new AuthException($this->error());
        }
        $this->config->database = $database;
        $this->config->schema = $schema;
    }

    /**
     * @inheritDoc
     */
    public function minVersion(string $version, string $mariaDb = '')
    {
        $info = $this->connection->serverInfo();
        if ($mariaDb && preg_match('~([\d.]+)-MariaDB~', $info, $match)) {
            $info = $match[1];
            $version = $mariaDb;
        }
        return (version_compare($info, $version) >= 0);
    }

    /**
     * @inheritDoc
     */
    public function charset()
    {
        // SHOW CHARSET would require an extra query
        return ($this->minVersion('5.5.3', 0) ? 'utf8mb4' : 'utf8');
    }

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

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

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

    /**
     * @inheritDoc
     */
    public function setUtf8mb4(string $create)
    {
        static $set = false;
        // possible false positive
        if (!$set && preg_match('~\butf8mb4~i', $create)) {
            $set = true;
            return 'SET NAMES ' . $this->charset() . ";\n\n";
        }
        return '';
    }

    /**
     * @inheritDoc
     */
    public function execute(string $query)
    {
        $this->history->save($query);
        return $this->connection->query($query);
    }

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

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

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

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

    /**
     * @inheritDoc
     */
    public function keyValues(string $query, int $keyColumn = 0, int $valueColumn = 1)
    {
        $statement = $this->execute($query);
        if (!is_object($statement)) {
            return [];
        }
        $values = [];
        while ($row = $statement->fetchRow()) {
            $values[$row[$keyColumn]] = $row[$valueColumn];
        }
        return $values;
    }

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

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

    /**
     * Query printed after execution in the message
     *
     * @param string $query Executed query
     *
     * @return string
     */
    private function queryToLog(string $query/*, string $time*/): string
    {
        if (strlen($query) > 1e6) {
            // [\x80-\xFF] - valid UTF-8, \n - can end by one-line comment
            $query = preg_replace('~[\x80-\xFF]+$~', '', substr($query, 0, 1e6)) . "\n…";
        }
        return $query;
    }

    /**
     * Execute query
     *
     * @param string $query
     * @param bool $execute
     * @param bool $failed
     *
     * @return bool
     * @throws Exception
     */
    public function executeQuery(string $query, bool $execute = true,
        bool $failed = false/*, string $time = ''*/): bool
    {
        if ($execute) {
            // $start = microtime(true);
            $failed = !$this->execute($query);
            // $time = $this->trans->formatTime($start);
        }
        if ($failed) {
            $sql = '';
            if ($query) {
                $sql = $this->queryToLog($query/*, $time*/);
            }
            throw new Exception($this->error() . $sql);
        }
        return true;
    }

    /**
     * Create SQL condition from parsed query string
     *
     * @param array $where Parsed query string
     * @param array $fields
     *
     * @return string
     */
    public function where(array $where, array $fields = []): string
    {
        $clauses = [];
        $wheres = $where["where"] ?? [];
        foreach ((array) $wheres as $key => $value) {
            $key = $this->util->bracketEscape($key, 1); // 1 - back
            $column = $this->util->escapeKey($key);
            $clauses[] = $column .
                // LIKE because of floats but slow with ints
                ($this->jush() == "sql" && is_numeric($value) && preg_match('~\.~', $value) ? " LIKE " .
                $this->quote($value) : ($this->jush() == "mssql" ? " LIKE " .
                $this->quote(preg_replace('~[_%[]~', '[\0]', $value)) : " = " . // LIKE because of text
                $this->unconvertField($fields[$key], $this->quote($value)))); //! enum and set
            if ($this->jush() == "sql" &&
                preg_match('~char|text~', $fields[$key]->type) && preg_match("~[^ -@]~", $value)) {
                // not just [a-z] to catch non-ASCII characters
                $clauses[] = "$column = " . $this->quote($value) . " COLLATE " . $this->charset() . "_bin";
            }
        }
        $nulls = $where["null"] ?? [];
        foreach ((array) $nulls as $key) {
            $clauses[] = $this->util->escapeKey($key) . " IS NULL";
        }
        return implode(" AND ", $clauses);
    }
}


1			<?php
2
3			namespace Lagdo\DbAdmin\Driver;
4
5			use Exception;
6			use Lagdo\DbAdmin\Driver\Db\ConnectionInterface;
7			use Lagdo\DbAdmin\Driver\Db\ServerInterface;
8			use Lagdo\DbAdmin\Driver\Db\DatabaseInterface;
9			use Lagdo\DbAdmin\Driver\Db\TableInterface;
10			use Lagdo\DbAdmin\Driver\Db\QueryInterface;
11			use Lagdo\DbAdmin\Driver\Db\GrammarInterface;
12			use Lagdo\DbAdmin\Driver\Entity\ConfigEntity;
13			use Lagdo\DbAdmin\Driver\Exception\AuthException;
14
15			use function is_object;
16			use function preg_match;
17			use function preg_replace;
18			use function substr;
19			use function strlen;
20			use function version_compare;
21
22			abstract class Driver implements DriverInterface
23			{
24			use ErrorTrait;
25			use ConfigTrait;
			0 ignored issues – show introduced 2021-10-28 20:53 UTC by Report Bug Copy Issue Report The trait `Lagdo\DbAdmin\Driver\ConfigTrait` requires some properties which are not provided by `Lagdo\DbAdmin\Driver\Driver`: `$onActions`, `$jush`, `$numberRegex`, `$grouping`, `$editFunctions`, `$inout`, `$version`, `$unsigned`, `$enumLength`, `$functions`, `$types`, `$operators` Loading history...
26			use ConnectionTrait;
27			use ServerTrait;
28			use TableTrait;
29			use DatabaseTrait;
30			use QueryTrait;
31			use GrammarTrait;
32
33			/**
34			* @var UtilInterface
35			*/
36			protected $util;
37
38			/**
39			* @var TranslatorInterface
40			*/
41			protected $trans;
42
43			/**
44			* @var ServerInterface
45			*/
46			protected $server;
47
48			/**
49			* @var DatabaseInterface
50			*/
51			protected $database;
52
53			/**
54			* @var TableInterface
55			*/
56			protected $table;
57
58			/**
59			* @var QueryInterface
60			*/
61			protected $query;
62
63			/**
64			* @var GrammarInterface
65			*/
66			protected $grammar;
67
68			/**
69			* @var ConnectionInterface
70			*/
71			protected $connection;
72
73			/**
74			* @var ConnectionInterface
75			*/
76			protected $mainConnection;
77
78			/**
79			* @var ConfigEntity
80			*/
81			protected $config;
82
83			/**
84			* @var History
85			*/
86			protected $history;
87
88			/**
89			* The constructor
90			*
91			* @param UtilInterface $util
92			* @param TranslatorInterface $trans
93			* @param array $options
94			*/
95			public function __construct(UtilInterface $util, TranslatorInterface $trans, array $options)
96			{
97			$this->util = $util;
98			$this->util->setDriver($this);
99			$this->trans = $trans;
100			$this->config = new ConfigEntity($options);
101			$this->history = new History($trans);
102			$this->initConfig();
103			$this->createConnection();
104			// Set the current connection as the main connection.
105			$this->mainConnection = $this->connection;
106			}
107
108			/**
109			* @param ConnectionInterface $connection
110			*
111			* @return Driver
112			*/
113			public function useConnection(ConnectionInterface $connection)
114			{
115			$this->connection = $connection;
116			return $this;
117			}
118
119			/**
120			* @return Driver
121			*/
122			public function useMainConnection()
123			{
124			$this->connection = $this->mainConnection;
125			return $this;
126			}
127
128			/**
129			* Set driver config
130			*
131			* @return void
132			*/
133			abstract protected function initConfig();
134
135			/**
136			* @inheritDoc
137			* @throws AuthException
138			*/
139			public function connect(string $database, string $schema)
140			{
141			if (!$this->connection->open($database, $schema)) {
142			throw new AuthException($this->error());
143			}
144			$this->config->database = $database;
145			$this->config->schema = $schema;
146			}
147
148			/**
149			* @inheritDoc
150			*/
151			public function minVersion(string $version, string $mariaDb = '')
152			{
153			$info = $this->connection->serverInfo();
154			if ($mariaDb && preg_match('~([\d.]+)-MariaDB~', $info, $match)) {
155			$info = $match[1];
156			$version = $mariaDb;
157			}
158			return (version_compare($info, $version) >= 0);
159			}
160
161			/**
162			* @inheritDoc
163			*/
164			public function charset()
165			{
166			// SHOW CHARSET would require an extra query
167			return ($this->minVersion('5.5.3', 0) ? 'utf8mb4' : 'utf8');
168			}
169
170			/**
171			* @inheritDoc
172			*/
173			public function begin()
174			{
175			$result = $this->connection->query("BEGIN");
176			return $result !== false;
177			}
178
179			/**
180			* @inheritDoc
181			*/
182			public function commit()
183			{
184			$result = $this->connection->query("COMMIT");
185			return $result !== false;
186			}
187
188			/**
189			* @inheritDoc
190			*/
191			public function rollback()
192			{
193			$result = $this->connection->query("ROLLBACK");
194			return $result !== false;
195			}
196
197			/**
198			* @inheritDoc
199			*/
200			public function setUtf8mb4(string $create)
201			{
202			static $set = false;
203			// possible false positive
204			if (!$set && preg_match('~\butf8mb4~i', $create)) {
205			$set = true;
206			return 'SET NAMES ' . $this->charset() . ";\n\n";
207			}
208			return '';
209			}
210
211			/**
212			* @inheritDoc
213			*/
214			public function execute(string $query)
215			{
216			$this->history->save($query);
217			return $this->connection->query($query);
218			}
219
220			/**
221			* @inheritDoc
222			*/
223			public function queries()
224			{
225			return $this->history->queries();
226			}
227
228			/**
229			* @inheritDoc
230			*/
231			public function applyQueries(string $query, array $tables, $escape = null)
232			{
233			if (!$escape) {
234			$escape = function ($table) {
235			return $this->table($table);
236			};
237			}
238			foreach ($tables as $table) {
239			if (!$this->execute("$query " . $escape($table))) {
240			return false;
241			}
242			}
243			return true;
244			}
245
246			/**
247			* @inheritDoc
248			*/
249			public function values(string $query, int $column = 0)
250			{
251			$statement = $this->execute($query);
252			if (!is_object($statement)) {
253			return [];
254			}
255			$values = [];
256			while ($row = $statement->fetchRow()) {
257			$values[] = $row[$column];
258			}
259			return $values;
260			}
261
262			/**
263			* @inheritDoc
264			*/
265			public function colValues(string $query, string $column)
266			{
267			$statement = $this->execute($query);
268			if (!is_object($statement)) {
269			return [];
270			}
271			$values = [];
272			while ($row = $statement->fetchAssoc()) {
273			$values[] = $row[$column];
274			}
275			return $values;
276			}
277
278			/**
279			* @inheritDoc
280			*/
281			public function keyValues(string $query, int $keyColumn = 0, int $valueColumn = 1)
282			{
283			$statement = $this->execute($query);
284			if (!is_object($statement)) {
285			return [];
286			}
287			$values = [];
288			while ($row = $statement->fetchRow()) {
289			$values[$row[$keyColumn]] = $row[$valueColumn];
290			}
291			return $values;
292			}
293
294			/**
295			* @inheritDoc
296			*/
297			public function rows(string $query)
298			{
299			$statement = $this->execute($query);
300			if (!is_object($statement)) { // can return true
301			return [];
302			}
303			$rows = [];
304			while ($row = $statement->fetchAssoc()) {
305			$rows[] = $row;
306			}
307			return $rows;
308			}
309
310			/**
311			* Remove current user definer from SQL command
312			*
313			* @param string $query
314			*
315			* @return string
316			*/
317			public function removeDefiner(string $query): string
318			{
319			return preg_replace('~^([A-Z =]+) DEFINER=`' .
320			preg_replace('~@(.*)~', '`@`(%\|\1)', $this->user()) .
321			'`~', '\1', $query); //! proper escaping of user
322			}
323
324			/**
325			* Query printed after execution in the message
326			*
327			* @param string $query Executed query
328			*
329			* @return string
330			*/
331			private function queryToLog(string $query/, string $time/): string
332			{
333			if (strlen($query) > 1e6) {
334			// [\x80-\xFF] - valid UTF-8, \n - can end by one-line comment
335			$query = preg_replace('~[\x80-\xFF]+$~', '', substr($query, 0, 1e6)) . "\n…";
336			}
337			return $query;
338			}
339
340			/**
341			* Execute query
342			*
343			* @param string $query
344			* @param bool $execute
345			* @param bool $failed
346			*
347			* @return bool
348			* @throws Exception
349			*/
350			public function executeQuery(string $query, bool $execute = true,
351			bool $failed = false/, string $time = ''/): bool
352			{
353			if ($execute) {
354			// $start = microtime(true);
355			$failed = !$this->execute($query);
356			// $time = $this->trans->formatTime($start);
357			}
358			if ($failed) {
359			$sql = '';
360			if ($query) {
361			$sql = $this->queryToLog($query/, $time/);
362			}
363			throw new Exception($this->error() . $sql);
364			}
365			return true;
366			}
367
368			/**
369			* Create SQL condition from parsed query string
370			*
371			* @param array $where Parsed query string
372			* @param array $fields
373			*
374			* @return string
375			*/
376			public function where(array $where, array $fields = []): string
377			{
378			$clauses = [];
379			$wheres = $where["where"] ?? [];
380			foreach ((array) $wheres as $key => $value) {
381			$key = $this->util->bracketEscape($key, 1); // 1 - back
382			$column = $this->util->escapeKey($key);
383			$clauses[] = $column .
384			// LIKE because of floats but slow with ints
385			($this->jush() == "sql" && is_numeric($value) && preg_match('~\.~', $value) ? " LIKE " .
386			$this->quote($value) : ($this->jush() == "mssql" ? " LIKE " .
387			$this->quote(preg_replace('~[_%[]~', '[\0]', $value)) : " = " . // LIKE because of text
388			$this->unconvertField($fields[$key], $this->quote($value)))); //! enum and set
389			if ($this->jush() == "sql" &&
390			preg_match('~char\|text~', $fields[$key]->type) && preg_match("~[^ -@]~", $value)) {
391			// not just [a-z] to catch non-ASCII characters
392			$clauses[] = "$column = " . $this->quote($value) . " COLLATE " . $this->charset() . "_bin";
393			}
394			}
395			$nulls = $where["null"] ?? [];
396			foreach ((array) $nulls as $key) {
397			$clauses[] = $this->util->escapeKey($key) . " IS NULL";
398			}
399			return implode(" AND ", $clauses);
400			}
401			}
402

lagdo / dbadmin-driver

Push — main ( 317226...e95517 )

Driver::executeQuery() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like