Command::queryInternal() - Code Metrics - Inspection of "Fix psalm error" - yiisoft/db-sqlite - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#265)

by Sergei

created 2023-08-01 09:24 UTC

Command::queryInternal() A

↳ Parent: Command

Complexity

Conditions	4
Paths	3

Size

Total Lines	36
Code Lines	14

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	15
CRAP Score	4

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	14
dl	0
loc	36
ccs	15
cts	15
cp	1
rs	9.7998
c	1
b	0
f	0
cc	4
nc	3
nop	1
crap	4

<?php

declare(strict_types=1);

namespace Yiisoft\Db\Sqlite;

use PDOException;
use Throwable;
use Yiisoft\Db\Driver\Pdo\AbstractPdoCommand;
use Yiisoft\Db\Exception\ConvertException;
use Yiisoft\Db\Exception\Exception;
use Yiisoft\Db\Exception\InvalidArgumentException;
use Yiisoft\Db\QueryBuilder\QueryBuilderInterface;

use function array_pop;
use function count;
use function ltrim;
use function preg_match_all;
use function strpos;

/**
 * Implements a database command that can be executed with a PDO (PHP Data Object) database connection for SQLite
 * Server.
 */
final class Command extends AbstractPdoCommand
{
    public function insertWithReturningPks(string $table, array $columns): bool|array
    {
        $params = [];
        $sql = $this->db->getQueryBuilder()->insert($table, $columns, $params);
        $this->setSql($sql)->bindValues($params);

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

        $tableSchema = $this->db->getSchema()->getTableSchema($table);
        $tablePrimaryKeys = $tableSchema?->getPrimaryKey() ?? [];

        $result = [];
        foreach ($tablePrimaryKeys as $name) {
            if ($tableSchema?->getColumn($name)?->isAutoIncrement()) {
                $result[$name] = $this->db->getLastInsertID((string) $tableSchema?->getSequenceName());
                continue;
            }

            /** @psalm-var mixed */
            $result[$name] = $columns[$name] ?? $tableSchema?->getColumn($name)?->getDefaultValue();
        }

        return $result;
    }

    public function showDatabases(): array
    {
        $sql = <<<SQL
        SELECT name FROM pragma_database_list;
        SQL;

        return $this->setSql($sql)->queryColumn();
    }

    protected function getQueryBuilder(): QueryBuilderInterface
    {
        return $this->db->getQueryBuilder();
    }

    /**
     * Executes the SQL statement.
     *
     * This method should only be used for executing a non-query SQL statement, such as `INSERT`, `DELETE`, `UPDATE` SQLs.
     * No result set will be returned.
     *
     * @throws Exception
     * @throws Throwable The execution failed.
     *
     * @return int Number of rows affected by the execution.
     */
    public function execute(): int
    {
        $sql = $this->getSql();

        /** @psalm-var array<string, string> $params */
        $params = $this->params;

        $statements = $this->splitStatements($sql, $params);

        if ($statements === false) {

            return parent::execute();
        }

        $result = 0;

        /** @psalm-var array<array-key, array<array-key, string|array>> $statements */
        foreach ($statements as $statement) {
            [$statementSql, $statementParams] = $statement;
            $statementSql = is_string($statementSql) ? $statementSql : '';
            $statementParams = is_array($statementParams) ? $statementParams : [];
            $this->setSql($statementSql)->bindValues($statementParams);
            $result = parent::execute();
        }

        $this->setSql($sql)->bindValues($params);

        return $result;
    }

