Spiral\ORM\Entities\Loaders\RootLoader

Complexity

Total Complexity

13

Size/Duplication

Total Lines	166
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	15	1
A	withColumns()	0	10	1
A	initialQuery()	0	4	1
A	compiledQuery()	0	4	1
A	primaryKey()	0	4	1
A	getAlias()	0	4	1
A	configureQuery()	0	10	1
A	loadData()	0	18	3
A	initNode()	0	7	1
A	__clone()	0	5	1
A	getColumns()	0	4	1

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

namespace Spiral\ORM\Entities\Loaders;

use Spiral\Database\Builders\SelectQuery;
use Spiral\ORM\Entities\Loaders\Traits\ColumnsTrait;
use Spiral\ORM\Entities\Nodes\AbstractNode;
use Spiral\ORM\Entities\Nodes\RootNode;
use Spiral\ORM\ORMInterface;
use Spiral\ORM\Record;

/**
 * Primary ORM loader. Loader wraps at top of select query in order to modify it's conditions, joins
 * and etc based on nested loaders.
 *
 * Note, in RootLoader schema represent record schema since there is no self to self relation.
 */
class RootLoader extends AbstractLoader
{
    use ColumnsTrait;

    /**
     * Root loader always define primary SelectQuery.
     *
     * @var SelectQuery
     */
    private $query;

    /**
     * Only columns to be selected, by default all columns.
     *
     * @var null|array
     */
    private $columns = null;

    /**
     * @param string       $class
     * @param array        $schema Record schema for root loader.
     * @param ORMInterface $orm
     */
    public function __construct(string $class, array $schema, ORMInterface $orm)
    {
        //Constructing with truncated schema
        parent::__construct(
            $class,
            [
                Record::SH_PRIMARY_KEY   => $schema[Record::SH_PRIMARY_KEY],
                Record::RELATION_COLUMNS => array_keys($schema[Record::SH_DEFAULTS])
            ],
            $orm
        );

        //Getting our initial select query
        $this->query = $orm->table($class)->select();
    }

    /**
     * Columns to be selected, please note, primary will always be included, DO not include
     * column aliases in here, aliases will be added automatically. Creates new loader tree copy.
     *
     * @param array $columns
     *
     * @return RootLoader
     */
    public function withColumns(array $columns): self
    {
        $loader = clone $this;
        $loader->columns = array_merge(
            [$loader->schema[Record::SH_PRIMARY_KEY]],
            $columns
        );

        return $loader;
    }

    /**
     * Return initial loader query (attention, mutable instance).
     *
     * @return SelectQuery
     */
    public function initialQuery(): SelectQuery
    {
        return $this->query;
    }

    /**
     * Return build version of query.
     *
     * @return SelectQuery
     */
    public function compiledQuery(): SelectQuery
    {
        return $this->configureQuery(clone $this->query);
    }

    /**
     * Get primary key column if possible (aliased). Null when key is missing or non singular.
     *
     * @return string|null
     */
    public function primaryKey(): string
    {
        return $this->getAlias() . '.' . $this->schema[Record::SH_PRIMARY_KEY];
    }

    /**
     * We are using model role as alias. Visibility up.
     *
     * @return string
     */
    public function getAlias(): string
    {
        return $this->orm->define($this->class, ORMInterface::R_ROLE_NAME);
    }

    /**
     * @param SelectQuery $query
     *
     * @return SelectQuery
     */
    protected function configureQuery(SelectQuery $query): SelectQuery
    {
        //Clarifying table name
        $query->from("{$this->getTable()} AS {$this->getAlias()}");

        //Columns to be loaded for primary model
        $this->mountColumns($query, true, '', true);

        return parent::configureQuery($query);
    }

    /**
     * {@inheritdoc}
     */
    public function loadData(AbstractNode $node)
    {
        //Fetching results from database
        $statement = $this->configureQuery(clone $this->query)->run();
        $statement->setFetchMode(\PDO::FETCH_NUM);

        foreach ($statement as $row) {
            $node->parseRow(0, $row);
        }

        //Destroying statement
        $statement->close();

        //Executing child loaders
        foreach ($this->loaders as $relation => $loader) {
            $loader->loadData($node->fetchNode($relation));
        }
    }

    /**
     * {@inheritdoc}
     */
    public function initNode(): AbstractNode
    {
        return new RootNode(
            $this->getColumns(),
            $this->schema[Record::SH_PRIMARY_KEY]
        );
    }

    /**
     * Clone with initial query.
     */
    public function __clone()
    {
        $this->query = clone $this->query;
        parent::__clone();
    }

    /**
     * Relation columns.
     *
     * @return array
     */
    protected function getColumns(): array
    {
        return $this->columns ?? $this->schema[Record::RELATION_COLUMNS];
    }
}