DatabaseProcessor::fillQueryBuilder() - Code Metrics - rambler-digital-solutions/hydrogen - Measure and Improve Code Quality continuously with Scrutinizer

DatabaseProcessor::fillQueryBuilder() B
last analyzed 2020-03-11 13:09 UTC

↳ Parent: DatabaseProcessor

Complexity

Conditions	8
Paths	8

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	12
CRAP Score	13.0389

Importance

Changes

Metric	Value
dl	0
loc	40
ccs	12
cts	21
cp	0.5714
rs	8.0355
c	0
b	0
f	0
cc	8
nc	8
nop	2
crap	13.0389

<?php
/**
 * This file is part of Hydrogen package.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
declare(strict_types=1);

namespace RDS\Hydrogen\Processor;

use Doctrine\ORM\QueryBuilder;
use RDS\Hydrogen\Criteria;
use RDS\Hydrogen\Criteria\Common\Field;
use RDS\Hydrogen\Criteria\CriterionInterface;
use RDS\Hydrogen\Query;

/**
 * Class DatabaseProcessor
 */
class DatabaseProcessor extends Processor
{
    /**
     * @var string[]|BuilderInterface[]
     */
    protected const CRITERIA_MAPPINGS = [
        Criteria\GroupBy::class     => DatabaseProcessor\GroupByBuilder::class,
        Criteria\Having::class      => DatabaseProcessor\HavingBuilder::class,
        Criteria\HavingGroup::class => DatabaseProcessor\HavingGroupBuilder::class,
        Criteria\Join::class        => DatabaseProcessor\JoinBuilder::class,
        Criteria\Limit::class       => DatabaseProcessor\LimitBuilder::class,
        Criteria\Offset::class      => DatabaseProcessor\OffsetBuilder::class,
        Criteria\OrderBy::class     => DatabaseProcessor\OrderByBuilder::class,
        Criteria\Relation::class    => DatabaseProcessor\RelationBuilder::class,
        Criteria\Selection::class   => DatabaseProcessor\SelectBuilder::class,
        Criteria\Where::class       => DatabaseProcessor\WhereBuilder::class,
        Criteria\WhereGroup::class  => DatabaseProcessor\GroupBuilder::class,
    ];

    /**
     * @param Query $query
     * @param string $field
     * @return mixed
     */
    public function getScalarResult(Query $query, string $field)
    {
        $query->from($this->repository);

        /** @var QueryBuilder $builder */
        [$deferred, $builder] = $this->await($this->createQueryBuilder($query));


        return $builder->getQuery()->getSingleScalarResult();
    }

    /**
     * @param Query $query
     * @return string
     */
    public function dump(Query $query): string
    {
        $query->from($this->repository);

        /** @var QueryBuilder $builder */
        [$deferred, $builder] = $this->await($this->createQueryBuilder($query));


        return $builder->getQuery()->getDQL();
    }

    /**
     * @param Query $query
     * @return \Generator
     */
    protected function createQueryBuilder(Query $query): \Generator
    {
        $builder = $this->em->createQueryBuilder();
        $builder->from($query->getRepository()->getClassName(), $query->getAlias());
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        $builder->setCacheable(false);

        return $this->fillQueryBuilder($builder, $query);
    }

    /**
     * @param QueryBuilder $builder
     * @param Query $query
     * @return \Generator
     */
    protected function fillQueryBuilder(QueryBuilder $builder, Query $query): \Generator
    {
        /**
         * @var \Generator $context
         * @var CriterionInterface $criterion
         */
        foreach ($this->bypass($builder, $query) as $criterion => $context) {
            while ($context->valid()) {
                [$key, $value] = [$context->key(), $context->current()];


                switch (true) {
                    case $key instanceof Field:
                        $context->send($placeholder = $query->createPlaceholder($key->toString()));
                        $builder->setParameter($placeholder, $value);
                        continue 2;

                    case $value instanceof Field:
                        $context->send($value->toString($criterion->getQueryAlias()));

                        continue 2;

                    case $value instanceof Query:
                        $context->send($query->attach($value));
                        continue 2;

                    default:
                        $result = (yield $key => $value);

                        if ($result === null) {
                            $stmt = \is_object($value) ? \get_class($value) : \gettype($value);
                            $error = 'Unrecognized coroutine\'s return statement: ' . $stmt;
                            $context->throw(new \InvalidArgumentException($error));
                        }

                        $context->send($result);
                }
            }
        }

        return $builder;
    }

