EntityReader::withFilterHandlers() - Code Metrics - yiisoft/yii-cycle - Measure and Improve Code Quality continuously with Scrutinizer

EntityReader::withFilterHandlers() A
last analyzed 2024-03-08 08:21 UTC

↳ Parent: EntityReader

Complexity

Conditions	1
Paths	1

Size

Total Lines	10
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	7
CRAP Score	1

Importance

Changes

Metric	Value
cc	1
eloc	6
nc	1
nop	1
dl	0
loc	10
ccs	7
cts	7
cp	1
crap	1
rs	10
c	0
b	0
f	0

<?php

declare(strict_types=1);

namespace Yiisoft\Yii\Cycle\Data\Reader;

use Closure;
use Cycle\Database\Query\SelectQuery;
use Cycle\ORM\Select;
use Cycle\ORM\Select\QueryBuilder;
use Generator;
use InvalidArgumentException;
use RuntimeException;
use Yiisoft\Data\Reader\DataReaderInterface;
use Yiisoft\Data\Reader\FilterHandlerInterface;
use Yiisoft\Data\Reader\FilterInterface;
use Yiisoft\Data\Reader\Sort;
use Yiisoft\Yii\Cycle\Data\Reader\Cache\CachedCollection;
use Yiisoft\Yii\Cycle\Data\Reader\Cache\CachedCount;

/**
 * @template TKey as array-key
 * @template TValue as array|object
 *
 * @implements DataReaderInterface<TKey, TValue>
 */
final class EntityReader implements DataReaderInterface
{
    private Select|SelectQuery $query;
    private ?int $limit = null;
    private ?int $offset = null;
    private ?Sort $sorting = null;
    private ?FilterInterface $filter = null;
    private CachedCount $countCache;
    private CachedCollection $itemsCache;
    private CachedCollection $oneItemCache;
    /** @var FilterHandlerInterface[]|QueryBuilderFilterHandler[] */
    private array $filterHandlers = [];

    public function __construct(Select|SelectQuery $query)
    {
        $this->query = clone $query;
        $this->countCache = new CachedCount($this->query);
        $this->itemsCache = new CachedCollection();
        $this->oneItemCache = new CachedCollection();
        $this->setFilterHandlers(
            new FilterHandler\AllHandler(),
            new FilterHandler\AnyHandler(),
            new FilterHandler\EqualsHandler(),
            new FilterHandler\GreaterThanHandler(),
            new FilterHandler\GreaterThanOrEqualHandler(),
            new FilterHandler\InHandler(),
            new FilterHandler\LessThanHandler(),
            new FilterHandler\LessThanOrEqualHandler(),
            new FilterHandler\LikeHandler(),
            // new Processor\Not()
        );
    }

    public function getSort(): ?Sort
    {
        return $this->sorting;
    }

    /**
     * @psalm-mutation-free
     */
    public function withLimit(int $limit): static
    {
        if ($limit < 0) {
            throw new InvalidArgumentException('$limit must not be less than 0.');
        }
        $new = clone $this;
        if ($new->limit !== $limit) {
            $new->limit = $limit;
            $new->itemsCache = new CachedCollection();
        }
        return $new;
    }

    /**
     * @psalm-mutation-free
     */
    public function withOffset(int $offset): static
    {
        $new = clone $this;
        if ($new->offset !== $offset) {
            $new->offset = $offset;
            $new->itemsCache = new CachedCollection();
        }
        return $new;
    }

    /**
     * @psalm-mutation-free
     */
    public function withSort(?Sort $sort): static
    {
        $new = clone $this;
        if ($new->sorting !== $sort) {
            $new->sorting = $sort;
            $new->itemsCache = new CachedCollection();
            $new->oneItemCache = new CachedCollection();
        }
        return $new;
    }

    /**
     * @psalm-mutation-free
     */
    public function withFilter(FilterInterface $filter): static
    {
        $new = clone $this;
        if ($new->filter !== $filter) {
            $new->filter = $filter;
            $new->itemsCache = new CachedCollection();
            $new->oneItemCache = new CachedCollection();
            /** @psalm-suppress ImpureMethodCall */
            $new->resetCountCache();
        }
        return $new;
    }

