ResultIterator::createEmpyIterator() - Code Metrics - Inspection of "create empty resultIterator" - thecodingmachine/tdbm - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#170)

by ARP
created 2019-08-30 08:57 UTC
ResultIterator::createEmpyIterator() A

↳ Parent: ResultIterator
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
eloc	1
c	0
b	0
f	0
dl	0
loc	3
rs	10
cc	1
nc	1
nop	0
<?php
declare(strict_types=1);

namespace TheCodingMachine\TDBM;

use function array_map;
use Doctrine\DBAL\Connection;
use Doctrine\DBAL\Statement;
use function is_array;
use function is_int;
use Mouf\Database\MagicQuery;
use TheCodingMachine\TDBM\QueryFactory\QueryFactory;
use Porpaginas\Result;
use Psr\Log\LoggerInterface;
use TheCodingMachine\TDBM\Utils\DbalUtils;
use Traversable;

/*
 Copyright (C) 2006-2017 David Négrier - THE CODING MACHINE

 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/**
 * Iterator used to retrieve results.
 */
class ResultIterator implements Result, \ArrayAccess, \JsonSerializable
{
    /**
     * @var Statement
     */
    protected $statement;

    private $objectStorage;
    private $className;

    private $tdbmService;
    private $parameters;
    private $magicQuery;

    /**
     * @var QueryFactory
     */
    private $queryFactory;

    /**
     * @var InnerResultIterator|null
     */
    private $innerResultIterator;

    private $totalCount;

    private $mode;

    private $logger;

    /**
     * @param mixed[] $parameters
     */
    public function __construct(?QueryFactory $queryFactory, ?array $parameters, ?ObjectStorageInterface $objectStorage, ?string $className, ?TDBMService $tdbmService, ?MagicQuery $magicQuery, int $mode, ?LoggerInterface $logger)
    {
        if ($mode !== TDBMService::MODE_CURSOR && $mode !== TDBMService::MODE_ARRAY) {
            throw new TDBMException("Unknown fetch mode: '".$mode."'");
        }

        if (!$queryFactory) {
            $this->totalCount = 0;
        } else {
            $this->queryFactory = $queryFactory;
            $this->objectStorage = $objectStorage;
            $this->className = $className;
            $this->tdbmService = $tdbmService;
            $this->parameters = $parameters;
            $this->magicQuery = $magicQuery;
            $this->mode = $mode;
            $this->logger = $logger;
        }
    }

    public static function createEmpyIterator(): self
    {
        return new self(null, null, null, null, null, null, TDBMService::MODE_ARRAY, null);
    }

    protected function executeCountQuery(): void
    {
        $sql = $this->magicQuery->buildPreparedStatement($this->queryFactory->getMagicSqlCount(), $this->parameters);
        $this->logger->debug('Running count query: '.$sql);
        $this->totalCount = (int) $this->tdbmService->getConnection()->fetchColumn($sql, $this->parameters, 0, DbalUtils::generateArrayTypes($this->parameters));
    }

    /**
     * Counts found records (this is the number of records fetched, taking into account the LIMIT and OFFSET settings).
     *
     * @return int
     */
    public function count(): int
    {
        if ($this->totalCount === null) {
            $this->executeCountQuery();
        }

        return $this->totalCount;
    }

    /**
     * Casts the result set to a PHP array.
     *
     * @return AbstractTDBMObject[]
     */
    public function toArray(): array
    {
        if ($this->totalCount === 0) {
            return [];
        }
        return iterator_to_array($this->getIterator());
    }

    /**
     * Returns a new iterator mapping any call using the $callable function.
     *
     * @param callable $callable
     *
     * @return MapIterator
     */
    public function map(callable $callable): MapIterator
    {
        if ($this->totalCount === 0) {
            return new MapIterator([], null);
        }
        return new MapIterator($this->getIterator(), $callable);
    }

    /**
     * Retrieve an external iterator.
     *
     * @link http://php.net/manual/en/iteratoraggregate.getiterator.php
     *
     * @return InnerResultIterator An instance of an object implementing <b>Iterator</b> or
     *                             <b>Traversable</b>
     *
     * @since 5.0.0
     */
    public function getIterator()
    {
        if ($this->innerResultIterator === null) {
            if ($this->totalCount === 0) {
                $this->innerResultIterator = new InnerResultArray(null, null, null, null, null, null, null, null, null, null);
            } elseif ($this->mode === TDBMService::MODE_CURSOR) {
                $this->innerResultIterator = new InnerResultIterator($this->queryFactory->getMagicSql(), $this->parameters, null, null, $this->queryFactory->getColumnDescriptors(), $this->objectStorage, $this->className, $this->tdbmService, $this->magicQuery, $this->logger);
            } else {
                $this->innerResultIterator = new InnerResultArray($this->queryFactory->getMagicSql(), $this->parameters, null, null, $this->queryFactory->getColumnDescriptors(), $this->objectStorage, $this->className, $this->tdbmService, $this->magicQuery, $this->logger);
            }
        }

        return $this->innerResultIterator;
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
    }

