Query - Code Metrics - Inspection of "fix bug and formating" - injitools/cms-Inji - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 4b8bb5...60b638 )

by Alexey

created 2016-11-30 05:33 UTC

Query D

↳ Parent: Project

Complexity

Total Complexity

121

Size/Duplication

Total Lines	436
Duplicated Lines	44.5 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

Metric	Value
dl	194
loc	436
rs	4.8717
c	0
b	0
f	0
wmc	121
lcom	1
cbo	3

18 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	2
A	insert()	0	7	1
A	select()	0	5	1
A	update()	7	7	1
A	delete()	6	6	1
A	createTable()	0	7	1
A	cols()	0	7	2
A	join()	8	14	4
A	where()	7	7	2
A	having()	7	7	2
A	group()	0	3	1
A	order()	6	16	4
A	limit()	0	8	2
B	buildJoin()	0	18	5
D	buildWhere()	76	79	31
D	buildHaving()	75	78	31
F	buildQuery()	0	77	24
B	query()	0	22	6

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Query often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Query, and based on these observations, apply Extract Interface, too.

<?php

/**
 * Query class for mysql driver
 *
 * @author Alexey Krupskiy <[email protected]>
 * @link http://inji.ru/
 * @copyright 2015 Alexey Krupskiy
 * @license https://github.com/injitools/cms-Inji/blob/master/LICENSE
 */

namespace Db\Mysql;

class Query extends \Object {

    public $curInstance = null;
    public $where = [];
    public $whereString = '';
    public $having = [];
    public $havingString = '';
    public $cols = [];
    public $order = null;
    public $join = [];
    public $group = [];
    public $limit = '';
    public $error = '';
    public $query = '';
    public $table = '';
    public $operation = '';
    public $indexes = [];
    public $params = [];
    public $distinct = false;

    public function __construct($instance = null) {
        if (!$instance) {
            $this->curInstance = \App::$cur->db->connection;
        } else {
            $this->curInstance = $instance;
        }
    }

    public function insert($table, $data) {
        $this->operation = 'INSERT';
        $this->table = $table;
        $this->cols = $data;
        $this->query();
        return $this->curInstance->pdo->lastInsertId();
    }

    public function select($table) {
        $this->operation = 'SELECT';
        $this->table = $table;
        return $this->query();
    }

    public function update($table, $data) {
        $this->operation = 'UPDATE';
        $this->table = $table;
        $this->cols = $data;
        $result = $this->query();
        return $result->pdoResult->rowCount();
    }

    public function delete($table) {
        $this->operation = 'DELETE';
        $this->table = $table;
        $result = $this->query();
        return $result->pdoResult->rowCount();
    }

    public function createTable($table_name, $cols, $indexes = []) {
        $this->operation = 'CREATE TABLE';
        $this->table = $table_name;
        $this->cols = $cols;
        $this->indexes = $indexes;
        return $this->query();
    }

    public function cols($cols) {
        if (is_array($cols)) {
            $this->cols = array_merge($this->cols, array_values($cols));
        } else {
            $this->cols[] = $cols;
        }
    }

    public function join($table, $where = false, $type = 'LEFT', $alias = '') {
        if (is_array($table)) {
            foreach ($table as $item) {

                if (!is_array($item)) {
                    call_user_func_array(array($this, 'join'), $table);
                    break;
                } else {
                    $this->join($item);
                }
            }
        } else {
            $this->join[] = [$table, $where, $type, $alias];
        }
    }

    public function where($where = '', $value = '', $operation = false, $concatenation = 'AND') {
        if (!is_array($where)) {
            $this->where[] = [$where, $value, $operation, $concatenation];
        } else {
            $this->where[] = $where;
        }
    }

    public function having($where = '', $value = '', $operation = false, $concatenation = 'AND') {
        if (!is_array($where)) {
            $this->having[] = [$where, $value, $operation, $concatenation];
        } else {
            $this->having[] = $where;
        }
    }

    public function group($colname) {
        $this->group[] = $colname;
    }

