Orm::getPrimary() - Code Metrics - Inspection of "feature/nymfonya : Component Model Orm - getPrimar..." - pierre-fromager/nymfonya - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 0ced5e...1a41ca )

by Pierre

created 2019-11-15 09:30 UTC

Orm::getPrimary() A

↳ Parent: Orm

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
cc	1
eloc	1
c	0
b	0
f	0
nc	1
nop	0
dl	0
loc	3
ccs	2
cts	2
cp	1
crap	1
rs	10

<?php

namespace App\Component\Model\Orm;

use App\Config;
use App\Container;
use NilPortugues\Sql\QueryBuilder\Builder\GenericBuilder;
use NilPortugues\Sql\QueryBuilder\Manipulation\Select;
use NilPortugues\Sql\QueryBuilder\Manipulation\Update;
use NilPortugues\Sql\QueryBuilder\Manipulation\Insert;
use NilPortugues\Sql\QueryBuilder\Manipulation\Delete;

/**
 * Poor man orm
 */
class Orm implements IOrm
{

    /**
     * config
     *
     * @var Config
     */
    protected $config;

    /**
     * columns fields
     * @var array
     */
    protected $columns;

    /**
     * where criterias
     * @var array
     */
    protected $where;

    /**
     * sort order
     * @var array
     */
    protected $order;

    /**
     * table name
     * @var string
     */
    protected $tablename;

    /**
     * table primary key
     * @var string
     */
    protected $primary;

    /**
     * database name
     * @var string
     */
    protected $dbname;

    /**
     * pool name
     * @var string
     */
    protected $poolname;

    /**
     * query builder instance
     * @var GenericBuilder
     * @see https://github.com/nilportugues/php-sql-query-builder
     */
    protected $queryBuilder;

    /**
     * query from builder
     * @var object
     */
    protected $query;

    /**
     * instanciate
     * @param Container $container
     */
    public function __construct(Container $container)
    {
        $this->config = $container->getService(Config::class);
        $this->queryBuilder = new GenericBuilder();
        $this->query = null;
        $this->columns = [];
        $this->where = [];
        return $this;
    }

    /**
     * set required columns
     *
     * @param array $columns
     * @return Orm
     */
    public function setColumns(array $columns): Orm
    {
        $this->columns = $columns;
        return $this;
    }

    /**
     * find a record with columns field matching where criterias
     * @param array $columns
     * @param array $where
     * @param array $order
     */
    public function find(array $columns = [], array $where = [], array $order = []): Orm
    {
        $this->where = $where;
        $order = (empty($order)) ? [$this->primary => 'DESC'] : $order;
        $this
            ->setColumns($columns)
            ->setQuery(new Select())
            ->build($this->tablename, $this->columns, $this->where)
            ->setOrder($order);
        return $this;
    }

    /**
     * count records matching where criterias.
     * aliases is formely [columnn => column_alias]
     *
     * @param array $where
     * @param array $aliases
     * @return Orm
     */
    public function count(array $where = [], array $aliases = []): Orm
    {
        $this->where = $where;
        $this->setQuery(new Select());
        if (empty($aliases)) {
            $this->query->count();
        } else {
            reset($aliases);
            $fistKey = key($aliases);
            $aliasValue = $aliases[$fistKey];
            $this->query->count($fistKey, $aliasValue);
        }
        return $this->buildWhere($this->where);
    }

    /**
     * update a record with columns fields matching where criterias
     * @param array $columns
     * @param array $where
     */
    public function update(array $columns = [], array $where = []): Orm
    {
        $this->where = $where;
        return $this->setColumns($columns)
            ->setQuery(new Update())
            ->build($this->tablename, $this->columns, $this->where);
    }

    /**
     * insert record with columns fields
     * @param array $columns
     */
    public function insert(array $columns = []): Orm
    {
        return $this
            ->setColumns($columns)
            ->setQuery(new Insert())
            ->build($this->tablename, $this->columns, []);
    }

    /**
     * delete matching where criterias
     * @param array $where
     */
    public function delete(array $where = []): Orm
    {
        $this->where = $where;
        return $this
            ->setQuery(new Delete())
            ->build($this->tablename, [], $this->where);
    }

    /**
     * get primary key
     *
     * @return string
     */
    public function getPrimary(): string
    {
        return $this->primary;
    }

