Cycle\ORM\Select\Loader\ManyToManyLoader

Complexity

Total Complexity

21

Size/Duplication

Total Lines	221
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__clone()	0	4	1
A	__construct()	0	6	1
B	configureQuery()	0	61	7
A	withContext()	0	15	1
A	loadRelation()	0	17	4
A	createNode()	0	6	1
A	mountColumns()	0	8	1
A	initNode()	0	15	2
A	isDataDuplicationPossible()	0	3	1
A	loadChild()	0	8	2

<?php

/**
 * Cycle DataMapper ORM
 *
 * @license   MIT
 * @author    Anton Titov (Wolfy-J)
 */

declare(strict_types=1);

namespace Cycle\ORM\Select\Loader;

use Cycle\ORM\Exception\LoaderException;
use Cycle\ORM\ORMInterface;
use Cycle\ORM\Parser\AbstractNode;
use Cycle\ORM\Parser\SingularNode;
use Cycle\ORM\Parser\Typecast;
use Cycle\ORM\Relation;
use Cycle\ORM\Schema;
use Cycle\ORM\Select\JoinableLoader;
use Cycle\ORM\Select\LoaderInterface;
use Cycle\ORM\Select\Traits\OrderByTrait;
use Cycle\ORM\Select\Traits\WhereTrait;
use Spiral\Database\Injection\Parameter;
use Spiral\Database\Query\SelectQuery;

class ManyToManyLoader extends JoinableLoader
{
    use OrderByTrait;
    use WhereTrait;

    /**
     * Default set of relation options. Child implementation might defined their of default options.
     *
     * @var array
     */
    protected $options = [
        'load' => false,
        'scope' => true,
        'method' => self::POSTLOAD,
        'minify' => true,
        'as' => null,
        'using' => null,
        'where' => null,
        'orderBy' => null,
        'pivot' => null,
    ];

    /** @var PivotLoader */
    protected $pivot;

    /**
     * {@inheritdoc}
     */
    public function __construct(ORMInterface $orm, string $name, string $target, array $schema)
    {
        parent::__construct($orm, $name, $target, $schema);
        $this->pivot = new PivotLoader($orm, 'pivot', $schema[Relation::THROUGH_ENTITY], $schema);
        $this->options['where'] = $schema[Relation::WHERE] ?? [];
        $this->options['orderBy'] = $schema[Relation::ORDER_BY] ?? [];
    }

    /**
     * Make sure that pivot loader is always carried with parent relation.
     */
    public function __clone()
    {
        parent::__clone();
        $this->pivot = clone $this->pivot;
    }

    /**
     * @param LoaderInterface $parent
     * @param array           $options
     *
     * @return LoaderInterface
     */
    public function withContext(LoaderInterface $parent, array $options = []): LoaderInterface
    {
        $options = $this->prepareOptions($options);

        /** @var ManyToManyLoader $loader */
        $loader = parent::withContext($parent, $options);
        $loader->pivot = $loader->pivot->withContext(
            $loader,
            [
                'load' => $loader->isLoaded(),
                'method' => $options['method'] ?? self::JOIN,
            ] + ($options['pivot'] ?? [])
        );

        return $loader;
    }

    /**
     * @param string $relation
     * @param array  $options
     * @param bool   $join
     * @param bool   $load
     *
     * @return LoaderInterface
     */
    public function loadRelation(
        string $relation,
        array $options,
        bool $join = false,
        bool $load = false
    ): LoaderInterface {
        if ($relation === '@' || $relation === '@.@') {
            unset($options['method']);
            if ($options !== []) {
                // re-configure
                $this->pivot = $this->pivot->withContext($this, $options);
            }

            return $this->pivot;
        }

        return parent::loadRelation($relation, $options, $join, $load);
    }

    /**
     * {@inheritdoc}
     */
    public function configureQuery(SelectQuery $query, array $outerKeys = []): SelectQuery
    {
        if ($this->isLoaded() && $this->isJoined() && (int) $query->getLimit() !== 0) {
            throw new LoaderException('Unable to load data using join with limit on parent query');
        }

        if ($this->options['using'] !== null) {
            // use pre-defined query
            return parent::configureQuery($this->pivot->configureQuery($query), $outerKeys);
        }

        // Manually join pivoted table
        if ($this->isJoined()) {
            $query->join(
                $this->getJoinMethod(),
                $this->pivot->getJoinTable()
            )->on(
                $this->pivot->localKey(Relation::THROUGH_INNER_KEY),
                $this->parentKey(Relation::INNER_KEY)
            );

            $query->join(
                $this->getJoinMethod(),
                $this->getJoinTable()
            )->on(
                $this->localKey(Relation::OUTER_KEY),
                $this->pivot->localKey(Relation::THROUGH_OUTER_KEY)
            );
        } else {
            // reset all the columns when query is isolated (we have to do it manually
            // since underlying loader believes it's loaded)
            $query->columns([]);

            $query->join(
                $this->getJoinMethod(),
                $this->pivot->getJoinTable()
            )->on(
                $this->pivot->localKey(Relation::THROUGH_OUTER_KEY),
                $this->localKey(Relation::OUTER_KEY)
            )->where(

It seems like where() must be provided by classes using this trait. How about adding it as abstract method to this trait?

                $this->pivot->localKey(Relation::THROUGH_INNER_KEY),
                new Parameter($outerKeys)
            );
        }

        // user specified WHERE conditions
        $this->setWhere(
            $query,
            $this->getAlias(),
            $this->isJoined() ? 'onWhere' : 'where',
            $this->options['where'] ?? $this->schema[Relation::WHERE] ?? []
        );

        // user specified ORDER_BY rules
        $this->setOrderBy(
            $query,
            $this->getAlias(),
            $this->options['orderBy'] ?? $this->schema[Relation::ORDER_BY] ?? []
        );

        return parent::configureQuery($this->pivot->configureQuery($query));
    }

    /**
     * {@inheritdoc}
     */
    public function createNode(): AbstractNode
    {
        $node = $this->pivot->createNode();
        $node->joinNode('@', parent::createNode());

        return $node;
    }

    public function isDataDuplicationPossible(): bool
    {
        return true;
    }

    /**
     * @param AbstractNode $node
     */
    protected function loadChild(AbstractNode $node): void
    {
        $rootNode = $node->getNode('@');
        foreach ($this->load as $relation => $loader) {
            $loader->loadData($rootNode->getNode($relation));
        }

        $this->pivot->loadChild($node);
    }

    /**
     * {@inheritdoc}
     */
    protected function mountColumns(
        SelectQuery $query,
        bool $minify = false,
        string $prefix = '',
        bool $overwrite = false

The parameter $overwrite is not used and could be removed.

    ): SelectQuery {
        // columns are reset on earlier stage to allow pivot loader mount it's own aliases
        return parent::mountColumns($query, $minify, $prefix, false);
    }

    /**
     * {@inheritdoc}
     */
    protected function initNode(): AbstractNode
    {
        $node = new SingularNode(
            $this->columnNames(),
            $this->define(Schema::PRIMARY_KEY),
            $this->schema[Relation::OUTER_KEY],
            $this->schema[Relation::THROUGH_OUTER_KEY]
        );

        $typecast = $this->define(Schema::TYPECAST);
        if ($typecast !== null) {
            $node->setTypecast(new Typecast($typecast, $this->getSource()->getDatabase()));
        }

        return $node;
    }
}