Merge pull request #11839 from greg0ire/3.3.x

Merge 2.20.x up into 3.3.x

Author: greg0ire

docs/en/tutorials/composite-primary-keys.rst

@@ -85,11 +85,12 @@ And for querying you can use arrays to both DQL and EntityRepositories:
     namespace VehicleCatalogue\Model;
 
     // $em is the EntityManager
-    $audi = $em->find("VehicleCatalogue\Model\Car", array("name" => "Audi A8", "year" => 2010));
+    $audi = $em->find("VehicleCatalogue\Model\Car", ["name" => "Audi A8", "year" => 2010]);
 
-    $dql = "SELECT c FROM VehicleCatalogue\Model\Car c WHERE c.id = ?1";
+    $dql = "SELECT c FROM VehicleCatalogue\Model\Car c WHERE c.name = ?1 AND c.year = ?2";
     $audi = $em->createQuery($dql)
-               ->setParameter(1, ["name" => "Audi A8", "year" => 2010])
+               ->setParameter(1, "Audi A8")
+               ->setParameter(2, 2010)
                ->getSingleResult();
 
 You can also use this entity in associations. Doctrine will then generate two foreign keys one for ``name``

src/Persisters/Entity/BasicEntityPersister.php

@@ -1334,6 +1334,12 @@ protected function getSelectColumnsSQL(): string
                     $joinCondition[] = $this->getSQLTableAlias($association->sourceEntity, $assocAlias) . '.' . $sourceCol . ' = '
                         . $this->getSQLTableAlias($association->targetEntity) . '.' . $targetCol;
                 }
+
+                // Add filter SQL
+                $filterSql = $this->generateFilterConditionSQL($eagerEntity, $joinTableAlias);
+                if ($filterSql) {
+                    $joinCondition[] = $filterSql;
+                }
             }
 
             $this->currentPersisterContext->selectJoinSql .= ' ' . $joinTableName . ' ' . $joinTableAlias . ' ON ';

src/Tools/Pagination/LimitSubqueryOutputWalker.php

@@ -89,17 +89,24 @@ public function __construct(
         $this->platform = $query->getEntityManager()->getConnection()->getDatabasePlatform();
         $this->rsm      = $parserResult->getResultSetMapping();
 
-        $query = clone $query;
+        $cloneQuery = clone $query;
+
+        $cloneQuery->setParameters(clone $query->getParameters());
+        $cloneQuery->setCacheable(false);
+
+        foreach ($query->getHints() as $name => $value) {
+            $cloneQuery->setHint($name, $value);
+        }
 
         // Reset limit and offset
-        $this->firstResult = $query->getFirstResult();
-        $this->maxResults  = $query->getMaxResults();
-        $query->setFirstResult(0)->setMaxResults(null);
+        $this->firstResult = $cloneQuery->getFirstResult();
+        $this->maxResults  = $cloneQuery->getMaxResults();
+        $cloneQuery->setFirstResult(0)->setMaxResults(null);
 
-        $this->em            = $query->getEntityManager();
+        $this->em            = $cloneQuery->getEntityManager();
         $this->quoteStrategy = $this->em->getConfiguration()->getQuoteStrategy();
 
-        parent::__construct($query, $parserResult, $queryComponents);
+        parent::__construct($cloneQuery, $parserResult, $queryComponents);
     }
 
     /**

tests/Tests/ORM/Functional/EagerFetchCollectionTest.php

@@ -8,9 +8,11 @@
 use Doctrine\Common\Collections\Collection;
 use Doctrine\ORM\Mapping as ORM;
 use Doctrine\ORM\Query\QueryException;
+use Doctrine\ORM\Tools\Pagination\Paginator;
 use Doctrine\Tests\OrmFunctionalTestCase;
 
 use function count;
+use function iterator_to_array;
 
 class EagerFetchCollectionTest extends OrmFunctionalTestCase
 {
@@ -97,6 +99,16 @@ public function testSubselectFetchJoinWithAllowedWhenOverriddenNotEager(): void
         $this->assertIsString($query->getSql());
     }
 
+    public function testSubselectFetchJoinWithAllowedWhenOverriddenNotEagerPaginator(): void
+    {
+        $query = $this->_em->createQuery('SELECT o, c FROM ' . EagerFetchOwner::class . ' o JOIN o.children c WITH c.id = 1');
+        $query->setMaxResults(1);
+        $query->setFetchMode(EagerFetchChild::class, 'owner', ORM\ClassMetadata::FETCH_LAZY);
+
+        $paginator = new Paginator($query, true);
+        $this->assertIsArray(iterator_to_array($paginator));
+    }
+
     public function testEagerFetchWithIterable(): void
     {
         $this->createOwnerWithChildren(2);

tests/Tests/ORM/Functional/SQLFilterTest.php

@@ -503,6 +503,21 @@ public function testToOneFilter(): void
         self::assertEquals(2, count($query->getResult()));
     }
 
+    public function testOneToOneInverseSideWithFilter(): void
+    {
+        $this->loadFixtureData();
+
+        $conf = $this->_em->getConfiguration();
+        $conf->addFilter('country', '\Doctrine\Tests\ORM\Functional\CMSCountryFilter');
+        $this->_em->getFilters()->enable('country')->setParameterList('country', ['Germany'], Types::STRING);
+
+        $user = $this->_em->find(CmsUser::class, $this->userId);
+        self::assertNotEmpty($user->address);
+
+        $user2 = $this->_em->find(CmsUser::class, $this->userId2);
+        self::assertEmpty($user2->address);
+    }
+
     public function testManyToManyFilter(): void
     {
         $this->loadFixtureData();

tests/Tests/ORM/Tools/Pagination/LimitSubqueryOutputWalkerTest.php

@@ -14,6 +14,24 @@
 
 final class LimitSubqueryOutputWalkerTest extends PaginationTestCase
 {
+    public function testSubqueryClonedCompletely(): void
+    {
+        $query = $this->createQuery('SELECT p FROM Doctrine\Tests\ORM\Tools\Pagination\MyBlogPost p');
+        $query->setParameter('dummy-param', 123);
+        $query->setHint('dummy-hint', 'dummy-value');
+        $query->setCacheable(true);
+
+        $walker = new LimitSubqueryOutputWalker($query, new Query\ParserResult(), []);
+
+        self::assertNotSame($query, $walker->getQuery());
+        self::assertTrue($walker->getQuery()->hasHint('dummy-hint'));
+        self::assertSame('dummy-value', $walker->getQuery()->getHint('dummy-hint'));
+        self::assertNotSame($query->getParameters(), $walker->getQuery()->getParameters());
+        self::assertInstanceOf(Query\Parameter::class, $param = $walker->getQuery()->getParameter('dummy-param'));
+        self::assertSame(123, $param->getValue());
+        self::assertFalse($walker->getQuery()->isCacheable());
+    }
+
     public function testLimitSubquery(): void
     {
         $this->assertQuerySql(