17019780057

Committed 17 Aug 2025 10:11AM UTC coverage: 91.652% (+0.009%) from 91.643%

Build # 17019780057

Build Type

Pull #763

github

Committed by

web-flow

Commit Message

Merge 74a960232 into 787d648e2

Pull Request Pull Request #763: collection: fix repeated queryBuilder construction

Run Details

28 of 29 new or added lines in 1 file covered. (96.55%)

2 existing lines in 1 file now uncovered.

4139 of 4516 relevant lines covered (91.65%)

4.57 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.52

/src/Collection/DbalCollection.php

<?php declare(strict_types = 1);

namespace Nextras\Orm\Collection;


use Iterator;
use Nextras\Dbal\IConnection;
use Nextras\Dbal\Platforms\Data\Fqn;
use Nextras\Dbal\Platforms\MySqlPlatform;
use Nextras\Dbal\Platforms\SqlServerPlatform;
use Nextras\Dbal\QueryBuilder\QueryBuilder;
use Nextras\Orm\Collection\Expression\ExpressionContext;
use Nextras\Orm\Collection\Functions\Result\DbalExpressionResult;
use Nextras\Orm\Collection\Helpers\DbalQueryBuilderHelper;
use Nextras\Orm\Collection\Helpers\FetchPairsHelper;
use Nextras\Orm\Entity\IEntity;
use Nextras\Orm\Exception\InvalidStateException;
use Nextras\Orm\Exception\MemberAccessException;
use Nextras\Orm\Exception\NoResultException;
use Nextras\Orm\Mapper\Dbal\DbalMapper;
use Nextras\Orm\Mapper\IRelationshipMapper;
use function count;
use function is_array;


/**
 * @template E of IEntity
 * @implements ICollection<E>
 */
class DbalCollection implements ICollection
{
        /** @var list<callable(\Traversable<E> $entities): void> */
        public array $onEntityFetch = [];

        protected IRelationshipMapper|null $relationshipMapper = null;
        protected IEntity|null $relationshipParent = null;

        /** @var Iterator<E>|null */
        protected Iterator|null $fetchIterator = null;

        /** @var array<mixed> FindBy expressions for deferred processing */
        protected array $filtering = [];

        /** @var array<array{DbalExpressionResult, string}> OrderBy expression result & sorting direction */
        protected array $ordering = [];

        /** @var array{int|null, int|null}|null */
        protected array|null $limitBy = null;

        protected DbalQueryBuilderHelper|null $helper = null;

        /** @var list<E>|null */
        protected ?array $result = null;
        protected ?int $resultCount = null;
        protected bool $entityFetchEventTriggered = false;

        protected QueryBuilder|null $queryBuilderCache = null;


        /**
         * @param DbalMapper<E> $mapper
         */
        public function __construct(
                protected readonly DbalMapper $mapper,
                protected readonly IConnection $connection,
                protected QueryBuilder $queryBuilder,
        )
        {
        }


        public function getBy(array $conds): ?IEntity
        {
                return $this->findBy($conds)->fetch();
        }


        public function getByChecked(array $conds): IEntity
        {
                return $this->findBy($conds)->fetchChecked();
        }


        public function getById($id): ?IEntity
        {
                return $this->getBy(['id' => $id]);
        }


        public function getByIdChecked($id): IEntity
        {
                $entity = $this->getById($id);
                if ($entity === null) {
                        throw new NoResultException();
                }
                return $entity;
        }


        public function findBy(array $conds): ICollection
        {
                $collection = clone $this;
                $collection->filtering[] = $conds;
                return $collection;
        }


        public function orderBy($expression, string $direction = ICollection::ASC): ICollection
        {
                $collection = clone $this;
                $helper = $collection->getHelper();
                if (is_array($expression) && !isset($expression[0])) {
                        /** @var array<string, string> $expression */
                        $expression = $expression; // no-op for PHPStan

                        foreach ($expression as $subExpression => $subDirection) {
                                $collection->ordering[] = [
                                        $helper->processExpression($collection->queryBuilder, $subExpression, null),
                                        $subDirection,
                                ];
                        }
                } else {
                        $collection->ordering[] = [
                                $helper->processExpression($collection->queryBuilder, $expression, null),
                                $direction,
                        ];
                }
                return $collection;
        }