    /**
     * @psalm-suppress UnusedClosureParam
     *
     * @throws Throwable
     */
    protected function internalExecute(string|null $rawSql): void
    {
        $attempt = 0;

        while (true) {
            try {
                if (
                    ++$attempt === 1
                    && $this->isolationLevel !== null
                    && $this->db->getTransaction() === null
                ) {
                    $this->db->transaction(
                        function () use ($rawSql): void {
                            $this->internalExecute($rawSql);
                        },
                        $this->isolationLevel,
                    );
                } else {
                    $this->pdoStatement?->execute();
                }
                break;
            } catch (PDOException $e) {
                $rawSql = $rawSql ?: $this->getRawSql();
                $e = (new ConvertException($e, $rawSql))->run();

                if ($this->retryHandler === null || !($this->retryHandler)($e, $attempt)) {
                    throw $e;
                }
            }
        }
    }

    /**
     * Performs the actual DB query of an SQL statement.
     *
     * @param int $queryMode Return results as DataReader
     *
     * @throws Exception
     * @throws Throwable If the query causes any problem.
     *
     * @return mixed The method execution result.
     */
    protected function queryInternal(int $queryMode): mixed
    {
        $sql = $this->getSql();

        /** @psalm-var array<string, string> $params */
        $params = $this->params;

        $statements = $this->splitStatements($sql, $params);

        if ($statements === false || $statements === []) {

            return parent::queryInternal($queryMode);
        }

        [$lastStatementSql, $lastStatementParams] = array_pop($statements);

        /**
         * @psalm-var array<array-key, array> $statements
         */
        foreach ($statements as $statement) {
            /**
             * @psalm-var string $statementSql
             * @psalm-var array $statementParams
             */
            [$statementSql, $statementParams] = $statement;
            $this->setSql($statementSql)->bindValues($statementParams);
            parent::execute();
        }

        $this->setSql($lastStatementSql)->bindValues($lastStatementParams);

        /** @psalm-var string $result */
        $result = parent::queryInternal($queryMode);

        $this->setSql($sql)->bindValues($params);

        return $result;
    }

    /**
     * Splits the specified SQL into individual SQL statements and returns them or `false` if there's a single
     * statement.
     *
     * @param string $sql SQL to split.
     *
     * @throws InvalidArgumentException
     *
     * @return array|bool List of SQL statements or `false` if there's a single statement.
     *
     * @psalm-param array<string, string> $params
     *
     * @psalm-return false|list<array{0: string, 1: array}>
     */
    private function splitStatements(string $sql, array $params): bool|array
    {
        $semicolonIndex = strpos($sql, ';');

        if ($semicolonIndex === false || $semicolonIndex === mb_strlen($sql, '8bit') - 1) {
            return false;
        }

        $tokenizer = new SqlTokenizer($sql);

        $codeToken = $tokenizer->tokenize();

        if (count($codeToken->getChildren()) === 1) {
            return false;
        }

        $statements = [];

        foreach ($codeToken->getChildren() as $statement) {
            $statements[] = [$statement->getSql(), $this->extractUsedParams($statement, $params)];
        }

        return $statements;
    }

