rkrx / php-mysql-query-builder

src/Databases/MySQL/MySQLRunnableSelect.php

<?php
namespace Kir\MySQL\Databases\MySQL;

use Closure;
use Generator;
use Kir\MySQL\Builder\Helpers\DBIgnoreRow;
use Kir\MySQL\Builder\Helpers\FieldTypeProvider;
use Kir\MySQL\Builder\Helpers\FieldValueConverter;
use Kir\MySQL\Builder\QueryStatement;
use Kir\MySQL\Databases\MySQL;
use PDO;
use stdClass;
use Throwable;
use Traversable;

/**
 */
class MySQLRunnableSelect extends MySQLSelect {
	/** @var array<string, mixed> */
	private array $values = [];
	private bool $preserveTypes;
	private string $defaultClassName;
	private int $foundRows = 0;

	/**
	 * @param MySQL $db
	 * @param array<string, mixed> $options
	 */
	public function __construct($db, array $options = []) {
		parent::__construct($db);
		$this->preserveTypes = array_key_exists('preserve-types-default', $options) ? $options['preserve-types-default'] : false;
		$this->defaultClassName = array_key_exists('fetch-object-class-default', $options) ? $options['fetch-object-class-default'] : stdClass::class;
	}

	/**
	 * @inheritDoc
	 */
	public function bindValues(array $values) {
		$this->values = array_merge($this->values, $values);
		return $this;
	}

	/**
	 * @inheritDoc
	 */
	public function bindValue(string $key, $value) {
		$this->values[$key] = $value;
		return $this;
	}

	/**
	 * @inheritDoc
	 */
	public function clearValues(): self {
		$this->values = [];
		return $this;
	}

	/**
	 * @inheritDoc
	 */
	public function setPreserveTypes(bool $preserveTypes = true): self {
		$this->preserveTypes = $preserveTypes;
		return $this;
	}

	/**
	 * @inheritDoc
	 */
	public function fetchIndexedRows($callback = null): array {
		return $this->fetchAll($callback, PDO::FETCH_NUM);
	}

	/**
	 * @inheritDoc
	 */
	public function fetchRows($callback = null): array {
		return $this->fetchAll($callback, PDO::FETCH_ASSOC);
	}

	/**
	 * @inheritDoc
	 */
	public function fetchRowsLazy($callback = null) {
		$callback ??= static fn($row) => $row;
		yield from $this->fetchLazy($callback, PDO::FETCH_ASSOC);
	}

	/**
	 * @inheritDoc
	 */
	public function fetchRow($callback = null): array {
		$callback ??= static fn($row) => $row;
		return $this->fetch($callback, PDO::FETCH_ASSOC, null, static fn($row) => [

The expression return $this->fetch($callback, PDO::FETCH_ASSOC, null, function(...) { /* ... */ }) could return the type Kir\MySQL\Databases\MySQL\T|Kir\MySQL\Databases\MySQL\U which is incompatible with the type-hinted return array. Consider adding an additional type-check to rule them out.

			'valid' => is_array($row),
			'default' => []
		]);
	}

	/**
	 * @inheritDoc
	 */
	public function fetchObjects(string $className = 'stdClass', $callback = null): array {
		return $this->createTempStatement(function (QueryStatement $statement) use ($className, $callback) {
			$data = $statement->fetchAll(PDO::FETCH_CLASS, $className);
			if($this->preserveTypes) {
				$columnDefinitions = FieldTypeProvider::getFieldTypes($statement);
				$data = array_map(static fn($row) => FieldValueConverter::convertValues($row, $columnDefinitions), $data);
			}
			if($callback !== null) {
				return call_user_func(static function ($resultData = []) use ($data, $callback) {
					foreach($data as $row) {
						$result = $callback($row);
						if($result !== null && !($result instanceof DBIgnoreRow)) {
							$resultData[] = $result;
						} else {
							$resultData[] = $row;
						}
					}
					return $resultData;
				});
			}
			return $data;
		});
	}

