#26521

pending completion

Build # #26521

Build Type

push

github

Committed by

web-flow

Commit Message

<a href="https://github.com/api-platform/core/commit/<a class=hub.com/api-platform/core/commit/9a73148209c69a7fdc9eeb629bd05a2c060c9987">9a7314820<a href="https://github.com/api-platform/core/commit/9a73148209c69a7fdc9eeb629bd05a2c060c9987">">Merge </a><a class="double-link" href="https://github.com/api-platform/core/commit/<a class="double-link" href="https://github.com/api-platform/core/commit/f9f375fe56500b8fce1337d46c5de653b86e8c21">f9f375fe5</a>">f9f375fe5</a><a href="https://github.com/api-platform/core/commit/9a73148209c69a7fdc9eeb629bd05a2c060c9987"> into a5196ae96">a5196ae96</a>

Run Details

6 of 6 new or added lines in 1 file covered. (100.0%)

9503 of 11452 relevant lines covered (82.98%)

14.86 hits per line

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

94.81

/src/Bridge/Doctrine/Orm/Extension/FilterEagerLoadingExtension.php

<?php

/*
 * This file is part of the API Platform project.
 *
 * (c) Kévin Dunglas <dunglas@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace ApiPlatform\Core\Bridge\Doctrine\Orm\Extension;

use ApiPlatform\Core\Api\ResourceClassResolverInterface;
use ApiPlatform\Core\Bridge\Doctrine\Orm\Util\EagerLoadingTrait;
use ApiPlatform\Core\Bridge\Doctrine\Orm\Util\QueryBuilderHelper;
use ApiPlatform\Core\Bridge\Doctrine\Orm\Util\QueryNameGeneratorInterface;
use ApiPlatform\Core\Exception\InvalidArgumentException;
use ApiPlatform\Core\Metadata\Resource\Factory\ResourceMetadataFactoryInterface;
use Doctrine\ORM\Query\Expr\Join;
use Doctrine\ORM\QueryBuilder;

/**
 * Fixes filters on OneToMany associations
 * https://github.com/api-platform/core/issues/944.
 */
final class FilterEagerLoadingExtension implements ContextAwareQueryCollectionExtensionInterface
{
    use EagerLoadingTrait;

    private $resourceClassResolver;

    public function __construct(ResourceMetadataFactoryInterface $resourceMetadataFactory, bool $forceEager = true, ResourceClassResolverInterface $resourceClassResolver = null)
    {
        $this->resourceMetadataFactory = $resourceMetadataFactory;
        $this->forceEager = $forceEager;
        $this->resourceClassResolver = $resourceClassResolver;
    }

    /**
     * {@inheritdoc}
     */
    public function applyToCollection(QueryBuilder $queryBuilder, QueryNameGeneratorInterface $queryNameGenerator, string $resourceClass = null, string $operationName = null, array $context = [])
    {
        if (null === $resourceClass) {
            throw new InvalidArgumentException('The "$resourceClass" parameter must not be null');
        }

        $em = $queryBuilder->getEntityManager();
        $classMetadata = $em->getClassMetadata($resourceClass);

        if (!$this->shouldOperationForceEager($resourceClass, ['collection_operation_name' => $operationName]) && !$this->hasFetchEagerAssociation($em, $classMetadata)) {
            return;
        }

        //If no where part, nothing to do
        $wherePart = $queryBuilder->getDQLPart('where');

        if (!$wherePart) {
            return;
        }

        $joinParts = $queryBuilder->getDQLPart('join');
        $originAlias = $queryBuilder->getRootAliases()[0];

        if (!$joinParts || !isset($joinParts[$originAlias])) {
            return;
        }

        $queryBuilderClone = clone $queryBuilder;
        $queryBuilderClone->resetDQLPart('where');
        $changedWhereClause = false;

        if (!$classMetadata->isIdentifierComposite) {
            $replacementAlias = $queryNameGenerator->generateJoinAlias($originAlias);
            $in = $this->getQueryBuilderWithNewAliases($queryBuilder, $queryNameGenerator, $originAlias, $replacementAlias);

            if ($classMetadata->containsForeignIdentifier) {
                $identifier = current($classMetadata->getIdentifier());
                $in->select("IDENTITY($replacementAlias.$identifier)");
                $queryBuilderClone->andWhere($queryBuilderClone->expr()->in("$originAlias.$identifier", $in->getDQL()));
            } else {
                $in->select($replacementAlias);
                $queryBuilderClone->andWhere($queryBuilderClone->expr()->in($originAlias, $in->getDQL()));
            }

            $changedWhereClause = true;
        } else {
            // Because Doctrine doesn't support WHERE ( foo, bar ) IN () (https://github.com/doctrine/doctrine2/issues/5238), we are building as many subqueries as they are identifiers
            foreach ($classMetadata->getIdentifier() as $identifier) {
                if (!$classMetadata->hasAssociation($identifier)) {
                    continue;
                }

                $replacementAlias = $queryNameGenerator->generateJoinAlias($originAlias);
                $in = $this->getQueryBuilderWithNewAliases($queryBuilder, $queryNameGenerator, $originAlias, $replacementAlias);
                $in->select("IDENTITY($replacementAlias.$identifier)");
                $queryBuilderClone->andWhere($queryBuilderClone->expr()->in("$originAlias.$identifier", $in->getDQL()));
                $changedWhereClause = true;
            }
        }

        if (false === $changedWhereClause) {
            return;
        }

        $queryBuilder->resetDQLPart('where');
        $queryBuilder->add('where', $queryBuilderClone->getDQLPart('where'));
    }

