DbQuery - Code Metrics - Inspection of "DBAL-misc-41a52.69: More work on DBAL" - supernova-ws/SuperNova - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — work-fleets ( 961997...006942 )

by SuperNova.WS

created 2016-09-06 12:53 UTC

DbQuery C

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	455
Duplicated Lines	1.32 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

100%

Importance

Changes	9
Bugs	0	Features	1

Metric	Value
c	9
b	0
f	1
dl	6
loc	455
ccs	190
cts	190
cp	1
rs	6.0975
wmc	60
lcom	1
cbo	4

32 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	2
A	build()	0	3	1
A	select()	0	11	1
A	delete()	0	9	1
A	update()	0	10	1
A	setInsertCommand()	0	15	3
A	insertSet()	0	7	1
A	insertBatch()	0	11	1
A	setTable()	0	5	1
A	setOneRow()	0	5	1
A	setValues()	0	5	1
A	setValuesDanger()	0	5	1
A	setAdjust()	0	5	1
A	setAdjustDanger()	0	5	1
A	setFields()	0	5	1
A	setWhereArray()	0	5	1
A	setWhereArrayDanger()	0	5	1
A	escape()	0	3	1
A	escapeEmulator()	0	8	1
A	stringValue()	0	3	1
A	quote()	0	3	1
A	makeAdjustString()	0	6	2
A	makeFieldEqualValue()	0	5	2
A	quoteTable()	0	3	1
D	castAsDbValue()	0	29	9
B	buildCommand()	6	21	7
B	buildSetFields()	0	22	6
A	buildFieldNames()	0	3	1
A	buildValuesVector()	0	13	3
A	buildWhere()	0	11	2
A	buildLimit()	0	5	2
A	__toString()	0	3	1

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 DbQuery 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 DbQuery, and based on these observations, apply Extract Interface, too.

<?php
/**
 * Created by Gorlum 07.08.2016 2:36
 */

namespace DBAL;

use \HelperArray;
use \db_mysql;
use \classSupernova;

/**
 * Class DbQuery
 *
 * New replacement for DbQueryConstructor
 * Simplified version
 * Chained calls - "Fluid interface"
 *
 * @package DBAL
 */
class DbQuery {

  const SELECT = 'SELECT';
  const REPLACE = 'REPLACE';
  const INSERT = 'INSERT';
  const INSERT_IGNORE = 'INSERT IGNORE';
  const UPDATE = 'UPDATE';
  const DELETE = 'DELETE';

  /**
   * @var db_mysql
   */
  protected $db;

  /**
   * Which command would be performed
   *
   * @var string $command
   */
  protected $command;

  protected $table = '';

  /**
   * Contains field names integer keyed
   *
   * For SELECT {fields} FROM
   * For INSERT/REPLACE {fields} UPDATE ...
   *
   * @var array $fields
   */
  protected $fields = array();
  protected $where = array();
  protected $whereDanger = array();

  /**
   * Contain array of values - fielded or not
   *
   * For INSERT/REPLACE ... SET, UPDATE ... SET contains fieldName => value
   * For INSERT/REPLACE ... VALUES contains values[][]
   *
   * @var array
   */
  protected $values = array();
  /**
   * Contain array of DANGER values for batch INSERT/REPLACE
   *
   * @var string[]
   */
  protected $valuesDanger = array();
  protected $adjust = array();
  protected $adjustDanger = array();


  /**
   * Variable for incremental query build
   *
   * @var string[] $build
   */
  protected $build = array();

  protected $isOneRow = false;

  /**
   * DbQuery constructor.
   *
   * @param  null|\db_mysql $db
   */
  // TODO - $db should be supplied externally
  public function __construct($db = null) {
    $this->db = empty($db) ? classSupernova::$gc->db : $db;
  }

  /**
   * @param null|db_mysql $db
   *
   * @return static
   */
  public static function build($db = null) {
    return new static($db);
  }


  public function select() {
    $this->build = array();

    $this->buildCommand(static::SELECT);
    $this->build[] = ' *';
    $this->build[] = " FROM " . $this->quoteTable($this->table);
    $this->buildWhere();
    $this->buildLimit();

    return $this->__toString();
  }

  public function delete() {
    $this->build = array();

    $this->buildCommand(static::DELETE);
    $this->buildWhere();
    $this->buildLimit();

    return $this->__toString();
  }

