QueryChecker::hasOrderByOnFetchJoinedToManyAssociation() - Code Metrics - Inspection of "Merge pull request #2689 from soyuka/master" - api-platform/core - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( ea7306...be932e )

by Antoine

created 2019-04-04 12:39 UTC

hasOrderByOnFetchJoinedToManyAssociation() C

↳ Parent: QueryChecker

Complexity

Conditions	17
Paths	76

Size

Total Lines	59
Code Lines	31

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	17
eloc	31
nc	76
nop	2
dl	0
loc	59
rs	5.2166
c	0
b	0
f	0

How to fix Long Method Complexity

<?php

/*
 * This file is part of the API Platform project.
 *
 * (c) Kévin Dunglas <[email protected]>
 *
 * 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\Util;

use Doctrine\Common\Persistence\ManagerRegistry;
use Doctrine\ORM\Mapping\ClassMetadata;
use Doctrine\ORM\Query\Expr\Join;
use Doctrine\ORM\QueryBuilder;

/**
 * Utility functions for working with Doctrine ORM query.
 *
 * @author Teoh Han Hui <[email protected]>
 * @author Vincent Chalamon <[email protected]>
 *
 * @internal
 */
final class QueryChecker
{
    private function __construct()
    {
    }

    /**
     * Determines whether the QueryBuilder uses a HAVING clause.
     */
    public static function hasHavingClause(QueryBuilder $queryBuilder): bool
    {
        return null !== $queryBuilder->getDQLPart('having');
    }

    /**
     * Determines whether the QueryBuilder has any root entity with foreign key identifier.
     */
    public static function hasRootEntityWithForeignKeyIdentifier(QueryBuilder $queryBuilder, ManagerRegistry $managerRegistry): bool
    {
        foreach ($queryBuilder->getRootEntities() as $rootEntity) {
            /** @var ClassMetadata $rootMetadata */
            $rootMetadata = $managerRegistry
                ->getManagerForClass($rootEntity)
                ->getClassMetadata($rootEntity);

            if ($rootMetadata->containsForeignIdentifier) {
                return true;
            }
        }

        return false;
    }

    /**
     * Determines whether the QueryBuilder has any composite identifier.
     */
    public static function hasRootEntityWithCompositeIdentifier(QueryBuilder $queryBuilder, ManagerRegistry $managerRegistry): bool
    {
        foreach ($queryBuilder->getRootEntities() as $rootEntity) {
            /** @var ClassMetadata $rootMetadata */
            $rootMetadata = $managerRegistry
                ->getManagerForClass($rootEntity)
                ->getClassMetadata($rootEntity);

            if ($rootMetadata->isIdentifierComposite) {
                return true;
            }
        }

        return false;
    }

    /**
     * Determines whether the QueryBuilder has a limit on the maximum number of results.
     */
    public static function hasMaxResults(QueryBuilder $queryBuilder): bool
    {
        return null !== $queryBuilder->getMaxResults();
    }

    /**
     * Determines whether the QueryBuilder has ORDER BY on a column from a fetch joined to-many association.
     */
    public static function hasOrderByOnFetchJoinedToManyAssociation(QueryBuilder $queryBuilder, ManagerRegistry $managerRegistry): bool
    {
        if (
            0 === \count($selectParts = $queryBuilder->getDQLPart('select')) ||
            0 === \count($queryBuilder->getDQLPart('join')) ||
            0 === \count($orderByParts = $queryBuilder->getDQLPart('orderBy'))
        ) {
            return false;
        }

        $rootAliases = $queryBuilder->getRootAliases();

        $selectAliases = [];

        foreach ($selectParts as $select) {
            foreach ($select->getParts() as $part) {
                [$alias] = explode('.', $part);

                $selectAliases[] = $alias;
            }
        }

        $selectAliases = array_diff($selectAliases, $rootAliases);
        if (0 === \count($selectAliases)) {
            return false;
        }

        $orderByAliases = [];

        foreach ($orderByParts as $orderBy) {
            foreach ($orderBy->getParts() as $part) {
                if (false !== strpos($part, '.')) {
                    [$alias] = explode('.', $part);

                    $orderByAliases[] = $alias;
                }
            }
        }

        $orderByAliases = array_diff($orderByAliases, $rootAliases);
        if (0 === \count($orderByAliases)) {
            return false;
        }

        foreach ($orderByAliases as $orderByAlias) {
            $inToManyContext = false;

            foreach (QueryBuilderHelper::traverseJoins($orderByAlias, $queryBuilder, $managerRegistry) as $alias => [$metadata, $association]) {
                if ($inToManyContext && \in_array($alias, $selectAliases, true)) {
                    return true;
                }

                if (null !== $association && $metadata->isCollectionValuedAssociation($association)) {
                    $inToManyContext = true;
                }
            }
        }

        return false;
    }

