Query::execute() - Code Metrics - Inspection of "add fix to support DBAL V3 (#53)" - DamienHarper/auditor - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 25b702...de7f7b )

by Damien

created 2021-10-10 16:49 UTC

Query::execute() A

↳ Parent: Query

Complexity

Conditions	3
Paths	3

Size

Total Lines	16
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	1	Features	1

Metric	Value
eloc	9
c	2
b	1
f	1
dl	0
loc	16
rs	9.9666
cc	3
nc	3
nop	0

<?php

namespace DH\Auditor\Provider\Doctrine\Persistence\Reader;

use DH\Auditor\Exception\InvalidArgumentException;
use DH\Auditor\Model\Entry;
use DH\Auditor\Provider\Doctrine\Persistence\Helper\SchemaHelper;
use DH\Auditor\Provider\Doctrine\Persistence\Reader\Filter\DateRangeFilter;
use DH\Auditor\Provider\Doctrine\Persistence\Reader\Filter\FilterInterface;
use DH\Auditor\Provider\Doctrine\Persistence\Reader\Filter\RangeFilter;
use DH\Auditor\Provider\Doctrine\Persistence\Reader\Filter\SimpleFilter;
use Doctrine\DBAL\Connection;
use Doctrine\DBAL\ForwardCompatibility\DriverStatement;
use Doctrine\DBAL\Query\QueryBuilder;
use Exception;
use PDO;

class Query
{
    public const TYPE = 'type';
    public const CREATED_AT = 'created_at';
    public const TRANSACTION_HASH = 'transaction_hash';
    public const OBJECT_ID = 'object_id';
    public const USER_ID = 'blame_id';
    public const ID = 'id';
    public const DISCRIMINATOR = 'discriminator';

    /**
     * @var array
     */
    private $filters = [];

    /**
     * @var array
     */
    private $orderBy = [];

    /**
     * @var Connection
     */
    private $connection;

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

    /**
     * @var int
     */
    private $offset = 0;

    /**
     * @var int
     */
    private $limit = 0;

    public function __construct(string $table, Connection $connection)
    {
        $this->connection = $connection;
        $this->table = $table;

        foreach ($this->getSupportedFilters() as $filterType) {
            $this->filters[$filterType] = [];
        }
    }

    public function execute(): array
    {
        $queryBuilder = $this->buildQueryBuilder();
        $statement = $queryBuilder->execute();

        if ($statement instanceof \Doctrine\DBAL\Result) {

            $result = [];
            foreach ($statement->fetchAllAssociative() as $row) {
                $result[] = Entry::fromArray($row);
            }
            return $result;
        }

        $statement->setFetchMode(PDO::FETCH_CLASS, Entry::class);

        return $statement->fetchAll();
    }

    public function count(): int
    {
        $queryBuilder = $this->buildQueryBuilder();

        try {
            $result = $queryBuilder
                ->resetQueryPart('select')
                ->resetQueryPart('orderBy')
                ->setMaxResults(null)
                ->setFirstResult(null)
                ->select('COUNT(id)')
                ->execute();

            if ($result instanceof \Doctrine\DBAL\Result) {

                $result = $result->fetchOne();
            }
            else {
                $result = $result->fetchColumn(0);
            }

        } catch (Exception $e) {
            $result = false;
        }

        return false === $result ? 0 : $result;
    }

    public function addFilter(FilterInterface $filter): self
    {
        $this->checkFilter($filter->getName());
        $this->filters[$filter->getName()][] = $filter;

        return $this;
    }

    public function addOrderBy(string $field, string $direction = 'DESC'): self
    {
        $this->checkFilter($field);

        if (!\in_array($direction, ['ASC', 'DESC'], true)) {
            throw new InvalidArgumentException('Invalid sort direction, allowed value: ASC, DESC');
        }

        $this->orderBy[$field] = $direction;

        return $this;
    }

    public function limit(int $limit, int $offset = 0): self
    {
        if (0 > $limit) {
            throw new InvalidArgumentException('Limit cannot be negative.');
        }
        if (0 > $offset) {
            throw new InvalidArgumentException('Offset cannot be negative.');
        }

        $this->limit = $limit;
        $this->offset = $offset;

        return $this;
    }