    /**
     * @psalm-mutation-free
     */
    public function withFilterHandlers(FilterHandlerInterface ...$filterHandlers): static
    {
        $new = clone $this;
        /** @psalm-suppress ImpureMethodCall */
        $new->setFilterHandlers(...$filterHandlers);
        /** @psalm-suppress ImpureMethodCall */
        $new->resetCountCache();
        $new->itemsCache = new CachedCollection();
        $new->oneItemCache = new CachedCollection();
        return $new;
    }

    public function count(): int
    {
        return $this->countCache->getCount();
    }

    public function read(): iterable
    {
        if ($this->itemsCache->getCollection() === null) {
            $query = $this->buildSelectQuery();
            $this->itemsCache->setCollection($query->fetchAll());
        }
        return $this->itemsCache->getCollection();
    }

    public function readOne(): null|array|object
    {
        if (!$this->oneItemCache->isCollected()) {
            $item = $this->itemsCache->isCollected()
                // get first item from cached collection
                ? $this->itemsCache->getGenerator()->current()
                // read data with limit 1
                : $this->withLimit(1)->getIterator()->current();
            $this->oneItemCache->setCollection($item === null ? [] : [$item]);
        }

        return $this->oneItemCache->getGenerator()->current();
    }

    /**
     * Get Iterator without caching
     */
    public function getIterator(): Generator
    {
        yield from $this->itemsCache->getCollection() ?? $this->buildSelectQuery()->getIterator();
    }

    public function getSql(): string
    {
        $query = $this->buildSelectQuery();
        return (string)($query instanceof Select ? $query->buildQuery() : $query);
    }

    private function setFilterHandlers(FilterHandlerInterface ...$filterHandlers): void
    {
        $handlers = [];
        foreach ($filterHandlers as $filterHandler) {
            if ($filterHandler instanceof QueryBuilderFilterHandler) {
                $handlers[$filterHandler->getOperator()] = $filterHandler;
            }
        }
        $this->filterHandlers = array_merge($this->filterHandlers, $handlers);
    }

    private function buildSelectQuery(): SelectQuery|Select
    {
        $newQuery = clone $this->query;
        if ($this->offset !== null) {
            $newQuery->offset($this->offset);
        }
        if ($this->sorting !== null) {
            $newQuery->orderBy($this->normalizeSortingCriteria($this->sorting->getCriteria()));
        }
        if ($this->limit !== null) {
            $newQuery->limit($this->limit);
        }
        if ($this->filter !== null) {
            $newQuery->andWhere($this->makeFilterClosure($this->filter));
        }
        return $newQuery;
    }

    private function makeFilterClosure(FilterInterface $filter): Closure
    {
        return function (QueryBuilder $select) use ($filter) {
            $filterArray = $filter->toCriteriaArray();
            $operation = array_shift($filterArray);
            $arguments = $filterArray;

            if (!array_key_exists($operation, $this->filterHandlers)) {
                throw new RuntimeException(sprintf('Filter operator "%s" is not supported.', $operation));
            }
            /** @var QueryBuilderFilterHandler $handler */
            $handler = $this->filterHandlers[$operation];
            $select->where(...$handler->getAsWhereArguments($arguments, $this->filterHandlers));
        };
    }

    private function resetCountCache(): void
    {
        $newQuery = clone $this->query;
        if ($this->filter !== null) {
            $newQuery->andWhere($this->makeFilterClosure($this->filter));
        }
        $this->countCache = new CachedCount($newQuery);
    }