    /**
     * @param Query $query
     * @param string ...$fields
     * @return iterable
     */
    public function getResult(Query $query, string ...$fields): iterable
    {
        $query->from($this->repository);

        if (! $query->has(Criteria\Selection::class)) {
            $query->select(':' . $query->getAlias());
        }

        /**
         * @var QueryBuilder $builder
         * @var Queue $deferred
         */
        [$deferred, $builder] = $this->await($this->createQueryBuilder($query));


        return \count($fields) > 0
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());
}
            ? $this->executeFetchFields($builder, $fields)
            : $this->executeFetchData($builder, $deferred);
    }

    /**
     * @param QueryBuilder $builder
     * @param array $fields
     * @return array
     */
    private function executeFetchFields(QueryBuilder $builder, array $fields): array
    {
        $result = [];

        foreach ($builder->getQuery()->getArrayResult() as $record) {
            $result[] = \array_merge(\array_only($record, $fields), \array_only($record[0] ?? [], $fields));
        }

        return $result;
    }

    /**
     * @param QueryBuilder $builder
     * @param Queue $deferred
     * @return array
     */
    private function executeFetchData(QueryBuilder $builder, Queue $deferred): array
    {
        $query = $builder->getQuery();

        $deferred->invoke($result = $query->getResult());

        return $result;
    }
}