    public function getSupportedFilters(): array
    {
        return array_keys(SchemaHelper::getAuditTableIndices('fake'));
    }

    public function getFilters(): array
    {
        return $this->filters;
    }

    public function getOrderBy(): array
    {
        return $this->orderBy;
    }

    public function getLimit(): array
    {
        return [$this->limit, $this->offset];
    }

    private function buildQueryBuilder(): QueryBuilder
    {
        $queryBuilder = $this->connection->createQueryBuilder();
        $queryBuilder
            ->select('*')
            ->from($this->table, 'at')
        ;

        // build WHERE clause(s)
        $queryBuilder = $this->buildWhere($queryBuilder);

        // build ORDER BY part
        $queryBuilder = $this->buildOrderBy($queryBuilder);

        // build LIMIT part
        return $this->buildLimit($queryBuilder);
    }

    private function groupFilters(array $filters): array
    {
        $grouped = [];

        foreach ($filters as $filter) {
            $class = \get_class($filter);
            if (!isset($grouped[$class])) {
                $grouped[$class] = [];
            }
            $grouped[$class][] = $filter;
        }

        return $grouped;
    }

    private function mergeSimpleFilters(array $filters): SimpleFilter
    {
        $merged = [];
        $name = null;

        foreach ($filters as $filter) {
            if (null === $name) {
                $name = $filter->getName();
            }

            if (\is_array($filter->getValue())) {
                $merged = array_merge($merged, $filter->getValue());
            } else {
                $merged[] = $filter->getValue();
            }
        }

        return new SimpleFilter($name, $merged);
    }

    private function buildWhere(QueryBuilder $queryBuilder): QueryBuilder
    {
        foreach ($this->filters as $name => $rawFilters) {
            if (0 === \count($rawFilters)) {
                continue;
            }

            // group filters by class
            $grouped = $this->groupFilters($rawFilters);

            foreach ($grouped as $class => $filters) {
                switch ($class) {
                    case SimpleFilter::class:
                        $filters = [$this->mergeSimpleFilters($filters)];

                        break;
                    case RangeFilter::class:
                    case DateRangeFilter::class:
                        break;
                }

                foreach ($filters as $filter) {
                    $data = $filter->getSQL();

                    $queryBuilder->andWhere($data['sql']);

                    foreach ($data['params'] as $name => $value) {

                        if (\is_array($value)) {
                            $queryBuilder->setParameter($name, $value, Connection::PARAM_STR_ARRAY);
                        } else {
                            $queryBuilder->setParameter($name, $value);
                        }
                    }
                }
            }
        }

        return $queryBuilder;
    }

    private function buildOrderBy(QueryBuilder $queryBuilder): QueryBuilder
    {
        foreach ($this->orderBy as $field => $direction) {
            $queryBuilder->addOrderBy($field, $direction);
        }

        return $queryBuilder;
    }

    private function buildLimit(QueryBuilder $queryBuilder): QueryBuilder
    {
        if (0 < $this->limit) {
            $queryBuilder->setMaxResults($this->limit);
        }
        if (0 < $this->offset) {
            $queryBuilder->setFirstResult($this->offset);
        }

        return $queryBuilder;
    }

    private function checkFilter(string $filter): void
    {
        if (!\in_array($filter, $this->getSupportedFilters(), true)) {
            throw new InvalidArgumentException(sprintf('Unsupported "%s" filter, allowed filters: %s.', $filter, implode(', ', $this->getSupportedFilters())));
        }
    }
}


