Final Class Yiisoft\Data\Cycle\Reader\EntityReader

                public function __construct(Select|SelectQuery $query, array $extraFilterHandlers = [])
{
    $this->query = clone $query;
    $this->countCache = new CachedCount($this->query);
    $this->itemsCache = new CachedCollection();
    $this->oneItemCache = new CachedCollection();
    /**
     * @psalm-suppress InternalMethod There is no other way to get driver for SelectQuery.
     * @psalm-suppress UndefinedMagicMethod The magic method is not defined in annotations.
     */
    $likeHandler = LikeHandlerFactory::getLikeHandler($this->query->getDriver()?->getType() ?? 'SQLite');
    $this->setFilterHandlers(
        new FilterHandler\AllHandler(),
        new FilterHandler\NoneHandler(),
        new FilterHandler\AndXHandler(),
        new FilterHandler\OrXHandler(),
        new FilterHandler\BetweenHandler(),
        new FilterHandler\EqualsHandler(),
        new FilterHandler\EqualsNullHandler(),
        new FilterHandler\GreaterThanHandler(),
        new FilterHandler\GreaterThanOrEqualHandler(),
        new FilterHandler\InHandler(),
        new FilterHandler\LessThanHandler(),
        new FilterHandler\LessThanOrEqualHandler(),
        $likeHandler,
        new FilterHandler\NotHandler(),
        ...$extraFilterHandlers,
    );
    $this->filter = new All();
}

            

                #[\Override]
public function count(): int
{
    return $this->countCache->getCount();
}

            

                #[\Override]
public function getFilter(): FilterInterface
{
    return $this->filter;
}

            

                #[\Override]
public function getIterator(): Generator
{
    yield from $this->itemsCache->getCollection() ?? $this->buildSelectQuery()->getIterator();
}

            

                #[\Override]
public function getLimit(): ?int
{
    return $this->limit;
}

            

                #[\Override]
public function getOffset(): int
{
    return $this->offset;
}

            

                #[\Override]
public function getSort(): ?Sort
{
    return $this->sorting;
}

            

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

            

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

            

                #[\Override]
public function readOne(): null|array|object
{
    if (!$this->oneItemCache->isCollected()) {
        $item = $this->itemsCache->isCollected()
            // get the first item from a 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();
}

            

                #[\Override]
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;
}

            

                #[\Override]
public function withLimit(?int $limit): static
{
    /** @psalm-suppress DocblockTypeContradiction */
    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;
}

            

                #[\Override]
public function withOffset(int $offset): static
{
    $new = clone $this;
    if ($new->offset !== $offset) {
        $new->offset = $offset;
        $new->itemsCache = new CachedCollection();
    }
    return $new;
}

            

                #[\Override]
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;
}