KeyWalkStrategy::next() - Code Metrics - Inspection of "[FRAM-86] Walker: reset cursor clause on key walk..." - b2pweb/bdf-prime - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — 2.0 (#62)

by Vincent

created 2023-01-30 13:03 UTC

KeyWalkStrategy::next() C

↳ Parent: KeyWalkStrategy

Complexity

Conditions	12
Paths	68

Size

Total Lines	45
Code Lines	25

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	23
CRAP Score	12.0104

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	25
c	1
b	0
f	0
dl	0
loc	45
ccs	23
cts	24
cp	0.9583
rs	6.9666
cc	12
nc	68
nop	1
crap	12.0104

How to fix Complexity

<?php

namespace Bdf\Prime\Query\Pagination\WalkStrategy;

use Bdf\Prime\Collection\CollectionInterface;
use Bdf\Prime\Connection\ConnectionInterface;
use Bdf\Prime\Query\Clause;
use Bdf\Prime\Query\CompilableClause;
use Bdf\Prime\Query\Contract\Limitable;
use Bdf\Prime\Query\Contract\Orderable;
use Bdf\Prime\Query\Contract\ReadOperation;
use Bdf\Prime\Query\Contract\Whereable;
use Bdf\Prime\Query\ReadCommandInterface;
use InvalidArgumentException;

/**
 * Walk strategy using a primary key (or any unique key) as cursor
 * This strategy supports deleting entities during the walk, but the entity must contains a single primary key, and the query must be ordered by this key
 * Any sort on other attribute are not supported
 *
 * @template E as object
 * @implements WalkStrategyInterface<E>
 */
final class KeyWalkStrategy implements WalkStrategyInterface
{
    /**
     * @var KeyInterface<E>
     */
    private $key;

    /**
     * PrimaryKeyWalkStrategy constructor.
     *
     * @param KeyInterface<E> $key
     */
    public function __construct(KeyInterface $key)
    {
        $this->key = $key;
    }

    /**
     * {@inheritdoc}
     */
    public function initialize(ReadCommandInterface $query, int $chunkSize, int $startPage): WalkCursor
    {
        if (!self::supports($query, $startPage, $this->key->name())) {
            throw new InvalidArgumentException('KeyWalkStrategy is not supported by this query');
        }

        /** @var Limitable&Orderable&ReadCommandInterface<ConnectionInterface, E> $query */
        $query = clone $query;

        if (!isset($query->getOrders()[$this->key->name()])) {
            $query->order($this->key->name(), Orderable::ORDER_ASC);
        }

        $query->limit($chunkSize);

        /** @var WalkCursor<E> */
        return new WalkCursor($query);
    }

    /**
     * {@inheritdoc}
     */
    #[ReadOperation]
    public function next(WalkCursor $cursor): WalkCursor
    {
        $cursor = clone $cursor;

        if ($cursor->entities) {
            $cursor->cursor = $this->getLastKeyOfEntities($cursor);
        }

        if ($cursor->cursor !== null) {
            /** @var ReadCommandInterface<ConnectionInterface, E>&Orderable&Whereable $query */
            $query = $cursor->query;
            $column = $this->key->name();
            $operator = $query->getOrders()[$column] === Orderable::ORDER_ASC ? '>' : '<';
            $operator = $query->/** @scrutinizer ignore-call */ getOrders()[$column] === Orderable::ORDER_ASC ? '>' : '<';

            // Quick fix for FRAM-86 : reset where clause
            $set = false;

            if ($query instanceof CompilableClause && !empty($query->statements['where'])) {
                foreach ($query->statements['where'] as $key => $statement) {
                    if (
                        isset($statement['column'], $statement['operator'], $statement['value'])
                        && $statement['column'] === $column
                        && $statement['operator'] === $operator
                    ) {
                        $query->statements['where'][$key]['value'] = $cursor->cursor;
                        $set = true;
                        $query->state()->invalidate('where');
                        break;
                    }
                }
            }

            if (!$set) {
                $query->where($column, $operator, $cursor->cursor);
                        where($column, $operator, $cursor->cursor);
            }
        }

        $cursor->entities = $cursor->query->all();


        if ($cursor->entities instanceof CollectionInterface) {
            $cursor->entities = $cursor->entities->all();
        }

        return $cursor;
    }

    /**
     * Check if the strategy supports the given parameters
     *
     * @param ReadCommandInterface $query The query
     * @param int|null $startPage The start page
     * @param string $key The cursor key
     *
     * @return bool
     *
     * @psalm-assert-if-true Orderable&Limitable&Whereable $query
     */
    public static function supports(ReadCommandInterface $query, ?int $startPage, string $key): bool
    {
        if ($startPage !== null && $startPage !== 1) {
            return false;
        }

        if (!($query instanceof Orderable && $query instanceof Limitable && $query instanceof Whereable)) {
            return false;
        }

        $orders = $query->getOrders();

        return empty($orders) || (count($orders) === 1 && isset($orders[$key]));
    }

    /**
     * Find the last key to be set as cursor value
     *
     * @param WalkCursor $cursor
     * @return mixed
     *
     * @see WalkCursor::$cursor
     */
    private function getLastKeyOfEntities(WalkCursor $cursor)
    {
        $lastEntity = end($cursor->entities);
        $lastEntity = end(/** @scrutinizer ignore-type */ $cursor->entities);

        // Basic select query : results are an ordered list, so the last key is always the key of the last entity
        if (array_is_list($cursor->entities)) {
            return $this->key->get($lastEntity);
        }

        // group by query
        // Because index can be overridden (or value are added), order is not guaranteed
        // So we should iterate other entities to find the "max" key
        // In case of "by combine", values of each key are ordered list, so we simply need to take the last entity's key of each index
        $lastKey = $this->key->get(is_array($lastEntity) ? end($lastEntity) : $lastEntity);

        /** @var ReadCommandInterface<ConnectionInterface, E>&Orderable&Whereable $query */
        $query = $cursor->query;
        $asc = $query->getOrders()[$this->key->name()] === Orderable::ORDER_ASC;

        foreach ($cursor->entities as $entity) {
            $key = $this->key->get(is_array($entity) ? end($entity) : $entity);
            $gt = $key > $lastKey;

            // order is ascendant and key is > lastKey
            // or order is descendant and key is < lastKey
            if ($asc === $gt) {
                $lastKey = $key;
            }
        }

        return $lastKey;
    }
}


b2pweb / bdf-prime

Pull Request — 2.0 (#62)

KeyWalkStrategy::next() C

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like