Command::queryInternal() - Code Metrics - Inspection of "Move methods from command to abstract pdo command..." - yiisoft/db-sqlite - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — master ( 11f981...26eaf4 )

by Sergei

created 2023-11-07 10:47 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	19
CRAP Score	4

Importance

Changes	2
Bugs	0	Features	0

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

<?php

declare(strict_types=1);

namespace Yiisoft\Db\Sqlite;

use Throwable;
use Yiisoft\Db\Driver\Pdo\AbstractPdoCommand;
use Yiisoft\Db\Exception\Exception;
use Yiisoft\Db\Exception\InvalidArgumentException;

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();
    }

    /**
     * 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;
    }

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

yiisoft / db-sqlite

Push — master ( 11f981...26eaf4 )

Command::queryInternal() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like