    /**
     * Determines whether the QueryBuilder has ORDER BY on a column from a fetch joined to-many association.
     *
     * @deprecated
     */
    public static function hasOrderByOnToManyJoin(QueryBuilder $queryBuilder, ManagerRegistry $managerRegistry): bool
    {
        @trigger_error(sprintf('The use of "%s::hasOrderByOnToManyJoin()" is deprecated since 2.4 and will be removed in 3.0. Use "%1$s::hasOrderByOnFetchJoinedToManyAssociation()" instead.', __CLASS__), E_USER_DEPRECATED);

        return self::hasOrderByOnFetchJoinedToManyAssociation($queryBuilder, $managerRegistry);
    }

    /**
     * Determines whether the QueryBuilder already has a left join.
     */
    public static function hasLeftJoin(QueryBuilder $queryBuilder): bool
    {
        foreach ($queryBuilder->getDQLPart('join') as $joins) {
            foreach ($joins as $join) {
                if (Join::LEFT_JOIN === $join->getJoinType()) {
                    return true;
                }
            }
        }

        return false;
    }

    /**
     * Determines whether the QueryBuilder has a joined to-many association.
     */
    public static function hasJoinedToManyAssociation(QueryBuilder $queryBuilder, ManagerRegistry $managerRegistry): bool
    {
        if (
            0 === \count($queryBuilder->getDQLPart('join'))
        ) {
            return false;
        }

        $joinAliases = array_diff($queryBuilder->getAllAliases(), $queryBuilder->getRootAliases());
        if (0 === \count($joinAliases)) {
            return false;
        }

        foreach ($joinAliases as $joinAlias) {
            foreach (QueryBuilderHelper::traverseJoins($joinAlias, $queryBuilder, $managerRegistry) as $alias => [$metadata, $association]) {
                if (null !== $association && $metadata->isCollectionValuedAssociation($association)) {
                    return true;
                }
            }
        }

        return false;
    }
}