    private function normalizeSortingCriteria(array $criteria): array
    {
        foreach ($criteria as $field => $direction) {
            if (is_int($direction)) {
                $direction = match ($direction) {
                    SORT_DESC => 'DESC',
                    default => 'ASC',
                };
            }
            $criteria[$field] = $direction;
        }

        return $criteria;
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Yiisoft\Yii\Cycle\Data\Reader;
6
7		use Closure;
8		use Cycle\Database\Query\SelectQuery;
9		use Cycle\ORM\Select;
10		use Cycle\ORM\Select\QueryBuilder;
11		use Generator;
12		use InvalidArgumentException;
13		use RuntimeException;
14		use Yiisoft\Data\Reader\DataReaderInterface;
15		use Yiisoft\Data\Reader\FilterHandlerInterface;
16		use Yiisoft\Data\Reader\FilterInterface;
17		use Yiisoft\Data\Reader\Sort;
18		use Yiisoft\Yii\Cycle\Data\Reader\Cache\CachedCollection;
19		use Yiisoft\Yii\Cycle\Data\Reader\Cache\CachedCount;
20
21		/**
22		* @template TKey as array-key
23		* @template TValue as array\|object
24		*
25		* @implements DataReaderInterface<TKey, TValue>
26		*/
27		final class EntityReader implements DataReaderInterface
28		{
29		private Select\|SelectQuery $query;
30		private ?int $limit = null;
31		private ?int $offset = null;
32		private ?Sort $sorting = null;
33		private ?FilterInterface $filter = null;
34		private CachedCount $countCache;
35		private CachedCollection $itemsCache;
36		private CachedCollection $oneItemCache;
37		/** @var FilterHandlerInterface[]\|QueryBuilderFilterHandler[] */
38		private array $filterHandlers = [];
39
40	16	public function __construct(Select\|SelectQuery $query)
41		{
42	16	$this->query = clone $query;
43	16	$this->countCache = new CachedCount($this->query);
44	16	$this->itemsCache = new CachedCollection();
45	16	$this->oneItemCache = new CachedCollection();
46	16	$this->setFilterHandlers(
47	16	new FilterHandler\AllHandler(),
48	16	new FilterHandler\AnyHandler(),
49	16	new FilterHandler\EqualsHandler(),
50	16	new FilterHandler\GreaterThanHandler(),
51	16	new FilterHandler\GreaterThanOrEqualHandler(),
52	16	new FilterHandler\InHandler(),
53	16	new FilterHandler\LessThanHandler(),
54	16	new FilterHandler\LessThanOrEqualHandler(),
55	16	new FilterHandler\LikeHandler(),
56	16	// new Processor\Not()
57	16	);
58		}
59
60	1	public function getSort(): ?Sort
61		{
62	1	return $this->sorting;
63		}
64
65		/**
66		* @psalm-mutation-free
67		*/
68	4	public function withLimit(int $limit): static
69		{
70	4	if ($limit < 0) {
71	1	throw new InvalidArgumentException('$limit must not be less than 0.');
72		}
73	3	$new = clone $this;
74	3	if ($new->limit !== $limit) {
75	3	$new->limit = $limit;
76	3	$new->itemsCache = new CachedCollection();
77		}
78	3	return $new;
79		}
80
81		/**
82		* @psalm-mutation-free
83		*/
84	2	public function withOffset(int $offset): static
85		{
86	2	$new = clone $this;
87	2	if ($new->offset !== $offset) {
88	2	$new->offset = $offset;
89	2	$new->itemsCache = new CachedCollection();
90		}
91	2	return $new;
92		}
93
94		/**
95		* @psalm-mutation-free
96		*/
97	2	public function withSort(?Sort $sort): static
98		{
99	2	$new = clone $this;
100	2	if ($new->sorting !== $sort) {
101	2	$new->sorting = $sort;
102	2	$new->itemsCache = new CachedCollection();
103	2	$new->oneItemCache = new CachedCollection();
104		}
105	2	return $new;
106		}
107
108		/**
109		* @psalm-mutation-free
110		*/
111	13	public function withFilter(FilterInterface $filter): static
112		{
113	13	$new = clone $this;
114	13	if ($new->filter !== $filter) {
115	13	$new->filter = $filter;
116	13	$new->itemsCache = new CachedCollection();
117	13	$new->oneItemCache = new CachedCollection();
118		/** @psalm-suppress ImpureMethodCall */
119	13	$new->resetCountCache();
120		}
121	10	return $new;
122		}
123
124		/**
125		* @psalm-mutation-free
126		*/
127	1	public function withFilterHandlers(FilterHandlerInterface ...$filterHandlers): static
128		{
129	1	$new = clone $this;
130		/** @psalm-suppress ImpureMethodCall */
131	1	$new->setFilterHandlers(...$filterHandlers);
132		/** @psalm-suppress ImpureMethodCall */
133	1	$new->resetCountCache();
134	1	$new->itemsCache = new CachedCollection();
135	1	$new->oneItemCache = new CachedCollection();
136	1	return $new;
137		}
138
139	3	public function count(): int
140		{
141	3	return $this->countCache->getCount();
142		}
143
144	10	public function read(): iterable
145		{
146	10	if ($this->itemsCache->getCollection() === null) {
147	10	$query = $this->buildSelectQuery();
148	10	$this->itemsCache->setCollection($query->fetchAll());
149		}
150	10	return $this->itemsCache->getCollection();
151		}
152
153	2	public function readOne(): null\|array\|object
154		{
155	2	if (!$this->oneItemCache->isCollected()) {
156	2	$item = $this->itemsCache->isCollected()
157	2	// get first item from cached collection
158	1	? $this->itemsCache->getGenerator()->current()
159	2	// read data with limit 1
160	1	: $this->withLimit(1)->getIterator()->current();
161	2	$this->oneItemCache->setCollection($item === null ? [] : [$item]);
162		}
163
164	2	return $this->oneItemCache->getGenerator()->current();
165		}
166
167		/**
168		* Get Iterator without caching
169		*/
170	1	public function getIterator(): Generator
171		{
172	1	yield from $this->itemsCache->getCollection() ?? $this->buildSelectQuery()->getIterator();
173		}
174
175	4	public function getSql(): string
176		{
177	4	$query = $this->buildSelectQuery();
178	4	return (string)($query instanceof Select ? $query->buildQuery() : $query);
179		}
180
181	16	private function setFilterHandlers(FilterHandlerInterface ...$filterHandlers): void
182		{
183	16	$handlers = [];
184	16	foreach ($filterHandlers as $filterHandler) {
185	16	if ($filterHandler instanceof QueryBuilderFilterHandler) {
186	16	$handlers[$filterHandler->getOperator()] = $filterHandler;
187		}
188		}
189	16	$this->filterHandlers = array_merge($this->filterHandlers, $handlers);
190		}
191
192	12	private function buildSelectQuery(): SelectQuery\|Select
193		{
194	12	$newQuery = clone $this->query;
195	12	if ($this->offset !== null) {
196	1	$newQuery->offset($this->offset);
197		}
198	12	if ($this->sorting !== null) {
199	1	$newQuery->orderBy($this->normalizeSortingCriteria($this->sorting->getCriteria()));
200		}
201	12	if ($this->limit !== null) {
202	1	$newQuery->limit($this->limit);
203		}
204	12	if ($this->filter !== null) {
205	9	$newQuery->andWhere($this->makeFilterClosure($this->filter));
206		}
207	12	return $newQuery;
208		}
209
210	12	private function makeFilterClosure(FilterInterface $filter): Closure
211		{
212	12	return function (QueryBuilder $select) use ($filter) {
213	12	$filterArray = $filter->toCriteriaArray();
214	12	$operation = array_shift($filterArray);
215	12	$arguments = $filterArray;
216
217	12	if (!array_key_exists($operation, $this->filterHandlers)) {
218		throw new RuntimeException(sprintf('Filter operator "%s" is not supported.', $operation));
219		}
220		/** @var QueryBuilderFilterHandler $handler */
221	12	$handler = $this->filterHandlers[$operation];
222	12	$select->where(...$handler->getAsWhereArguments($arguments, $this->filterHandlers));
223	12	};
224		}
225
226	12	private function resetCountCache(): void
227		{
228	12	$newQuery = clone $this->query;
229	12	if ($this->filter !== null) {
230	12	$newQuery->andWhere($this->makeFilterClosure($this->filter));
231		}
232	9	$this->countCache = new CachedCount($newQuery);
233		}
234
235	2	private function normalizeSortingCriteria(array $criteria): array
236		{
237	2	foreach ($criteria as $field => $direction) {
238	2	if (is_int($direction)) {
239	2	$direction = match ($direction) {
240	2	SORT_DESC => 'DESC',
241	2	default => 'ASC',
242	2	};
243		}
244	2	$criteria[$field] = $direction;
245		}
246
247	2	return $criteria;
248		}
249		}
250

yiisoft / yii-cycle

EntityReader::withFilterHandlers() A last analyzed 2024-03-08 08:21 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

EntityReader::withFilterHandlers() A
last analyzed 2024-03-08 08:21 UTC