	/**
	 * @inheritDoc
	 */
	public function fetchObjectsLazy($className = null, $callback = null) {
		$callback ??= static fn($row) => $row;
		yield from $this->fetchLazy($callback, PDO::FETCH_CLASS, $className ?: $this->defaultClassName);
	}

	/**
	 * @inheritDoc
	 */
	public function fetchObject($className = null, $callback = null) {
		$callback ??= static fn($row) => $row;
		return $this->fetch($callback, PDO::FETCH_CLASS, $className ?: $this->defaultClassName, static fn($row) => [
			'valid' => is_object($row),
			'default' => null
		]);
	}

	/**
	 * @inheritDoc
	 */
	public function fetchKeyValue($treatValueAsArray = false): array {
		return $this->createTempStatement(static function (QueryStatement $statement) use ($treatValueAsArray) {
			if($treatValueAsArray) {
				$rows = $statement->fetchAll(PDO::FETCH_ASSOC);
				$result = [];
				foreach($rows as $row) {
					[$key] = array_values($row);
					$result[$key] = $row;
				}
				return $result;
			}
			return $statement->fetchAll(PDO::FETCH_KEY_PAIR);
		});
	}

	/**
	 * @inheritDoc
	 */
	public function fetchGroups(array $fields): array {
		$rows = $this->fetchRows();
		$result = [];
		foreach($rows as $row) {
			/** @var array<string, mixed> $tmp */
			$tmp = &$result;
			foreach($fields as $field) {
				$value = (string) $row[$field];
				if(!array_key_exists($value, $tmp)) {
					$tmp[$value] = [];
				}
				$tmp = &$tmp[$value];
			}
			$tmp[] = $row;
		}
		return $result;
	}

	/**
	 * @inheritDoc
	 */
	public function fetchArray(?callable $fn = null): array {
		return $this->createTempStatement(static function (QueryStatement $stmt) use ($fn) {
			if($fn !== null) {
				return $stmt->fetchAll(PDO::FETCH_FUNC, $fn);
			}
			return $stmt->fetchAll(PDO::FETCH_COLUMN);
		});
	}

	/**
	 * @inheritDoc
	 */
	public function fetchValue($default = null, ?callable $fn = null) {
		return $this->createTempStatement(static function (QueryStatement $stmt) use ($default, $fn) {
			$result = $stmt->fetchAll(PDO::FETCH_COLUMN);
			if($result !== false && array_key_exists(0, $result)) {
				return $fn !== null ? $fn($result[0]) : $result[0];
			}
			return $default;
		});
	}

	/**
	 * @inheritDoc
	 */
	public function getFoundRows(): int {
		return $this->foundRows;
	}

	/**
	 * @param callable $fn
	 * @return mixed
	 */
	private function createTempStatement(callable $fn) {
		$stmt = $this->createStatement();
		try {
			return $fn($stmt);
		} finally {
			$stmt->closeCursor();
		}
	}

	/**
	 * @return QueryStatement
	 */
	private function createStatement(): QueryStatement {
		$db = $this->db();
		$query = $this->__toString();
		$statement = $db->prepare($query);
		$statement->execute($this->values);
		if($this->getCalcFoundRows()) {
			$this->foundRows = (int) $db->query('SELECT FOUND_ROWS()')->fetchColumn();
		}
		return $statement;
	}

	/**
	 * @return Traversable<int, array<string, bool|float|int|string|null>>
	 */
	public function getIterator(): Traversable {
		yield from $this->fetchRowsLazy();
	}