1		<?php
2		/**
3		* This file is part of Hydrogen package.
4		*
5		* For the full copyright and license information, please view the LICENSE
6		* file that was distributed with this source code.
7		*/
8		declare(strict_types=1);
9
10		namespace RDS\Hydrogen\Processor;
11
12		use Doctrine\ORM\QueryBuilder;
13		use RDS\Hydrogen\Criteria;
14		use RDS\Hydrogen\Criteria\Common\Field;
15		use RDS\Hydrogen\Criteria\CriterionInterface;
16		use RDS\Hydrogen\Query;
17
18		/**
19		* Class DatabaseProcessor
20		*/
21		class DatabaseProcessor extends Processor
22		{
23		/**
24		* @var string[]\|BuilderInterface[]
25		*/
26		protected const CRITERIA_MAPPINGS = [
27		Criteria\GroupBy::class => DatabaseProcessor\GroupByBuilder::class,
28		Criteria\Having::class => DatabaseProcessor\HavingBuilder::class,
29		Criteria\HavingGroup::class => DatabaseProcessor\HavingGroupBuilder::class,
30		Criteria\Join::class => DatabaseProcessor\JoinBuilder::class,
31		Criteria\Limit::class => DatabaseProcessor\LimitBuilder::class,
32		Criteria\Offset::class => DatabaseProcessor\OffsetBuilder::class,
33		Criteria\OrderBy::class => DatabaseProcessor\OrderByBuilder::class,
34		Criteria\Relation::class => DatabaseProcessor\RelationBuilder::class,
35		Criteria\Selection::class => DatabaseProcessor\SelectBuilder::class,
36		Criteria\Where::class => DatabaseProcessor\WhereBuilder::class,
37		Criteria\WhereGroup::class => DatabaseProcessor\GroupBuilder::class,
38		];
39
40		/**
41		* @param Query $query
42		* @param string $field
43		* @return mixed
44		*/
45	10	public function getScalarResult(Query $query, string $field)
46		{
47	10	$query->from($this->repository);
48
49		/** @var QueryBuilder $builder */
50	10	[$deferred, $builder] = $this->await($this->createQueryBuilder($query));
		0 ignored issues – show Bug introduced 2018-09-05 02:06 UTC by Report Bug Copy Issue Report The variable `$deferred` does not exist. Did you forget to declare it? This check marks access to variables or properties that have not been declared yet. While PHP has no explicit notion of declaring a variable, accessing it before a value is assigned to it is most likely a bug. Loading history... Bug introduced 2018-09-05 02:06 UTC by Report Bug Copy Issue Report The variable `$builder` does not exist. Did you forget to declare it? This check marks access to variables or properties that have not been declared yet. While PHP has no explicit notion of declaring a variable, accessing it before a value is assigned to it is most likely a bug. Loading history...
51
52	10	return $builder->getQuery()->getSingleScalarResult();
53		}
54
55		/**
56		* @param Query $query
57		* @return string
58		*/
59		public function dump(Query $query): string
60		{
61		$query->from($this->repository);
62
63		/** @var QueryBuilder $builder */
64		[$deferred, $builder] = $this->await($this->createQueryBuilder($query));
		0 ignored issues – show Bug introduced 2018-09-05 02:06 UTC by Report Bug Copy Issue Report The variable `$deferred` does not exist. Did you forget to declare it? This check marks access to variables or properties that have not been declared yet. While PHP has no explicit notion of declaring a variable, accessing it before a value is assigned to it is most likely a bug. Loading history... Bug introduced 2018-09-05 02:06 UTC by Report Bug Copy Issue Report The variable `$builder` does not exist. Did you forget to declare it? This check marks access to variables or properties that have not been declared yet. While PHP has no explicit notion of declaring a variable, accessing it before a value is assigned to it is most likely a bug. Loading history...
65
66		return $builder->getQuery()->getDQL();
67		}
68
69		/**
70		* @param Query $query
71		* @return \Generator
72		*/
73	30	protected function createQueryBuilder(Query $query): \Generator
74		{
75	30	$builder = $this->em->createQueryBuilder();
76	30	$builder->from($query->getRepository()->getClassName(), $query->getAlias());
		0 ignored issues – show Bug introduced 2018-09-02 05:50 UTC by Report Bug Copy Issue Report The method `getClassName` does only exist in `Doctrine\Common\Persistence\ObjectRepository`, but not in `RDS\Hydrogen\Hydrogen`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
77	30	$builder->setCacheable(false);
78
79	30	return $this->fillQueryBuilder($builder, $query);
80		}
81
82		/**
83		* @param QueryBuilder $builder
84		* @param Query $query
85		* @return \Generator
86		*/
87	30	protected function fillQueryBuilder(QueryBuilder $builder, Query $query): \Generator
88		{
89		/**
90		* @var \Generator $context
91		* @var CriterionInterface $criterion
92		*/
93	30	foreach ($this->bypass($builder, $query) as $criterion => $context) {
94	30	while ($context->valid()) {
95	30	[$key, $value] = [$context->key(), $context->current()];
		0 ignored issues – show Bug introduced 2018-09-05 02:06 UTC by Report Bug Copy Issue Report The variable `$key` does not exist. Did you forget to declare it? This check marks access to variables or properties that have not been declared yet. While PHP has no explicit notion of declaring a variable, accessing it before a value is assigned to it is most likely a bug. Loading history... Bug introduced 2018-09-05 02:06 UTC by Report Bug Copy Issue Report The variable `$value` does not exist. Did you forget to declare it? This check marks access to variables or properties that have not been declared yet. While PHP has no explicit notion of declaring a variable, accessing it before a value is assigned to it is most likely a bug. Loading history...
96
97		switch (true) {
98	30	case $key instanceof Field:
99	8	$context->send($placeholder = $query->createPlaceholder($key->toString()));
100	8	$builder->setParameter($placeholder, $value);
101	8	continue 2;
102
103	30	case $value instanceof Field:
104	30	$context->send($value->toString($criterion->getQueryAlias()));
		0 ignored issues – show Bug introduced 2018-09-05 02:06 UTC by Report Bug Copy Issue Report The method `getQueryAlias` cannot be called on `$criterion` (of type `integer\|string`). Methods can only be called on objects. This check looks for methods being called on variables that have been inferred to never be objects. Loading history...
105	30	continue 2;
106
107		case $value instanceof Query:
108		$context->send($query->attach($value));
109		continue 2;
110
111		default:
112		$result = (yield $key => $value);
113
114		if ($result === null) {
115		$stmt = \is_object($value) ? \get_class($value) : \gettype($value);
116		$error = 'Unrecognized coroutine\'s return statement: ' . $stmt;
117		$context->throw(new \InvalidArgumentException($error));
118		}
119
120		$context->send($result);
121		}
122		}
123		}
124
125	30	return $builder;
126		}
127
128		/**
129		* @param Query $query
130		* @param string ...$fields
131		* @return iterable
132		*/
133	20	public function getResult(Query $query, string ...$fields): iterable
134		{
135	20	$query->from($this->repository);
136
137	20	if (! $query->has(Criteria\Selection::class)) {
138	20	$query->select(':' . $query->getAlias());
139		}
140
141		/**
142		* @var QueryBuilder $builder
143		* @var Queue $deferred
144		*/
145	20	[$deferred, $builder] = $this->await($this->createQueryBuilder($query));
		0 ignored issues – show Bug introduced 2018-09-05 02:06 UTC by Report Bug Copy Issue Report The variable `$deferred` does not exist. Did you forget to declare it? This check marks access to variables or properties that have not been declared yet. While PHP has no explicit notion of declaring a variable, accessing it before a value is assigned to it is most likely a bug. Loading history... Bug introduced 2018-09-05 02:06 UTC by Report Bug Copy Issue Report The variable `$builder` does not exist. Did you forget to declare it? This check marks access to variables or properties that have not been declared yet. While PHP has no explicit notion of declaring a variable, accessing it before a value is assigned to it is most likely a bug. Loading history...
146
147	20	return \count($fields) > 0
		0 ignored issues – show Bug Best Practice introduced 2018-09-05 02:06 UTC by Report Bug Copy Issue Report The return type of `return \count($fields) >...a($builder, $deferred);` (`array`) is incompatible with the return type declared by the interface `RDS\Hydrogen\Processor\P...sorInterface::getResult` of type `RDS\Hydrogen\Processor\iterable`. 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...
148	2	? $this->executeFetchFields($builder, $fields)
149	20	: $this->executeFetchData($builder, $deferred);
150		}
151
152		/**
153		* @param QueryBuilder $builder
154		* @param array $fields
155		* @return array
156		*/
157	2	private function executeFetchFields(QueryBuilder $builder, array $fields): array
158		{
159	2	$result = [];
160
161	2	foreach ($builder->getQuery()->getArrayResult() as $record) {
162	2	$result[] = \array_merge(\array_only($record, $fields), \array_only($record[0] ?? [], $fields));
163		}
164
165	2	return $result;
166		}
167
168		/**
169		* @param QueryBuilder $builder
170		* @param Queue $deferred
171		* @return array
172		*/
173	20	private function executeFetchData(QueryBuilder $builder, Queue $deferred): array
174		{
175	20	$query = $builder->getQuery();
176
177	20	$deferred->invoke($result = $query->getResult());
178
179	20	return $result;
180		}
181		}
182

rambler-digital-solutions / hydrogen

DatabaseProcessor::fillQueryBuilder() B last analyzed 2020-03-11 13:09 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like

DatabaseProcessor::fillQueryBuilder() B
last analyzed 2020-03-11 13:09 UTC