    public function order($order, $type = 'ASC') {


        if (!is_array($order)) {
            $this->order[] = "{$order} {$type}";
        } else {
            foreach ($order as $item) {

                if (!is_array($item)) {
                    call_user_func_array(array($this, 'order'), $order);
                    break;
                } else {
                    $this->order($item);
                }
            }
        }
    }

    public function limit($start = 0, $len = 0) {
        $start = intval($start);
        $len = intval($len);
        $this->limit = "LIMIT {$start}";
        if ($len !== 0) {
            $this->limit .= ",{$len}";
        }
    }

    public function buildJoin($table, $where = false, $type = 'LEFT', $alias = '') {
        $join = '';
        if (is_array($table)) {
            $joins = func_get_args();
            foreach ($joins as $joinAr) {
                $join .= call_user_func_array([$this, 'buildJoin'], $joinAr);
            }
        } else {
            $join .= " {$type} JOIN {$this->curInstance->table_prefix}{$table}";
            if ($alias) {
                $join .= " AS `{$alias}`";
            }
            if ($where) {
                $join .= " ON {$where}";
            }
        }
        return $join;
    }

    /**
     * Build where string
     * 
     * @param string|array $where
     * @param mixed $value
     * @param string $operation
     * @param string $concatenation
     */
    public function buildWhere($where = '', $value = '', $operation = '=', $concatenation = 'AND') {
        if (!is_array($where)) {
            if (empty($operation)) {
                $operation = '=';
            }

            if ($concatenation === false) {
                $concatenation = 'AND';
            } elseif ($concatenation === true) {
                $concatenation = '';
            }

            if ($this->whereString == NULL) {
                $this->whereString = ' WHERE ';
            }

            if (stristr($operation, 'IN') || stristr($operation, 'NOT IN')) {
                if (is_array($value)) {
                    $newValue = '';
                    foreach ($value as $item) {
                        if ($newValue) {
                            $newValue .= ',';
                        }
                        if (is_string($item)) {
                            $newValue .= '"' . $item . '"';
                        } else {
                            $newValue .= $item;
                        }
                    }
                    $value = '(' . $newValue . ')';
                } elseif (!preg_match('!\(!', $value) && !preg_match('![^0-9,\.\(\) ]!', $value)) {
                    $value = "({$value})";
                } elseif (preg_match('!\(!', $value) && preg_match('![^0-9,\.\(\) ]!', $value)) {
                    $value = "\"{$value}\"";
                }
            } elseif (!in_array($value, array('CURRENT_TIMESTAMP'))) {
                $this->params[] = $value;
                $value = "?";
            }

            if (substr($this->whereString, -1, 1) == '(' || substr($this->whereString, -2, 2) == 'E ') {
                $this->whereString .= " {$where} {$operation} {$value} ";
            } else {
                $this->whereString .= "{$concatenation} {$where} {$operation} {$value} ";
            }
        } else {
            $i = -1;
            while (isset($where[++$i])) {
                $item = $where[$i];
                if (isset($where[$i + 1]) && !isset($where[$i - 1]) && is_array($where[$i])) {
                    if ($this->whereString != null && substr($this->whereString, -1, 1) != '(' && $this->whereString != 'WHERE ') {
                        if (!isset($item[3])) {
                            $concatenation = 'AND';
                        } else {
                            $concatenation = $item[3];
                        }

                        $this->whereString .= "{$concatenation} ";
                    }

                    if ($this->whereString != NULL) {
                        $this->whereString .= '(';
                    } else {
                        $this->whereString = 'WHERE (';
                    }
                }

                if (!is_array($item)) {
                    call_user_func_array(array($this, 'buildWhere'), $where);
                    break;
                } else {
                    $this->buildWhere($item);
                }
                if (!isset($where[$i + 1]) && isset($where[$i - 1])) {
                    $this->whereString .= ') ';
                }
            }
        }
    }