    /**
     * builder instance
     * @return GenericBuilder
     */
    public function getQueryBuilder(): GenericBuilder
    {
        return $this->queryBuilder;
    }

    /**
     * query instance
     * @return object
     */
    public function getQuery()
    {
        return $this->query;
    }

    /**
     * query builder values
     * @return array
     */
    public function getBuilderValues(): array
    {
        $this->getSql();
        return $this->queryBuilder->getValues();
    }

    /**
     * set query instance
     *
     * @param Select|Update|Insert|Delete $query
     * @return Orm
     */
    public function setQuery($query): Orm
    {
        $this->query = $query;
        return $this;
    }

    /**
     * query sql string
     * @return string
     */
    public function getSql(): string
    {
        return $this->queryBuilder->write($this->query);
    }

    /**
     * build query
     *
     * @param string $tablename
     * @param array $columns
     * @param array $where
     * @return Orm
     */
    protected function build(string $tablename, array $columns, array $where): Orm
    {
        if (false === is_object($this->getQuery())) {
            throw new \Exception('Build : Invalid query instance');
        }
        $queryClassname = get_class($this->getQuery());
        $allowedClasses = [
            Update::class, Select::class, Delete::class, Insert::class
        ];
        if (false === in_array($queryClassname, $allowedClasses)) {
            throw new \Exception('Build : Invalid query type');
        }
        $this->query->setTable($tablename);
        switch ($queryClassname) {
            case Select::class:
                $this->query->setColumns($columns);
                break;
            case Update::class:
                if (empty($columns)) {
                    throw new \Exception(
                        'Build : Update requires not empty payload'
                    );
                }
                if (empty($where)) {
                    throw new \Exception(
                        'Build : Update requires at least one condition'
                    );
                }
                $this->query->setValues($columns);
                break;
            case Insert::class:
                if (empty($columns)) {
                    throw new \Exception(
                        'Build : Insert requires not empty payload'
                    );
                }
                $this->query->setValues($columns);
                break;
            case Delete::class:
                if (empty($where)) {
                    throw new \Exception(
                        'Build : Delete requires at least one condition'
                    );
                }
                break;
        }
        return $this->buildWhere($where);
    }

    /**
     * build where condition on query
     *
     * @param array $where
     * @return Orm
     */
    protected function buildWhere(array $where): Orm
    {
        if (false === empty($where)) {
            foreach ($where as $k => $v) {
                $whereOperator = $this->getWhereOperator($k, $v);
                $this->query->where()->{$whereOperator}($k, $v);
            }
        }
        return $this;
    }

    /**
     * check where condition ket values to find operators
     *
     * @param string $whereColumn
     * @return string
     */
    protected function getWhereOperator(string &$whereColumn, $value): string
    {
        $hasArray = is_array($value);
        $operator = $whereColumn[strlen($whereColumn) - 1];
        $hasOperator = in_array($operator, self::OPERATORS);
        if (false === $hasOperator) {
            return ($hasArray) ? 'in' : 'equals';
        }
        foreach (self::OPERATORS as $op) {
            $whereColumn = str_replace($op, '', $whereColumn);
        }
        if ($operator == '!') {
            return ($hasArray) ? 'notIn' : 'notEquals';
        } elseif ($operator == '<') {
            return 'lessThan';
        } elseif ($operator == '>') {
            return 'greaterThan';
        } elseif ($operator == '#') {
            return 'like';
        }
    }

    /**
     * set query sort order
     *
     * @param array $orders
     * @return Orm
     */
    protected function setOrder(array $orders): Orm
    {
        $this->order = $orders;
        foreach ($this->order as $k => $v) {
            $this->query->orderBy($k, $v);
        }
        return $this;
    }
}


