Database - Code Metrics - Inspection of "add orm sort and update readme" - jayacode/framework - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 2940c5...7528f1 )

by Restu

created 2016-05-16 06:47 UTC

Database B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	467
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes	11
Bugs	1	Features	5

Metric	Value
c	11
b	1
f	5
dl	0
loc	467
rs	8.3673
wmc	45
lcom	1
cbo	3

32 Methods

Rating	Name	Size	Complexity
A	__construct()	13	2
A	create()	4	1
A	initialize()	10	1
A	createConnection()	5	1
A	sql()	5	1
A	table()	5	1
A	select()	5	1
A	insert()	13	2
A	update()	18	2
A	delete()	14	3
A	whereQ()	5	1
A	where()	5	1
A	andWhere()	5	1
A	orWhere()	5	1
A	like()	5	1
A	andLike()	5	1
A	orLike()	5	1
A	between()	5	1
A	andBetween()	5	1
A	orBetween()	5	1
A	asc()	5	1
A	desc()	5	1
A	execute()	9	2
A	all()	20	3
A	first()	7	1
A	get()	11	3
A	executeIfNotAlreadyExecutedPreviously()	6	2
A	clear()	8	1
A	clearUsingModel()	4	1
A	getModel()	4	1
A	setModel()	11	3
A	lastInsertId()	4	1

How to fix Complexity

<?php
namespace JayaCode\Framework\Core\Database;

use JayaCode\Framework\Core\Database\Connector\Connector;
use JayaCode\Framework\Core\Database\Connector\ConnectorMySql;
use JayaCode\Framework\Core\Database\Query\Grammar\Grammar;
use JayaCode\Framework\Core\Database\Query\Grammar\GrammarMySql;
use JayaCode\Framework\Core\Database\Query\Query;
use PDO;

/**
 * Class Database
 * @package JayaCode\Framework\Core\Database
 */
class Database
{
    /**
     * @var Connector
     */
    protected $connector;

    /**
     * @var \PDO
     */
    protected $pdo;

    /**
     * @var \PDOStatement
     */
    protected $statement;

    /**
     * @var Query
     */
    protected $query;

    /**
     * @var Grammar
     */
    protected $grammar;

    /**
     * @var array
     */
    protected $driver = [
        "mysql" => [
            "connector" => ConnectorMySql::class,
            "grammar" => GrammarMySql::class,
        ]
    ];

    /**
     * @var array
     */
    protected $config = [
        "driver" => "mysql",

        "host" => "",
        "username" => "",
        "password" => "",

        "dbname" => "",
        "options" => [
            PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
            PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC
        ]
    ];

    /**
     * @var string
     */
    protected $model = null;

    /**
     * @param $config
     */
    public function __construct($config)
    {
        $options = isset($config["options"])?
            arr_merge_all($this->config["options"], $config["options"])
            :$this->config["options"];

        $this->config = arr_merge_all($this->config, $config);

        $this->config['options'] = $options;
        $this->initialize();

        $this->createConnection();
    }

    /**
     * @param $config
     * @return static
     */
    public static function create($config)
    {
        return new static($config);
    }

    /**
     *
     */
    protected function initialize()
    {
        $connectorClass = $this->driver[$this->config["driver"]]["connector"];
        $this->connector = new $connectorClass();

        $grammarClass = $this->driver[$this->config["driver"]]["grammar"];
        $this->grammar = new $grammarClass();

        $this->query = new Query();
    }

    /**
     * @return PDO
     */
    public function createConnection()
    {
        $this->pdo = $this->connector->connect($this->config);
        return $this->pdo;
    }

    /**
     * @param $query
     * @param null $params
     * @return $this
     */
    public function sql($query, $params = null)
    {
        $this->query = $this->query->sql($query, $params);
        return $this;
    }

    /**
     * @param $table
     * @return $this
     */
    public function table($table)
    {
        $this->query->setTable($table);
        return $this;
    }

    /**
     * @param null $columns
     * @return $this
     */
    public function select($columns = null)
    {
        $this->query->select($columns);
        return $this;
    }

