LimitSubqueryWalker::walkSelectStatement() - Code Metrics - Inspection of "ページネータの修正" - EC-CUBE/ec-cube - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Pull Request — master (#1922)

by chihiro

created 2016-11-15 09:56 UTC

LimitSubqueryWalker::walkSelectStatement() B

↳ Parent: LimitSubqueryWalker

Complexity

Conditions	7
Paths	9

Size

Total Lines	56
Code Lines	33

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	30
CRAP Score	7.0016

Importance

Changes

Metric	Value
cc	7
eloc	33
nc	9
nop	1
dl	0
loc	56
ccs	30
cts	31
cp	0.9677
crap	7.0016
rs	7.7489
c	0
b	0
f	0

How to fix Long Method

<?php

/**
 * Doctrine ORM
 *
 * LICENSE
 *
 * This source file is subject to the new BSD license that is bundled
 * with this package in the file LICENSE. This license can also be viewed
 * at http://hobodave.com/license.txt
 *
 * @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
 */

namespace Eccube\Doctrine\ORM\Tools\Pagination;

use Doctrine\DBAL\Types\Type;
use Doctrine\ORM\Mapping\ClassMetadataInfo;
use Doctrine\ORM\ORMException;
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 = array();

        $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->getTypeOfField($identifier))
        );

        $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		/**
4		* Doctrine ORM
5		*
6		* LICENSE
7		*
8		* This source file is subject to the new BSD license that is bundled
9		* with this package in the file LICENSE. This license can also be viewed
10		* at http://hobodave.com/license.txt
11		*
12		* @category DoctrineExtensions
13		* @package DoctrineExtensions\Paginate
14		* @author David Abdemoulaie <[email protected]>
15		* @copyright Copyright (c) 2010 David Abdemoulaie (http://hobodave.com/)
16		* @license http://hobodave.com/license.txt New BSD License
17		*/
18
19		namespace Eccube\Doctrine\ORM\Tools\Pagination;
20
21		use Doctrine\DBAL\Types\Type;
22		use Doctrine\ORM\Mapping\ClassMetadataInfo;
23		use Doctrine\ORM\ORMException;
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	11	public function walkSelectStatement(SelectStatement $AST)
65		{
66	11	$queryComponents = $this->_getQueryComponents();
67		// Get the root entity and alias from the AST fromClause
68	11	$from = $AST->fromClause->identificationVariableDeclarations;
69	11	$fromRoot = reset($from);
70	11	$rootAlias = $fromRoot->rangeVariableDeclaration->aliasIdentificationVariable;
71	11	$rootClass = $queryComponents[$rootAlias]['metadata'];
72	11	$selectExpressions = array();
73
74	11	$this->validate($AST);
75
76	11	foreach ($queryComponents as $dqlAlias => $qComp) {
77		// Preserve mixed data in query for ordering.
78	11	if (isset($qComp['resultVariable'])) {
79	2	$selectExpressions[] = new SelectExpression($qComp['resultVariable'], $dqlAlias);
80	11	continue;
81		}
82		}
83
		0 ignored issues – show introduced 2016-11-15 09:27 UTC by Report Bug Copy Issue Report Please trim any trailing whitespace Loading history...
84	11	$identifier = $rootClass->getSingleIdentifierFieldName();
85
		0 ignored issues – show introduced 2016-11-15 09:27 UTC by Report Bug Copy Issue Report Please trim any trailing whitespace Loading history...
86	11	if (isset($rootClass->associationMappings[$identifier])) {
87		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	11	$this->_getQuery()->setHint(
91	11	self::IDENTIFIER_TYPE,
92	11	Type::getType($rootClass->getTypeOfField($identifier))
93		);
94
95	11	$pathExpression = new PathExpression(
96	11	PathExpression::TYPE_STATE_FIELD \| PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION,
97		$rootAlias,
98		$identifier
99		);
100	11	$pathExpression->type = PathExpression::TYPE_STATE_FIELD;
101
102	11	array_unshift($selectExpressions, new SelectExpression($pathExpression, '_dctrn_id'));
103	11	$AST->selectClause->selectExpressions = $selectExpressions;
104
105	11	if (isset($AST->orderByClause)) {
106	11	foreach ($AST->orderByClause->orderByItems as $item) {
107	11	if ( ! $item->expression instanceof PathExpression) {
108	2	continue;
109		}
110
		0 ignored issues – show introduced 2016-11-15 09:27 UTC by Report Bug Copy Issue Report Please trim any trailing whitespace Loading history...
111	11	$AST->selectClause->selectExpressions[] = new SelectExpression(
112	11	$this->createSelectExpressionItem($item->expression),
113	11	'_dctrn_ord' . $this->_aliasCounter++
		0 ignored issues – show Coding Style introduced 2016-11-15 09:27 UTC by Report Bug Copy Issue Report Concat operator must not be surrounded by spaces Loading history...
114		);
115		}
116		}
117
118	11	$AST->selectClause->isDistinct = true;
119		}
120
121		/**
122		* Validate the AST to ensure that this walker is able to properly manipulate it.
123		*
124		* @param SelectStatement $AST
125		*/
126	11	private function validate(SelectStatement $AST)
127		{
128		// Prevent LimitSubqueryWalker from being used with queries that include
129		// a limit, a fetched to-many join, and an order by condition that
130		// references a column from the fetch joined table.
131	11	$queryComponents = $this->getQueryComponents();
132	11	$query = $this->_getQuery();
133	11	$from = $AST->fromClause->identificationVariableDeclarations;
134	11	$fromRoot = reset($from);
135
136	11	if ($query instanceof Query
137	11	&& $query->getMaxResults()
138	11	&& $AST->orderByClause
139	11	&& count($fromRoot->joins)) {
140		// Check each orderby item.
141		// TODO: check complex orderby items too...
142	4	foreach ($AST->orderByClause->orderByItems as $orderByItem) {
143	4	$expression = $orderByItem->expression;
144	4	if ($orderByItem->expression instanceof PathExpression
145	4	&& isset($queryComponents[$expression->identificationVariable])) {
146	4	$queryComponent = $queryComponents[$expression->identificationVariable];
147	4	if (isset($queryComponent['parent'])
148	4	&& $queryComponent['relation']['type'] & ClassMetadataInfo::TO_MANY) {
149	4	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.");
150		}
151		}
152		}
153		}
154		}
155
		0 ignored issues – show introduced 2016-11-15 09:27 UTC by Report Bug Copy Issue Report Please trim any trailing whitespace Loading history...
156		/**
157		* Retrieve either an IdentityFunction (IDENTITY(u.assoc)) or a state field (u.name).
158		*
159		* @param \Doctrine\ORM\Query\AST\PathExpression $pathExpression
160		*
161		* @return \Doctrine\ORM\Query\AST\Functions\IdentityFunction
162		*/
163	11	private function createSelectExpressionItem(PathExpression $pathExpression)
164		{
165	11	if ($pathExpression->type === PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION) {
166		$identity = new IdentityFunction('identity');
167
		0 ignored issues – show introduced 2016-11-15 09:27 UTC by Report Bug Copy Issue Report Please trim any trailing whitespace Loading history...
168		$identity->pathExpression = clone $pathExpression;
169
		0 ignored issues – show introduced 2016-11-15 09:27 UTC by Report Bug Copy Issue Report Please trim any trailing whitespace Loading history...
170		return $identity;
171		}
172
		0 ignored issues – show introduced 2016-11-15 09:27 UTC by Report Bug Copy Issue Report Please trim any trailing whitespace Loading history...
173	11	return clone $pathExpression;
		0 ignored issues – show Bug Best Practice introduced 2016-11-15 09:27 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 `Eccube\Doctrine\ORM\Tool...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...
174		}
175		}
176

EC-CUBE / ec-cube

Pull Request — master (#1922)

LimitSubqueryWalker::walkSelectStatement() B

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like