Orm::getDatabase() - Code Metrics - Inspection of "feature/nymfonya : init Component Migration" - pierre-fromager/nymfonya - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( c889ea...14eda7 )

by Pierre

created 2019-11-24 15:39 UTC

Orm::getDatabase() 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 Nymfonya\Component\Config;
use Nymfonya\Component\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
{

    /**
     * service container
     *
     * @var Container
     */
    private $container;

    /**
     * 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 $database;

    /**
     * db slot pool name
     * @var string
     */
    protected $slot;

    /**
     * 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->container = $container;
        $this->config = $container->getService(Config::class);
        $this->queryBuilder = new GenericBuilder();
        $this->query = null;
        $this->columns = [];
        $this->where = [];
        return $this;
    }

    /**
     * reset query builder
     *
     * @return void
     */
    public function resetBuilder(): Orm
    {
        $this->queryBuilder = new GenericBuilder();
        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;
    }

    /**
     * get slot name
     *
     * @return string
     */
    public function getSlot(): string
    {
        return $this->slot;
    }

    /**
     * get service container
     *
     * @return Container
     */
    public function getContainer(): Container
    {
        return $this->container;
    }

    /**
     * get database name
     *
     * @return string
     */
    public function getDatabase(): string
    {
        return $this->database;
    }

    /**
     * get table name
     *
     * @return string
     */
    public function getTable(): string
    {
        return $this->tablename;
    }

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

pierre-fromager / nymfonya

Push — master ( c889ea...14eda7 )

Orm::getDatabase() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like