  public function update() {
    $this->build = array();

    $this->buildCommand(static::UPDATE);
    $this->buildSetFields();
    $this->buildWhere();
    $this->buildLimit();

    return $this->__toString();
  }

  /**
   * @param int $replace
   *
   * @return string
   */
  protected function setInsertCommand($replace) {
    switch($replace) {
      case DB_INSERT_IGNORE:
        $result = static::INSERT_IGNORE;
      break;
      case DB_INSERT_REPLACE:
        $result = static::REPLACE;
      break;
      default:
        $result = static::INSERT;
      break;
    }

    return $result;
  }

  public function insertSet($replace = DB_INSERT_PLAIN) {
    $this->build = array();
    $this->buildCommand($this->setInsertCommand($replace));
    $this->buildSetFields();

    return $this->__toString();
  }

  public function insertBatch($replace = DB_INSERT_PLAIN) {
    $this->build = array();

    $this->buildCommand($this->setInsertCommand($replace));
    $this->build[] = " (";
    $this->buildFieldNames();
    $this->build[] = ") VALUES ";
    $this->buildValuesVector();

    return $this->__toString();
  }


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

    return $this;
  }

  /**
   * @param bool $oneRow - DB_RECORDS_ALL || DB_RECORD_ONE
   *
   * @return $this
   */
  public function setOneRow($oneRow = DB_RECORDS_ALL) {
    $this->isOneRow = $oneRow;

    return $this;
  }

  /**
   * @param array $values
   *
   * @return $this
   */
  public function setValues($values = array()) {
    HelperArray::merge($this->values, $values, HelperArray::MERGE_PHP);

    return $this;
  }

  /**
   * @param array $values
   *
   * @return $this
   */
  public function setValuesDanger($values = array()) {
    HelperArray::merge($this->valuesDanger, $values, HelperArray::MERGE_PHP);

    return $this;
  }

  /**
   * @param array $values
   *
   * @return $this
   */
  public function setAdjust($values = array()) {
    HelperArray::merge($this->adjust, $values, HelperArray::MERGE_PHP);

    return $this;
  }

  /**
   * @param array $values
   *
   * @return $this
   */
  public function setAdjustDanger($values = array()) {
    HelperArray::merge($this->adjustDanger, $values, HelperArray::MERGE_PHP);

    return $this;
  }

  /**
   * @param array $fields
   *
   * @return $this
   */
  public function setFields($fields = array()) {
    HelperArray::merge($this->fields, $fields, HelperArray::MERGE_PHP);

    return $this;
  }

  /**
   * Merges WHERE array as array_merge()
   *
   * @param array $whereArray
   *
   * @return $this
   */
  public function setWhereArray($whereArray = array()) {
    HelperArray::merge($this->where, $whereArray, HelperArray::MERGE_PHP);

    return $this;
  }

  /**
   * Sets DANGER array - where values should be escaped BEFORE entering DBAL
   *
   * Deprecated - all values should pass through DBAL
   *
   * @param array $whereArrayDanger
   *
   * @return $this
   */
  public function setWhereArrayDanger($whereArrayDanger = array()) {
    HelperArray::merge($this->whereDanger, $whereArrayDanger, HelperArray::MERGE_PHP);

    return $this;
  }


  /**
   * Wrapper for db_escape()
   *
   * @param $string
   *
   * @return string
   */
  protected function escape($string) {
    return $this->db->db_escape($string);
  }

  protected function escapeEmulator($value) {
    // Characters encoded are NUL (ASCII 0), \n, \r, \, ', ", and Control-Z.
    return str_replace(
      array("\\", "\0", "\n", "\r", "'", "\"", "\z",),
      array('\\\\', '\0', '\n', '\r', '\\\'', '\"', '\z',),
      $value
    );
  }

  /**
   * Escaping string value and quoting it
   *
   * @param mixed $value
   *
   * @return string
   */
  protected function stringValue($value) {
    return "'" . $this->escape((string)$value) . "'";
  }

  /**
   * Quote mysql DB identifier
   *
   * @param mixed $fieldName
   *
   * @return string
   */
  public function quote($fieldName) {
    return "`" . $this->escape((string)$fieldName) . "`";
  }

  public function makeAdjustString($fieldValue, $fieldName) {
    return is_int($fieldName)
      ? $fieldValue
      : (($fieldNameQuoted = $this->quote($fieldName)) . " = " .
        $fieldNameQuoted . " + (" . $this->castAsDbValue($fieldValue) . ")");
  }

  public function makeFieldEqualValue($fieldValue, $fieldName) {
    return is_int($fieldName)
      ? $fieldValue
      : ($this->quote($fieldName) . " = " . $this->castAsDbValue($fieldValue));
  }

  /**
   * Quote table name with `{{ }}`
   *
   * @param mixed $tableName
   *
   * @return string
   */
  protected function quoteTable($tableName) {
    return "`{{" . $this->escape((string)$tableName) . "}}`";
  }

  public function castAsDbValue($value) {
    switch(gettype($value)) {
      case TYPE_INTEGER:
      case TYPE_DOUBLE:
        // do nothing
      break;

      case TYPE_BOOLEAN:
        $value = $value ? 1 : 0;
      break;

      case TYPE_NULL:
        $value = 'NULL';
      break;

      case TYPE_EMPTY:
        // No-type defaults to string
        /** @noinspection PhpMissingBreakStatementInspection */
      case TYPE_ARRAY:
        $value = serialize($value);
      // Continuing with serialized array value
      case TYPE_STRING:
      default:
        $value = $this->stringValue($value);
      break;
    }

    return $value;
  }


  protected function buildCommand($command) {
    switch($this->command = $command) {
      case static::UPDATE:

        $this->build[] = $this->command . " " . $this->quoteTable($this->table);
      break;

      case static::DELETE:

        $this->build[] = $this->command . " FROM " . $this->quoteTable($this->table);
      break;

      case static::REPLACE:
      case static::INSERT_IGNORE:
      case static::INSERT:
        $this->build[] = $this->command . " INTO " . $this->quoteTable($this->table);
      break;

      case static::SELECT:
        $this->build[] = $this->command;
      break;
    }
  }

  // UPDATE and INSERT ... SET
  protected function buildSetFields() {
    $safeFields = array();
    // Sets overwritten by Adjusts
    if ($safeValuesDanger = implode(',', $this->valuesDanger)) {
      $safeFields[] = &$safeValuesDanger;
    }
    if ($safeFieldsEqualValues = implode(',', HelperArray::map($this->values, array($this, 'makeFieldEqualValue'), true))) {
      $safeFields[] = &$safeFieldsEqualValues;
    }
    if ($safeAdjustDanger = implode(',', $this->adjustDanger)) {
      $safeFields[] = &$safeAdjustDanger;
    }
    if ($safeAdjust = implode(',', HelperArray::map($this->adjust, array($this, 'makeAdjustString'), true))) {
      $safeFields[] = &$safeAdjust;
    }
    $safeFieldsString = implode(',', $safeFields);

    if (!empty($safeFieldsString)) {
      $this->build[] = ' SET ';
      $this->build[] = $safeFieldsString;
    }
  }

  // INSERT ... VALUES
  protected function buildFieldNames() {
    $this->build[] = implode(',', HelperArray::map($this->fields, array($this, 'quote')));
  }

  /**
   * Vector values is for batch INSERT/REPLACE
   */
  // TODO - CHECK!
  protected function buildValuesVector() {
    $compiled = array();

    if (!empty($this->valuesDanger)) {
      $compiled = $this->valuesDanger;
    }

    foreach ($this->values as $valuesVector) {
      $compiled[] = '(' . implode(',', HelperArray::map($valuesVector, array($this, 'castAsDbValue'))) . ')';
    }

    $this->build[] = implode(',', $compiled);
  }


  protected function buildWhere() {
    $safeWhere = implode(
      ' AND ',
      $this->whereDanger +
      HelperArray::map($this->where, array($this, 'makeFieldEqualValue'), true)
    );

    if (!empty($safeWhere)) {
      $this->build[] = " WHERE {$safeWhere}";
    }
  }

  protected function buildLimit() {
    if ($this->isOneRow == DB_RECORD_ONE) {
      $this->build[] = ' LIMIT 1';
    }
  }


  public function __toString() {
    return implode('', $this->build);
  }

}


