LimitSubqueryWalker::walkSelectStatement() - Code Metrics - Inspection of "Allow internal functions to be overridden." - doctrine/orm - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#6500)

by Mathew

created 2017-06-19 09:08 UTC

LimitSubqueryWalker::walkSelectStatement() B

↳ Parent: LimitSubqueryWalker

Complexity

Conditions	7
Paths	9

Size

Total Lines	58
Code Lines	33

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	31
CRAP Score	7.0336

Importance

Changes

Metric	Value
dl	0
loc	58
ccs	31
cts	34
cp	0.9118
rs	7.6045
c	0
b	0
f	0
cc	7
eloc	33
nc	9
nop	1
crap	7.0336

How to fix Long Method

<?php
/*
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * This software consists of voluntary contributions made by many individuals
 * and is licensed under the MIT license. For more information, see
 * <http://www.doctrine-project.org>.
 */

namespace Doctrine\ORM\Tools\Pagination;

use Doctrine\DBAL\Types\Type;
use Doctrine\ORM\Mapping\ClassMetadataInfo;
use Doctrine\ORM\Query;
use Doctrine\ORM\Query\TreeWalkerAdapter;
use Doctrine\ORM\Query\AST\Functions\IdentityFunction;
use Doctrine\ORM\Query\AST\PathExpression;
use Doctrine\ORM\Query\AST\SelectExpression;
use Doctrine\ORM\Query\AST\SelectStatement;

/**
 * Replaces the selectClause of the AST with a SELECT DISTINCT root.id equivalent.
 *
 * @category    DoctrineExtensions
 * @package     DoctrineExtensions\Paginate
 * @author      David Abdemoulaie <[email protected]>
 * @copyright   Copyright (c) 2010 David Abdemoulaie (http://hobodave.com/)
 * @license     http://hobodave.com/license.txt New BSD License
 */
class LimitSubqueryWalker extends TreeWalkerAdapter
{
    /**
     * ID type hint.
     */
    const IDENTIFIER_TYPE = 'doctrine_paginator.id.type';

    /**
     * Counter for generating unique order column aliases.
     *
     * @var int
     */
    private $_aliasCounter = 0;

    /**
     * Walks down a SelectStatement AST node, modifying it to retrieve DISTINCT ids
     * of the root Entity.
     *
     * @param SelectStatement $AST
     *
     * @return void
     *
     * @throws \RuntimeException
     */
    public function walkSelectStatement(SelectStatement $AST)
    {
        $queryComponents = $this->_getQueryComponents();
        // Get the root entity and alias from the AST fromClause
        $from      = $AST->fromClause->identificationVariableDeclarations;
        $fromRoot  = reset($from);
        $rootAlias = $fromRoot->rangeVariableDeclaration->aliasIdentificationVariable;
        $rootClass = $queryComponents[$rootAlias]['metadata'];
        $selectExpressions = [];

        $this->validate($AST);

        foreach ($queryComponents as $dqlAlias => $qComp) {
            // Preserve mixed data in query for ordering.
            if (isset($qComp['resultVariable'])) {
                $selectExpressions[] = new SelectExpression($qComp['resultVariable'], $dqlAlias);
                continue;
            }
        }

        $identifier = $rootClass->getSingleIdentifierFieldName();

        if (isset($rootClass->associationMappings[$identifier])) {
            throw new \RuntimeException("Paginating an entity with foreign key as identifier only works when using the Output Walkers. Call Paginator#setUseOutputWalkers(true) before iterating the paginator.");
        }

        $this->_getQuery()->setHint(
            self::IDENTIFIER_TYPE,
            Type::getType($rootClass->fieldMappings[$identifier]['type'])
        );

        $pathExpression = new PathExpression(
            PathExpression::TYPE_STATE_FIELD | PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION,
            $rootAlias,
            $identifier
        );

        $pathExpression->type = PathExpression::TYPE_STATE_FIELD;

        array_unshift($selectExpressions, new SelectExpression($pathExpression, '_dctrn_id'));

        $AST->selectClause->selectExpressions = $selectExpressions;

        if (isset($AST->orderByClause)) {
            foreach ($AST->orderByClause->orderByItems as $item) {
                if ( ! $item->expression instanceof PathExpression) {
                    continue;
                }

                $AST->selectClause->selectExpressions[] = new SelectExpression(
                    $this->createSelectExpressionItem($item->expression),
                    '_dctrn_ord' . $this->_aliasCounter++
                );
            }
        }

        $AST->selectClause->isDistinct = true;
    }