        public function resetOrderBy(): ICollection
        {
                $collection = clone $this;
                $collection->ordering = [];
                // reset default ordering from mapper
                $collection->queryBuilder->orderBy(null);
                return $collection;
        }


        public function limitBy(int $limit, int|null $offset = null): ICollection
        {
                $collection = clone $this;
                $collection->limitBy = [$limit, $offset];
                return $collection;
        }


        public function fetch(): ?IEntity
        {
                if ($this->fetchIterator === null) {
                        $this->fetchIterator = $this->getIterator();
                }

                if ($this->fetchIterator->valid()) {
                        $current = $this->fetchIterator->current();
                        $this->fetchIterator->next();
                        return $current;
                }

                return null;
        }


        public function fetchChecked(): IEntity
        {
                $entity = $this->fetch();
                if ($entity === null) {
                        throw new NoResultException();
                }
                return $entity;
        }


        public function fetchAll(): array
        {
                return iterator_to_array($this->getIterator(), preserve_keys: false);
        }


        public function fetchPairs(string|null $key = null, string|null $value = null): array
        {
                return FetchPairsHelper::process($this->getIterator(), $key, $value);
        }


        /**
         * @param mixed[] $args
         * @return never
         * @throws MemberAccessException
         */
        public function __call(string $name, array $args)
        {
                $class = get_class($this);
                throw new MemberAccessException("Call to undefined method $class::$name().");
        }


        /**
         * @return Iterator<int, E>
         */
        public function getIterator(): Iterator
        {
                if ($this->relationshipParent !== null && $this->relationshipMapper !== null) {
                        /** @var Iterator<E> $entityIterator */
                        $entityIterator = $this->relationshipMapper->getIterator($this->relationshipParent, $this);
                } else {
                        if ($this->result === null) {
                                $this->execute();
                        }

                        assert(is_array($this->result));
                        /** @var Iterator<E> $entityIterator */
                        $entityIterator = new EntityIterator($this->result);
                }

                if (!$this->entityFetchEventTriggered) {
                        foreach ($this->onEntityFetch as $entityFetchCallback) {
                                $entityFetchCallback($entityIterator);
                        }
                        $entityIterator->rewind();
                        $this->entityFetchEventTriggered = true;
                }

                return $entityIterator;
        }


        public function count(): int
        {
                return iterator_count($this->getIterator());
        }


        public function countStored(): int
        {
                if ($this->relationshipParent !== null && $this->relationshipMapper !== null) {
                        return $this->relationshipMapper->getIteratorCount($this->relationshipParent, $this);
                }

                return $this->getIteratorCount();
        }


        public function toMemoryCollection(): MemoryCollection
        {
                $collection = clone $this;
                $entities = $collection->fetchAll();
                return new ArrayCollection($entities, $this->mapper->getRepository());
        }


        public function setRelationshipMapper(IRelationshipMapper|null $mapper): ICollection
        {
                $this->relationshipMapper = $mapper;
                return $this;
        }


        public function getRelationshipMapper(): ?IRelationshipMapper
        {
                return $this->relationshipMapper;
        }


        public function setRelationshipParent(IEntity $parent): ICollection
        {
                $collection = clone $this;
                $collection->relationshipParent = $parent;
                return $collection;
        }


        public function subscribeOnEntityFetch(callable $callback): void
        {
                $this->onEntityFetch[] = $callback;
        }


        public function __clone()
        {
                // clone is needed for resetOrderBy()
                $this->queryBuilder = clone $this->queryBuilder;
                $this->queryBuilderCache = null;
                $this->result = null;
                $this->resultCount = null;
                $this->fetchIterator = null;
                $this->entityFetchEventTriggered = false;
        }