    /**
     * @param array $columnsVal
     * @param bool $runExecute
     * @return $this|mixed
     */
    public function insert(array $columnsVal, $runExecute = false)
    {
        $this->query->insert($columnsVal);

        if ($runExecute) {
            $status = $this->execute(false);
            $this->clear();

            return $status;
        }

        return $this;
    }

    /**
     * @param array $columnsVal
     * @param null $primaryKey
     * @return mixed
     */
    public function update(array $columnsVal, $primaryKey = null)
    {
        if ($primaryKey) {
            $keyVal = $columnsVal[$primaryKey];
            $columnsVal = arr_exclude($columnsVal, [$primaryKey]);

            $this->query->update($columnsVal)->where($primaryKey, $keyVal);

            $status = $this->execute(false);
            $this->clear();

            return $status;
        }

        $this->query->update($columnsVal);

        return $this;
    }

    /**
     * @param null $primaryKey
     * @param null $primaryKeyVal
     * @return mixed
     */
    public function delete($primaryKey = null, $primaryKeyVal = null)
    {
        if ($primaryKey && $primaryKeyVal) {
            $this->query->delete()->where($primaryKey, $primaryKeyVal);

            $status = $this->execute(false);
            $this->clear();

            return $status;
        }

        $this->query->delete();
        return $this;
    }

    /**
     * @param $query
     * @param string $type
     * @return Query
     */
    public function whereQ($query, $type = "AND")
    {
        $this->query->whereQ($query, $type);
        return $this;
    }

    /**
     * @param $column
     * @param $value
     * @param string $operator
     * @param string $type
     * @return $this
     */
    public function where($column, $value, $operator = "=", $type = "AND")
    {
        $this->query->where($column, $value, $operator, $type);
        return $this;
    }

    /**
     * @param $column
     * @param $value
     * @param string $operator
     * @return $this
     */
    public function andWhere($column, $value, $operator = "=")
    {
        $this->query->andWhere($column, $value, $operator);
        return $this;
    }

    /**
     * @param $column
     * @param $value
     * @param string $operator
     * @return $this
     */
    public function orWhere($column, $value, $operator = "=")
    {
        $this->query->orWhere($column, $value, $operator);
        return $this;
    }

    /**
     * @param $column
     * @param $value
     * @param string $type
     * @return $this
     */
    public function like($column, $value, $type = "AND")
    {
        $this->query->like($column, $value, $type);
        return $this;
    }

    /**
     * @param $column
     * @param $value
     * @return $this
     */
    public function andLike($column, $value)
    {
        $this->query->andLike($column, $value);
        return $this;
    }

    /**
     * @param $column
     * @param $value
     * @return $this
     */
    public function orLike($column, $value)
    {
        $this->query->orLike($column, $value);
        return $this;
    }

    /**
     * @param $column
     * @param $value
     * @param string $type
     * @return $this
     */
    public function between($column, $value, $type = "AND")
    {
        $this->query->between($column, $value, $type);
        return $this;
    }

    /**
     * @param $column
     * @param $value
     * @return $this
     */
    public function andBetween($column, $value)
    {
        $this->query->andBetween($column, $value);
        return $this;
    }

    /**
     * @param $column
     * @param $value
     * @return $this
     */
    public function orBetween($column, $value)
    {
        $this->query->orBetween($column, $value);
        return $this;
    }

    /**
     * @param $column
     * @return $this
     */
    public function asc($column)
    {
        $this->query->asc($column);
        return $this;
    }

    /**
     * @param $column
     * @return $this
     */
    public function desc($column)
    {
        $this->query->desc($column);
        return $this;
    }

    /**
     * @param bool $returnThis
     * @return mixed
     */
    public function execute($returnThis = true)
    {
        $qArr = $this->query->build($this->grammar);

        $this->statement = $this->pdo->prepare($qArr[0]);
        $status = $this->statement->execute($qArr[1]);

        return ($returnThis) ? $this : $status;
    }