    /**
     * Validate the AST to ensure that this walker is able to properly manipulate it.
     *
     * @param SelectStatement $AST
     */
    private function validate(SelectStatement $AST)
    {
        // Prevent LimitSubqueryWalker from being used with queries that include
        // a limit, a fetched to-many join, and an order by condition that
        // references a column from the fetch joined table.
        $queryComponents = $this->getQueryComponents();
        $query           = $this->_getQuery();
        $from            = $AST->fromClause->identificationVariableDeclarations;
        $fromRoot        = reset($from);

        if ($query instanceof Query
            && $query->getMaxResults()
            && $AST->orderByClause
            && count($fromRoot->joins)) {
            // Check each orderby item.
            // TODO: check complex orderby items too...
            foreach ($AST->orderByClause->orderByItems as $orderByItem) {
                $expression = $orderByItem->expression;
                if ($orderByItem->expression instanceof PathExpression
                    && isset($queryComponents[$expression->identificationVariable])) {
                    $queryComponent = $queryComponents[$expression->identificationVariable];
                    if (isset($queryComponent['parent'])
                        && $queryComponent['relation']['type'] & ClassMetadataInfo::TO_MANY) {
                        throw new \RuntimeException("Cannot select distinct identifiers from query with LIMIT and ORDER BY on a column from a fetch joined to-many association. Use output walkers.");
                    }
                }
            }
        }
    }

    /**
     * Retrieve either an IdentityFunction (IDENTITY(u.assoc)) or a state field (u.name).
     *
     * @param \Doctrine\ORM\Query\AST\PathExpression $pathExpression
     *
     * @return \Doctrine\ORM\Query\AST\Functions\IdentityFunction
     */
    private function createSelectExpressionItem(PathExpression $pathExpression)
    {
        if ($pathExpression->type === PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION) {
            $identity = new IdentityFunction('identity');

            $identity->pathExpression = clone $pathExpression;

            return $identity;
        }

        return clone $pathExpression;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }
}