1		<?php
2
3		namespace App\Component\Model\Orm;
4
5		use App\Config;
6		use App\Container;
7		use NilPortugues\Sql\QueryBuilder\Builder\GenericBuilder;
8		use NilPortugues\Sql\QueryBuilder\Manipulation\Select;
9		use NilPortugues\Sql\QueryBuilder\Manipulation\Update;
10		use NilPortugues\Sql\QueryBuilder\Manipulation\Insert;
11		use NilPortugues\Sql\QueryBuilder\Manipulation\Delete;
12
13		/**
14		* Poor man orm
15		*/
16		class Orm implements IOrm
17		{
18
19		/**
20		* config
21		*
22		* @var Config
23		*/
24		protected $config;
25
26		/**
27		* columns fields
28		* @var array
29		*/
30		protected $columns;
31
32		/**
33		* where criterias
34		* @var array
35		*/
36		protected $where;
37
38		/**
39		* sort order
40		* @var array
41		*/
42		protected $order;
43
44		/**
45		* table name
46		* @var string
47		*/
48		protected $tablename;
49
50		/**
51		* table primary key
52		* @var string
53		*/
54		protected $primary;
55
56		/**
57		* database name
58		* @var string
59		*/
60		protected $dbname;
61
62		/**
63		* pool name
64		* @var string
65		*/
66		protected $poolname;
67
68		/**
69		* query builder instance
70		* @var GenericBuilder
71		* @see https://github.com/nilportugues/php-sql-query-builder
72		*/
73		protected $queryBuilder;
74
75		/**
76		* query from builder
77		* @var object
78		*/
79		protected $query;
80
81		/**
82		* instanciate
83		* @param Container $container
84		*/
85	25	public function __construct(Container $container)
86		{
87	25	$this->config = $container->getService(Config::class);
88	25	$this->queryBuilder = new GenericBuilder();
89	25	$this->query = null;
90	25	$this->columns = [];
91	25	$this->where = [];
92	25	return $this;
93		}
94
95		/**
96		* set required columns
97		*
98		* @param array $columns
99		* @return Orm
100		*/
101	8	public function setColumns(array $columns): Orm
102		{
103	8	$this->columns = $columns;
104	8	return $this;
105		}
106
107		/**
108		* find a record with columns field matching where criterias
109		* @param array $columns
110		* @param array $where
111		* @param array $order
112		*/
113	6	public function find(array $columns = [], array $where = [], array $order = []): Orm
114		{
115	6	$this->where = $where;
116	6	$order = (empty($order)) ? [$this->primary => 'DESC'] : $order;
117		$this
118	6	->setColumns($columns)
119	6	->setQuery(new Select())
120	6	->build($this->tablename, $this->columns, $this->where)
121	6	->setOrder($order);
122	6	return $this;
123		}
124
125		/**
126		* count records matching where criterias.
127		* aliases is formely [columnn => column_alias]
128		*
129		* @param array $where
130		* @param array $aliases
131		* @return Orm
132		*/
133	2	public function count(array $where = [], array $aliases = []): Orm
134		{
135	2	$this->where = $where;
136	2	$this->setQuery(new Select());
137	2	if (empty($aliases)) {
138	1	$this->query->count();
139		} else {
140	1	reset($aliases);
141	1	$fistKey = key($aliases);
142	1	$aliasValue = $aliases[$fistKey];
143	1	$this->query->count($fistKey, $aliasValue);
144		}
145	2	return $this->buildWhere($this->where);
146		}
147
148		/**
149		* update a record with columns fields matching where criterias
150		* @param array $columns
151		* @param array $where
152		*/
153	1	public function update(array $columns = [], array $where = []): Orm
154		{
155	1	$this->where = $where;
156	1	return $this->setColumns($columns)
157	1	->setQuery(new Update())
158	1	->build($this->tablename, $this->columns, $this->where);
159		}
160
161		/**
162		* insert record with columns fields
163		* @param array $columns
164		*/
165	1	public function insert(array $columns = []): Orm
166		{
167		return $this
168	1	->setColumns($columns)
169	1	->setQuery(new Insert())
170	1	->build($this->tablename, $this->columns, []);
171		}
172
173		/**
174		* delete matching where criterias
175		* @param array $where
176		*/
177	1	public function delete(array $where = []): Orm
178		{
179	1	$this->where = $where;
180		return $this
181	1	->setQuery(new Delete())
182	1	->build($this->tablename, [], $this->where);
183		}
184
185		/**
186		* get primary key
187		*
188		* @return string
189		*/
190	1	public function getPrimary(): string
191		{
192	1	return $this->primary;
193		}
194
195		/**
196		* builder instance
197		* @return GenericBuilder
198		*/
199	1	public function getQueryBuilder(): GenericBuilder
200		{
201	1	return $this->queryBuilder;
202		}
203
204		/**
205		* query instance
206		* @return object
207		*/
208	18	public function getQuery()
209		{
210	18	return $this->query;
211		}
212
213		/**
214		* query builder values
215		* @return array
216		*/
217	1	public function getBuilderValues(): array
218		{
219	1	$this->getSql();
220	1	return $this->queryBuilder->getValues();
221		}
222
223		/**
224		* set query instance
225		*
226		* @param Select\|Update\|Insert\|Delete $query
227		* @return Orm
228		*/
229	19	public function setQuery($query): Orm
230		{
231	19	$this->query = $query;
232	19	return $this;
233		}
234
235		/**
236		* query sql string
237		* @return string
238		*/
239	3	public function getSql(): string
240		{
241	3	return $this->queryBuilder->write($this->query);
242		}
243
244		/**
245		* build query
246		*
247		* @param string $tablename
248		* @param array $columns
249		* @param array $where
250		* @return Orm
251		*/
252	10	protected function build(string $tablename, array $columns, array $where): Orm
253		{
254	10	if (false === is_object($this->getQuery())) {
255	1	throw new \Exception('Build : Invalid query instance');
256		}
257	9	$queryClassname = get_class($this->getQuery());
258		$allowedClasses = [
259	9	Update::class, Select::class, Delete::class, Insert::class
260		];
261	9	if (false === in_array($queryClassname, $allowedClasses)) {
262	1	throw new \Exception('Build : Invalid query type');
263		}
264	8	$this->query->setTable($tablename);
265	8	switch ($queryClassname) {
266		case Select::class:
267	1	$this->query->setColumns($columns);
268	1	break;
269		case Update::class:
270	3	if (empty($columns)) {
271	1	throw new \Exception(
272	1	'Build : Update requires not empty payload'
273		);
274		}
275	2	if (empty($where)) {
276	1	throw new \Exception(
277	1	'Build : Update requires at least one condition'
278		);
279		}
280	1	$this->query->setValues($columns);
281	1	break;
282		case Insert::class:
283	2	if (empty($columns)) {
284	1	throw new \Exception(
285	1	'Build : Insert requires not empty payload'
286		);
287		}
288	1	$this->query->setValues($columns);
289	1	break;
290		case Delete::class:
291	2	if (empty($where)) {
292	1	throw new \Exception(
293	1	'Build : Delete requires at least one condition'
294		);
295		}
296	1	break;
297		}
298	4	return $this->buildWhere($where);
299		}
300
301		/**
302		* build where condition on query
303		*
304		* @param array $where
305		* @return Orm
306		*/
307	1	protected function buildWhere(array $where): Orm
308		{
309	1	if (false === empty($where)) {
310	1	foreach ($where as $k => $v) {
311	1	$whereOperator = $this->getWhereOperator($k, $v);
312	1	$this->query->where()->{$whereOperator}($k, $v);
313		}
314		}
315	1	return $this;
316		}
317
318		/**
319		* check where condition ket values to find operators
320		*
321		* @param string $whereColumn
322		* @return string
323		*/
324	1	protected function getWhereOperator(string &$whereColumn, $value): string
325		{
326	1	$hasArray = is_array($value);
327	1	$operator = $whereColumn[strlen($whereColumn) - 1];
328	1	$hasOperator = in_array($operator, self::OPERATORS);
329	1	if (false === $hasOperator) {
330	1	return ($hasArray) ? 'in' : 'equals';
331		}
332	1	foreach (self::OPERATORS as $op) {
333	1	$whereColumn = str_replace($op, '', $whereColumn);
334		}
335	1	if ($operator == '!') {
336	1	return ($hasArray) ? 'notIn' : 'notEquals';
337	1	} elseif ($operator == '<') {
338	1	return 'lessThan';
339	1	} elseif ($operator == '>') {
340	1	return 'greaterThan';
341	1	} elseif ($operator == '#') {
342	1	return 'like';
343		}
344		}
345
346		/**
347		* set query sort order
348		*
349		* @param array $orders
350		* @return Orm
351		*/
352	1	protected function setOrder(array $orders): Orm
353		{
354	1	$this->order = $orders;
355	1	foreach ($this->order as $k => $v) {
356	1	$this->query->orderBy($k, $v);
357		}
358	1	return $this;
359		}
360		}
361

pierre-fromager / nymfonya

Push — master ( 0ced5e...1a41ca )

Orm::getPrimary() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like