    /**
     * Returns a clone of the given query builder where everything gets re-aliased.
     *
     * @param string $originAlias the base alias
     * @param string $replacement the replacement for the base alias, will change the from alias
     */
    private function getQueryBuilderWithNewAliases(QueryBuilder $queryBuilder, QueryNameGeneratorInterface $queryNameGenerator, string $originAlias = 'o', string $replacement = 'o_2'): QueryBuilder
    {
        $queryBuilderClone = clone $queryBuilder;

        $joinParts = $queryBuilder->getDQLPart('join');
        $wherePart = $queryBuilder->getDQLPart('where');

        //reset parts
        $queryBuilderClone->resetDQLPart('join');
        $queryBuilderClone->resetDQLPart('where');
        $queryBuilderClone->resetDQLPart('orderBy');
        $queryBuilderClone->resetDQLPart('groupBy');
        $queryBuilderClone->resetDQLPart('having');

        //Change from alias
        $from = $queryBuilderClone->getDQLPart('from')[0];
        $queryBuilderClone->resetDQLPart('from');
        $queryBuilderClone->from($from->getFrom(), $replacement);

        $aliases = ["$originAlias."];
        $replacements = ["$replacement."];

        //Change join aliases
        foreach ($joinParts[$originAlias] as $joinPart) {
            /** @var Join $joinPart */
            $joinString = str_replace($aliases, $replacements, $joinPart->getJoin());
            $pos = strpos($joinString, '.');
            if (false === $pos) {
                if (null !== $joinPart->getCondition() && null !== $this->resourceClassResolver && $this->resourceClassResolver->isResourceClass($joinString)) {
                    $newAlias = $queryNameGenerator->generateJoinAlias($joinPart->getAlias());
                    $aliases[] = "{$joinPart->getAlias()}.";
                    $replacements[] = "$newAlias.";
                    $condition = str_replace($aliases, $replacements, $joinPart->getCondition());
                    $join = new Join($joinPart->getJoinType(), $joinPart->getJoin(), $newAlias, $joinPart->getConditionType(), $condition);
                    $queryBuilderClone->add('join', [$replacement => $join], true);
                }

                continue;
            }
            $alias = substr($joinString, 0, $pos);
            $association = substr($joinString, $pos + 1);
            $newAlias = $queryNameGenerator->generateJoinAlias($association);
            $aliases[] = "{$joinPart->getAlias()}.";
            $replacements[] = "$newAlias.";
            $condition = str_replace($aliases, $replacements, $joinPart->getCondition() ?? '');
            QueryBuilderHelper::addJoinOnce($queryBuilderClone, $queryNameGenerator, $alias, $association, $joinPart->getJoinType(), $joinPart->getConditionType(), $condition, $originAlias, $newAlias);
        }

        $queryBuilderClone->add('where', str_replace($aliases, $replacements, (string) $wherePart));

        return $queryBuilderClone;
    }
}