1		<?php
2		/*
3		* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
4		* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
5		* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
6		* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
7		* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
8		* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
9		* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
10		* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
11		* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
12		* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
13		* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
14		*
15		* This software consists of voluntary contributions made by many individuals
16		* and is licensed under the MIT license. For more information, see
17		* <http://www.doctrine-project.org>.
18		*/
19
20		namespace Doctrine\ORM\Tools\Pagination;
21
22		use Doctrine\DBAL\Types\Type;
23		use Doctrine\ORM\Mapping\ClassMetadataInfo;
24		use Doctrine\ORM\Query;
25		use Doctrine\ORM\Query\TreeWalkerAdapter;
26		use Doctrine\ORM\Query\AST\Functions\IdentityFunction;
27		use Doctrine\ORM\Query\AST\PathExpression;
28		use Doctrine\ORM\Query\AST\SelectExpression;
29		use Doctrine\ORM\Query\AST\SelectStatement;
30
31		/**
32		* Replaces the selectClause of the AST with a SELECT DISTINCT root.id equivalent.
33		*
34		* @category DoctrineExtensions
35		* @package DoctrineExtensions\Paginate
36		* @author David Abdemoulaie <[email protected]>
37		* @copyright Copyright (c) 2010 David Abdemoulaie (http://hobodave.com/)
38		* @license http://hobodave.com/license.txt New BSD License
39		*/
40		class LimitSubqueryWalker extends TreeWalkerAdapter
41		{
42		/**
43		* ID type hint.
44		*/
45		const IDENTIFIER_TYPE = 'doctrine_paginator.id.type';
46
47		/**
48		* Counter for generating unique order column aliases.
49		*
50		* @var int
51		*/
52		private $_aliasCounter = 0;
53
54		/**
55		* Walks down a SelectStatement AST node, modifying it to retrieve DISTINCT ids
56		* of the root Entity.
57		*
58		* @param SelectStatement $AST
59		*
60		* @return void
61		*
62		* @throws \RuntimeException
63		*/
64	28	public function walkSelectStatement(SelectStatement $AST)
65		{
66	28	$queryComponents = $this->_getQueryComponents();
67		// Get the root entity and alias from the AST fromClause
68	28	$from = $AST->fromClause->identificationVariableDeclarations;
69	28	$fromRoot = reset($from);
70	28	$rootAlias = $fromRoot->rangeVariableDeclaration->aliasIdentificationVariable;
71	28	$rootClass = $queryComponents[$rootAlias]['metadata'];
72	28	$selectExpressions = [];
73
74	28	$this->validate($AST);
75
76	26	foreach ($queryComponents as $dqlAlias => $qComp) {
77		// Preserve mixed data in query for ordering.
78	26	if (isset($qComp['resultVariable'])) {
79		$selectExpressions[] = new SelectExpression($qComp['resultVariable'], $dqlAlias);
80	26	continue;
81		}
82		}
83
84	26	$identifier = $rootClass->getSingleIdentifierFieldName();
85
86	26	if (isset($rootClass->associationMappings[$identifier])) {
87	1	throw new \RuntimeException("Paginating an entity with foreign key as identifier only works when using the Output Walkers. Call Paginator#setUseOutputWalkers(true) before iterating the paginator.");
88		}
89
90	25	$this->_getQuery()->setHint(
91	25	self::IDENTIFIER_TYPE,
92	25	Type::getType($rootClass->fieldMappings[$identifier]['type'])
93		);
94
95	25	$pathExpression = new PathExpression(
96	25	PathExpression::TYPE_STATE_FIELD \| PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION,
97		$rootAlias,
98	25	$identifier
99		);
100
101	25	$pathExpression->type = PathExpression::TYPE_STATE_FIELD;
102
103	25	array_unshift($selectExpressions, new SelectExpression($pathExpression, '_dctrn_id'));
104
105	25	$AST->selectClause->selectExpressions = $selectExpressions;
106
107	25	if (isset($AST->orderByClause)) {
108	20	foreach ($AST->orderByClause->orderByItems as $item) {
109	20	if ( ! $item->expression instanceof PathExpression) {
110		continue;
111		}
112
113	20	$AST->selectClause->selectExpressions[] = new SelectExpression(
114	20	$this->createSelectExpressionItem($item->expression),
115	20	'_dctrn_ord' . $this->_aliasCounter++
116		);
117		}
118		}
119
120	25	$AST->selectClause->isDistinct = true;
121	25	}
122
123		/**
124		* Validate the AST to ensure that this walker is able to properly manipulate it.
125		*
126		* @param SelectStatement $AST
127		*/
128	28	private function validate(SelectStatement $AST)
129		{
130		// Prevent LimitSubqueryWalker from being used with queries that include
131		// a limit, a fetched to-many join, and an order by condition that
132		// references a column from the fetch joined table.
133	28	$queryComponents = $this->getQueryComponents();
134	28	$query = $this->_getQuery();
135	28	$from = $AST->fromClause->identificationVariableDeclarations;
136	28	$fromRoot = reset($from);
137
138	28	if ($query instanceof Query
139	28	&& $query->getMaxResults()
140	28	&& $AST->orderByClause
141	28	&& count($fromRoot->joins)) {
142		// Check each orderby item.
143		// TODO: check complex orderby items too...
144	10	foreach ($AST->orderByClause->orderByItems as $orderByItem) {
145	10	$expression = $orderByItem->expression;
146	10	if ($orderByItem->expression instanceof PathExpression
147	10	&& isset($queryComponents[$expression->identificationVariable])) {
148	10	$queryComponent = $queryComponents[$expression->identificationVariable];
149	10	if (isset($queryComponent['parent'])
150	10	&& $queryComponent['relation']['type'] & ClassMetadataInfo::TO_MANY) {
151	10	throw new \RuntimeException("Cannot select distinct identifiers from query with LIMIT and ORDER BY on a column from a fetch joined to-many association. Use output walkers.");
152		}
153		}
154		}
155		}
156	26	}
157
158		/**
159		* Retrieve either an IdentityFunction (IDENTITY(u.assoc)) or a state field (u.name).
160		*
161		* @param \Doctrine\ORM\Query\AST\PathExpression $pathExpression
162		*
163		* @return \Doctrine\ORM\Query\AST\Functions\IdentityFunction
164		*/
165	20	private function createSelectExpressionItem(PathExpression $pathExpression)
166		{
167	20	if ($pathExpression->type === PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION) {
168	1	$identity = new IdentityFunction('identity');
169
170	1	$identity->pathExpression = clone $pathExpression;
171
172	1	return $identity;
173		}
174
175	19	return clone $pathExpression;
		0 ignored issues – show Bug Best Practice introduced 2015-12-29 16:33 UTC by Report Bug Copy Issue Report The return type of `return clone $pathExpression;` (`Doctrine\ORM\Query\AST\PathExpression`) is incompatible with the return type documented by `Doctrine\ORM\Tools\Pagin...ateSelectExpressionItem` of type `Doctrine\ORM\Query\AST\Functions\IdentityFunction`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
176		}
177		}
178

doctrine / orm

Pull Request — master (#6500)

LimitSubqueryWalker::walkSelectStatement() B

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like