	/**
	 * @template TFnReturnType of array<int|string, mixed>
	 * @param null|(callable(array<string, null|scalar>): (TFnReturnType|DBIgnoreRow|null|void)) $callback

The doc comment null|(callable(array<string, null|scalar>): (TFnReturnType|DBIgnoreRow|null|void)) at position 3 could not be parsed: Expected ')' at position 3, but found 'callable'.

	 * @param int $mode
	 * @param mixed $arg0
	 * @return ($callback is null ? array<int, ($mode is PDO::FETCH_NUM ? array<int, null|scalar> : array<string, null|scalar>)> : array<int, TFnReturnType>)

The doc comment ($callback at position 1 could not be parsed: Unknown type name '$callback' at position 1 in ($callback.

	 */
	private function fetchAll($callback = null, int $mode = 0, $arg0 = null) {
		return $this->createTempStatement(function (QueryStatement $statement) use ($callback, $mode, $arg0) {
			$statement->setFetchMode($mode, $arg0);
			$data = $statement->fetchAll();
			if($this->preserveTypes) {
				$columnDefinitions = FieldTypeProvider::getFieldTypes($statement);
				$data = array_map(static fn($row) => FieldValueConverter::convertValues($row, $columnDefinitions), $data);
			}
			if($callback !== null) {
				return call_user_func(static function ($resultData = []) use ($data, $callback) {
					foreach($data as $row) {
						$result = $callback($row);
						if($result instanceof DBIgnoreRow) {
							continue;
						}
						if($result !== null) {
							$resultData[] = $result;
						} else {
							$resultData[] = $row;
						}
					}
					return $resultData;
				});
			}
			return $data;
		});
	}

	/**
	 * @template T
	 * @template U
	 * @param null|callable(T): U $callback
	 * @param int $mode
	 * @param mixed $arg0
	 * @return ($callback is null ? Generator<int, T> : Generator<int, U>)

The doc comment ($callback at position 1 could not be parsed: Unknown type name '$callback' at position 1 in ($callback.

	 */
	private function fetchLazy($callback = null, int $mode = PDO::FETCH_ASSOC, $arg0 = null): Generator {
		$statement = $this->createStatement();
		$statement->setFetchMode($mode, $arg0);
		try {
			while($row = $statement->fetch()) {
				/** @var T $row */
//				if($this->preserveTypes) {
//					$columnDefinitions = FieldTypeProvider::getFieldTypes($statement);
//					$row = FieldValueConverter::convertValues($row, $columnDefinitions);
//				}
				$result = $callback($row);
				if($result instanceof DBIgnoreRow) {
					// Skip row in this case
					continue;
				}
				if($result !== null) {
					yield $result;
				} else {
					yield $row;
				}
			}
		} finally {
			try { $statement->closeCursor(); } catch (Throwable $e) {}

Consider moving this CATCH statement to a new line.

		}
	}

	/**
	 * @template T
	 * @template U
	 * @param callable(T): U $callback
	 * @param int $mode
	 * @param mixed $arg0
	 * @param Closure|null $resultValidator
	 * @return T|U|array<string, mixed>

The type Kir\MySQL\Databases\MySQL\U was not found. Maybe you did not declare it correctly or list all dependencies?

The type Kir\MySQL\Databases\MySQL\T was not found. Maybe you did not declare it correctly or list all dependencies?

	 */
	private function fetch($callback, int $mode = PDO::FETCH_ASSOC, $arg0 = null, ?Closure $resultValidator = null) {
		return $this->createTempStatement(function (QueryStatement $statement) use ($callback, $mode, $arg0, $resultValidator) {
			$statement->setFetchMode($mode, $arg0);
			$row = $statement->fetch();
			$result = $resultValidator === null ? ['valid' => true] : $resultValidator($row);
			if(!$result['valid']) {
				return $result['default'];
			}
			if($this->preserveTypes) {
				$columnDefinitions = FieldTypeProvider::getFieldTypes($statement);
				$row = FieldValueConverter::convertValues($row, $columnDefinitions);

$row of type Kir\MySQL\Builder\T is incompatible with the type array expected by parameter $row of Kir\MySQL\Builder\Helpers\FieldValueConverter::convertValues().

			}
			if($callback !== null) {

The condition $callback !== null is always true.

				$result = $callback($row);
				if($result !== null) {
					$row = $result;
				}
			}
			return $row;
		});
	}
}