Orm::buildWhere() - Code Metrics - Inspection of "test/nymfonya : Component Model Orm - cov 100%" - pierre-fromager/nymfonya - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( f5981b...225f0a )

by Pierre

created 2019-11-14 17:07 UTC

Orm::buildWhere() A

↳ Parent: Orm

Complexity

Conditions	3
Paths	2

Size

Total Lines	9
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	6
CRAP Score	3

Importance

Changes

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

<?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;

    /**
     * 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
     */
    public function find(array $columns = [], array $where = []): Orm
    {
        $this->where = $where;
        $this
            ->setColumns($columns)
            ->setQuery(new Select())
            ->build($this->tablename, $this->columns, $this->where);
        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);
    }

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

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

    /**
     * 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()
    {
        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';
        }
    }
}


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

pierre-fromager / nymfonya

Push — master ( f5981b...225f0a )

Orm::buildWhere() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like