    /**
     * @return array
     * @throws \Exception
     */
    public function all()
    {
        $this->executeIfNotAlreadyExecutedPreviously();

        if ($this->model) {
            $dataModel = array();
            while ($model = $this->get()) {
                $dataModel[] = $model;
            }

            $this->clear();

            return $dataModel;
        }

        $data = $this->statement->fetchAll();
        $this->clear();
        
        return $data;
    }

    /**
     * @return mixed
     */
    public function first()
    {
        // TODO: use limit after query builder limit finish
        $data = $this->get();
        $this->clear();
        return $data;
    }

    /**
     * @return mixed
     * @throws \Exception
     */
    protected function get()
    {
        $this->executeIfNotAlreadyExecutedPreviously();

        if ($this->model) {
            $data = $this->statement->fetch();
            return $data?new $this->model($data, false):$data;
        }

        return $this->statement->fetch();
    }

    /**
     * @throws \Exception
     */
    protected function executeIfNotAlreadyExecutedPreviously()
    {
        if (!$this->statement) {
            $this->execute();
        }
    }

    /**
     * Clear statement PDO and query builder
     */
    public function clear()
    {
        $this->statement = null;
        $this->clearUsingModel();

        $this->query->clear();
        $this->grammar->clear();
    }

    /**
     *
     */
    public function clearUsingModel()
    {
        $this->model = null;
    }

    /**
     * @return string
     */
    public function getModel()
    {
        return $this->model;
    }

    /**
     * @param string $model
     * @param null $table
     * @throws \Exception
     */
    public function setModel($model, $table = null)
    {
        if (!class_exists($model)) {
            throw new \Exception("class {$model} is not exist");
        }

        if ($table) {
            $this->table($table);
        }
        $this->model = $model;
    }

    /**
     * @return string
     */
    public function lastInsertId()
    {
        return $this->pdo->lastInsertId();
    }
}


