RDS\Hydrogen\Processor\DatabaseProcessor

Complexity

Total Complexity

17

Size/Duplication

Total Lines	161
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

74.51%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	getScalarResult()	0	9	1
A	dump()	0	9	1
A	createQueryBuilder()	0	8	1
B	fillQueryBuilder()	0	40	8
A	getResult()	0	18	3
A	executeFetchFields()	0	10	2
A	executeFetchData()	0	8	1

<?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));

The variable $deferred does not exist. Did you forget to declare it?

The variable $builder does not exist. Did you forget to declare it?

        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));

The variable $deferred does not exist. Did you forget to declare it?

The variable $builder does not exist. Did you forget to declare it?

        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());

The method getClassName does only exist in Doctrine\Common\Persistence\ObjectRepository, but not in RDS\Hydrogen\Hydrogen.

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

The variable $key does not exist. Did you forget to declare it?

The variable $value does not exist. Did you forget to declare it?

                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()));

The method getQueryAlias cannot be called on $criterion (of type integer|string).

                        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));

The variable $deferred does not exist. Did you forget to declare it?

The variable $builder does not exist. Did you forget to declare it?

        return \count($fields) > 0

The return type of return \count($fields) > 0 ? $this->executeFetchFields($builder, $fields) : $this->executeFetchData($builder, $deferred); (array) is incompatible with the return type declared by the interface RDS\Hydrogen\Processor\ProcessorInterface::getResult of type RDS\Hydrogen\Processor\iterable.

            ? $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;
    }
}