1			<?php
2
3			/*
4			* This file is part of the API Platform project.
5			*
6			* (c) Kévin Dunglas <[email protected]>
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\Util;
15
16			use Doctrine\Common\Persistence\ManagerRegistry;
17			use Doctrine\ORM\Mapping\ClassMetadata;
18			use Doctrine\ORM\Query\Expr\Join;
19			use Doctrine\ORM\QueryBuilder;
20
21			/**
22			* Utility functions for working with Doctrine ORM query.
23			*
24			* @author Teoh Han Hui <[email protected]>
25			* @author Vincent Chalamon <[email protected]>
26			*
27			* @internal
28			*/
29			final class QueryChecker
30			{
31			private function __construct()
32			{
33			}
34
35			/**
36			* Determines whether the QueryBuilder uses a HAVING clause.
37			*/
38			public static function hasHavingClause(QueryBuilder $queryBuilder): bool
39			{
40			return null !== $queryBuilder->getDQLPart('having');
41			}
42
43			/**
44			* Determines whether the QueryBuilder has any root entity with foreign key identifier.
45			*/
46			public static function hasRootEntityWithForeignKeyIdentifier(QueryBuilder $queryBuilder, ManagerRegistry $managerRegistry): bool
47			{
48			foreach ($queryBuilder->getRootEntities() as $rootEntity) {
49			/** @var ClassMetadata $rootMetadata */
50			$rootMetadata = $managerRegistry
51			->getManagerForClass($rootEntity)
52			->getClassMetadata($rootEntity);
53
54			if ($rootMetadata->containsForeignIdentifier) {
55			return true;
56			}
57			}
58
59			return false;
60			}
61
62			/**
63			* Determines whether the QueryBuilder has any composite identifier.
64			*/
65			public static function hasRootEntityWithCompositeIdentifier(QueryBuilder $queryBuilder, ManagerRegistry $managerRegistry): bool
66			{
67			foreach ($queryBuilder->getRootEntities() as $rootEntity) {
68			/** @var ClassMetadata $rootMetadata */
69			$rootMetadata = $managerRegistry
70			->getManagerForClass($rootEntity)
71			->getClassMetadata($rootEntity);
72
73			if ($rootMetadata->isIdentifierComposite) {
74			return true;
75			}
76			}
77
78			return false;
79			}
80
81			/**
82			* Determines whether the QueryBuilder has a limit on the maximum number of results.
83			*/
84			public static function hasMaxResults(QueryBuilder $queryBuilder): bool
85			{
86			return null !== $queryBuilder->getMaxResults();
87			}
88
89			/**
90			* Determines whether the QueryBuilder has ORDER BY on a column from a fetch joined to-many association.
91			*/
92			public static function hasOrderByOnFetchJoinedToManyAssociation(QueryBuilder $queryBuilder, ManagerRegistry $managerRegistry): bool
93			{
94			if (
95			0 === \count($selectParts = $queryBuilder->getDQLPart('select')) \|\|
96			0 === \count($queryBuilder->getDQLPart('join')) \|\|
97			0 === \count($orderByParts = $queryBuilder->getDQLPart('orderBy'))
98			) {
99			return false;
100			}
101
102			$rootAliases = $queryBuilder->getRootAliases();
103
104			$selectAliases = [];
105
106			foreach ($selectParts as $select) {
107			foreach ($select->getParts() as $part) {
108			[$alias] = explode('.', $part);
109
110			$selectAliases[] = $alias;
111			}
112			}
113
114			$selectAliases = array_diff($selectAliases, $rootAliases);
115			if (0 === \count($selectAliases)) {
116			return false;
117			}
118
119			$orderByAliases = [];
120
121			foreach ($orderByParts as $orderBy) {
122			foreach ($orderBy->getParts() as $part) {
123			if (false !== strpos($part, '.')) {
124			[$alias] = explode('.', $part);
125
126			$orderByAliases[] = $alias;
127			}
128			}
129			}
130
131			$orderByAliases = array_diff($orderByAliases, $rootAliases);
132			if (0 === \count($orderByAliases)) {
133			return false;
134			}
135
136			foreach ($orderByAliases as $orderByAlias) {
137			$inToManyContext = false;
138
139			foreach (QueryBuilderHelper::traverseJoins($orderByAlias, $queryBuilder, $managerRegistry) as $alias => [$metadata, $association]) {
140			if ($inToManyContext && \in_array($alias, $selectAliases, true)) {
141			return true;
142			}
143
144			if (null !== $association && $metadata->isCollectionValuedAssociation($association)) {
145			$inToManyContext = true;
146			}
147			}
148			}
149
150			return false;
151			}
152
153			/**
154			* Determines whether the QueryBuilder has ORDER BY on a column from a fetch joined to-many association.
155			*
156			* @deprecated
157			*/
158			public static function hasOrderByOnToManyJoin(QueryBuilder $queryBuilder, ManagerRegistry $managerRegistry): bool
159			{
160			@trigger_error(sprintf('The use of "%s::hasOrderByOnToManyJoin()" is deprecated since 2.4 and will be removed in 3.0. Use "%1$s::hasOrderByOnFetchJoinedToManyAssociation()" instead.', __CLASS__), E_USER_DEPRECATED);
161
162			return self::hasOrderByOnFetchJoinedToManyAssociation($queryBuilder, $managerRegistry);
163			}
164
165			/**
166			* Determines whether the QueryBuilder already has a left join.
167			*/
168			public static function hasLeftJoin(QueryBuilder $queryBuilder): bool
169			{
170			foreach ($queryBuilder->getDQLPart('join') as $joins) {
171			foreach ($joins as $join) {
172			if (Join::LEFT_JOIN === $join->getJoinType()) {
173			return true;
174			}
175			}
176			}
177
178			return false;
179			}
180
181			/**
182			* Determines whether the QueryBuilder has a joined to-many association.
183			*/
184			public static function hasJoinedToManyAssociation(QueryBuilder $queryBuilder, ManagerRegistry $managerRegistry): bool
185			{
186			if (
187			0 === \count($queryBuilder->getDQLPart('join'))
188			) {
189			return false;
190			}
191
192			$joinAliases = array_diff($queryBuilder->getAllAliases(), $queryBuilder->getRootAliases());
193			if (0 === \count($joinAliases)) {
194			return false;
195			}
196
197			foreach ($joinAliases as $joinAlias) {
198			foreach (QueryBuilderHelper::traverseJoins($joinAlias, $queryBuilder, $managerRegistry) as $alias => [$metadata, $association]) {
199			if (null !== $association && $metadata->isCollectionValuedAssociation($association)) {
200			return true;
201			}
202			}
203			}
204
205			return false;
206			}
207			}
208

api-platform / core

Push — master ( ea7306...be932e )

hasOrderByOnFetchJoinedToManyAssociation() C

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like