HasManyLoader::configureQuery() - Code Metrics - spiral/orm - Measure and Improve Code Quality continuously with Scrutinizer

HasManyLoader::configureQuery() B
last analyzed 2018-08-29 15:23 UTC

↳ Parent: HasManyLoader

Complexity

Conditions	6
Paths	9

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	52
rs	8.425
c	0
b	0
f	0
cc	6
nc	9
nop	3

How to fix Long Method

<?php
/**
 * Spiral, Core Components
 *
 * @author Wolfy-J
 */

namespace Spiral\ORM\Entities\Loaders;

use Spiral\Database\Builders\SelectQuery;
use Spiral\Database\Injections\Parameter;
use Spiral\ORM\Entities\Loaders\Traits\ConstrainTrait;
use Spiral\ORM\Entities\Loaders\Traits\WhereTrait;
use Spiral\ORM\Entities\Nodes\AbstractNode;
use Spiral\ORM\Entities\Nodes\ArrayNode;
use Spiral\ORM\ORMInterface;
use Spiral\ORM\Record;
use Spiral\ORM\RecordEntity;

/**
 * Dedicated to load HAS_MANY relation data, POSTLOAD is preferred loading method. Additional where
 * conditions and morph keys are supported.
 *
 * Please note that OUTER and INNER keys defined from perspective of parent (reversed for our
 * purposes).
 */
class HasManyLoader extends RelationLoader
{
    use WhereTrait, ConstrainTrait;

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

    /**
     * @param string                   $class
     * @param string                   $relation
     * @param array                    $schema
     * @param \Spiral\ORM\ORMInterface $orm
     */
    public function __construct($class, $relation, array $schema, ORMInterface $orm)
    {
        parent::__construct($class, $relation, $schema, $orm);

        if (!empty($schema[RecordEntity::ORDER_BY])) {
            //Default sorting direction
            $this->options['orderBy'] = $schema[RecordEntity::ORDER_BY];
        }
    }

    /**
     * {@inheritdoc}
     */
    protected function configureQuery(SelectQuery $query, bool $loadColumns = true, array $outerKeys = []): SelectQuery
    {
        if (!empty($this->options['using'])) {
            //Use pre-defined query
            return parent::configureQuery($query, $loadColumns, $outerKeys);
        }

        if ($this->isJoined()) {
            $query->join(
                $this->getMethod() == self::JOIN ? 'INNER' : 'LEFT',
                "{$this->getTable()} AS {$this->getAlias()}")
                ->on(
                    $this->localKey(Record::OUTER_KEY),
                    $this->parentKey(Record::INNER_KEY)
                );
        } else {
            //This relation is loaded using external query
            $query->where(
                $this->localKey(Record::OUTER_KEY),
                'IN',
                new Parameter($outerKeys)
            );

            $this->configureWindow($query, $this->options['orderBy'], $this->options['limit']);
        }

        //When relation is joined we will use ON statements, when not - normal WHERE
        $whereTarget = $this->isJoined() ? 'onWhere' : 'where';

        //Where conditions specified in relation definition
        $this->setWhere($query, $this->getAlias(), $whereTarget, $this->schema[Record::WHERE]);

        //User specified WHERE conditions
        $this->setWhere($query, $this->getAlias(), $whereTarget, $this->options['where']);

        //Morphed records
        if (!empty($this->schema[Record::MORPH_KEY])) {
            $this->setWhere(
                $query,
                $this->getAlias(),
                $whereTarget,
                [
                    $this->localKey(Record::MORPH_KEY) => $this->orm->define(
                        $this->parent->getClass(),
                        ORMInterface::R_ROLE_NAME
                    )
                ]
            );
        }

        return parent::configureQuery($query, $loadColumns);
    }

    /**
     * {@inheritdoc}
     */
    protected function initNode(): AbstractNode
    {
        $node = new ArrayNode(
            $this->schema[Record::RELATION_COLUMNS],
            $this->schema[Record::OUTER_KEY],
            $this->schema[Record::INNER_KEY],
            $this->schema[Record::SH_PRIMARY_KEY]
        );

        return $node->asJoined($this->isJoined());
    }
}

