RetailCRM-Mirror/doctrine2
1
0
Fork 0
mirror of synced 2025-02-02 21:41:45 +03:00
Code Issues Projects Releases Wiki Activity

Make LimitSubqueryOutputWalker a bit more readable

Browse Source 
Also simplifying the REGEX to remove the ORDER BY type (ASC/DESC) with a
substr() since OrderByItem#type is always defined.
This commit is contained in:
Luís Cobucci 2017-07-22 20:34:18 +02:00
parent 3d5acd607b
commit 5389ad7261
No known key found for this signature in database
GPG Key ID: EC61C5F01750ED3C
2 changed files with 124 additions and 120 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

156
lib/Doctrine/ORM/Tools/Pagination/LimitSubqueryOutputWalker.php
View File

@ -43,6 +43,8 @@ use Doctrine\ORM\Query\AST\SelectStatement;
*/
class LimitSubqueryOutputWalker extends SqlWalker
{
private const ORDER_BY_PATH_EXPRESSION = '/(?<![a-z0-9_])%s\.%s(?![a-z0-9_])/i';
/**
* @var \Doctrine\DBAL\Platforms\AbstractPlatform
*/
@ -354,85 +356,95 @@ class LimitSubqueryOutputWalker extends SqlWalker
/**
* Generates new SQL for statements with an order by clause
*
* @param array $sqlIdentifier
* @param string $innerSql
* @param string $sql
* @param OrderByClause $orderByClause
* @param array $sqlIdentifier
* @param string $innerSql
* @param string $sql
* @param OrderByClause|null $orderByClause
*
* @return string
*/
private function preserveSqlOrdering(array $sqlIdentifier, $innerSql, $sql, $orderByClause)
{
// If the sql statement has an order by clause, we need to wrap it in a new select distinct
// statement
if (! $orderByClause instanceof OrderByClause) {
private function preserveSqlOrdering(
array $sqlIdentifier,
string $innerSql,
string $sql,
?OrderByClause $orderByClause
) : string {
// If the sql statement has an order by clause, we need to wrap it in a new select distinct statement
if (! $orderByClause) {
return $sql;
}
// Rebuild the order by clause to work in the scope of the new select statement
/* @var array $orderBy an array of rebuilt order by items */
$orderBy = $this->rebuildOrderByClauseForOuterScope($orderByClause);
$innerSqlIdentifier = $sqlIdentifier;
foreach ($orderBy as $field) {
$field = preg_replace('/((\S+)\s+(ASC|DESC)\s*,?)*/', '${2}', $field);
// skip fields that are selected by identifiers,
// if those are ordered by in the query
if (in_array($field, $sqlIdentifier, true)) {
continue;
}
$innerSqlIdentifier[] = $field;
}
// Build the innner select statement
$sql = sprintf(
'SELECT DISTINCT %s FROM (%s) dctrn_result_inner ORDER BY %s',
implode(', ', $innerSqlIdentifier),
$innerSql,
implode(', ', $orderBy)
);
// now only select distinct identifier
$sql = sprintf('SELECT DISTINCT %s FROM (%s) dctrn_result', implode(', ', $sqlIdentifier), $sql);
return $sql;
return \sprintf(
'SELECT DISTINCT %s FROM (%s) dctrn_result',
\implode(', ', $sqlIdentifier),
$this->recreateInnerSql($orderByClause, $sqlIdentifier, $innerSql)
);
}
/**
* Generates a new order by clause that works in the scope of a select query wrapping the original
* Generates a new SQL statement for the inner query to keep the correct sorting
*
* @param OrderByClause $orderByClause
* @return array
* @param array $identifiers
* @param string $innerSql
*
* @return string
*/
private function rebuildOrderByClauseForOuterScope(OrderByClause $orderByClause)
{
$dqlAliasToSqlTableAliasMap
= $searchPatterns
= $replacements
= $dqlAliasToClassMap
= $selectListAdditions
= $orderByItems
= [];
private function recreateInnerSql(
OrderByClause $orderByClause,
array $identifiers,
string $innerSql
) : string {
[$searchPatterns, $replacements] = $this->generateSqlAliasReplacements();
// Generate DQL alias -> SQL table alias mapping
foreach(array_keys($this->rsm->aliasMap) as $dqlAlias) {
$dqlAliasToClassMap[$dqlAlias] = $class = $this->queryComponents[$dqlAlias]['metadata'];
$dqlAliasToSqlTableAliasMap[$dqlAlias] = $this->getSQLTableAlias($class->getTableName(), $dqlAlias);
$orderByItems = [];
foreach ($orderByClause->orderByItems as $orderByItem) {
// Walk order by item to get string representation of it and
// replace path expressions in the order by clause with their column alias
$orderByItemString = \preg_replace(
$searchPatterns,
$replacements,
$this->walkOrderByItem($orderByItem)
);
$orderByItems[] = $orderByItemString;
$identifier = \substr($orderByItemString, 0, \strrpos($orderByItemString, ' '));
if (! \in_array($identifier, $identifiers, true)) {
$identifiers[] = $identifier;
}
}
// Pattern to find table path expressions in the order by clause
$fieldSearchPattern = '/(?<![a-z0-9_])%s\.%s(?![a-z0-9_])/i';
return $sql = \sprintf(
'SELECT DISTINCT %s FROM (%s) dctrn_result_inner ORDER BY %s',
\implode(', ', $identifiers),
$innerSql,
\implode(', ', $orderByItems)
);
}
/**
* @return string[][]
*/
private function generateSqlAliasReplacements() : array
{
$aliasMap = $searchPatterns = $replacements = $metadataList = [];
// Generate DQL alias -> SQL table alias mapping
foreach (\array_keys($this->rsm->aliasMap) as $dqlAlias) {
$metadataList[$dqlAlias] = $class = $this->queryComponents[$dqlAlias]['metadata'];
$aliasMap[$dqlAlias] = $this->getSQLTableAlias($class->getTableName(), $dqlAlias);
}
// Generate search patterns for each field's path expression in the order by clause
foreach($this->rsm->fieldMappings as $fieldAlias => $fieldName) {
foreach ($this->rsm->fieldMappings as $fieldAlias => $fieldName) {
$dqlAliasForFieldAlias = $this->rsm->columnOwnerMap[$fieldAlias];
$class = $dqlAliasToClassMap[$dqlAliasForFieldAlias];
$class = $metadataList[$dqlAliasForFieldAlias];
// If the field is from a joined child table, we won't be ordering
// on it.
if (!isset($class->fieldMappings[$fieldName])) {
// If the field is from a joined child table, we won't be ordering on it.
if (! isset($class->fieldMappings[$fieldName])) {
continue;
}
@ -441,37 +453,29 @@ class LimitSubqueryOutputWalker extends SqlWalker
// Get the proper column name as will appear in the select list
$columnName = $this->quoteStrategy->getColumnName(
$fieldName,
$dqlAliasToClassMap[$dqlAliasForFieldAlias],
$metadataList[$dqlAliasForFieldAlias],
$this->em->getConnection()->getDatabasePlatform()
);
// Get the SQL table alias for the entity and field
$sqlTableAliasForFieldAlias = $dqlAliasToSqlTableAliasMap[$dqlAliasForFieldAlias];
$sqlTableAliasForFieldAlias = $aliasMap[$dqlAliasForFieldAlias];
if (isset($fieldMapping['declared']) && $fieldMapping['declared'] !== $class->name) {
// Field was declared in a parent class, so we need to get the proper SQL table alias
// for the joined parent table.
$otherClassMetadata = $this->em->getClassMetadata($fieldMapping['declared']);
if (!$otherClassMetadata->isMappedSuperclass) {
if (! $otherClassMetadata->isMappedSuperclass) {
$sqlTableAliasForFieldAlias = $this->getSQLTableAlias($otherClassMetadata->getTableName(), $dqlAliasForFieldAlias);
}
}
// Compose search/replace patterns
$searchPatterns[] = sprintf($fieldSearchPattern, $sqlTableAliasForFieldAlias, $columnName);
$replacements[] = $fieldAlias;
// Compose search and replace patterns
$searchPatterns[] = \sprintf(self::ORDER_BY_PATH_EXPRESSION, $sqlTableAliasForFieldAlias, $columnName);
$replacements[] = $fieldAlias;
}
foreach($orderByClause->orderByItems as $orderByItem) {
// Walk order by item to get string representation of it
$orderByItemString = $this->walkOrderByItem($orderByItem);
// Replace path expressions in the order by clause with their column alias
$orderByItemString = preg_replace($searchPatterns, $replacements, $orderByItemString);
$orderByItems[] = $orderByItemString;
}
return $orderByItems;
return [$searchPatterns, $replacements];
}
/**

88
tests/Doctrine/Tests/ORM/Tools/Pagination/LimitSubqueryOutputWalkerTest.php
View File

@ -8,9 +8,9 @@ use Doctrine\DBAL\Platforms\PostgreSqlPlatform;
use Doctrine\ORM\Query;
use Doctrine\ORM\Tools\Pagination\LimitSubqueryOutputWalker;
class LimitSubqueryOutputWalkerTest extends PaginationTestCase
final class LimitSubqueryOutputWalkerTest extends PaginationTestCase
{
public function testLimitSubquery()
public function testLimitSubquery() : void
{
$query = $this->entityManager->createQuery(
'SELECT p, c, a FROM Doctrine\Tests\ORM\Tools\Pagination\MyBlogPost p JOIN p.category c JOIN p.author a');
@ -18,12 +18,12 @@ class LimitSubqueryOutputWalkerTest extends PaginationTestCase
$limitQuery = clone $query;
$limitQuery->setHint(Query::HINT_CUSTOM_OUTPUT_WALKER, LimitSubqueryOutputWalker::class);
$this->assertEquals(
self::assertSame(
"SELECT DISTINCT id_0 FROM (SELECT m0_.id AS id_0, m0_.title AS title_1, c1_.id AS id_2, a2_.id AS id_3, a2_.name AS name_4, m0_.author_id AS author_id_5, m0_.category_id AS category_id_6 FROM MyBlogPost m0_ INNER JOIN Category c1_ ON m0_.category_id = c1_.id INNER JOIN Author a2_ ON m0_.author_id = a2_.id) dctrn_result", $limitQuery->getSQL()
);
}
public function testLimitSubqueryWithSortPg()
public function testLimitSubqueryWithSortPg() : void
{
$odp = $this->entityManager->getConnection()->getDatabasePlatform();
$this->entityManager->getConnection()->setDatabasePlatform(new PostgreSqlPlatform);
@ -33,14 +33,14 @@ class LimitSubqueryOutputWalkerTest extends PaginationTestCase
$limitQuery = clone $query;
$limitQuery->setHint(Query::HINT_CUSTOM_OUTPUT_WALKER, LimitSubqueryOutputWalker::class);
$this->assertEquals(
self::assertSame(
"SELECT DISTINCT id_0, MIN(sclr_5) AS dctrn_minrownum FROM (SELECT m0_.id AS id_0, m0_.title AS title_1, c1_.id AS id_2, a2_.id AS id_3, a2_.name AS name_4, ROW_NUMBER() OVER(ORDER BY m0_.title ASC) AS sclr_5, m0_.author_id AS author_id_6, m0_.category_id AS category_id_7 FROM MyBlogPost m0_ INNER JOIN Category c1_ ON m0_.category_id = c1_.id INNER JOIN Author a2_ ON m0_.author_id = a2_.id) dctrn_result GROUP BY id_0 ORDER BY dctrn_minrownum ASC", $limitQuery->getSQL()
);
$this->entityManager->getConnection()->setDatabasePlatform($odp);
}
public function testLimitSubqueryWithScalarSortPg()
public function testLimitSubqueryWithScalarSortPg() : void
{
$odp = $this->entityManager->getConnection()->getDatabasePlatform();
$this->entityManager->getConnection()->setDatabasePlatform(new PostgreSqlPlatform);
@ -51,7 +51,7 @@ class LimitSubqueryOutputWalkerTest extends PaginationTestCase
$limitQuery = clone $query;
$limitQuery->setHint(Query::HINT_CUSTOM_OUTPUT_WALKER, LimitSubqueryOutputWalker::class);
$this->assertEquals(
self::assertSame(
"SELECT DISTINCT id_1, MIN(sclr_3) AS dctrn_minrownum FROM (SELECT COUNT(g0_.id) AS sclr_0, u1_.id AS id_1, g0_.id AS id_2, ROW_NUMBER() OVER(ORDER BY COUNT(g0_.id) ASC) AS sclr_3 FROM User u1_ INNER JOIN user_group u2_ ON u1_.id = u2_.user_id INNER JOIN groups g0_ ON g0_.id = u2_.group_id) dctrn_result GROUP BY id_1 ORDER BY dctrn_minrownum ASC",
$limitQuery->getSQL()
);
@ -59,7 +59,7 @@ class LimitSubqueryOutputWalkerTest extends PaginationTestCase
$this->entityManager->getConnection()->setDatabasePlatform($odp);
}
public function testLimitSubqueryWithMixedSortPg()
public function testLimitSubqueryWithMixedSortPg() : void
{
$odp = $this->entityManager->getConnection()->getDatabasePlatform();
$this->entityManager->getConnection()->setDatabasePlatform(new PostgreSqlPlatform);
@ -70,7 +70,7 @@ class LimitSubqueryOutputWalkerTest extends PaginationTestCase
$limitQuery = clone $query;
$limitQuery->setHint(Query::HINT_CUSTOM_OUTPUT_WALKER, LimitSubqueryOutputWalker::class);
$this->assertEquals(
self::assertSame(
"SELECT DISTINCT id_1, MIN(sclr_3) AS dctrn_minrownum FROM (SELECT COUNT(g0_.id) AS sclr_0, u1_.id AS id_1, g0_.id AS id_2, ROW_NUMBER() OVER(ORDER BY COUNT(g0_.id) ASC, u1_.id DESC) AS sclr_3 FROM User u1_ INNER JOIN user_group u2_ ON u1_.id = u2_.user_id INNER JOIN groups g0_ ON g0_.id = u2_.group_id) dctrn_result GROUP BY id_1 ORDER BY dctrn_minrownum ASC",
$limitQuery->getSQL()
);
@ -78,7 +78,7 @@ class LimitSubqueryOutputWalkerTest extends PaginationTestCase
$this->entityManager->getConnection()->setDatabasePlatform($odp);
}
public function testLimitSubqueryWithHiddenScalarSortPg()
public function testLimitSubqueryWithHiddenScalarSortPg() : void
{
$odp = $this->entityManager->getConnection()->getDatabasePlatform();
$this->entityManager->getConnection()->setDatabasePlatform(new PostgreSqlPlatform);
@ -89,7 +89,7 @@ class LimitSubqueryOutputWalkerTest extends PaginationTestCase
$limitQuery = clone $query;
$limitQuery->setHint(Query::HINT_CUSTOM_OUTPUT_WALKER, LimitSubqueryOutputWalker::class);
$this->assertEquals(
self::assertSame(
"SELECT DISTINCT id_1, MIN(sclr_3) AS dctrn_minrownum FROM (SELECT COUNT(g0_.id) AS sclr_0, u1_.id AS id_1, g0_.id AS id_2, ROW_NUMBER() OVER(ORDER BY COUNT(g0_.id) ASC, u1_.id DESC) AS sclr_3 FROM User u1_ INNER JOIN user_group u2_ ON u1_.id = u2_.user_id INNER JOIN groups g0_ ON g0_.id = u2_.group_id) dctrn_result GROUP BY id_1 ORDER BY dctrn_minrownum ASC",
$limitQuery->getSQL()
);
@ -97,7 +97,7 @@ class LimitSubqueryOutputWalkerTest extends PaginationTestCase
$this->entityManager->getConnection()->setDatabasePlatform($odp);
}
public function testLimitSubqueryPg()
public function testLimitSubqueryPg() : void
{
$odp = $this->entityManager->getConnection()->getDatabasePlatform();
$this->entityManager->getConnection()->setDatabasePlatform(new PostgreSqlPlatform);
@ -107,7 +107,7 @@ class LimitSubqueryOutputWalkerTest extends PaginationTestCase
$this->entityManager->getConnection()->setDatabasePlatform($odp);
}
public function testLimitSubqueryWithSortOracle()
public function testLimitSubqueryWithSortOracle() : void
{
$odp = $this->entityManager->getConnection()->getDatabasePlatform();
$this->entityManager->getConnection()->setDatabasePlatform(new OraclePlatform);
@ -118,14 +118,14 @@ class LimitSubqueryOutputWalkerTest extends PaginationTestCase
$limitQuery = clone $query;
$limitQuery->setHint(Query::HINT_CUSTOM_OUTPUT_WALKER, LimitSubqueryOutputWalker::class);
$this->assertEquals(
self::assertSame(
"SELECT DISTINCT ID_0, MIN(SCLR_5) AS dctrn_minrownum FROM (SELECT m0_.id AS ID_0, m0_.title AS TITLE_1, c1_.id AS ID_2, a2_.id AS ID_3, a2_.name AS NAME_4, ROW_NUMBER() OVER(ORDER BY m0_.title ASC) AS SCLR_5, m0_.author_id AS AUTHOR_ID_6, m0_.category_id AS CATEGORY_ID_7 FROM MyBlogPost m0_ INNER JOIN Category c1_ ON m0_.category_id = c1_.id INNER JOIN Author a2_ ON m0_.author_id = a2_.id) dctrn_result GROUP BY ID_0 ORDER BY dctrn_minrownum ASC", $limitQuery->getSQL()
);
$this->entityManager->getConnection()->setDatabasePlatform($odp);
}
public function testLimitSubqueryWithScalarSortOracle()
public function testLimitSubqueryWithScalarSortOracle() : void
{
$odp = $this->entityManager->getConnection()->getDatabasePlatform();
$this->entityManager->getConnection()->setDatabasePlatform(new OraclePlatform);
@ -137,7 +137,7 @@ class LimitSubqueryOutputWalkerTest extends PaginationTestCase
$limitQuery = clone $query;
$limitQuery->setHint(Query::HINT_CUSTOM_OUTPUT_WALKER, LimitSubqueryOutputWalker::class);
$this->assertEquals(
self::assertSame(
"SELECT DISTINCT ID_1, MIN(SCLR_3) AS dctrn_minrownum FROM (SELECT COUNT(g0_.id) AS SCLR_0, u1_.id AS ID_1, g0_.id AS ID_2, ROW_NUMBER() OVER(ORDER BY COUNT(g0_.id) ASC) AS SCLR_3 FROM User u1_ INNER JOIN user_group u2_ ON u1_.id = u2_.user_id INNER JOIN groups g0_ ON g0_.id = u2_.group_id) dctrn_result GROUP BY ID_1 ORDER BY dctrn_minrownum ASC",
$limitQuery->getSQL()
);
@ -145,7 +145,7 @@ class LimitSubqueryOutputWalkerTest extends PaginationTestCase
$this->entityManager->getConnection()->setDatabasePlatform($odp);
}
public function testLimitSubqueryWithMixedSortOracle()
public function testLimitSubqueryWithMixedSortOracle() : void
{
$odp = $this->entityManager->getConnection()->getDatabasePlatform();
$this->entityManager->getConnection()->setDatabasePlatform(new OraclePlatform);
@ -157,7 +157,7 @@ class LimitSubqueryOutputWalkerTest extends PaginationTestCase
$limitQuery = clone $query;
$limitQuery->setHint(Query::HINT_CUSTOM_OUTPUT_WALKER, LimitSubqueryOutputWalker::class);
$this->assertEquals(
self::assertSame(
"SELECT DISTINCT ID_1, MIN(SCLR_3) AS dctrn_minrownum FROM (SELECT COUNT(g0_.id) AS SCLR_0, u1_.id AS ID_1, g0_.id AS ID_2, ROW_NUMBER() OVER(ORDER BY COUNT(g0_.id) ASC, u1_.id DESC) AS SCLR_3 FROM User u1_ INNER JOIN user_group u2_ ON u1_.id = u2_.user_id INNER JOIN groups g0_ ON g0_.id = u2_.group_id) dctrn_result GROUP BY ID_1 ORDER BY dctrn_minrownum ASC",
$limitQuery->getSQL()
);
@ -165,7 +165,7 @@ class LimitSubqueryOutputWalkerTest extends PaginationTestCase
$this->entityManager->getConnection()->setDatabasePlatform($odp);
}
public function testLimitSubqueryOracle()
public function testLimitSubqueryOracle() : void
{
$odp = $this->entityManager->getConnection()->getDatabasePlatform();
$this->entityManager->getConnection()->setDatabasePlatform(new OraclePlatform);
@ -176,21 +176,21 @@ class LimitSubqueryOutputWalkerTest extends PaginationTestCase
$limitQuery = clone $query;
$limitQuery->setHint(Query::HINT_CUSTOM_OUTPUT_WALKER, LimitSubqueryOutputWalker::class);
$this->assertEquals(
self::assertSame(
"SELECT DISTINCT ID_0 FROM (SELECT m0_.id AS ID_0, m0_.title AS TITLE_1, c1_.id AS ID_2, a2_.id AS ID_3, a2_.name AS NAME_4, m0_.author_id AS AUTHOR_ID_5, m0_.category_id AS CATEGORY_ID_6 FROM MyBlogPost m0_ INNER JOIN Category c1_ ON m0_.category_id = c1_.id INNER JOIN Author a2_ ON m0_.author_id = a2_.id) dctrn_result", $limitQuery->getSQL()
);
$this->entityManager->getConnection()->setDatabasePlatform($odp);
}
public function testCountQueryMixedResultsWithName()
public function testCountQueryMixedResultsWithName() : void
{
$query = $this->entityManager->createQuery(
'SELECT a, sum(a.name) as foo FROM Doctrine\Tests\ORM\Tools\Pagination\Author a');
$limitQuery = clone $query;
$limitQuery->setHint(Query::HINT_CUSTOM_OUTPUT_WALKER, LimitSubqueryOutputWalker::class);
$this->assertEquals(
self::assertSame(
"SELECT DISTINCT id_0 FROM (SELECT a0_.id AS id_0, a0_.name AS name_1, sum(a0_.name) AS sclr_2 FROM Author a0_) dctrn_result", $limitQuery->getSQL()
);
}
@ -198,7 +198,7 @@ class LimitSubqueryOutputWalkerTest extends PaginationTestCase
/**
* @group DDC-3336
*/
public function testCountQueryWithArithmeticOrderByCondition()
public function testCountQueryWithArithmeticOrderByCondition() : void
{
$query = $this->entityManager->createQuery(
'SELECT a FROM Doctrine\Tests\ORM\Tools\Pagination\Author a ORDER BY (1 - 1000) * 1 DESC'
@ -213,7 +213,7 @@ class LimitSubqueryOutputWalkerTest extends PaginationTestCase
);
}
public function testCountQueryWithComplexScalarOrderByItem()
public function testCountQueryWithComplexScalarOrderByItem() : void
{
$query = $this->entityManager->createQuery(
'SELECT a FROM Doctrine\Tests\ORM\Tools\Pagination\Avatar a ORDER BY a.image_height * a.image_width DESC'
@ -228,7 +228,7 @@ class LimitSubqueryOutputWalkerTest extends PaginationTestCase
);
}
public function testCountQueryWithComplexScalarOrderByItemJoined()
public function testCountQueryWithComplexScalarOrderByItemJoined() : void
{
$query = $this->entityManager->createQuery(
'SELECT u FROM Doctrine\Tests\ORM\Tools\Pagination\User u JOIN u.avatar a ORDER BY a.image_height * a.image_width DESC'
@ -243,7 +243,7 @@ class LimitSubqueryOutputWalkerTest extends PaginationTestCase
);
}
public function testCountQueryWithComplexScalarOrderByItemJoinedWithPartial()
public function testCountQueryWithComplexScalarOrderByItemJoinedWithPartial() : void
{
$query = $this->entityManager->createQuery(
'SELECT u, partial a.{id, image_alt_desc} FROM Doctrine\Tests\ORM\Tools\Pagination\User u JOIN u.avatar a ORDER BY a.image_height * a.image_width DESC'
@ -258,7 +258,7 @@ class LimitSubqueryOutputWalkerTest extends PaginationTestCase
);
}
public function testCountQueryWithComplexScalarOrderByItemOracle()
public function testCountQueryWithComplexScalarOrderByItemOracle() : void
{
$query = $this->entityManager->createQuery(
'SELECT a FROM Doctrine\Tests\ORM\Tools\Pagination\Avatar a ORDER BY a.image_height * a.image_width DESC'
@ -276,7 +276,7 @@ class LimitSubqueryOutputWalkerTest extends PaginationTestCase
/**
* @group DDC-3434
*/
public function testLimitSubqueryWithHiddenSelectionInOrderBy()
public function testLimitSubqueryWithHiddenSelectionInOrderBy() : void
{
$query = $this->entityManager->createQuery(
'SELECT a, a.name AS HIDDEN ord FROM Doctrine\Tests\ORM\Tools\Pagination\Author a ORDER BY ord DESC'
@ -284,13 +284,13 @@ class LimitSubqueryOutputWalkerTest extends PaginationTestCase
$query->setHint(Query::HINT_CUSTOM_OUTPUT_WALKER, LimitSubqueryOutputWalker::class);
$this->assertEquals(
self::assertSame(
'SELECT DISTINCT id_0 FROM (SELECT DISTINCT id_0, name_2 FROM (SELECT a0_.id AS id_0, a0_.name AS name_1, a0_.name AS name_2 FROM Author a0_) dctrn_result_inner ORDER BY name_2 DESC) dctrn_result',
$query->getSQL()
);
}
public function testLimitSubqueryWithColumnWithSortDirectionInName()
public function testLimitSubqueryWithColumnWithSortDirectionInName() : void
{
$query = $this->entityManager->createQuery(
'SELECT a FROM Doctrine\Tests\ORM\Tools\Pagination\Avatar a ORDER BY a.image_alt_desc DESC'
@ -305,7 +305,7 @@ class LimitSubqueryOutputWalkerTest extends PaginationTestCase
);
}
public function testLimitSubqueryWithOrderByInnerJoined()
public function testLimitSubqueryWithOrderByInnerJoined() : void
{
$query = $this->entityManager->createQuery(
'SELECT b FROM Doctrine\Tests\ORM\Tools\Pagination\BlogPost b JOIN b.author a ORDER BY a.name ASC'
@ -313,13 +313,13 @@ class LimitSubqueryOutputWalkerTest extends PaginationTestCase
$query->setHint(Query::HINT_CUSTOM_OUTPUT_WALKER, LimitSubqueryOutputWalker::class);
$this->assertEquals(
self::assertSame(
'SELECT DISTINCT id_0 FROM (SELECT DISTINCT id_0, name_1 FROM (SELECT b0_.id AS id_0, a1_.name AS name_1, b0_.author_id AS author_id_2, b0_.category_id AS category_id_3 FROM BlogPost b0_ INNER JOIN Author a1_ ON b0_.author_id = a1_.id) dctrn_result_inner ORDER BY name_1 ASC) dctrn_result',
$query->getSQL()
);
}
public function testLimitSubqueryWithOrderByAndSubSelectInWhereClauseMySql()
public function testLimitSubqueryWithOrderByAndSubSelectInWhereClauseMySql() : void
{
$this->entityManager->getConnection()->setDatabasePlatform(new MySqlPlatform());
$query = $this->entityManager->createQuery(
@ -329,13 +329,13 @@ ORDER BY b.id DESC'
);
$query->setHint(Query::HINT_CUSTOM_OUTPUT_WALKER, LimitSubqueryOutputWalker::class);
$this->assertEquals(
self::assertSame(
'SELECT DISTINCT id_0 FROM (SELECT DISTINCT id_0 FROM (SELECT b0_.id AS id_0, b0_.author_id AS author_id_1, b0_.category_id AS category_id_2 FROM BlogPost b0_ WHERE ((SELECT COUNT(b1_.id) AS sclr_3 FROM BlogPost b1_) = 1)) dctrn_result_inner ORDER BY id_0 DESC) dctrn_result',
$query->getSQL()
);
}
public function testLimitSubqueryWithOrderByAndSubSelectInWhereClausePgSql()
public function testLimitSubqueryWithOrderByAndSubSelectInWhereClausePgSql() : void
{
$this->entityManager->getConnection()->setDatabasePlatform(new PostgreSqlPlatform());
$query = $this->entityManager->createQuery(
@ -345,7 +345,7 @@ ORDER BY b.id DESC'
);
$query->setHint(Query::HINT_CUSTOM_OUTPUT_WALKER, LimitSubqueryOutputWalker::class);
$this->assertEquals(
self::assertSame(
'SELECT DISTINCT id_0, MIN(sclr_1) AS dctrn_minrownum FROM (SELECT b0_.id AS id_0, ROW_NUMBER() OVER(ORDER BY b0_.id DESC) AS sclr_1, b0_.author_id AS author_id_2, b0_.category_id AS category_id_3 FROM BlogPost b0_ WHERE ((SELECT COUNT(b1_.id) AS sclr_4 FROM BlogPost b1_) = 1)) dctrn_result GROUP BY id_0 ORDER BY dctrn_minrownum ASC',
$query->getSQL()
);
@ -354,7 +354,7 @@ ORDER BY b.id DESC'
/**
* This tests ordering by property that has the 'declared' field.
*/
public function testLimitSubqueryOrderByFieldFromMappedSuperclass()
public function testLimitSubqueryOrderByFieldFromMappedSuperclass() : void
{
$this->entityManager->getConnection()->setDatabasePlatform(new MySqlPlatform());
@ -364,7 +364,7 @@ ORDER BY b.id DESC'
);
$query->setHint(Query::HINT_CUSTOM_OUTPUT_WALKER, LimitSubqueryOutputWalker::class);
$this->assertEquals(
self::assertSame(
'SELECT DISTINCT id_0 FROM (SELECT DISTINCT id_0 FROM (SELECT b0_.id AS id_0, b0_.name AS name_1 FROM Banner b0_) dctrn_result_inner ORDER BY id_0 DESC) dctrn_result',
$query->getSQL()
);
@ -373,7 +373,7 @@ ORDER BY b.id DESC'
/**
* Tests order by on a subselect expression (mysql).
*/
public function testLimitSubqueryOrderBySubSelectOrderByExpression()
public function testLimitSubqueryOrderBySubSelectOrderByExpression() : void
{
$this->entityManager->getConnection()->setDatabasePlatform(new MySqlPlatform());
@ -389,7 +389,7 @@ ORDER BY b.id DESC'
);
$query->setHint(Query::HINT_CUSTOM_OUTPUT_WALKER, LimitSubqueryOutputWalker::class);
$this->assertEquals(
self::assertSame(
'SELECT DISTINCT id_0 FROM (SELECT DISTINCT id_0, sclr_2 FROM (SELECT a0_.id AS id_0, a0_.name AS name_1, (SELECT MIN(m1_.title) AS sclr_3 FROM MyBlogPost m1_ WHERE m1_.author_id = a0_.id) AS sclr_2 FROM Author a0_) dctrn_result_inner ORDER BY sclr_2 DESC) dctrn_result',
$query->getSQL()
);
@ -398,7 +398,7 @@ ORDER BY b.id DESC'
/**
* Tests order by on a subselect expression invoking RowNumberOverFunction (postgres).
*/
public function testLimitSubqueryOrderBySubSelectOrderByExpressionPg()
public function testLimitSubqueryOrderBySubSelectOrderByExpressionPg() : void
{
$this->entityManager->getConnection()->setDatabasePlatform(new PostgreSqlPlatform());
@ -414,7 +414,7 @@ ORDER BY b.id DESC'
);
$query->setHint(Query::HINT_CUSTOM_OUTPUT_WALKER, LimitSubqueryOutputWalker::class);
$this->assertEquals(
self::assertSame(
'SELECT DISTINCT id_0, MIN(sclr_4) AS dctrn_minrownum FROM (SELECT a0_.id AS id_0, a0_.name AS name_1, (SELECT MIN(m1_.title) AS sclr_3 FROM MyBlogPost m1_ WHERE m1_.author_id = a0_.id) AS sclr_2, ROW_NUMBER() OVER(ORDER BY (SELECT MIN(m1_.title) AS sclr_5 FROM MyBlogPost m1_ WHERE m1_.author_id = a0_.id) DESC) AS sclr_4 FROM Author a0_) dctrn_result GROUP BY id_0 ORDER BY dctrn_minrownum ASC',
$query->getSQL()
);
@ -423,7 +423,7 @@ ORDER BY b.id DESC'
/**
* Tests order by on a subselect expression invoking RowNumberOverFunction (oracle).
*/
public function testLimitSubqueryOrderBySubSelectOrderByExpressionOracle()
public function testLimitSubqueryOrderBySubSelectOrderByExpressionOracle() : void
{
$this->entityManager->getConnection()->setDatabasePlatform(new OraclePlatform());
@ -439,7 +439,7 @@ ORDER BY b.id DESC'
);
$query->setHint(Query::HINT_CUSTOM_OUTPUT_WALKER, LimitSubqueryOutputWalker::class);
$this->assertEquals(
self::assertSame(
'SELECT DISTINCT ID_0, MIN(SCLR_4) AS dctrn_minrownum FROM (SELECT a0_.id AS ID_0, a0_.name AS NAME_1, (SELECT MIN(m1_.title) AS SCLR_3 FROM MyBlogPost m1_ WHERE m1_.author_id = a0_.id) AS SCLR_2, ROW_NUMBER() OVER(ORDER BY (SELECT MIN(m1_.title) AS SCLR_5 FROM MyBlogPost m1_ WHERE m1_.author_id = a0_.id) DESC) AS SCLR_4 FROM Author a0_) dctrn_result GROUP BY ID_0 ORDER BY dctrn_minrownum ASC',
$query->getSQL()
);