    /**
     * Returns named bindings used in the specified statement token.
     *
     * @psalm-param array<string, string> $params
     */
    private function extractUsedParams(SqlToken $statement, array $params): array
    {
        preg_match_all('/(?P<placeholder>:\w+)/', $statement->getSql(), $matches, PREG_SET_ORDER);

        $result = [];

        foreach ($matches as $match) {
            $phName = ltrim($match['placeholder'], ':');
            if (isset($params[$phName])) {
                $result[$phName] = $params[$phName];
            } elseif (isset($params[':' . $phName])) {
                $result[':' . $phName] = $params[':' . $phName];
            }
        }

        return $result;
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Yiisoft\Db\Sqlite;
6
7		use PDOException;
8		use Throwable;
9		use Yiisoft\Db\Driver\Pdo\AbstractPdoCommand;
10		use Yiisoft\Db\Exception\ConvertException;
11		use Yiisoft\Db\Exception\Exception;
12		use Yiisoft\Db\Exception\InvalidArgumentException;
13		use Yiisoft\Db\QueryBuilder\QueryBuilderInterface;
14
15		use function array_pop;
16		use function count;
17		use function ltrim;
18		use function preg_match_all;
19		use function strpos;
20
21		/**
22		* Implements a database command that can be executed with a PDO (PHP Data Object) database connection for SQLite
23		* Server.
24		*/
25		final class Command extends AbstractPdoCommand
26		{
27	4	public function insertWithReturningPks(string $table, array $columns): bool\|array
28		{
29	4	$params = [];
30	4	$sql = $this->db->getQueryBuilder()->insert($table, $columns, $params);
31	4	$this->setSql($sql)->bindValues($params);
32
33	4	if (!$this->execute()) {
34		return false;
35		}
36
37	4	$tableSchema = $this->db->getSchema()->getTableSchema($table);
38	4	$tablePrimaryKeys = $tableSchema?->getPrimaryKey() ?? [];
39
40	4	$result = [];
41	4	foreach ($tablePrimaryKeys as $name) {
42	4	if ($tableSchema?->getColumn($name)?->isAutoIncrement()) {
43	3	$result[$name] = $this->db->getLastInsertID((string) $tableSchema?->getSequenceName());
44	3	continue;
45		}
46
47		/** @psalm-var mixed */
48	1	$result[$name] = $columns[$name] ?? $tableSchema?->getColumn($name)?->getDefaultValue();
49		}
50
51	4	return $result;
52		}
53
54	1	public function showDatabases(): array
55		{
56	1	$sql = <<<SQL
57		SELECT name FROM pragma_database_list;
58	1	SQL;
59
60	1	return $this->setSql($sql)->queryColumn();
61		}
62
63	283	protected function getQueryBuilder(): QueryBuilderInterface
64		{
65	283	return $this->db->getQueryBuilder();
66		}
67
68		/**
69		* Executes the SQL statement.
70		*
71		* This method should only be used for executing a non-query SQL statement, such as `INSERT`, `DELETE`, `UPDATE` SQLs.
72		* No result set will be returned.
73		*
74		* @throws Exception
75		* @throws Throwable The execution failed.
76		*
77		* @return int Number of rows affected by the execution.
78		*/
79	110	public function execute(): int
80		{
81	110	$sql = $this->getSql();
82
83		/** @psalm-var array<string, string> $params */
84	110	$params = $this->params;
85
86	110	$statements = $this->splitStatements($sql, $params);
87
88	110	if ($statements === false) {
		0 ignored issues – show introduced 2022-02-12 13:04 UTC by Report Bug Copy Issue Report The condition `$statements === false` is always `true`. Loading history...
89	98	return parent::execute();
90		}
91
92	12	$result = 0;
93
94		/** @psalm-var array<array-key, array<array-key, string\|array>> $statements */
95	12	foreach ($statements as $statement) {
96	12	[$statementSql, $statementParams] = $statement;
97	12	$statementSql = is_string($statementSql) ? $statementSql : '';
98	12	$statementParams = is_array($statementParams) ? $statementParams : [];
99	12	$this->setSql($statementSql)->bindValues($statementParams);
100	12	$result = parent::execute();
101		}
102
103	12	$this->setSql($sql)->bindValues($params);
104
105	12	return $result;
106		}
107
108		/**
109		* @psalm-suppress UnusedClosureParam
110		*
111		* @throws Throwable
112		*/
113	250	protected function internalExecute(string\|null $rawSql): void
114		{
115	250	$attempt = 0;
116
117	250	while (true) {
118		try {
119		if (
120	250	++$attempt === 1
121	250	&& $this->isolationLevel !== null
122	250	&& $this->db->getTransaction() === null
123		) {
124	1	$this->db->transaction(
125	1	function () use ($rawSql): void {
126	1	$this->internalExecute($rawSql);
127	1	},
128	1	$this->isolationLevel,
129	1	);
130		} else {
131	250	$this->pdoStatement?->execute();
132		}
133	250	break;
134	2	} catch (PDOException $e) {
135	2	$rawSql = $rawSql ?: $this->getRawSql();
136	2	$e = (new ConvertException($e, $rawSql))->run();
137
138	2	if ($this->retryHandler === null \|\| !($this->retryHandler)($e, $attempt)) {
139	2	throw $e;
140		}
141		}
142		}
143		}
144
145		/**
146		* Performs the actual DB query of an SQL statement.
147		*
148		* @param int $queryMode Return results as DataReader
149		*
150		* @throws Exception
151		* @throws Throwable If the query causes any problem.
152		*
153		* @return mixed The method execution result.
154		*/
155	250	protected function queryInternal(int $queryMode): mixed
156		{
157	250	$sql = $this->getSql();
158
159		/** @psalm-var array<string, string> $params */
160	250	$params = $this->params;
161
162	250	$statements = $this->splitStatements($sql, $params);
163
164	250	if ($statements === false \|\| $statements === []) {
		0 ignored issues – show introduced 2022-02-12 13:04 UTC by Report Bug Copy Issue Report The condition `$statements === false` is always `true`. Loading history...
165	250	return parent::queryInternal($queryMode);
166		}
167
168	1	[$lastStatementSql, $lastStatementParams] = array_pop($statements);
169
170		/**
171		* @psalm-var array<array-key, array> $statements
172		*/
173	1	foreach ($statements as $statement) {
174		/**
175		* @psalm-var string $statementSql
176		* @psalm-var array $statementParams
177		*/
178	1	[$statementSql, $statementParams] = $statement;
179	1	$this->setSql($statementSql)->bindValues($statementParams);
180	1	parent::execute();
181		}
182
183	1	$this->setSql($lastStatementSql)->bindValues($lastStatementParams);
184
185		/** @psalm-var string $result */
186	1	$result = parent::queryInternal($queryMode);
187
188	1	$this->setSql($sql)->bindValues($params);
189
190	1	return $result;
191		}
192
193		/**
194		* Splits the specified SQL into individual SQL statements and returns them or `false` if there's a single
195		* statement.
196		*
197		* @param string $sql SQL to split.
198		*
199		* @throws InvalidArgumentException
200		*
201		* @return array\|bool List of SQL statements or `false` if there's a single statement.
202		*
203		* @psalm-param array<string, string> $params
204		*
205		* @psalm-return false\|list<array{0: string, 1: array}>
206		*/
207	251	private function splitStatements(string $sql, array $params): bool\|array
208		{
209	251	$semicolonIndex = strpos($sql, ';');
210
211	251	if ($semicolonIndex === false \|\| $semicolonIndex === mb_strlen($sql, '8bit') - 1) {
212	251	return false;
213		}
214
215	13	$tokenizer = new SqlTokenizer($sql);
216
217	13	$codeToken = $tokenizer->tokenize();
218
219	13	if (count($codeToken->getChildren()) === 1) {
220	1	return false;
221		}
222
223	12	$statements = [];
224
225	12	foreach ($codeToken->getChildren() as $statement) {
226	12	$statements[] = [$statement->getSql(), $this->extractUsedParams($statement, $params)];
227		}
228
229	12	return $statements;
230		}
231
232		/**
233		* Returns named bindings used in the specified statement token.
234		*
235		* @psalm-param array<string, string> $params
236		*/
237	12	private function extractUsedParams(SqlToken $statement, array $params): array
238		{
239	12	preg_match_all('/(?P<placeholder>:\w+)/', $statement->getSql(), $matches, PREG_SET_ORDER);
240
241	12	$result = [];
242
243	12	foreach ($matches as $match) {
244	12	$phName = ltrim($match['placeholder'], ':');
245	12	if (isset($params[$phName])) {
246	1	$result[$phName] = $params[$phName];
247	11	} elseif (isset($params[':' . $phName])) {
248	11	$result[':' . $phName] = $params[':' . $phName];
249		}
250		}
251
252	12	return $result;
253		}
254		}
255

yiisoft / db-sqlite

Pull Request — master (#265)

Command::queryInternal() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like