1			<?php
2			/**
3			* Spiral, Core Components
4			*
5			* @author Wolfy-J
6			*/
7
8			namespace Spiral\ORM\Entities\Loaders;
9
10			use Spiral\Database\Builders\SelectQuery;
11			use Spiral\Database\Injections\Parameter;
12			use Spiral\ORM\Entities\Loaders\Traits\ConstrainTrait;
13			use Spiral\ORM\Entities\Loaders\Traits\WhereTrait;
14			use Spiral\ORM\Entities\Nodes\AbstractNode;
15			use Spiral\ORM\Entities\Nodes\ArrayNode;
16			use Spiral\ORM\ORMInterface;
17			use Spiral\ORM\Record;
18			use Spiral\ORM\RecordEntity;
19
20			/**
21			* Dedicated to load HAS_MANY relation data, POSTLOAD is preferred loading method. Additional where
22			* conditions and morph keys are supported.
23			*
24			* Please note that OUTER and INNER keys defined from perspective of parent (reversed for our
25			* purposes).
26			*/
27			class HasManyLoader extends RelationLoader
28			{
29			use WhereTrait, ConstrainTrait;
30
31			/**
32			* Default set of relation options. Child implementation might defined their of default options.
33			*
34			* @var array
35			*/
36			protected $options = [
37			'method' => self::POSTLOAD,
38			'minify' => true,
39			'alias' => null,
40			'using' => null,
41			'where' => null,
42			'orderBy' => [],
43			'limit' => 0
44			];
45
46			/**
47			* @param string $class
48			* @param string $relation
49			* @param array $schema
50			* @param \Spiral\ORM\ORMInterface $orm
51			*/
52			public function __construct($class, $relation, array $schema, ORMInterface $orm)
53			{
54			parent::__construct($class, $relation, $schema, $orm);
55
56			if (!empty($schema[RecordEntity::ORDER_BY])) {
57			//Default sorting direction
58			$this->options['orderBy'] = $schema[RecordEntity::ORDER_BY];
59			}
60			}
61
62			/**
63			* {@inheritdoc}
64			*/
65			protected function configureQuery(SelectQuery $query, bool $loadColumns = true, array $outerKeys = []): SelectQuery
66			{
67			if (!empty($this->options['using'])) {
68			//Use pre-defined query
69			return parent::configureQuery($query, $loadColumns, $outerKeys);
70			}
71
72			if ($this->isJoined()) {
73			$query->join(
74			$this->getMethod() == self::JOIN ? 'INNER' : 'LEFT',
75			"{$this->getTable()} AS {$this->getAlias()}")
76			->on(
77			$this->localKey(Record::OUTER_KEY),
78			$this->parentKey(Record::INNER_KEY)
79			);
80			} else {
81			//This relation is loaded using external query
82			$query->where(
83			$this->localKey(Record::OUTER_KEY),
84			'IN',
85			new Parameter($outerKeys)
86			);
87
88			$this->configureWindow($query, $this->options['orderBy'], $this->options['limit']);
89			}
90
91			//When relation is joined we will use ON statements, when not - normal WHERE
92			$whereTarget = $this->isJoined() ? 'onWhere' : 'where';
93
94			//Where conditions specified in relation definition
95			$this->setWhere($query, $this->getAlias(), $whereTarget, $this->schema[Record::WHERE]);
96
97			//User specified WHERE conditions
98			$this->setWhere($query, $this->getAlias(), $whereTarget, $this->options['where']);
99
100			//Morphed records
101			if (!empty($this->schema[Record::MORPH_KEY])) {
102			$this->setWhere(
103			$query,
104			$this->getAlias(),
105			$whereTarget,
106			[
107			$this->localKey(Record::MORPH_KEY) => $this->orm->define(
108			$this->parent->getClass(),
109			ORMInterface::R_ROLE_NAME
110			)
111			]
112			);
113			}
114
115			return parent::configureQuery($query, $loadColumns);
116			}
117
118			/**
119			* {@inheritdoc}
120			*/
121			protected function initNode(): AbstractNode
122			{
123			$node = new ArrayNode(
124			$this->schema[Record::RELATION_COLUMNS],
125			$this->schema[Record::OUTER_KEY],
126			$this->schema[Record::INNER_KEY],
127			$this->schema[Record::SH_PRIMARY_KEY]
128			);
129
130			return $node->asJoined($this->isJoined());
131			}
132			}

spiral / orm

HasManyLoader::configureQuery() B last analyzed 2018-08-29 15:23 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like

HasManyLoader::configureQuery() B
last analyzed 2018-08-29 15:23 UTC