1	<?php
2
3	/*
4	* This file is part of the API Platform project.
5	*
6	* (c) Kévin Dunglas <dunglas@gmail.com>
7	*
8	* For the full copyright and license information, please view the LICENSE
9	* file that was distributed with this source code.
10	*/
11
12	declare(strict_types=1);
13
14	namespace ApiPlatform\Core\Bridge\Doctrine\Orm\Extension;
15
16	use ApiPlatform\Core\Api\ResourceClassResolverInterface;
17	use ApiPlatform\Core\Bridge\Doctrine\Orm\Util\EagerLoadingTrait;
18	use ApiPlatform\Core\Bridge\Doctrine\Orm\Util\QueryBuilderHelper;
19	use ApiPlatform\Core\Bridge\Doctrine\Orm\Util\QueryNameGeneratorInterface;
20	use ApiPlatform\Core\Exception\InvalidArgumentException;
21	use ApiPlatform\Core\Metadata\Resource\Factory\ResourceMetadataFactoryInterface;
22	use Doctrine\ORM\Query\Expr\Join;
23	use Doctrine\ORM\QueryBuilder;
24
25	/**
26	* Fixes filters on OneToMany associations
27	* https://github.com/api-platform/core/issues/944.
28	*/
29	final class FilterEagerLoadingExtension implements ContextAwareQueryCollectionExtensionInterface
30	{
31	use EagerLoadingTrait;
32
33	private $resourceClassResolver;
34
35	public function __construct(ResourceMetadataFactoryInterface $resourceMetadataFactory, bool $forceEager = true, ResourceClassResolverInterface $resourceClassResolver = null)
36	{
37	$this->resourceMetadataFactory = $resourceMetadataFactory;	20✔
38	$this->forceEager = $forceEager;	20✔
39	$this->resourceClassResolver = $resourceClassResolver;	20✔
40	}	20✔
41
42	/**
43	* {@inheritdoc}
44	*/
45	public function applyToCollection(QueryBuilder $queryBuilder, QueryNameGeneratorInterface $queryNameGenerator, string $resourceClass = null, string $operationName = null, array $context = [])
46	{
47	if (null === $resourceClass) {	20✔
48	throw new InvalidArgumentException('The "$resourceClass" parameter must not be null');	×
49	}
50
51	$em = $queryBuilder->getEntityManager();	20✔
52	$classMetadata = $em->getClassMetadata($resourceClass);	20✔
53
54	if (!$this->shouldOperationForceEager($resourceClass, ['collection_operation_name' => $operationName]) && !$this->hasFetchEagerAssociation($em, $classMetadata)) {	20✔
55	return;	3✔
56	}
57
58	//If no where part, nothing to do
59	$wherePart = $queryBuilder->getDQLPart('where');	17✔
60
61	if (!$wherePart) {	17✔
62	return;	7✔
63	}
64
65	$joinParts = $queryBuilder->getDQLPart('join');	10✔
66	$originAlias = $queryBuilder->getRootAliases()[0];	10✔
67
68	if (!$joinParts \|\| !isset($joinParts[$originAlias])) {	10✔
69	return;	1✔
70	}
71
72	$queryBuilderClone = clone $queryBuilder;	9✔
73	$queryBuilderClone->resetDQLPart('where');	9✔
74	$changedWhereClause = false;	9✔
75
76	if (!$classMetadata->isIdentifierComposite) {	9✔
77	$replacementAlias = $queryNameGenerator->generateJoinAlias($originAlias);	5✔
78	$in = $this->getQueryBuilderWithNewAliases($queryBuilder, $queryNameGenerator, $originAlias, $replacementAlias);	5✔
79
80	if ($classMetadata->containsForeignIdentifier) {	5✔
81	$identifier = current($classMetadata->getIdentifier());	×
82	$in->select("IDENTITY($replacementAlias.$identifier)");	×
83	$queryBuilderClone->andWhere($queryBuilderClone->expr()->in("$originAlias.$identifier", $in->getDQL()));	×
84	} else {
85	$in->select($replacementAlias);	5✔
86	$queryBuilderClone->andWhere($queryBuilderClone->expr()->in($originAlias, $in->getDQL()));	5✔
87	}
88
89	$changedWhereClause = true;	5✔
90	} else {
91	// Because Doctrine doesn't support WHERE ( foo, bar ) IN () (https://github.com/doctrine/doctrine2/issues/5238), we are building as many subqueries as they are identifiers
92	foreach ($classMetadata->getIdentifier() as $identifier) {	4✔
93	if (!$classMetadata->hasAssociation($identifier)) {	4✔
94	continue;	2✔
95	}
96
97	$replacementAlias = $queryNameGenerator->generateJoinAlias($originAlias);	3✔
98	$in = $this->getQueryBuilderWithNewAliases($queryBuilder, $queryNameGenerator, $originAlias, $replacementAlias);	3✔
99	$in->select("IDENTITY($replacementAlias.$identifier)");	3✔
100	$queryBuilderClone->andWhere($queryBuilderClone->expr()->in("$originAlias.$identifier", $in->getDQL()));	3✔
101	$changedWhereClause = true;	3✔
102	}
103	}
104
105	if (false === $changedWhereClause) {	9✔
106	return;	1✔
107	}
108
109	$queryBuilder->resetDQLPart('where');	8✔
110	$queryBuilder->add('where', $queryBuilderClone->getDQLPart('where'));	8✔
111	}	8✔
112
113	/**
114	* Returns a clone of the given query builder where everything gets re-aliased.
115	*
116	* @param string $originAlias the base alias
117	* @param string $replacement the replacement for the base alias, will change the from alias
118	*/
119	private function getQueryBuilderWithNewAliases(QueryBuilder $queryBuilder, QueryNameGeneratorInterface $queryNameGenerator, string $originAlias = 'o', string $replacement = 'o_2'): QueryBuilder
120	{
121	$queryBuilderClone = clone $queryBuilder;	8✔
122
123	$joinParts = $queryBuilder->getDQLPart('join');	8✔
124	$wherePart = $queryBuilder->getDQLPart('where');	8✔
125
126	//reset parts
127	$queryBuilderClone->resetDQLPart('join');	8✔
128	$queryBuilderClone->resetDQLPart('where');	8✔
129	$queryBuilderClone->resetDQLPart('orderBy');	8✔
130	$queryBuilderClone->resetDQLPart('groupBy');	8✔
131	$queryBuilderClone->resetDQLPart('having');	8✔
132
133	//Change from alias
134	$from = $queryBuilderClone->getDQLPart('from')[0];	8✔
135	$queryBuilderClone->resetDQLPart('from');	8✔
136	$queryBuilderClone->from($from->getFrom(), $replacement);	8✔
137
138	$aliases = ["$originAlias."];	8✔
139	$replacements = ["$replacement."];	8✔
140
141	//Change join aliases
142	foreach ($joinParts[$originAlias] as $joinPart) {	8✔
143	/** @var Join $joinPart */
144	$joinString = str_replace($aliases, $replacements, $joinPart->getJoin());	8✔
145	$pos = strpos($joinString, '.');	8✔
146	if (false === $pos) {	8✔
147	if (null !== $joinPart->getCondition() && null !== $this->resourceClassResolver && $this->resourceClassResolver->isResourceClass($joinString)) {	2✔
148	$newAlias = $queryNameGenerator->generateJoinAlias($joinPart->getAlias());	1✔
149	$aliases[] = "{$joinPart->getAlias()}.";	1✔
150	$replacements[] = "$newAlias.";	1✔
151	$condition = str_replace($aliases, $replacements, $joinPart->getCondition());	1✔
152	$join = new Join($joinPart->getJoinType(), $joinPart->getJoin(), $newAlias, $joinPart->getConditionType(), $condition);	1✔
153	$queryBuilderClone->add('join', [$replacement => $join], true);	1✔
154	}
155
156	continue;	2✔
157	}
158	$alias = substr($joinString, 0, $pos);	8✔
159	$association = substr($joinString, $pos + 1);	8✔
160	$newAlias = $queryNameGenerator->generateJoinAlias($association);	8✔
161	$aliases[] = "{$joinPart->getAlias()}.";	8✔
162	$replacements[] = "$newAlias.";	8✔
163	$condition = str_replace($aliases, $replacements, $joinPart->getCondition() ?? '');	8✔
164	QueryBuilderHelper::addJoinOnce($queryBuilderClone, $queryNameGenerator, $alias, $association, $joinPart->getJoinType(), $joinPart->getConditionType(), $condition, $originAlias, $newAlias);	8✔
165	}
166
167	$queryBuilderClone->add('where', str_replace($aliases, $replacements, (string) $wherePart));	8✔
168
169	return $queryBuilderClone;	8✔
170	}
171	}

api-platform / core / #26521

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