        /**
         * @internal
         */
        public function getQueryBuilder(): QueryBuilder
        {
                if ($this->queryBuilderCache !== null) {
                        return $this->queryBuilderCache;
                }

                $joins = [];
                $groupBy = [];
                $queryBuilder = clone $this->queryBuilder;
                $helper = $this->getHelper();

                $filtering = $this->filtering;
                if (count($filtering) > 0) {
                        array_unshift($filtering, ICollection::AND);
                        $expression = $helper->processExpression(
                                builder: $queryBuilder,
                                expression: $filtering,
                                aggregator: null,
                        );
                        $finalContext = $expression->havingExpression === null
                                ? ExpressionContext::FilterAnd
                                : ExpressionContext::FilterAndWithHavingClause;
                        $expression = $expression->collect($finalContext);
                        $joins = $expression->joins;
                        $groupBy = $expression->groupBy;
                        if ($expression->expression !== null && $expression->args !== []) {
                                $queryBuilder->andWhere($expression->expression, ...$expression->args);
                        }
                        if ($expression->havingExpression !== null && $expression->havingArgs !== []) {
                                $queryBuilder->andHaving($expression->havingExpression, ...$expression->havingArgs);
                        }
                        if ($this->mapper->getDatabasePlatform()->getName() === MySqlPlatform::NAME) {
                                $this->applyGroupByWithSameNamedColumnsWorkaround($queryBuilder, $groupBy);
                        }
                }

                foreach ($this->ordering as [$expression, $direction]) {
                        $joins = array_merge($joins, $expression->joins);
                        $groupBy = array_merge($groupBy, $expression->groupBy);
                        $orderingExpression = $helper->processOrderDirection($expression, $direction);
                        $queryBuilder->addOrderBy('%ex', $orderingExpression);
                }

                if ($this->limitBy !== null) {
                        $queryBuilder->limitBy($this->limitBy[0], $this->limitBy[1]);
                }

                $mergedJoins = $helper->mergeJoins('%and', $joins);
                foreach ($mergedJoins as $join) {
                        $join->applyJoin($queryBuilder);
                }

                if (count($groupBy) > 0) {
                        foreach ($this->ordering as [$expression]) {
                                $groupBy = array_merge($groupBy, $expression->columns);
                        }
                }

                if (count($groupBy) > 0) {
                        $unique = [];
                        foreach ($groupBy as $groupByFqn) {
                                $unique[$groupByFqn->getUnescaped()] = $groupByFqn;
                        }
                        $queryBuilder->groupBy('%column[]', array_values($unique));
                }

                $this->queryBuilderCache = $queryBuilder;
                return $queryBuilder;
        }


        protected function getIteratorCount(): int
        {
                if ($this->resultCount !== null) {
                        return $this->resultCount;
                }

                $builder = clone $this->getQueryBuilder();

                if ($this->connection->getPlatform()->getName() === SqlServerPlatform::NAME) {
                        if (!$builder->hasLimitOffsetClause()) {
                                $builder->orderBy(null);
                        }
                } else {
                        $builder->orderBy(null);
                }

                $select = $builder->getClause('select')[0];
                if (is_array($select) && count($select) === 1 && $select[0] === "%table.*") {
                        $builder->select(null);
                        foreach ($this->mapper->getConventions()->getStoragePrimaryKey() as $column) {
                                $builder->addSelect('%table.%column', $builder->getFromAlias(), $column);
                        }
                }
                $sql = 'SELECT COUNT(*) AS count FROM (' . $builder->getQuerySql() . ') temp';
                $args = $builder->getQueryParameters();

                $this->resultCount = $this->connection->queryArgs($sql, $args)->fetchField()
                        ?? throw new InvalidStateException("Unable to fetch collection count.");
                return $this->resultCount;
        }


        protected function execute(): void
        {
                $result = $this->connection->queryByQueryBuilder($this->getQueryBuilder());

                $this->result = [];
                while (($data = $result->fetch()) !== null) {
                        $entity = $this->mapper->hydrateEntity($data->toArray());
                        if ($entity === null) continue;
                        $this->result[] = $entity;
                }
        }


        protected function getHelper(): DbalQueryBuilderHelper
        {
                if ($this->helper === null) {
                        $repository = $this->mapper->getRepository();
                        $this->helper = new DbalQueryBuilderHelper($repository);
                }

                return $this->helper;
        }