    /**
     * Build having string
     * 
     * @param string|array $where
     * @param mixed $value
     * @param string $operation
     * @param string $concatenation
     */
    public function buildHaving($where = '', $value = '', $operation = '=', $concatenation = 'AND') {
        if (!is_array($where)) {
            if (empty($operation)) {
                $operation = '=';
            }
            if ($concatenation === false) {
                $concatenation = 'AND';
            } elseif ($concatenation === true) {
                $concatenation = '';
            }

            if ($this->havingString == NULL) {
                $this->havingString = ' HAVING ';
            }

            if (stristr($operation, 'IN') || stristr($operation, 'NOT IN')) {
                if (is_array($value)) {
                    $newValue = '';
                    foreach ($value as $item) {
                        if ($newValue) {
                            $newValue .= ',';
                        }
                        if (is_string($item)) {
                            $newValue .= '"' . $item . '"';
                        } else {
                            $newValue .= $item;
                        }
                    }
                    $value = '(' . $newValue . ')';
                } elseif (!preg_match('!\(!', $value) && !preg_match('![^0-9,\.\(\) ]!', $value)) {
                    $value = "({$value})";
                } elseif (preg_match('!\(!', $value) && preg_match('![^0-9,\.\(\) ]!', $value)) {
                    $value = "\"{$value}\"";
                }
            } elseif (!in_array($value, array('CURRENT_TIMESTAMP'))) {
                $this->params[] = $value;
                $value = "?";
            }

            if (substr($this->havingString, -1, 1) == '(' || substr($this->havingString, -2, 2) == 'E ') {
                $this->havingString .= " {$where} {$operation} {$value} ";
            } else {
                $this->havingString .= "{$concatenation} {$where} {$operation} {$value} ";
            }
        } else {
            $i = -1;
            while (isset($where[++$i])) {
                $item = $where[$i];
                if (isset($where[$i + 1]) && !isset($where[$i - 1]) && is_array($where[$i])) {
                    if ($this->havingString != null && substr($this->havingString, -1, 1) != '(' && $this->havingString != 'HAVING ') {
                        if (!isset($item[3])) {
                            $concatenation = 'AND';
                        } else {
                            $concatenation = $item[3];
                        }

                        $this->havingString .= "{$concatenation} ";
                    }

                    if ($this->havingString != NULL) {
                        $this->havingString .= '(';
                    } else {
                        $this->havingString = 'HAVING (';
                    }
                }

                if (!is_array($item)) {
                    call_user_func_array(array($this, 'buildHaving'), $where);
                    break;
                } else {
                    $this->buildHaving($item);
                }
                if (!isset($where[$i + 1]) && isset($where[$i - 1])) {
                    $this->havingString .= ') ';
                }
            }
        }
    }

    public function buildQuery() {
        $query = $this->operation;
        $this->operation = strtoupper($this->operation);

        switch ($this->operation) {
            case 'SELECT':

                $query .= ' ' . ($this->distinct ? 'DISTINCT' : '');
                $query .= ' ' . (!$this->cols ? '*' : ((is_array($this->cols) ? implode(',', $this->cols) : $this->cols)));
            case 'DELETE':
                $query .= ' FROM';
                break;
            case 'INSERT':
                $query .= ' INTO';
                break;
        }
        $query .= " `{$this->curInstance->db_name}`.`{$this->curInstance->table_prefix}{$this->table}`";
        if ($this->join) {
            $query .= $this->buildJoin($this->join);
        }
        switch ($this->operation) {
            case 'INSERT':
                $this->params = array_merge($this->params, array_values($this->cols));
                $colsStr = '';
                if ($this->cols) {
                    $colsStr = '`' . implode('`,`', array_keys($this->cols)) . '`';
                }
                $query .= ' (' . $colsStr . ') VALUES (' . rtrim(str_repeat('?,', count($this->cols)), ',') . ')';
                break;
            case 'CREATE TABLE':
                $query .= " (";
                foreach ($this->cols as $col_name => $param) {
                    if ($param == 'pk') {
                        $param = "int(11) UNSIGNED NOT NULL AUTO_INCREMENT, PRIMARY KEY (`{$col_name}`)";
                    }
                    $query .= " `{$col_name}` {$param},";
                }
                $query = rtrim($query, ',');
                if ($this->indexes) {
                    $query .= ', ' . implode(',', $this->indexes);
                }
                $query .= ") ENGINE = INNODB CHARACTER SET utf8 COLLATE utf8_general_ci";
                break;
            case 'UPDATE':

                $updates = [];
                foreach ($this->cols as $key => $item) {
                    if (!in_array($item, array('CURRENT_TIMESTAMP'))) {
                        $this->params[] = $item;
                        $updates[] = "`{$key}` = ?";
                    } else {
                        $updates[] = "`{$key}` = {$item}";
                    }
                }
                $update = implode(',', $updates);
                $query .= " SET {$update}";
            case 'SELECT':
            case 'DELETE':
                $this->buildWhere($this->where);
                if ($this->whereString) {
                    $query .= ' ' . $this->whereString;
                }
                break;
        }
        if ($this->group) {
            $query .= ' GROUP BY ' . implode(',', $this->group);
        }
        $this->buildHaving($this->having);
        if ($this->havingString) {
            $query .= ' ' . $this->havingString;
        }
        if ($this->order) {
            $query .= ' ORDER BY ' . implode(',', $this->order);
        }
        if ($this->limit) {
            $query .= ' ' . $this->limit;
        }
        return ['query' => $query, 'params' => $this->params];
    }

