Database - Code Metrics - Inspection of "deleting models" - jayacode/framework - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( cef321...103503 )

by Restu

created 2016-05-15 19:18 UTC

Database B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	441
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes	10
Bugs	1	Features	4

Metric	Value
c	10
b	1
f	4
dl	0
loc	441
rs	8.295
wmc	42
lcom	1
cbo	3

30 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	execute()	8	1
A	all()	16	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 mixed
     */
    public function insert(array $columnsVal, $runExecute = false)
    {
        $this->query->insert($columnsVal);

        if ($runExecute) {
            $status = $this->execute();
            $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();
            $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();
            $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;
    }

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

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

        return $this->statement->execute($qArr[1]);
    }

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

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

            $this->clear();

            return $dataModel;
        }
        return $this->statement->fetchAll();
    }

    /**
     * @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 mixed
158			*/
159			public function insert(array $columnsVal, $runExecute = false)
160			{
161			$this->query->insert($columnsVal);
162
163			if ($runExecute) {
164			$status = $this->execute();
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();
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();
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			* @return bool
335			*/
336			public function execute()
337			{
338			$qArr = $this->query->build($this->grammar);
339
340			$this->statement = $this->pdo->prepare($qArr[0]);
341
342			return $this->statement->execute($qArr[1]);
343			}
344
345			/**
346			* @return array
347			* @throws \Exception
348			*/
349			public function all()
350			{
351			$this->executeIfNotAlreadyExecutedPreviously();
352
353			if ($this->model) {
354			$dataModel = array();
355			while ($model = $this->get()) {
356			$dataModel[] = $model;
357			}
358
359			$this->clear();
360
361			return $dataModel;
362			}
363			return $this->statement->fetchAll();
364			}
365
366			/**
367			* @return mixed
368			*/
369			public function first()
370			{
371			// TODO: use limit after query builder limit finish
372			$data = $this->get();
373			$this->clear();
374			return $data;
375			}
376
377			/**
378			* @return mixed
379			* @throws \Exception
380			*/
381			protected function get()
382			{
383			$this->executeIfNotAlreadyExecutedPreviously();
384
385			if ($this->model) {
386			$data = $this->statement->fetch();
387			return $data?new $this->model($data, false):$data;
388			}
389
390			return $this->statement->fetch();
391			}
392
393			/**
394			* @throws \Exception
395			*/
396			protected function executeIfNotAlreadyExecutedPreviously()
397			{
398			if (!$this->statement) {
399			$this->execute();
400			}
401			}
402
403			/**
404			* Clear statement PDO and query builder
405			*/
406			public function clear()
407			{
408			$this->statement = null;
409			$this->clearUsingModel();
410
411			$this->query->clear();
412			$this->grammar->clear();
413			}
414
415			/**
416			*
417			*/
418			public function clearUsingModel()
419			{
420			$this->model = null;
421			}
422
423			/**
424			* @return string
425			*/
426			public function getModel()
427			{
428			return $this->model;
429			}
430
431			/**
432			* @param string $model
433			* @param null $table
434			* @throws \Exception
435			*/
436			public function setModel($model, $table = null)
437			{
438			if (!class_exists($model)) {
439			throw new \Exception("class {$model} is not exist");
440			}
441
442			if ($table) {
443			$this->table($table);
444			}
445			$this->model = $model;
446			}
447
448			/**
449			* @return string
450			*/
451			public function lastInsertId()
452			{
453			return $this->pdo->lastInsertId();
454			}
455			}
456

jayacode / framework

Push — master ( cef321...103503 )

Database B

Complexity

Size/Duplication

Coupling/Cohesion

Importance

30 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like