Result::mixed() - Code Metrics - Inspection of "Rename "local" to "primary" in Relation-related fi..." - rougin/windstorm - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 9f58b4...83392d )

by Rougin

created 2019-01-10 03:35 UTC

Result::mixed() A

↳ Parent: Result

Complexity

Conditions	2
Paths	2

Size

Total Lines	20
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	11
CRAP Score	2

Importance

Changes

Metric	Value
cc	2
eloc	9
nc	2
nop	1
dl	0
loc	20
ccs	11
cts	11
cp	1
crap	2
rs	9.9666
c	0
b	0
f	0

<?php

namespace Rougin\Windstorm\Doctrine;

use Doctrine\DBAL\Connection;
use Rougin\Windstorm\MixedInterface;
use Rougin\Windstorm\QueryInterface;
use Rougin\Windstorm\ResultInterface;

/**
 * Result
 *
 * @package Windstorm
 * @author  Rougin Gutib <[email protected]>
 */
class Result implements ResultInterface
{
    /**
     * @var integer
     */
    protected $affected = 0;

    /**
     * @var \Rougin\Windstorm\MixedInterface|null
     */
    protected $mixed = null;

    /**
     * @var \Doctrine\DBAL\Connection
     */
    protected $connection;

    /**
     * @var integer
     */
    protected $fetch = \PDO::FETCH_ASSOC;

    /**
     * @var \Doctrine\DBAL\Driver\Statement
     */
    protected $result;

    /**
     * Initializes the result instance.
     *
     * @param \Doctrine\DBAL\Connection $connection
     */
    public function __construct(Connection $connection)
    {
        $this->connection = $connection;
    }

    /**
     * Returns a number of affected rows.
     *
     * @return integer
     */
    public function affected()
    {
        return $this->affected;
    }

    /**
     * Returns a result from a query instance.
     *
     * @param  \Rougin\Windstorm\QueryInterface $query
     * @return self
     */
    public function execute(QueryInterface $query)
    {
        if ($query->type() !== QueryInterface::TYPE_SELECT)
        {
            $this->affected = $this->response($query);


            return $this;
        }

        $this->result = $this->response($query);

        if ($query instanceof MixedInterface)
        {
            $this->mixed = $query;
        }

        return $this;
    }

    /**
     * Returns the first row from result.
     *
     * @return mixed
     */
    public function first()
    {
        $result = $this->result->fetch($this->fetch);

        if ($this->mixed)
        {
            $items = array($result);

            $items = $this->mixed($items);

            return current($items);
        }

        return $result;
    }

    /**
     * Returns all items from the result.
     *
     * @return mixed
     */
    public function items()
    {
        $items = $this->result->fetchAll($this->fetch);

        if ($this->mixed)
        {
            return $this->mixed($items);
        }

        return $items;
    }

    /**
     * Appends children output to original result.
     *
     * @param  array  $items
     * @param  array  $result
     * @param  string $primary
     * @param  string $foreign
     * @param  string $field
     * @return array
     */
    protected function append($items, $result, $primary, $foreign, $field)
    {
        foreach ($items as $key => $item)
        {
            $items[$key][$field] = array();

            foreach ($result as $child)
            {
                if ($child[$foreign] === $item[$primary])
                {
                    $items[$key][$field][] = $child;
                }
            }
        }

        return $items;
    }

    /**
     * Appends result from mixed query to main result.
     *
     * @param  array $items
     * @return array
     */
    protected function mixed($items)
    {
        foreach ($this->mixed->children() as $child)
        foreach ($this->mixed->/** @scrutinizer ignore-call */ children() as $child)
        {
            $foreign = $child->foreign();

            $field = $child->field();

            $primary = $child->primary();

            $ids = $this->identities($items, $primary);
            $ids = $this->identities(/** @scrutinizer ignore-type */ $items, $primary);

            $stmt = $this->response($child->query()->where($foreign)->in($ids));

            $result = $stmt->fetchAll($this->fetch);

            $items = $this->append($items, $result, $primary, $foreign, $field);
        }

        return $items;
    }

    /**
     * Returns the values based of specified key.
     *
     * @param  string $items
     * @param  string $key
     * @return array
     */
    protected function identities($items, $key)
    {
        $ids = array();

        foreach ($items as $item)

        {
            $ids[] = $item[$key];
        }

        return $ids;
    }

    /**
     * Executes the query from the connection instance.
     *
     * @param  \Rougin\Windstorm\QueryInterface $query
     * @return \Doctrine\DBAL\Driver\Statement|null
     */
    protected function response(QueryInterface $query)
    {
        $bindings = $query->bindings();

        $sql = (string) $query->sql();

        if ($query->type() === QueryInterface::TYPE_SELECT)
        {
            return $this->connection->executeQuery($sql, $bindings);
        }

        return $this->connection->executeUpdate($sql, $bindings);
    }
}


rougin / windstorm

Push — master ( 9f58b4...83392d )

Result::mixed() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like