    /**
     * @param int $offset
     * @param int $limit
     *
     * @return PageIterator
     */
    public function take($offset, $limit)
    {
        if ($this->totalCount === 0) {
            return new PageIterator($this, null, [], null, null, null, null, null, null, null, null, null);
        }
        return new PageIterator($this, $this->queryFactory->getMagicSql(), $this->parameters, $limit, $offset, $this->queryFactory->getColumnDescriptors(), $this->objectStorage, $this->className, $this->tdbmService, $this->magicQuery, $this->mode, $this->logger);
    }

    /**
     * Whether a offset exists.
     *
     * @link http://php.net/manual/en/arrayaccess.offsetexists.php
     *
     * @param mixed $offset <p>
     *                      An offset to check for.
     *                      </p>
     *
     * @return bool true on success or false on failure.
     *              </p>
     *              <p>
     *              The return value will be casted to boolean if non-boolean was returned
     *
     * @since 5.0.0
     */
    public function offsetExists($offset)
    {
        return $this->getIterator()->offsetExists($offset);
    }

    /**
     * Offset to retrieve.
     *
     * @link http://php.net/manual/en/arrayaccess.offsetget.php
     *
     * @param mixed $offset <p>
     *                      The offset to retrieve.
     *                      </p>
     *
     * @return mixed Can return all value types
     *
     * @since 5.0.0
     */
    public function offsetGet($offset)
    {
        return $this->getIterator()->offsetGet($offset);
    }

    /**
     * Offset to set.
     *
     * @link http://php.net/manual/en/arrayaccess.offsetset.php
     *
     * @param mixed $offset <p>
     *                      The offset to assign the value to.
     *                      </p>
     * @param mixed $value  <p>
     *                      The value to set.
     *                      </p>
     *
     * @since 5.0.0
     */
    public function offsetSet($offset, $value)
    {
        return $this->getIterator()->offsetSet($offset, $value);
    }

    /**
     * Offset to unset.
     *
     * @link http://php.net/manual/en/arrayaccess.offsetunset.php
     *
     * @param mixed $offset <p>
     *                      The offset to unset.
     *                      </p>
     *
     * @since 5.0.0
     */
    public function offsetUnset($offset)
    {
        return $this->getIterator()->offsetUnset($offset);
    }

    /**
     * Specify data which should be serialized to JSON.
     *
     * @link http://php.net/manual/en/jsonserializable.jsonserialize.php
     *
     * @param bool $stopRecursion Parameter used internally by TDBM to
     *                            stop embedded objects from embedding
     *                            other objects
     *
     * @return mixed data which can be serialized by <b>json_encode</b>,
     *               which is a value of any type other than a resource
     *
     * @since 5.4.0
     */
    public function jsonSerialize($stopRecursion = false)
    {
        if ($this->totalCount === 0) {
            return [];
        }
        return array_map(function (AbstractTDBMObject $item) use ($stopRecursion) {
            return $item->jsonSerialize($stopRecursion);
            return $item->/** @scrutinizer ignore-call */ jsonSerialize($stopRecursion);
        }, $this->toArray());
    }

    /**
     * Returns only one value (the first) of the result set.
     * Returns null if no value exists.
     *
     * @return mixed|null
     */
    public function first()
    {
        if ($this->totalCount === 0) {
            return null;
        }
        $page = $this->take(0, 1);
        foreach ($page as $bean) {
            return $bean;
        }

        return null;
    }

    /**
     * Sets the ORDER BY directive executed in SQL and returns a NEW ResultIterator.
     *
     * For instance:
     *
     *  $resultSet = $resultSet->withOrder('label ASC, status DESC');
     *
     * **Important:** TDBM does its best to protect you from SQL injection. In particular, it will only allow column names in the "ORDER BY" clause. This means you are safe to pass input from the user directly in the ORDER BY parameter.
     * If you want to pass an expression to the ORDER BY clause, you will need to tell TDBM to stop checking for SQL injections. You do this by passing a `UncheckedOrderBy` object as a parameter:
     *
     *  $resultSet->withOrder(new UncheckedOrderBy('RAND()'))
     *
     * @param string|UncheckedOrderBy|null $orderBy
     *
     * @return ResultIterator
     */
    public function withOrder($orderBy) : ResultIterator
    {
        $clone = clone $this;
        if ($this->totalCount === 0) {
            return $clone;
        }
        $clone->queryFactory = clone $this->queryFactory;
        $clone->queryFactory->sort($orderBy);
        $clone->innerResultIterator = null;

        return $clone;
    }

    /**
     * Sets new parameters for the SQL query and returns a NEW ResultIterator.
     *
     * For instance:
     *
     *  $resultSet = $resultSet->withParameters([ 'status' => 'on' ]);
     *
     * @param mixed[] $parameters
     *
     * @return ResultIterator
     */
    public function withParameters(array $parameters) : ResultIterator
    {
        $clone = clone $this;
        if ($this->totalCount === 0) {
            return $clone;
        }
        $clone->parameters = $parameters;
        $clone->innerResultIterator = null;
        $clone->totalCount = null;

        return $clone;
    }
}

thecodingmachine / tdbm

Pull Request — master (#170)

ResultIterator::createEmpyIterator() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