1			<?php
2			namespace JayaCode\Framework\Core\Database;
3
4			use JayaCode\Framework\Core\Database\Connector\Connector;
5			use JayaCode\Framework\Core\Database\Connector\ConnectorMySql;
6			use JayaCode\Framework\Core\Database\Query\Grammar\Grammar;
7			use JayaCode\Framework\Core\Database\Query\Grammar\GrammarMySql;
8			use JayaCode\Framework\Core\Database\Query\Query;
9			use PDO;
10
11			/**
12			* Class Database
13			* @package JayaCode\Framework\Core\Database
14			*/
15			class Database
16			{
17			/**
18			* @var Connector
19			*/
20			protected $connector;
21
22			/**
23			* @var \PDO
24			*/
25			protected $pdo;
26
27			/**
28			* @var \PDOStatement
29			*/
30			protected $statement;
31
32			/**
33			* @var Query
34			*/
35			protected $query;
36
37			/**
38			* @var Grammar
39			*/
40			protected $grammar;
41
42			/**
43			* @var array
44			*/
45			protected $driver = [
46			"mysql" => [
47			"connector" => ConnectorMySql::class,
48			"grammar" => GrammarMySql::class,
49			]
50			];
51
52			/**
53			* @var array
54			*/
55			protected $config = [
56			"driver" => "mysql",
57
58			"host" => "",
59			"username" => "",
60			"password" => "",
61
62			"dbname" => "",
63			"options" => [
64			PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
65			PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC
66			]
67			];
68
69			/**
70			* @var string
71			*/
72			protected $model = null;
73
74			/**
75			* @param $config
76			*/
77			public function __construct($config)
78			{
79			$options = isset($config["options"])?
80			arr_merge_all($this->config["options"], $config["options"])
81			:$this->config["options"];
82
83			$this->config = arr_merge_all($this->config, $config);
84
85			$this->config['options'] = $options;
86			$this->initialize();
87
88			$this->createConnection();
89			}
90
91			/**
92			* @param $config
93			* @return static
94			*/
95			public static function create($config)
96			{
97			return new static($config);
98			}
99
100			/**
101			*
102			*/
103			protected function initialize()
104			{
105			$connectorClass = $this->driver[$this->config["driver"]]["connector"];
106			$this->connector = new $connectorClass();
107
108			$grammarClass = $this->driver[$this->config["driver"]]["grammar"];
109			$this->grammar = new $grammarClass();
110
111			$this->query = new Query();
112			}
113
114			/**
115			* @return PDO
116			*/
117			public function createConnection()
118			{
119			$this->pdo = $this->connector->connect($this->config);
120			return $this->pdo;
121			}
122
123			/**
124			* @param $query
125			* @param null $params
126			* @return $this
127			*/
128			public function sql($query, $params = null)
129			{
130			$this->query = $this->query->sql($query, $params);
131			return $this;
132			}
133
134			/**
135			* @param $table
136			* @return $this
137			*/
138			public function table($table)
139			{
140			$this->query->setTable($table);
141			return $this;
142			}
143
144			/**
145			* @param null $columns
146			* @return $this
147			*/
148			public function select($columns = null)
149			{
150			$this->query->select($columns);
151			return $this;
152			}
153
154			/**
155			* @param array $columnsVal
156			* @param bool $runExecute
157			* @return $this\|mixed
158			*/
159			public function insert(array $columnsVal, $runExecute = false)
160			{
161			$this->query->insert($columnsVal);
162
163			if ($runExecute) {
164			$status = $this->execute(false);
165			$this->clear();
166
167			return $status;
168			}
169
170			return $this;
171			}
172
173			/**
174			* @param array $columnsVal
175			* @param null $primaryKey
176			* @return mixed
177			*/
178			public function update(array $columnsVal, $primaryKey = null)
179			{
180			if ($primaryKey) {
181			$keyVal = $columnsVal[$primaryKey];
182			$columnsVal = arr_exclude($columnsVal, [$primaryKey]);
183
184			$this->query->update($columnsVal)->where($primaryKey, $keyVal);
185
186			$status = $this->execute(false);
187			$this->clear();
188
189			return $status;
190			}
191
192			$this->query->update($columnsVal);
193
194			return $this;
195			}
196
197			/**
198			* @param null $primaryKey
199			* @param null $primaryKeyVal
200			* @return mixed
201			*/
202			public function delete($primaryKey = null, $primaryKeyVal = null)
203			{
204			if ($primaryKey && $primaryKeyVal) {
205			$this->query->delete()->where($primaryKey, $primaryKeyVal);
206
207			$status = $this->execute(false);
208			$this->clear();
209
210			return $status;
211			}
212
213			$this->query->delete();
214			return $this;
215			}
216
217			/**
218			* @param $query
219			* @param string $type
220			* @return Query
221			*/
222			public function whereQ($query, $type = "AND")
223			{
224			$this->query->whereQ($query, $type);
225			return $this;
226			}
227
228			/**
229			* @param $column
230			* @param $value
231			* @param string $operator
232			* @param string $type
233			* @return $this
234			*/
235			public function where($column, $value, $operator = "=", $type = "AND")
236			{
237			$this->query->where($column, $value, $operator, $type);
238			return $this;
239			}
240
241			/**
242			* @param $column
243			* @param $value
244			* @param string $operator
245			* @return $this
246			*/
247			public function andWhere($column, $value, $operator = "=")
248			{
249			$this->query->andWhere($column, $value, $operator);
250			return $this;
251			}
252
253			/**
254			* @param $column
255			* @param $value
256			* @param string $operator
257			* @return $this
258			*/
259			public function orWhere($column, $value, $operator = "=")
260			{
261			$this->query->orWhere($column, $value, $operator);
262			return $this;
263			}
264
265			/**
266			* @param $column
267			* @param $value
268			* @param string $type
269			* @return $this
270			*/
271			public function like($column, $value, $type = "AND")
272			{
273			$this->query->like($column, $value, $type);
274			return $this;
275			}
276
277			/**
278			* @param $column
279			* @param $value
280			* @return $this
281			*/
282			public function andLike($column, $value)
283			{
284			$this->query->andLike($column, $value);
285			return $this;
286			}
287
288			/**
289			* @param $column
290			* @param $value
291			* @return $this
292			*/
293			public function orLike($column, $value)
294			{
295			$this->query->orLike($column, $value);
296			return $this;
297			}
298
299			/**
300			* @param $column
301			* @param $value
302			* @param string $type
303			* @return $this
304			*/
305			public function between($column, $value, $type = "AND")
306			{
307			$this->query->between($column, $value, $type);
308			return $this;
309			}
310
311			/**
312			* @param $column
313			* @param $value
314			* @return $this
315			*/
316			public function andBetween($column, $value)
317			{
318			$this->query->andBetween($column, $value);
319			return $this;
320			}
321
322			/**
323			* @param $column
324			* @param $value
325			* @return $this
326			*/
327			public function orBetween($column, $value)
328			{
329			$this->query->orBetween($column, $value);
330			return $this;
331			}
332
333			/**
334			* @param $column
335			* @return $this
336			*/
337			public function asc($column)
338			{
339			$this->query->asc($column);
340			return $this;
341			}
342
343			/**
344			* @param $column
345			* @return $this
346			*/
347			public function desc($column)
348			{
349			$this->query->desc($column);
350			return $this;
351			}
352
353			/**
354			* @param bool $returnThis
355			* @return mixed
356			*/
357			public function execute($returnThis = true)
358			{
359			$qArr = $this->query->build($this->grammar);
360
361			$this->statement = $this->pdo->prepare($qArr[0]);
362			$status = $this->statement->execute($qArr[1]);
363
364			return ($returnThis) ? $this : $status;
365			}
366
367			/**
368			* @return array
369			* @throws \Exception
370			*/
371			public function all()
372			{
373			$this->executeIfNotAlreadyExecutedPreviously();
374
375			if ($this->model) {
376			$dataModel = array();
377			while ($model = $this->get()) {
378			$dataModel[] = $model;
379			}
380
381			$this->clear();
382
383			return $dataModel;
384			}
385
386			$data = $this->statement->fetchAll();
387			$this->clear();
388
389			return $data;
390			}
391
392			/**
393			* @return mixed
394			*/
395			public function first()
396			{
397			// TODO: use limit after query builder limit finish
398			$data = $this->get();
399			$this->clear();
400			return $data;
401			}
402
403			/**
404			* @return mixed
405			* @throws \Exception
406			*/
407			protected function get()
408			{
409			$this->executeIfNotAlreadyExecutedPreviously();
410
411			if ($this->model) {
412			$data = $this->statement->fetch();
413			return $data?new $this->model($data, false):$data;
414			}
415
416			return $this->statement->fetch();
417			}
418
419			/**
420			* @throws \Exception
421			*/
422			protected function executeIfNotAlreadyExecutedPreviously()
423			{
424			if (!$this->statement) {
425			$this->execute();
426			}
427			}
428
429			/**
430			* Clear statement PDO and query builder
431			*/
432			public function clear()
433			{
434			$this->statement = null;
435			$this->clearUsingModel();
436
437			$this->query->clear();
438			$this->grammar->clear();
439			}
440
441			/**
442			*
443			*/
444			public function clearUsingModel()
445			{
446			$this->model = null;
447			}
448
449			/**
450			* @return string
451			*/
452			public function getModel()
453			{
454			return $this->model;
455			}
456
457			/**
458			* @param string $model
459			* @param null $table
460			* @throws \Exception
461			*/
462			public function setModel($model, $table = null)
463			{
464			if (!class_exists($model)) {
465			throw new \Exception("class {$model} is not exist");
466			}
467
468			if ($table) {
469			$this->table($table);
470			}
471			$this->model = $model;
472			}
473
474			/**
475			* @return string
476			*/
477			public function lastInsertId()
478			{
479			return $this->pdo->lastInsertId();
480			}
481			}
482

jayacode / framework

Push — master ( 2940c5...7528f1 )

Database B

Complexity

Size/Duplication

Coupling/Cohesion

Importance

32 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like