1			<?php
2
3			namespace DH\Auditor\Provider\Doctrine\Persistence\Reader;
4
5			use DH\Auditor\Exception\InvalidArgumentException;
6			use DH\Auditor\Model\Entry;
7			use DH\Auditor\Provider\Doctrine\Persistence\Helper\SchemaHelper;
8			use DH\Auditor\Provider\Doctrine\Persistence\Reader\Filter\DateRangeFilter;
9			use DH\Auditor\Provider\Doctrine\Persistence\Reader\Filter\FilterInterface;
10			use DH\Auditor\Provider\Doctrine\Persistence\Reader\Filter\RangeFilter;
11			use DH\Auditor\Provider\Doctrine\Persistence\Reader\Filter\SimpleFilter;
12			use Doctrine\DBAL\Connection;
13			use Doctrine\DBAL\ForwardCompatibility\DriverStatement;
14			use Doctrine\DBAL\Query\QueryBuilder;
15			use Exception;
16			use PDO;
17
18			class Query
19			{
20			public const TYPE = 'type';
21			public const CREATED_AT = 'created_at';
22			public const TRANSACTION_HASH = 'transaction_hash';
23			public const OBJECT_ID = 'object_id';
24			public const USER_ID = 'blame_id';
25			public const ID = 'id';
26			public const DISCRIMINATOR = 'discriminator';
27
28			/**
29			* @var array
30			*/
31			private $filters = [];
32
33			/**
34			* @var array
35			*/
36			private $orderBy = [];
37
38			/**
39			* @var Connection
40			*/
41			private $connection;
42
43			/**
44			* @var string
45			*/
46			private $table;
47
48			/**
49			* @var int
50			*/
51			private $offset = 0;
52
53			/**
54			* @var int
55			*/
56			private $limit = 0;
57
58			public function __construct(string $table, Connection $connection)
59			{
60			$this->connection = $connection;
61			$this->table = $table;
62
63			foreach ($this->getSupportedFilters() as $filterType) {
64			$this->filters[$filterType] = [];
65			}
66			}
67
68			public function execute(): array
69			{
70			$queryBuilder = $this->buildQueryBuilder();
71			$statement = $queryBuilder->execute();
72
73			if ($statement instanceof \Doctrine\DBAL\Result) {
			0 ignored issues – show introduced 2021-10-08 20:02 UTC by Report Bug Copy Issue Report `$statement` is always a sub-type of `Doctrine\DBAL\Result`. Loading history...
74			$result = [];
75			foreach ($statement->fetchAllAssociative() as $row) {
76			$result[] = Entry::fromArray($row);
77			}
78			return $result;
79			}
80
81			$statement->setFetchMode(PDO::FETCH_CLASS, Entry::class);
82
83			return $statement->fetchAll();
84			}
85
86			public function count(): int
87			{
88			$queryBuilder = $this->buildQueryBuilder();
89
90			try {
91			$result = $queryBuilder
92			->resetQueryPart('select')
93			->resetQueryPart('orderBy')
94			->setMaxResults(null)
95			->setFirstResult(null)
96			->select('COUNT(id)')
97			->execute();
98
99			if ($result instanceof \Doctrine\DBAL\Result) {
			0 ignored issues – show introduced 2021-10-08 20:02 UTC by Report Bug Copy Issue Report `$result` is always a sub-type of `Doctrine\DBAL\Result`. Loading history...
100			$result = $result->fetchOne();
101			}
102			else {
103			$result = $result->fetchColumn(0);
104			}
105
106			} catch (Exception $e) {
107			$result = false;
108			}
109
110			return false === $result ? 0 : $result;
111			}
112
113			public function addFilter(FilterInterface $filter): self
114			{
115			$this->checkFilter($filter->getName());
116			$this->filters[$filter->getName()][] = $filter;
117
118			return $this;
119			}
120
121			public function addOrderBy(string $field, string $direction = 'DESC'): self
122			{
123			$this->checkFilter($field);
124
125			if (!\in_array($direction, ['ASC', 'DESC'], true)) {
126			throw new InvalidArgumentException('Invalid sort direction, allowed value: ASC, DESC');
127			}
128
129			$this->orderBy[$field] = $direction;
130
131			return $this;
132			}
133
134			public function limit(int $limit, int $offset = 0): self
135			{
136			if (0 > $limit) {
137			throw new InvalidArgumentException('Limit cannot be negative.');
138			}
139			if (0 > $offset) {
140			throw new InvalidArgumentException('Offset cannot be negative.');
141			}
142
143			$this->limit = $limit;
144			$this->offset = $offset;
145
146			return $this;
147			}
148
149			public function getSupportedFilters(): array
150			{
151			return array_keys(SchemaHelper::getAuditTableIndices('fake'));
152			}
153
154			public function getFilters(): array
155			{
156			return $this->filters;
157			}
158
159			public function getOrderBy(): array
160			{
161			return $this->orderBy;
162			}
163
164			public function getLimit(): array
165			{
166			return [$this->limit, $this->offset];
167			}
168
169			private function buildQueryBuilder(): QueryBuilder
170			{
171			$queryBuilder = $this->connection->createQueryBuilder();
172			$queryBuilder
173			->select('*')
174			->from($this->table, 'at')
175			;
176
177			// build WHERE clause(s)
178			$queryBuilder = $this->buildWhere($queryBuilder);
179
180			// build ORDER BY part
181			$queryBuilder = $this->buildOrderBy($queryBuilder);
182
183			// build LIMIT part
184			return $this->buildLimit($queryBuilder);
185			}
186
187			private function groupFilters(array $filters): array
188			{
189			$grouped = [];
190
191			foreach ($filters as $filter) {
192			$class = \get_class($filter);
193			if (!isset($grouped[$class])) {
194			$grouped[$class] = [];
195			}
196			$grouped[$class][] = $filter;
197			}
198
199			return $grouped;
200			}
201
202			private function mergeSimpleFilters(array $filters): SimpleFilter
203			{
204			$merged = [];
205			$name = null;
206
207			foreach ($filters as $filter) {
208			if (null === $name) {
209			$name = $filter->getName();
210			}
211
212			if (\is_array($filter->getValue())) {
213			$merged = array_merge($merged, $filter->getValue());
214			} else {
215			$merged[] = $filter->getValue();
216			}
217			}
218
219			return new SimpleFilter($name, $merged);
220			}
221
222			private function buildWhere(QueryBuilder $queryBuilder): QueryBuilder
223			{
224			foreach ($this->filters as $name => $rawFilters) {
225			if (0 === \count($rawFilters)) {
226			continue;
227			}
228
229			// group filters by class
230			$grouped = $this->groupFilters($rawFilters);
231
232			foreach ($grouped as $class => $filters) {
233			switch ($class) {
234			case SimpleFilter::class:
235			$filters = [$this->mergeSimpleFilters($filters)];
236
237			break;
238			case RangeFilter::class:
239			case DateRangeFilter::class:
240			break;
241			}
242
243			foreach ($filters as $filter) {
244			$data = $filter->getSQL();
245
246			$queryBuilder->andWhere($data['sql']);
247
248			foreach ($data['params'] as $name => $value) {
			0 ignored issues – show Comprehensibility Bug introduced 2021-02-25 23:55 UTC by Report Bug Copy Issue Report `$name` is overwriting a variable from outer foreach loop. Loading history...
249			if (\is_array($value)) {
250			$queryBuilder->setParameter($name, $value, Connection::PARAM_STR_ARRAY);
251			} else {
252			$queryBuilder->setParameter($name, $value);
253			}
254			}
255			}
256			}
257			}
258
259			return $queryBuilder;
260			}
261
262			private function buildOrderBy(QueryBuilder $queryBuilder): QueryBuilder
263			{
264			foreach ($this->orderBy as $field => $direction) {
265			$queryBuilder->addOrderBy($field, $direction);
266			}
267
268			return $queryBuilder;
269			}
270
271			private function buildLimit(QueryBuilder $queryBuilder): QueryBuilder
272			{
273			if (0 < $this->limit) {
274			$queryBuilder->setMaxResults($this->limit);
275			}
276			if (0 < $this->offset) {
277			$queryBuilder->setFirstResult($this->offset);
278			}
279
280			return $queryBuilder;
281			}
282
283			private function checkFilter(string $filter): void
284			{
285			if (!\in_array($filter, $this->getSupportedFilters(), true)) {
286			throw new InvalidArgumentException(sprintf('Unsupported "%s" filter, allowed filters: %s.', $filter, implode(', ', $this->getSupportedFilters())));
287			}
288			}
289			}
290

DamienHarper / auditor

Push — master ( 25b702...de7f7b )

Query::execute() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like