1			<?php
2			/**
3			* Created by Gorlum 07.08.2016 2:36
4			*/
5
6			namespace DBAL;
7
8			use \HelperArray;
9			use \db_mysql;
10			use \classSupernova;
11
12			/**
13			* Class DbQuery
14			*
15			* New replacement for DbQueryConstructor
16			* Simplified version
17			* Chained calls - "Fluid interface"
18			*
19			* @package DBAL
20			*/
21			class DbQuery {
22
23			const SELECT = 'SELECT';
24			const REPLACE = 'REPLACE';
25			const INSERT = 'INSERT';
26			const INSERT_IGNORE = 'INSERT IGNORE';
27			const UPDATE = 'UPDATE';
28			const DELETE = 'DELETE';
29
30			/**
31			* @var db_mysql
32			*/
33			protected $db;
34
35			/**
36			* Which command would be performed
37			*
38			* @var string $command
39			*/
40			protected $command;
41
42			protected $table = '';
43
44			/**
45			* Contains field names integer keyed
46			*
47			* For SELECT {fields} FROM
48			* For INSERT/REPLACE {fields} UPDATE ...
49			*
50			* @var array $fields
51			*/
52			protected $fields = array();
53			protected $where = array();
54			protected $whereDanger = array();
55
56			/**
57			* Contain array of values - fielded or not
58			*
59			* For INSERT/REPLACE ... SET, UPDATE ... SET contains fieldName => value
60			* For INSERT/REPLACE ... VALUES contains values[][]
61			*
62			* @var array
63			*/
64			protected $values = array();
65			/**
66			* Contain array of DANGER values for batch INSERT/REPLACE
67			*
68			* @var string[]
69			*/
70			protected $valuesDanger = array();
71			protected $adjust = array();
72			protected $adjustDanger = array();
73
74
75			/**
76			* Variable for incremental query build
77			*
78			* @var string[] $build
79			*/
80			protected $build = array();
81
82			protected $isOneRow = false;
83
84			/**
85			* DbQuery constructor.
86			*
87			* @param null\|\db_mysql $db
88			*/
89			// TODO - $db should be supplied externally
90	1		public function __construct($db = null) {
91	1		$this->db = empty($db) ? classSupernova::$gc->db : $db;
92	1		}
93
94			/**
95			* @param null\|db_mysql $db
96			*
97			* @return static
98			*/
99	1		public static function build($db = null) {
100	1		return new static($db);
101			}
102
103
104	1		public function select() {
105	1		$this->build = array();
106
107	1		$this->buildCommand(static::SELECT);
108	1		$this->build[] = ' *';
109	1		$this->build[] = " FROM " . $this->quoteTable($this->table);
110	1		$this->buildWhere();
111			$this->buildLimit();
112	1
113			return $this->__toString();
114			}
115	1
116	1		public function delete() {
117			$this->build = array();
118	1
119	1		$this->buildCommand(static::DELETE);
120	1		$this->buildWhere();
121	1		$this->buildLimit();
122	1
123			return $this->__toString();
124	1		}
125
126			public function update() {
127	1		$this->build = array();
128	1
129			$this->buildCommand(static::UPDATE);
130			$this->buildSetFields();
131	1		$this->buildWhere();
132	1		$this->buildLimit();
133	1
134	1		return $this->__toString();
135	1		}
136	1
137	1		/**
138	1		* @param int $replace
139	1		*
140	1		* @return string
141			*/
142	1		protected function setInsertCommand($replace) {
143	1		switch($replace) {
144			case DB_INSERT_IGNORE:
145	1		$result = static::INSERT_IGNORE;
146			break;
147			case DB_INSERT_REPLACE:
148	1		$result = static::REPLACE;
149	1		break;
150			default:
151			$result = static::INSERT;
152	1		break;
153	1		}
154	1
155	1		return $result;
156	1		}
157	1
158	1		public function insertSet($replace = DB_INSERT_PLAIN) {
159	1		$this->build = array();
160	1		$this->buildCommand($this->setInsertCommand($replace));
161	1		$this->buildSetFields();
162
163	1		return $this->__toString();
164	1		}
165	1
166	1		public function insertBatch($replace = DB_INSERT_PLAIN) {
167	1		$this->build = array();
168
169	1		$this->buildCommand($this->setInsertCommand($replace));
170			$this->build[] = " (";
171			$this->buildFieldNames();
172			$this->build[] = ") VALUES ";
173			$this->buildValuesVector();
174
175			return $this->__toString();
176			}
177
178	1
179	1		/**
180			* @param $table
181	1		*
182			* @return $this
183			*/
184			public function setTable($table) {
185			$this->table = $table;
186
187			return $this;
188			}
189	1
190	1		/**
191			* @param bool $oneRow - DB_RECORDS_ALL \|\| DB_RECORD_ONE
192	1		*
193			* @return $this
194			*/
195			public function setOneRow($oneRow = DB_RECORDS_ALL) {
196			$this->isOneRow = $oneRow;
197
198			return $this;
199			}
200	1
201	1		/**
202			* @param array $values
203	1		*
204			* @return $this
205			*/
206			public function setValues($values = array()) {
207			HelperArray::merge($this->values, $values, HelperArray::MERGE_PHP);
208
209			return $this;
210			}
211	1
212	1		/**
213			* @param array $values
214	1		*
215			* @return $this
216			*/
217			public function setValuesDanger($values = array()) {
218			HelperArray::merge($this->valuesDanger, $values, HelperArray::MERGE_PHP);
219
220			return $this;
221			}
222	1
223	1		/**
224			* @param array $values
225	1		*
226			* @return $this
227			*/
228			public function setAdjust($values = array()) {
229			HelperArray::merge($this->adjust, $values, HelperArray::MERGE_PHP);
230
231			return $this;
232			}
233	1
234	1		/**
235			* @param array $values
236	1		*
237			* @return $this
238			*/
239			public function setAdjustDanger($values = array()) {
240			HelperArray::merge($this->adjustDanger, $values, HelperArray::MERGE_PHP);
241
242			return $this;
243			}
244	1
245	1		/**
246			* @param array $fields
247	1		*
248			* @return $this
249			*/
250			public function setFields($fields = array()) {
251			HelperArray::merge($this->fields, $fields, HelperArray::MERGE_PHP);
252
253			return $this;
254			}
255
256			/**
257	1		* Merges WHERE array as array_merge()
258	1		*
259			* @param array $whereArray
260	1		*
261			* @return $this
262			*/
263			public function setWhereArray($whereArray = array()) {
264			HelperArray::merge($this->where, $whereArray, HelperArray::MERGE_PHP);
265
266			return $this;
267			}
268
269			/**
270			* Sets DANGER array - where values should be escaped BEFORE entering DBAL
271			*
272	1		* Deprecated - all values should pass through DBAL
273	1		*
274			* @param array $whereArrayDanger
275	1		*
276			* @return $this
277			*/
278			public function setWhereArrayDanger($whereArrayDanger = array()) {
279			HelperArray::merge($this->whereDanger, $whereArrayDanger, HelperArray::MERGE_PHP);
280
281			return $this;
282			}
283
284
285			/**
286	1		* Wrapper for db_escape()
287	1		*
288			* @param $string
289			*
290	1		* @return string
291			*/
292	1		protected function escape($string) {
293	1		return $this->db->db_escape($string);
294	1		}
295
296	1		protected function escapeEmulator($value) {
297			// Characters encoded are NUL (ASCII 0), \n, \r, \, ', ", and Control-Z.
298			return str_replace(
299			array("\\", "\0", "\n", "\r", "'", "\"", "\z",),
300			array('\\\\', '\0', '\n', '\r', '\\\'', '\"', '\z',),
301			$value
302			);
303			}
304
305			/**
306	1		* Escaping string value and quoting it
307	1		*
308			* @param mixed $value
309			*
310			* @return string
311			*/
312			protected function stringValue($value) {
313			return "'" . $this->escape((string)$value) . "'";
314			}
315
316			/**
317	1		* Quote mysql DB identifier
318	1		*
319			* @param mixed $fieldName
320			*
321	1		* @return string
322	1		*/
323	1		public function quote($fieldName) {
324	1		return "`" . $this->escape((string)$fieldName) . "`";
325	1		}
326
327			public function makeAdjustString($fieldValue, $fieldName) {
328	1		return is_int($fieldName)
329	1		? $fieldValue
330	1		: (($fieldNameQuoted = $this->quote($fieldName)) . " = " .
331	1		$fieldNameQuoted . " + (" . $this->castAsDbValue($fieldValue) . ")");
332			}
333
334			public function makeFieldEqualValue($fieldValue, $fieldName) {
335			return is_int($fieldName)
336			? $fieldValue
337			: ($this->quote($fieldName) . " = " . $this->castAsDbValue($fieldValue));
338			}
339
340			/**
341	1		* Quote table name with `{{ }}`
342	1		*
343			* @param mixed $tableName
344			*
345	13		* @return string
346	13		*/
347	13		protected function quoteTable($tableName) {
348	13		return "`{{" . $this->escape((string)$tableName) . "}}`";
349			}
350	4
351			public function castAsDbValue($value) {
352	9		switch(gettype($value)) {
353	2		case TYPE_INTEGER:
354	2		case TYPE_DOUBLE:
355			// do nothing
356	7		break;
357	1
358	1		case TYPE_BOOLEAN:
359			$value = $value ? 1 : 0;
360	6		break;
361
362			case TYPE_NULL:
363	6		$value = 'NULL';
364	2		break;
365
366	6		case TYPE_EMPTY:
367	6		// No-type defaults to string
368	6		/** @noinspection PhpMissingBreakStatementInspection */
369	6		case TYPE_ARRAY:
370	13		$value = serialize($value);
371			// Continuing with serialized array value
372	13		case TYPE_STRING:
373			default:
374			$value = $this->stringValue($value);
375			break;
376	7		}
377	7
378	7		return $value;
379	1		}
380	1
381
382	6		protected function buildCommand($command) {
383	1		switch($this->command = $command) {
384	1	View Code Duplication	case static::UPDATE:
			0 ignored issues – show Duplication introduced 2016-08-07 17:49 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...
385			$this->build[] = $this->command . " " . $this->quoteTable($this->table);
386	5		break;
387	5
388	5	View Code Duplication	case static::DELETE:
			0 ignored issues – show Duplication introduced 2016-08-07 17:49 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...
389	3		$this->build[] = $this->command . " FROM " . $this->quoteTable($this->table);
390	3		break;
391
392	2		case static::REPLACE:
393	1		case static::INSERT_IGNORE:
394	1		case static::INSERT:
395	7		$this->build[] = $this->command . " INTO " . $this->quoteTable($this->table);
396	7		break;
397
398			case static::SELECT:
399	1		$this->build[] = $this->command;
400	1		break;
401			}
402	1		}
403	1
404	1		// UPDATE and INSERT ... SET
405	1		protected function buildSetFields() {
406	1		$safeFields = array();
407	1		// Sets overwritten by Adjusts
408	1		if ($safeValuesDanger = implode(',', $this->valuesDanger)) {
409	1		$safeFields[] = &$safeValuesDanger;
410	1		}
411	1		if ($safeFieldsEqualValues = implode(',', HelperArray::map($this->values, array($this, 'makeFieldEqualValue'), true))) {
412	1		$safeFields[] = &$safeFieldsEqualValues;
413	1		}
414	1		if ($safeAdjustDanger = implode(',', $this->adjustDanger)) {
415			$safeFields[] = &$safeAdjustDanger;
416	1		}
417	1		if ($safeAdjust = implode(',', HelperArray::map($this->adjust, array($this, 'makeAdjustString'), true))) {
418	1		$safeFields[] = &$safeAdjust;
419	1		}
420	1		$safeFieldsString = implode(',', $safeFields);
421
422			if (!empty($safeFieldsString)) {
423	1		$this->build[] = ' SET ';
424	1		$this->build[] = $safeFieldsString;
425	1		}
426			}
427
428			// INSERT ... VALUES
429			protected function buildFieldNames() {
430			$this->build[] = implode(',', HelperArray::map($this->fields, array($this, 'quote')));
431	1		}
432	1
433			/**
434	1		* Vector values is for batch INSERT/REPLACE
435	1		*/
436	1		// TODO - CHECK!
437			protected function buildValuesVector() {
438	1		$compiled = array();
439	1
440	1		if (!empty($this->valuesDanger)) {
441			$compiled = $this->valuesDanger;
442	1		}
443	1
444			foreach ($this->values as $valuesVector) {
445			$compiled[] = '(' . implode(',', HelperArray::map($valuesVector, array($this, 'castAsDbValue'))) . ')';
446	1		}
447	1
448	1		$this->build[] = implode(',', $compiled);
449	1		}
450	1
451	1
452			protected function buildWhere() {
453	1		$safeWhere = implode(
454	1		' AND ',
455	1		$this->whereDanger +
456	1		HelperArray::map($this->where, array($this, 'makeFieldEqualValue'), true)
457			);
458	1
459	1		if (!empty($safeWhere)) {
460	1		$this->build[] = " WHERE {$safeWhere}";
461	1		}
462	1		}
463
464			protected function buildLimit() {
465	7		if ($this->isOneRow == DB_RECORD_ONE) {
466	7		$this->build[] = ' LIMIT 1';
467			}
468			}
469
470
471			public function __toString() {
472			return implode('', $this->build);
473			}
474
475			}
476

supernova-ws / SuperNova