        /**
         * Apply workaround for MySQL that is not able to properly resolve columns when there are more same-named
         * columns in the GROUP BY clause, even though they are properly referenced to their tables. Orm workarounds
         * this by adding them to the SELECT clause and renames them not to conflict anywhere.
         *
         * @param list<Fqn> $groupBy
         */
        private function applyGroupByWithSameNamedColumnsWorkaround(QueryBuilder $queryBuilder, array $groupBy): void
        {
                $map = [];
                foreach ($groupBy as $fqn) {
                        if (!isset($map[$fqn->name])) {
                                $map[$fqn->name] = [$fqn];
                        } else {
                                $map[$fqn->name][] = $fqn;
                        }
                }
                $i = 0;
                foreach ($map as $fqns) {
                        if (count($fqns) > 1) {
                                foreach ($fqns as $fqn) {
                                        $queryBuilder->addSelect("%column AS __nextras_fix_" . $i++, $fqn); // @phpstan-ignore-line
                                }
                        }
                }
        }
}

1	<?php declare(strict_types = 1);
2
3	namespace Nextras\Orm\Collection;
4
5
6	use Iterator;
7	use Nextras\Dbal\IConnection;
8	use Nextras\Dbal\Platforms\Data\Fqn;
9	use Nextras\Dbal\Platforms\MySqlPlatform;
10	use Nextras\Dbal\Platforms\SqlServerPlatform;
11	use Nextras\Dbal\QueryBuilder\QueryBuilder;
12	use Nextras\Orm\Collection\Expression\ExpressionContext;
13	use Nextras\Orm\Collection\Functions\Result\DbalExpressionResult;
14	use Nextras\Orm\Collection\Helpers\DbalQueryBuilderHelper;
15	use Nextras\Orm\Collection\Helpers\FetchPairsHelper;
16	use Nextras\Orm\Entity\IEntity;
17	use Nextras\Orm\Exception\InvalidStateException;
18	use Nextras\Orm\Exception\MemberAccessException;
19	use Nextras\Orm\Exception\NoResultException;
20	use Nextras\Orm\Mapper\Dbal\DbalMapper;
21	use Nextras\Orm\Mapper\IRelationshipMapper;
22	use function count;
23	use function is_array;
24
25
26	/**
27	* @template E of IEntity
28	* @implements ICollection<E>
29	*/
30	class DbalCollection implements ICollection
31	{
32	/** @var list<callable(\Traversable<E> $entities): void> */
33	public array $onEntityFetch = [];
34
35	protected IRelationshipMapper\|null $relationshipMapper = null;
36	protected IEntity\|null $relationshipParent = null;
37
38	/** @var Iterator<E>\|null */
39	protected Iterator\|null $fetchIterator = null;
40
41	/** @var array<mixed> FindBy expressions for deferred processing */
42	protected array $filtering = [];
43
44	/** @var array<array{DbalExpressionResult, string}> OrderBy expression result & sorting direction */
45	protected array $ordering = [];
46
47	/** @var array{int\|null, int\|null}\|null */
48	protected array\|null $limitBy = null;
49
50	protected DbalQueryBuilderHelper\|null $helper = null;
51
52	/** @var list<E>\|null */
53	protected ?array $result = null;
54	protected ?int $resultCount = null;
55	protected bool $entityFetchEventTriggered = false;
56
57	protected QueryBuilder\|null $queryBuilderCache = null;
58
59
60	/**
61	* @param DbalMapper<E> $mapper
62	*/
63	public function __construct(	5✔
64	protected readonly DbalMapper $mapper,
65	protected readonly IConnection $connection,
66	protected QueryBuilder $queryBuilder,
67	)
68	{
69	}	5✔
70
71
72	public function getBy(array $conds): ?IEntity
73	{
74	return $this->findBy($conds)->fetch();	5✔
75	}
76
77
78	public function getByChecked(array $conds): IEntity
79	{
80	return $this->findBy($conds)->fetchChecked();	5✔
81	}
82
83
84	public function getById($id): ?IEntity
85	{
86	return $this->getBy(['id' => $id]);	5✔
87	}
88
89
90	public function getByIdChecked($id): IEntity
91	{
92	$entity = $this->getById($id);	5✔
93	if ($entity === null) {	5✔
94	throw new NoResultException();	5✔
95	}
96	return $entity;	5✔
97	}
98
99
100	public function findBy(array $conds): ICollection
101	{
102	$collection = clone $this;	5✔
103	$collection->filtering[] = $conds;	5✔
104	return $collection;	5✔
105	}
106
107
108	public function orderBy($expression, string $direction = ICollection::ASC): ICollection
109	{
110	$collection = clone $this;	5✔
111	$helper = $collection->getHelper();	5✔
112	if (is_array($expression) && !isset($expression[0])) {	5✔
113	/** @var array<string, string> $expression */
114	$expression = $expression; // no-op for PHPStan	5✔
115
116	foreach ($expression as $subExpression => $subDirection) {	5✔
117	$collection->ordering[] = [	5✔
118	$helper->processExpression($collection->queryBuilder, $subExpression, null),	5✔
119	$subDirection,	5✔
120	];
121	}
122	} else {
123	$collection->ordering[] = [	5✔
124	$helper->processExpression($collection->queryBuilder, $expression, null),	5✔
125	$direction,	5✔
126	];
127	}
128	return $collection;	5✔
129	}
130
131
132	public function resetOrderBy(): ICollection
133	{
134	$collection = clone $this;	5✔
135	$collection->ordering = [];	5✔
136	// reset default ordering from mapper
137	$collection->queryBuilder->orderBy(null);	5✔
138	return $collection;	5✔
139	}
140
141
142	public function limitBy(int $limit, int\|null $offset = null): ICollection
143	{
144	$collection = clone $this;	5✔
145	$collection->limitBy = [$limit, $offset];	5✔
146	return $collection;	5✔
147	}
148
149
150	public function fetch(): ?IEntity
151	{
152	if ($this->fetchIterator === null) {	5✔
153	$this->fetchIterator = $this->getIterator();	5✔
154	}
155
156	if ($this->fetchIterator->valid()) {	5✔
157	$current = $this->fetchIterator->current();	5✔
158	$this->fetchIterator->next();	5✔
159	return $current;	5✔
160	}
161
162	return null;	5✔
163	}
164
165
166	public function fetchChecked(): IEntity
167	{
168	$entity = $this->fetch();	5✔
169	if ($entity === null) {	5✔
170	throw new NoResultException();	5✔
171	}
172	return $entity;	5✔
173	}
174
175
176	public function fetchAll(): array
177	{
178	return iterator_to_array($this->getIterator(), preserve_keys: false);	5✔
179	}
180
181
182	public function fetchPairs(string\|null $key = null, string\|null $value = null): array
183	{
184	return FetchPairsHelper::process($this->getIterator(), $key, $value);	5✔
185	}
186
187
188	/**
189	* @param mixed[] $args
190	* @return never
191	* @throws MemberAccessException
192	*/
193	public function __call(string $name, array $args)
194	{
UNCOV 195	$class = get_class($this);	×
196	throw new MemberAccessException("Call to undefined method $class::$name().");	×
197	}
198
199
200	/**
201	* @return Iterator<int, E>
202	*/
203	public function getIterator(): Iterator
204	{
205	if ($this->relationshipParent !== null && $this->relationshipMapper !== null) {	5✔
206	/** @var Iterator<E> $entityIterator */
207	$entityIterator = $this->relationshipMapper->getIterator($this->relationshipParent, $this);	5✔
208	} else {
209	if ($this->result === null) {	5✔
210	$this->execute();	5✔
211	}
212
213	assert(is_array($this->result));
214	/** @var Iterator<E> $entityIterator */
215	$entityIterator = new EntityIterator($this->result);	5✔
216	}
217
218	if (!$this->entityFetchEventTriggered) {	5✔
219	foreach ($this->onEntityFetch as $entityFetchCallback) {	5✔
220	$entityFetchCallback($entityIterator);	5✔
221	}
222	$entityIterator->rewind();	5✔
223	$this->entityFetchEventTriggered = true;	5✔
224	}
225
226	return $entityIterator;	5✔
227	}
228
229
230	public function count(): int
231	{
232	return iterator_count($this->getIterator());	5✔
233	}
234
235
236	public function countStored(): int
237	{
238	if ($this->relationshipParent !== null && $this->relationshipMapper !== null) {	5✔
239	return $this->relationshipMapper->getIteratorCount($this->relationshipParent, $this);	5✔
240	}
241
242	return $this->getIteratorCount();	5✔
243	}
244
245
246	public function toMemoryCollection(): MemoryCollection
247	{
248	$collection = clone $this;	5✔
249	$entities = $collection->fetchAll();	5✔
250	return new ArrayCollection($entities, $this->mapper->getRepository());	5✔
251	}
252
253
254	public function setRelationshipMapper(IRelationshipMapper\|null $mapper): ICollection
255	{
256	$this->relationshipMapper = $mapper;	5✔
257	return $this;	5✔
258	}
259
260
261	public function getRelationshipMapper(): ?IRelationshipMapper
262	{
263	return $this->relationshipMapper;	5✔
264	}
265
266
267	public function setRelationshipParent(IEntity $parent): ICollection
268	{
269	$collection = clone $this;	5✔
270	$collection->relationshipParent = $parent;	5✔
271	return $collection;	5✔
272	}
273
274
275	public function subscribeOnEntityFetch(callable $callback): void
276	{
277	$this->onEntityFetch[] = $callback;	5✔
278	}	5✔
279
280
281	public function __clone()
282	{
283	// clone is needed for resetOrderBy()
284	$this->queryBuilder = clone $this->queryBuilder;	5✔
285	$this->queryBuilderCache = null;	5✔
286	$this->result = null;	5✔
287	$this->resultCount = null;	5✔
288	$this->fetchIterator = null;	5✔
289	$this->entityFetchEventTriggered = false;	5✔
290	}	5✔
291
292
293	/**
294	* @internal
295	*/
296	public function getQueryBuilder(): QueryBuilder
297	{
298	if ($this->queryBuilderCache !== null) {	5✔
299	return $this->queryBuilderCache;	5✔
300	}
301
302	$joins = [];	5✔
303	$groupBy = [];	5✔
304	$queryBuilder = clone $this->queryBuilder;	5✔
305	$helper = $this->getHelper();	5✔
306
307	$filtering = $this->filtering;	5✔
308	if (count($filtering) > 0) {	5✔
309	array_unshift($filtering, ICollection::AND);	5✔
310	$expression = $helper->processExpression(	5✔
311	builder: $queryBuilder,
312	expression: $filtering,
313	aggregator: null,	5✔
314	);
315	$finalContext = $expression->havingExpression === null	5✔
316	? ExpressionContext::FilterAnd	5✔
317	: ExpressionContext::FilterAndWithHavingClause;	5✔
318	$expression = $expression->collect($finalContext);	5✔
319	$joins = $expression->joins;	5✔
320	$groupBy = $expression->groupBy;	5✔
321	if ($expression->expression !== null && $expression->args !== []) {	5✔
322	$queryBuilder->andWhere($expression->expression, ...$expression->args);	5✔
323	}
324	if ($expression->havingExpression !== null && $expression->havingArgs !== []) {	5✔
325	$queryBuilder->andHaving($expression->havingExpression, ...$expression->havingArgs);	5✔
326	}
327	if ($this->mapper->getDatabasePlatform()->getName() === MySqlPlatform::NAME) {	5✔
328	$this->applyGroupByWithSameNamedColumnsWorkaround($queryBuilder, $groupBy);	5✔
329	}
330	}
331
332	foreach ($this->ordering as [$expression, $direction]) {	5✔
333	$joins = array_merge($joins, $expression->joins);	5✔
334	$groupBy = array_merge($groupBy, $expression->groupBy);	5✔
335	$orderingExpression = $helper->processOrderDirection($expression, $direction);	5✔
336	$queryBuilder->addOrderBy('%ex', $orderingExpression);	5✔
337	}
338
339	if ($this->limitBy !== null) {	5✔
340	$queryBuilder->limitBy($this->limitBy[0], $this->limitBy[1]);	5✔
341	}
342
343	$mergedJoins = $helper->mergeJoins('%and', $joins);	5✔
344	foreach ($mergedJoins as $join) {	5✔
345	$join->applyJoin($queryBuilder);	5✔
346	}
347
348	if (count($groupBy) > 0) {	5✔
349	foreach ($this->ordering as [$expression]) {	5✔
350	$groupBy = array_merge($groupBy, $expression->columns);	5✔
351	}
352	}
353
354	if (count($groupBy) > 0) {	5✔
355	$unique = [];	5✔
356	foreach ($groupBy as $groupByFqn) {	5✔
357	$unique[$groupByFqn->getUnescaped()] = $groupByFqn;	5✔
358	}
359	$queryBuilder->groupBy('%column[]', array_values($unique));	5✔
360	}
361
362	$this->queryBuilderCache = $queryBuilder;	5✔
363	return $queryBuilder;	5✔
364	}
365
366
367	protected function getIteratorCount(): int
368	{
369	if ($this->resultCount !== null) {	5✔
NEW 370	return $this->resultCount;	×
371	}
372
373	$builder = clone $this->getQueryBuilder();	5✔
374
375	if ($this->connection->getPlatform()->getName() === SqlServerPlatform::NAME) {	5✔
376	if (!$builder->hasLimitOffsetClause()) {	5✔
377	$builder->orderBy(null);	5✔
378	}
379	} else {
380	$builder->orderBy(null);	5✔
381	}
382
383	$select = $builder->getClause('select')[0];	5✔
384	if (is_array($select) && count($select) === 1 && $select[0] === "%table.*") {	5✔
385	$builder->select(null);	5✔
386	foreach ($this->mapper->getConventions()->getStoragePrimaryKey() as $column) {	5✔
387	$builder->addSelect('%table.%column', $builder->getFromAlias(), $column);	5✔
388	}
389	}
390	$sql = 'SELECT COUNT(*) AS count FROM (' . $builder->getQuerySql() . ') temp';	5✔
391	$args = $builder->getQueryParameters();	5✔
392
393	$this->resultCount = $this->connection->queryArgs($sql, $args)->fetchField()	5✔
UNCOV 394	?? throw new InvalidStateException("Unable to fetch collection count.");	×
395	return $this->resultCount;	5✔
396	}
397
398
399	protected function execute(): void
400	{
401	$result = $this->connection->queryByQueryBuilder($this->getQueryBuilder());	5✔
402
403	$this->result = [];	5✔
404	while (($data = $result->fetch()) !== null) {	5✔
405	$entity = $this->mapper->hydrateEntity($data->toArray());	5✔
406	if ($entity === null) continue;	5✔
407	$this->result[] = $entity;	5✔
408	}
409	}	5✔
410
411
412	protected function getHelper(): DbalQueryBuilderHelper
413	{
414	if ($this->helper === null) {	5✔
415	$repository = $this->mapper->getRepository();	5✔
416	$this->helper = new DbalQueryBuilderHelper($repository);	5✔
417	}
418
419	return $this->helper;	5✔
420	}
421
422
423	/**
424	* Apply workaround for MySQL that is not able to properly resolve columns when there are more same-named
425	* columns in the GROUP BY clause, even though they are properly referenced to their tables. Orm workarounds
426	* this by adding them to the SELECT clause and renames them not to conflict anywhere.
427	*
428	* @param list<Fqn> $groupBy
429	*/
430	private function applyGroupByWithSameNamedColumnsWorkaround(QueryBuilder $queryBuilder, array $groupBy): void
431	{
432	$map = [];	5✔
433	foreach ($groupBy as $fqn) {	5✔
434	if (!isset($map[$fqn->name])) {	5✔
435	$map[$fqn->name] = [$fqn];	5✔
436	} else {
437	$map[$fqn->name][] = $fqn;	5✔
438	}
439	}
440	$i = 0;	5✔
441	foreach ($map as $fqns) {	5✔
442	if (count($fqns) > 1) {	5✔
443	foreach ($fqns as $fqn) {	5✔
444	$queryBuilder->addSelect("%column AS __nextras_fix_" . $i++, $fqn); // @phpstan-ignore-line	5✔
445	}
446	}
447	}
448	}	5✔
449	}

nextras / orm / 17019780057

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous