Ray\AuraSqlModule\Pagerfanta\ExtendedPdoAdapter

Complexity

Total Complexity

22

Size/Duplication

Total Lines	123
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
B	getNbResults()	0	23	6
A	getSlice()	0	7	2
B	getLimitClause()	0	18	7
B	rewriteCountQuery()	0	26	6

<?php
/**
 * This file is part of the Ray.AuraSqlModule package.
 *
 * @license http://opensource.org/licenses/MIT MIT
 */
namespace Ray\AuraSqlModule\Pagerfanta;

use Aura\Sql\ExtendedPdo;
use Aura\Sql\ExtendedPdoInterface;
use Pagerfanta\Adapter\AdapterInterface;

class ExtendedPdoAdapter implements AdapterInterface
{
    /**
     * @var ExtendedPdoInterface
     */
    private $pdo;

    /**
     * @var string
     */
    private $sql;

    /**
     * @var array
     */
    private $params;

    public function __construct(ExtendedPdoInterface $pdo, string $sql, array $params)
    {
        $this->pdo = $pdo;
        $this->sql = $sql;
        $this->params = $params;
    }

    /**
     * {@inheritdoc}
     */
    public function getNbResults()
    {
        // be smart and try to guess the total number of records
        $countQuery = $this->rewriteCountQuery($this->sql);
        if (! $countQuery) {
            // GROUP BY => fetch the whole result set and count the rows returned
            $result = $this->pdo->query($this->sql)->fetchAll();

            return ! $result ? 0 : \count($result);
        }
        if ($this->params) {

The expression $this->params 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.

            /** @var ExtendedPdo $pdo */
            $pdo = $this->pdo;
            $sth = $pdo->prepareWithValues($this->sql, $this->params);
            $sth->execute();
            $result = $sth->fetchAll();

            return ! $result ? 0 : \count($result);
        }
        $count = $this->pdo->query($countQuery)->fetchColumn();

        return ! $count ? 0 : (int) $count;
    }

    /**
     * {@inheritdoc}
     */
    public function getSlice($offset, $length)
    {
        $sql = $this->sql . $this->getLimitClause($offset, $length);
        $result = $this->pdo->perform($sql, $this->params)->fetchAll(\PDO::FETCH_ASSOC);

        return ! $result ? [] : $result;
    }

    /**
     * {@inheritdoc}
     */
    public function getLimitClause($offset, $length)
    {
        $hasLimit = $offset || $length;
        if ($offset && $length) {
            $clause = PHP_EOL . "LIMIT {$length}";
            if ($offset) {
                $clause .= " OFFSET {$offset}";
            }

            return $clause;
        }

        if ($hasLimit && $length) {
            return PHP_EOL . "LIMIT {$length}";
        }

        return '';
    }

    /**
     * Return count query
     *
     * @param string $query
     *
     * @return string
     *
     * @see https://github.com/pear/Pager/blob/master/examples/Pager_Wrapper.php
     * Taken from pear/pager and modified.
     * tested at https://github.com/pear/Pager/blob/80c0e31c8b94f913cfbdeccbe83b63822f42a2f8/tests/pager_wrapper_test.php#L19
     * @codeCoverageIgnore
     */
    public function rewriteCountQuery($query)
    {
        if (\is_int(\strpos(\strtolower($query), 'union'))) {
            return '';
        }
        if (\preg_match('/^\s*SELECT\s+\bDISTINCT\b/is', $query) || \preg_match('/\s+GROUP\s+BY\s+/is', $query)) {
            return '';
        }
        $openParenthesis = '(?:\()';
        $closeParenthesis = '(?:\))';
        $subQueryInSelect = $openParenthesis . '.*\bFROM\b.*' . $closeParenthesis;
        $pattern = '/(?:.*' . $subQueryInSelect . '.*)\bFROM\b\s+/Uims';
        if (\preg_match($pattern, $query)) {
            return '';
        }
        $subQueryWithLimitOrder = $openParenthesis . '.*\b(LIMIT|ORDER)\b.*' . $closeParenthesis;
        $pattern = '/.*\bFROM\b.*(?:.*' . $subQueryWithLimitOrder . '.*).*/Uims';
        if (\preg_match($pattern, $query)) {
            return '';
        }
        $queryCount = \preg_replace('/(?:.*)\bFROM\b\s+/Uims', 'SELECT COUNT(*) FROM ', $query, 1);
        list($queryCount) = \preg_split('/\s+ORDER\s+BY\s+/is', (string) $queryCount);
        list($queryCount) = \preg_split('/\bLIMIT\b/is', (string) $queryCount);

        return \trim((string) $queryCount);
    }
}