    /**
     * Execute query
     * 
     * @param string|array $query
     * @return \Db\Mysql\Result
     */
    public function query($query = []) {
        if (!$query) {
            $this->params = [];
            $query = $this->buildQuery();
        }

        if (is_string($query)) {
            $query = ['query' => $query, 'params' => $this->params];
        }

        $prepare = $this->curInstance->pdo->prepare($query['query']);
        $prepare->execute($query['params']);

        $this->curInstance->lastQuery = $query;
        $result = new Result();
        $result->pdoResult = $prepare;
        if ($this->curInstance->dbInstance && $this->curInstance->dbInstance->curQuery && $this->curInstance->dbInstance->curQuery === $this) {
            $this->curInstance->dbInstance->curQuery = null;
        }

        return $result;
    }

}


1		<?php
2
3		/**
4		* Query class for mysql driver
5		*
6		* @author Alexey Krupskiy <[email protected]>
7		* @link http://inji.ru/
8		* @copyright 2015 Alexey Krupskiy
9		* @license https://github.com/injitools/cms-Inji/blob/master/LICENSE
10		*/
11
12		namespace Db\Mysql;
13
14		class Query extends \Object {
15
16		public $curInstance = null;
17		public $where = [];
18		public $whereString = '';
19		public $having = [];
20		public $havingString = '';
21		public $cols = [];
22		public $order = null;
23		public $join = [];
24		public $group = [];
25		public $limit = '';
26		public $error = '';
27		public $query = '';
28		public $table = '';
29		public $operation = '';
30		public $indexes = [];
31		public $params = [];
32		public $distinct = false;
33
34		public function __construct($instance = null) {
35		if (!$instance) {
36		$this->curInstance = \App::$cur->db->connection;
37		} else {
38		$this->curInstance = $instance;
39		}
40		}
41
42		public function insert($table, $data) {
43		$this->operation = 'INSERT';
44		$this->table = $table;
45		$this->cols = $data;
46		$this->query();
47		return $this->curInstance->pdo->lastInsertId();
48		}
49
50		public function select($table) {
51		$this->operation = 'SELECT';
52		$this->table = $table;
53		return $this->query();
54		}
55
56	View Code Duplication	public function update($table, $data) {
57		$this->operation = 'UPDATE';
58		$this->table = $table;
59		$this->cols = $data;
60		$result = $this->query();
61		return $result->pdoResult->rowCount();
62		}
63
64	View Code Duplication	public function delete($table) {
65		$this->operation = 'DELETE';
66		$this->table = $table;
67		$result = $this->query();
68		return $result->pdoResult->rowCount();
69		}
70
71		public function createTable($table_name, $cols, $indexes = []) {
72		$this->operation = 'CREATE TABLE';
73		$this->table = $table_name;
74		$this->cols = $cols;
75		$this->indexes = $indexes;
76		return $this->query();
77		}
78
79		public function cols($cols) {
80		if (is_array($cols)) {
81		$this->cols = array_merge($this->cols, array_values($cols));
82		} else {
83		$this->cols[] = $cols;
84		}
85		}
86
87		public function join($table, $where = false, $type = 'LEFT', $alias = '') {
88		if (is_array($table)) {
89	View Code Duplication	foreach ($table as $item) {
		0 ignored issues – show Duplication introduced 2016-01-31 20:44 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
90		if (!is_array($item)) {
91		call_user_func_array(array($this, 'join'), $table);
92		break;
93		} else {
94		$this->join($item);
95		}
96		}
97		} else {
98		$this->join[] = [$table, $where, $type, $alias];
99		}
100		}
101
102	View Code Duplication	public function where($where = '', $value = '', $operation = false, $concatenation = 'AND') {
103		if (!is_array($where)) {
104		$this->where[] = [$where, $value, $operation, $concatenation];
105		} else {
106		$this->where[] = $where;
107		}
108		}
109
110	View Code Duplication	public function having($where = '', $value = '', $operation = false, $concatenation = 'AND') {
111		if (!is_array($where)) {
112		$this->having[] = [$where, $value, $operation, $concatenation];
113		} else {
114		$this->having[] = $where;
115		}
116		}
117
118		public function group($colname) {
119		$this->group[] = $colname;
120		}
121
122		public function order($order, $type = 'ASC') {
123
124
125		if (!is_array($order)) {
126		$this->order[] = "{$order} {$type}";
127		} else {
128	View Code Duplication	foreach ($order as $item) {
		0 ignored issues – show Duplication introduced 2016-01-31 20:44 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
129		if (!is_array($item)) {
130		call_user_func_array(array($this, 'order'), $order);
131		break;
132		} else {
133		$this->order($item);
134		}
135		}
136		}
137		}
138
139		public function limit($start = 0, $len = 0) {
140		$start = intval($start);
141		$len = intval($len);
142		$this->limit = "LIMIT {$start}";
143		if ($len !== 0) {
144		$this->limit .= ",{$len}";
145		}
146		}
147
148		public function buildJoin($table, $where = false, $type = 'LEFT', $alias = '') {
149		$join = '';
150		if (is_array($table)) {
151		$joins = func_get_args();
152		foreach ($joins as $joinAr) {
153		$join .= call_user_func_array([$this, 'buildJoin'], $joinAr);
154		}
155		} else {
156		$join .= " {$type} JOIN {$this->curInstance->table_prefix}{$table}";
157		if ($alias) {
158		$join .= " AS `{$alias}`";
159		}
160		if ($where) {
161		$join .= " ON {$where}";
162		}
163		}
164		return $join;
165		}
166
167		/**
168		* Build where string
169		*
170		* @param string\|array $where
171		* @param mixed $value
172		* @param string $operation
173		* @param string $concatenation
174		*/
175	View Code Duplication	public function buildWhere($where = '', $value = '', $operation = '=', $concatenation = 'AND') {
176		if (!is_array($where)) {
177		if (empty($operation)) {
178		$operation = '=';
179		}
180
181		if ($concatenation === false) {
182		$concatenation = 'AND';
183		} elseif ($concatenation === true) {
184		$concatenation = '';
185		}
186
187		if ($this->whereString == NULL) {
188		$this->whereString = ' WHERE ';
189		}
190
191		if (stristr($operation, 'IN') \|\| stristr($operation, 'NOT IN')) {
192		if (is_array($value)) {
193		$newValue = '';
194		foreach ($value as $item) {
195		if ($newValue) {
196		$newValue .= ',';
197		}
198		if (is_string($item)) {
199		$newValue .= '"' . $item . '"';
200		} else {
201		$newValue .= $item;
202		}
203		}
204		$value = '(' . $newValue . ')';
205		} elseif (!preg_match('!\(!', $value) && !preg_match('![^0-9,\.\(\) ]!', $value)) {
206		$value = "({$value})";
207		} elseif (preg_match('!\(!', $value) && preg_match('![^0-9,\.\(\) ]!', $value)) {
208		$value = "\"{$value}\"";
209		}
210		} elseif (!in_array($value, array('CURRENT_TIMESTAMP'))) {
211		$this->params[] = $value;
212		$value = "?";
213		}
214
215		if (substr($this->whereString, -1, 1) == '(' \|\| substr($this->whereString, -2, 2) == 'E ') {
216		$this->whereString .= " {$where} {$operation} {$value} ";
217		} else {
218		$this->whereString .= "{$concatenation} {$where} {$operation} {$value} ";
219		}
220		} else {
221		$i = -1;
222		while (isset($where[++$i])) {
223		$item = $where[$i];
224		if (isset($where[$i + 1]) && !isset($where[$i - 1]) && is_array($where[$i])) {
225		if ($this->whereString != null && substr($this->whereString, -1, 1) != '(' && $this->whereString != 'WHERE ') {
226		if (!isset($item[3])) {
227		$concatenation = 'AND';
228		} else {
229		$concatenation = $item[3];
230		}
231
232		$this->whereString .= "{$concatenation} ";
233		}
234
235		if ($this->whereString != NULL) {
236		$this->whereString .= '(';
237		} else {
238		$this->whereString = 'WHERE (';
239		}
240		}
241
242		if (!is_array($item)) {
243		call_user_func_array(array($this, 'buildWhere'), $where);
244		break;
245		} else {
246		$this->buildWhere($item);
247		}
248		if (!isset($where[$i + 1]) && isset($where[$i - 1])) {
249		$this->whereString .= ') ';
250		}
251		}
252		}
253		}
254
255		/**
256		* Build having string
257		*
258		* @param string\|array $where
259		* @param mixed $value
260		* @param string $operation
261		* @param string $concatenation
262		*/
263	View Code Duplication	public function buildHaving($where = '', $value = '', $operation = '=', $concatenation = 'AND') {
264		if (!is_array($where)) {
265		if (empty($operation)) {
266		$operation = '=';
267		}
268		if ($concatenation === false) {
269		$concatenation = 'AND';
270		} elseif ($concatenation === true) {
271		$concatenation = '';
272		}
273
274		if ($this->havingString == NULL) {
275		$this->havingString = ' HAVING ';
276		}
277
278		if (stristr($operation, 'IN') \|\| stristr($operation, 'NOT IN')) {
279		if (is_array($value)) {
280		$newValue = '';
281		foreach ($value as $item) {
282		if ($newValue) {
283		$newValue .= ',';
284		}
285		if (is_string($item)) {
286		$newValue .= '"' . $item . '"';
287		} else {
288		$newValue .= $item;
289		}
290		}
291		$value = '(' . $newValue . ')';
292		} elseif (!preg_match('!\(!', $value) && !preg_match('![^0-9,\.\(\) ]!', $value)) {
293		$value = "({$value})";
294		} elseif (preg_match('!\(!', $value) && preg_match('![^0-9,\.\(\) ]!', $value)) {
295		$value = "\"{$value}\"";
296		}
297		} elseif (!in_array($value, array('CURRENT_TIMESTAMP'))) {
298		$this->params[] = $value;
299		$value = "?";
300		}
301
302		if (substr($this->havingString, -1, 1) == '(' \|\| substr($this->havingString, -2, 2) == 'E ') {
303		$this->havingString .= " {$where} {$operation} {$value} ";
304		} else {
305		$this->havingString .= "{$concatenation} {$where} {$operation} {$value} ";
306		}
307		} else {
308		$i = -1;
309		while (isset($where[++$i])) {
310		$item = $where[$i];
311		if (isset($where[$i + 1]) && !isset($where[$i - 1]) && is_array($where[$i])) {
312		if ($this->havingString != null && substr($this->havingString, -1, 1) != '(' && $this->havingString != 'HAVING ') {
313		if (!isset($item[3])) {
314		$concatenation = 'AND';
315		} else {
316		$concatenation = $item[3];
317		}
318
319		$this->havingString .= "{$concatenation} ";
320		}
321
322		if ($this->havingString != NULL) {
323		$this->havingString .= '(';
324		} else {
325		$this->havingString = 'HAVING (';
326		}
327		}
328
329		if (!is_array($item)) {
330		call_user_func_array(array($this, 'buildHaving'), $where);
331		break;
332		} else {
333		$this->buildHaving($item);
334		}
335		if (!isset($where[$i + 1]) && isset($where[$i - 1])) {
336		$this->havingString .= ') ';
337		}
338		}
339		}
340		}
341
342		public function buildQuery() {
343		$query = $this->operation;
344		$this->operation = strtoupper($this->operation);
345
346		switch ($this->operation) {
347		case 'SELECT':
		0 ignored issues – show Coding Style introduced 2016-01-31 20:44 UTC by Report Bug Copy Issue Report There must be a comment when fall-through is intentional in a non-empty case body Loading history...
348		$query .= ' ' . ($this->distinct ? 'DISTINCT' : '');
349		$query .= ' ' . (!$this->cols ? '*' : ((is_array($this->cols) ? implode(',', $this->cols) : $this->cols)));
350		case 'DELETE':
351		$query .= ' FROM';
352		break;
353		case 'INSERT':
354		$query .= ' INTO';
355		break;
356		}
357		$query .= " `{$this->curInstance->db_name}`.`{$this->curInstance->table_prefix}{$this->table}`";
358		if ($this->join) {
359		$query .= $this->buildJoin($this->join);
360		}
361		switch ($this->operation) {
362		case 'INSERT':
363		$this->params = array_merge($this->params, array_values($this->cols));
364		$colsStr = '';
365		if ($this->cols) {
366		$colsStr = '`' . implode('`,`', array_keys($this->cols)) . '`';
367		}
368		$query .= ' (' . $colsStr . ') VALUES (' . rtrim(str_repeat('?,', count($this->cols)), ',') . ')';
369		break;
370		case 'CREATE TABLE':
371		$query .= " (";
372		foreach ($this->cols as $col_name => $param) {
373		if ($param == 'pk') {
374		$param = "int(11) UNSIGNED NOT NULL AUTO_INCREMENT, PRIMARY KEY (`{$col_name}`)";
375		}
376		$query .= " `{$col_name}` {$param},";
377		}
378		$query = rtrim($query, ',');
379		if ($this->indexes) {
380		$query .= ', ' . implode(',', $this->indexes);
381		}
382		$query .= ") ENGINE = INNODB CHARACTER SET utf8 COLLATE utf8_general_ci";
383		break;
384		case 'UPDATE':
		0 ignored issues – show Coding Style introduced 2016-01-31 20:44 UTC by Report Bug Copy Issue Report There must be a comment when fall-through is intentional in a non-empty case body Loading history...
385		$updates = [];
386		foreach ($this->cols as $key => $item) {
387		if (!in_array($item, array('CURRENT_TIMESTAMP'))) {
388		$this->params[] = $item;
389		$updates[] = "`{$key}` = ?";
390		} else {
391		$updates[] = "`{$key}` = {$item}";
392		}
393		}
394		$update = implode(',', $updates);
395		$query .= " SET {$update}";
396		case 'SELECT':
397		case 'DELETE':
398		$this->buildWhere($this->where);
399		if ($this->whereString) {
400		$query .= ' ' . $this->whereString;
401		}
402		break;
403		}
404		if ($this->group) {
405		$query .= ' GROUP BY ' . implode(',', $this->group);
406		}
407		$this->buildHaving($this->having);
408		if ($this->havingString) {
409		$query .= ' ' . $this->havingString;
410		}
411		if ($this->order) {
412		$query .= ' ORDER BY ' . implode(',', $this->order);
413		}
414		if ($this->limit) {
415		$query .= ' ' . $this->limit;
416		}
417		return ['query' => $query, 'params' => $this->params];
418		}
419
420		/**
421		* Execute query
422		*
423		* @param string\|array $query
424		* @return \Db\Mysql\Result
425		*/
426		public function query($query = []) {
427		if (!$query) {
428		$this->params = [];
429		$query = $this->buildQuery();
430		}
431
432		if (is_string($query)) {
433		$query = ['query' => $query, 'params' => $this->params];
434		}
435
436		$prepare = $this->curInstance->pdo->prepare($query['query']);
437		$prepare->execute($query['params']);
438
439		$this->curInstance->lastQuery = $query;
440		$result = new Result();
441		$result->pdoResult = $prepare;
442		if ($this->curInstance->dbInstance && $this->curInstance->dbInstance->curQuery && $this->curInstance->dbInstance->curQuery === $this) {
443		$this->curInstance->dbInstance->curQuery = null;
444		}
445
446		return $result;
447		}
448
449		}
450

injitools / cms-Inji