Query::chunk() - Code Metrics - Inspection of "Removed the `setPk()`\`getPk()` from the EntityInt..." - siriusphp/orm - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 33c6fc...b4603e )

by Adrian

created 2020-02-28 08:24 UTC

Query::chunk() A

↳ Parent: Query

Complexity

Conditions	5
Paths	8

Size

Total Lines	23
Code Lines	13

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	13
c	1
b	0
f	0
dl	0
loc	23
rs	9.5222
cc	5
nc	8
nop	3

<?php
declare(strict_types=1);

namespace Sirius\Orm;

use Sirius\Orm\Collection\Collection;
use Sirius\Orm\Collection\PaginatedCollection;
use Sirius\Sql\Bindings;
use Sirius\Sql\Select;

class Query extends Select
{
    /**
     * @var Mapper
     */
    protected $mapper;

    /**
     * @var array
     */
    protected $load = [];

    /**
     * @var array
     */
    protected $guards = [];

    /**
     * @var array
     */
    protected $scopes = [];

    public function __construct(Mapper $mapper, Bindings $bindings = null, string $indent = '')
    {
        parent::__construct($mapper->getReadConnection(), $bindings, $indent);
        $this->mapper = $mapper;
        $this->from($this->mapper->getTableReference());
        $this->resetColumns();
        $this->columns($this->mapper->getTableAlias(true) . '.*');
    }

    public function __call(string $method, array $params)
    {
        $scope = $this->mapper->getQueryScope($method);
        if ($scope && is_callable($scope)) {
            return $scope($this, ...$params);
        }

        return parent::__call($method, $params);
    }

    public function __clone()
    {
        $vars = get_object_vars($this);
        unset($vars['mapper']);
        foreach ($vars as $name => $prop) {
            if (is_object($prop)) {
                $this->$name = clone $prop;
            }
        }
    }


    public function load(...$relations): self
    {
        foreach ($relations as $relation) {
            if (is_array($relation)) {
                $name     = key($relation);
                $callback = current($relation);
            } else {
                $name     = $relation;
                $callback = null;
            }
            $this->load[$name] = $callback;
        }

        return $this;
    }

    public function joinWith($name): Query
    {
        if (! $this->mapper->hasRelation($name)) {
            throw new \InvalidArgumentException(
                sprintf("Relation %s, not defined for %s", $name, $this->mapper->getTable())
            );
        }
        $relation = $this->mapper->getRelation($name);

        return $relation->joinSubselect($this, $name);
    }

    public function subSelectForJoinWith(): Query
    {
        $subselect = new Query($this->mapper, $this->bindings, $this->indent . '    ');
        $subselect->resetFrom();
        $subselect->resetColumns();

        return $subselect;
    }

    public function first()
    {
        $row = $this->fetchOne();

        return $this->mapper->newEntityFromRow($row, $this->load);
    }

    public function get(): Collection
    {
        return $this->mapper->newCollectionFromRows(
            $this->connection->fetchAll($this->getStatement(), $this->getBindValues()),
            $this->load
        );
    }

    public function paginate($perPage, $page): PaginatedCollection
    {
        /** @var Query $countQuery */
        $countQuery = clone $this;
        $total      = $countQuery->count();

        if ($total == 0) {
            $this->mapper->newPaginatedCollectionFromRows([], $total, $perPage, $page, $this->load);
        }

        $this->perPage($perPage);
        $this->page($page);

        return $this->mapper->newPaginatedCollectionFromRows($this->fetchAll(), $total, $perPage, $page, $this->load);
    }

    /**
     * Executes the query with a limit of $size and applies the callback on each entity
     * The callback can change the DB in such a way that you can end up in an infinite loop
     * (depending on the sorting) so we set a limit on the number of chunks that can be processed
     *
     * @param int $size
     * @param callable $callback
     * @param int $limit
     */
    public function chunk(int $size, callable $callback, int $limit = 100000)
    {
        if (!$this->orderBy->build()) {
            $this->orderBy(...(array) $this->mapper->getPrimaryKey());
        }

        $run = 0;
        while ($run < $limit) {
            $query = clone $this;
            $query->limit($size);
            $query->offset($run * $size);

            $results = $query->get();

            if (count($results) === 0) {
                break;
            }

            foreach ($results as $entity) {
                $callback($entity);
            }

            $run++;
        }
    }

    public function count()
    {
        $this->resetOrderBy();
        $this->resetColumns();
        $this->columns('COUNT(*) AS total');

        return (int)$this->fetchValue();
    }

    public function setGuards(array $guards)
    {
        foreach ($guards as $column => $value) {
            if (is_int($column)) {
                $this->guards[] = $value;
            } else {
                $this->guards[$column] = $value;
            }
        }

        return $this;
    }

    public function resetGuards()
    {
        $this->guards = [];

        return;
    }

    protected function applyGuards()
    {
        if (empty($this->guards)) {
            return;
        }

        $this->groupCurrentWhere();
        foreach ($this->guards as $column => $value) {
            if (is_int($column)) {
                $this->where($value);
            } else {
                $this->where($column, $value);
            }
        }
    }

    public function getStatement(): string
    {
        $this->applyGuards();

        return parent::getStatement();
    }
}


