mindplay\sql\framework\Result

Complexity

Total Complexity

21

Size/Duplication

Total Lines	164
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

92%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	firstRow()	0	8	2
A	firstCol()	0	10	2
B	all()	0	23	4
A	getIterator()	0	4	1
C	createIterator()	0	52	11

<?php

namespace mindplay\sql\framework;

use Iterator;
use IteratorAggregate;
use RuntimeException;

/**
 * This class represents the result of fetching a `PreparedStatement`, e.g. the results of
 * a `SELECT` SQL query, and with Mappers being applied on-the-fly, in batches.
 *
 * It implements `IteratorAggregate`, allowing you to execute the query and iterate
 * over the result set with a `foreach` statement.
 */
class Result implements IteratorAggregate
{
    /**
     * @var PreparedStatement
     */
    private $statement;

    /**
     * @var int
     */
    private $batch_size;

    /**
     * @var Mapper[] list of Mappers to apply when fetching results
     */
    private $mappers;

    /**
     * @var Indexer|null
     */
    private $indexer = null;

    /**
     * @param PreparedStatement $statement  prepared statement
     * @param int               $batch_size batch-size (when fetching large result sets)
     * @param Mapper[]          $mappers    list of Mappers to apply while fetching results
     * @param Indexer|null      $indexer    optional Indexer (used to customize Generator keys)
     */
    public function __construct(PreparedStatement $statement, $batch_size, array $mappers, Indexer $indexer = null)
    {
        $this->statement = $statement;
        $this->batch_size = $batch_size;
        $this->mappers = $mappers;
        $this->indexer = $indexer;
    }

    /**
     * @return mixed|null first record of the record-set (or NULL, if the record-set is empty)
     */
    public function firstRow()
    {
        foreach ($this->createIterator(1) as $record) {
            return $record; // break from loop immediately after fetching the first record
        }

        return null;
    }

    /**
     * @return mixed|null first column value of the first record of the record-set (or NULL, if the record-set is empty)
     */
    public function firstCol()
    {
        foreach ($this->createIterator(1) as $record) {
            $keys = array_keys($record);

            return $record[$keys[0]]; // break from loop immediately after fetching the first record
        }

        return null;
    }

    /**
     * @return array all the records of the record-set
     *
     * @throws RuntimeException if the result-set contains overlapping keys (generated by an Indexer)
     */
    public function all()
    {
        if ($this->indexer === null) {
            return iterator_to_array($this->getIterator()); // performance optimization: no index-check required
        }

        // NOTE: an Indexer can generate duplicate keys, for example if a foreign key
        //       is used in a query that returns multiple records with the same key.
        //
        //       validate the result and throw an exception if we find a duplicate:

        $result = [];

        foreach ($this->getIterator() as $key => $record) {
            if (isset($result[$key])) {
                throw new RuntimeException("duplicate key: {$key}");
            }

            $result[$key] = $record;
        }

        return $result;
    }
    
    /**
     * Execute this Statement and return a Generator, so you can iterate over the results.
     *
     * This method implements `IteratorAggregate`, permitting you to iterate directly over
     * the resulting records (or objects) without explicitly having to call this method.
     *
     * @return Iterator
     */
    public function getIterator()
    {
        return $this->createIterator($this->batch_size);
    }

    /**
     * Create an Iterator with a given batch-size.
     *
     * @param int $batch_size batch-size when processing the result set
     *
     * @return Iterator
     */
    private function createIterator($batch_size)
    {
        $fetching = true;

        do {
            // fetch a batch of records:

            $batch = [];

            do {
                $record = $this->statement->fetch();

                if ($record) {

The expression $record of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

                    $batch[] = $record;
                } else {
                    if (count($batch) === 0) {
                        return; // last batch of records fetched
                    }

                    $fetching = false; // last record of batch fetched
                }
            } while ($fetching && (count($batch) < $batch_size));

            // apply Mappers to current batch of records:

            $num_records = count($batch);

            foreach ($this->mappers as $index => $mapper) {
                $batch = $mapper->map($batch);

                if (count($batch) !== $num_records) {
                    $count = count($batch);

                    throw new RuntimeException("Mapper #{$index} returned {$count} records, expected: {$num_records}");
                }
            }

            // return each record from the current batch:

            if ($this->indexer) {
                foreach ($batch as $record) {
                    $index = $this->indexer->index($record);

                    yield $index => $record;
                }
            } else {
                foreach ($batch as $record) {
                    yield $record;
                }
            }
        } while ($fetching);
    }
}