Kir\MySQL\Builder\QueryStatement

Complexity

Total Complexity

18

Size/Duplication

Total Lines	132
Duplicated Lines	0 %

Importance

Changes	6
Bugs	0	Features	0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	execute()	0	10	2
A	fetch()	0	2	1
A	__construct()	0	6	1
A	getStatement()	0	2	1
A	columnCount()	0	2	1
A	exceptionHandler()	0	5	2
A	closeCursor()	0	2	1
A	fetchAll()	0	12	3
A	setFetchMode()	0	10	3
A	getColumnMeta()	0	7	2
A	fetchColumn()	0	2	1

<?php
namespace Kir\MySQL\Builder;

use Kir\MySQL\Database\DatabaseStatement;
use Kir\MySQL\Databases\MySQL\MySQLExceptionInterpreter;
use Kir\MySQL\Exceptions\SqlException;
use Kir\MySQL\QueryLogger\QueryLoggers;
use PDO;
use PDOException;
use PDOStatement;

class QueryStatement implements DatabaseStatement {
	/**
	 * @param PDOStatement<mixed> $stmt
	 * @param string $query
	 * @param MySQLExceptionInterpreter $exceptionInterpreter
	 * @param QueryLoggers $queryLoggers
	 */
	public function __construct(
		private PDOStatement $stmt,
		private string $query,
		private MySQLExceptionInterpreter $exceptionInterpreter,
		private QueryLoggers $queryLoggers
	) {}

	/**
	 * @return PDOStatement<mixed>
	 */
	public function getStatement(): PDOStatement {
		return $this->stmt;
	}

	/**
	 * @param int $mode
	 * @param mixed $arg0
	 * @param array<mixed, mixed>|null $arg1
	 * @return $this
	 */
	public function setFetchMode(int $mode = PDO::FETCH_ASSOC, $arg0 = null, ?array $arg1 = null) {
		$args = [$mode];
		if($arg0 !== null) {
			$args[] = $arg0;
		}
		if($arg1 !== null) {
			$args[] = $arg1;
		}
		$this->stmt->setFetchMode(...$args);

$args is expanded, but the parameter $mode of PDOStatement::setFetchMode() does not expect variable arguments.

		return $this;
	}

	/**
	 * @param array<string, mixed> $params
	 * @throws SqlException
	 * @return $this
	 */
	public function execute(array $params = []) {
		$this->exceptionHandler(function() use ($params) {
			$this->queryLoggers->logRegion($this->query, function() use ($params) {
				$response = $this->stmt->execute($params);
				if(!$response) {
					throw new SqlException('Execution returned with "false".');
				}
			});
		});
		return $this;
	}

	/**
	 * @param int $fetchStyle
	 * @param mixed|null $fetchArgument
	 * @param mixed[] $ctorArgs
	 * @return array<mixed, mixed>
	 */
	public function fetchAll($fetchStyle = PDO::FETCH_ASSOC, $fetchArgument = null, array $ctorArgs = []): array {
		$result = $x = $this->exceptionHandler(function() use ($fetchStyle, $fetchArgument, $ctorArgs) {
			if($fetchArgument !== null) {
				return $this->stmt->fetchAll($fetchStyle, $fetchArgument, ...$ctorArgs);
			}
			return $this->stmt->fetchAll($fetchStyle);
		});
		/** @var array<mixed, mixed>|false $x */
		if($x === false) {
			return [];
		}
		return $result;

The expression return $result returns the type Kir\MySQL\Builder\T which is incompatible with the type-hinted return array.

	}

	/**
	 * @param int $fetchStyle
	 * @param int $cursorOrientation
	 * @param int $cursorOffset
	 * @return mixed
	 */
	public function fetch($fetchStyle = PDO::FETCH_ASSOC, $cursorOrientation = PDO::FETCH_ORI_NEXT, $cursorOffset = 0) {
		return $this->exceptionHandler(fn() => $this->stmt->fetch($fetchStyle, $cursorOrientation, $cursorOffset));
	}

	/**
	 * @param int $columnNo
	 * @return mixed
	 */
	public function fetchColumn($columnNo = 0) {
		return $this->exceptionHandler(fn() => $this->stmt->fetchColumn($columnNo));
	}

	/**
	 * @return bool
	 */
	public function closeCursor(): bool {
		return $this->exceptionHandler(fn() => $this->stmt->closeCursor());

The expression return $this->exceptionHandler(function(...) { /* ... */ }) returns the type Kir\MySQL\Builder\T which is incompatible with the type-hinted return boolean.

	}

	/**
	 * @return int
	 */
	public function columnCount(): int {
		return $this->exceptionHandler(fn() => $this->stmt->columnCount());

The expression return $this->exceptionHandler(function(...) { /* ... */ }) returns the type Kir\MySQL\Builder\T which is incompatible with the type-hinted return integer.

	}

	/**
	 * @param int $columnNo
	 * @return null|array<string, mixed>
	 */
	public function getColumnMeta(int $columnNo): ?array {
		return $this->exceptionHandler(function() use ($columnNo) {

The expression return $this->exceptionHandler(function(...) { /* ... */ }) returns the type Kir\MySQL\Builder\T which is incompatible with the type-hinted return array|null.

			$columnMeta = $this->stmt->getColumnMeta($columnNo);
			if($columnMeta === false) {
				return null;
			}
			return $columnMeta;
		});
	}

	/**
	 * @template T
	 * @param callable(): T $fn
	 * @return T
	 */
	private function exceptionHandler(callable $fn) {
		try {
			return $fn();
		} catch (PDOException $exception) {
			throw $this->exceptionInterpreter->getMoreConcreteException($exception);
		}
	}
}