1			<?php
2			declare(strict_types=1);
3
4			namespace Sirius\Orm;
5
6			use Sirius\Orm\Collection\Collection;
7			use Sirius\Orm\Collection\PaginatedCollection;
8			use Sirius\Sql\Bindings;
9			use Sirius\Sql\Select;
10
11			class Query extends Select
12			{
13			/**
14			* @var Mapper
15			*/
16			protected $mapper;
17
18			/**
19			* @var array
20			*/
21			protected $load = [];
22
23			/**
24			* @var array
25			*/
26			protected $guards = [];
27
28			/**
29			* @var array
30			*/
31			protected $scopes = [];
32
33			public function __construct(Mapper $mapper, Bindings $bindings = null, string $indent = '')
34			{
35			parent::__construct($mapper->getReadConnection(), $bindings, $indent);
36			$this->mapper = $mapper;
37			$this->from($this->mapper->getTableReference());
38			$this->resetColumns();
39			$this->columns($this->mapper->getTableAlias(true) . '.*');
40			}
41
42			public function __call(string $method, array $params)
43			{
44			$scope = $this->mapper->getQueryScope($method);
45			if ($scope && is_callable($scope)) {
46			return $scope($this, ...$params);
47			}
48
49			return parent::__call($method, $params);
50			}
51
52			public function __clone()
53			{
54			$vars = get_object_vars($this);
55			unset($vars['mapper']);
56			foreach ($vars as $name => $prop) {
57			if (is_object($prop)) {
58			$this->$name = clone $prop;
59			}
60			}
61			}
62
63
64			public function load(...$relations): self
65			{
66			foreach ($relations as $relation) {
67			if (is_array($relation)) {
68			$name = key($relation);
69			$callback = current($relation);
70			} else {
71			$name = $relation;
72			$callback = null;
73			}
74			$this->load[$name] = $callback;
75			}
76
77			return $this;
78			}
79
80			public function joinWith($name): Query
81			{
82			if (! $this->mapper->hasRelation($name)) {
83			throw new \InvalidArgumentException(
84			sprintf("Relation %s, not defined for %s", $name, $this->mapper->getTable())
85			);
86			}
87			$relation = $this->mapper->getRelation($name);
88
89			return $relation->joinSubselect($this, $name);
90			}
91
92			public function subSelectForJoinWith(): Query
93			{
94			$subselect = new Query($this->mapper, $this->bindings, $this->indent . ' ');
95			$subselect->resetFrom();
96			$subselect->resetColumns();
97
98			return $subselect;
99			}
100
101			public function first()
102			{
103			$row = $this->fetchOne();
104
105			return $this->mapper->newEntityFromRow($row, $this->load);
106			}
107
108			public function get(): Collection
109			{
110			return $this->mapper->newCollectionFromRows(
111			$this->connection->fetchAll($this->getStatement(), $this->getBindValues()),
112			$this->load
113			);
114			}
115
116			public function paginate($perPage, $page): PaginatedCollection
117			{
118			/** @var Query $countQuery */
119			$countQuery = clone $this;
120			$total = $countQuery->count();
121
122			if ($total == 0) {
123			$this->mapper->newPaginatedCollectionFromRows([], $total, $perPage, $page, $this->load);
124			}
125
126			$this->perPage($perPage);
127			$this->page($page);
128
129			return $this->mapper->newPaginatedCollectionFromRows($this->fetchAll(), $total, $perPage, $page, $this->load);
130			}
131
132			/**
133			* Executes the query with a limit of $size and applies the callback on each entity
134			* The callback can change the DB in such a way that you can end up in an infinite loop
135			* (depending on the sorting) so we set a limit on the number of chunks that can be processed
136			*
137			* @param int $size
138			* @param callable $callback
139			* @param int $limit
140			*/
141			public function chunk(int $size, callable $callback, int $limit = 100000)
142			{
143			if (!$this->orderBy->build()) {
144			$this->orderBy(...(array) $this->mapper->getPrimaryKey());
145			}
146
147			$run = 0;
148			while ($run < $limit) {
149			$query = clone $this;
150			$query->limit($size);
151			$query->offset($run * $size);
152
153			$results = $query->get();
154
155			if (count($results) === 0) {
156			break;
157			}
158
159			foreach ($results as $entity) {
160			$callback($entity);
161			}
162
163			$run++;
164			}
165			}
166
167			public function count()
168			{
169			$this->resetOrderBy();
170			$this->resetColumns();
171			$this->columns('COUNT(*) AS total');
172
173			return (int)$this->fetchValue();
174			}
175
176			public function setGuards(array $guards)
177			{
178			foreach ($guards as $column => $value) {
179			if (is_int($column)) {
180			$this->guards[] = $value;
181			} else {
182			$this->guards[$column] = $value;
183			}
184			}
185
186			return $this;
187			}
188
189			public function resetGuards()
190			{
191			$this->guards = [];
192
193			return;
194			}
195
196			protected function applyGuards()
197			{
198			if (empty($this->guards)) {
199			return;
200			}
201
202			$this->groupCurrentWhere();
203			foreach ($this->guards as $column => $value) {
204			if (is_int($column)) {
205			$this->where($value);
206			} else {
207			$this->where($column, $value);
208			}
209			}
210			}
211
212			public function getStatement(): string
213			{
214			$this->applyGuards();
215
216			return parent::getStatement();
217			}
218			}
219

siriusphp / orm

Push — master ( 33c6fc...b4603e )

Query::chunk() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like