QueryChecker::hasOrderByOnFetchJoinedToManyAssociation() - Code Metrics - Inspection of "Fix logic of protection against adding same join m..." - api-platform/core - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#3308)

by Karol

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

api-platform / core

Pull Request — master (#3308)

hasOrderByOnFetchJoinedToManyAssociation() C

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like