DBAL\DbQuery

Complexity

Total Complexity

62

Size/Duplication

Total Lines	455
Duplicated Lines	1.32 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

100%

Importance

Changes	10
Bugs	0	Features	1

31 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	2
A	build()	0	3	1
A	update()	0	10	1
A	quoteTable()	0	3	1
A	select()	0	11	1
A	delete()	0	9	1
A	setInsertCommand()	0	15	3
A	insert()	0	18	4
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
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

<?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 insert($replace = DB_INSERT_PLAIN, $forceSingleInsert = false) {
    $this->build = array();
    $this->buildCommand($this->setInsertCommand($replace));

    if(!$forceSingleInsert && is_array($this->fields) && !empty($this->fields)) {
      // If there are fields - it's batch insert... unless it forced single insert
      $this->build[] = " (";
      $this->buildFieldNames(); // used $this->fields
      $this->build[] = ") VALUES ";
      $this->buildValuesVector(); // $this->valuesDanger + $this->values

40% of this comment could be valid code. Did you maybe forget this after debugging?

    } else {
      // Otherwise - it's single field insert
      $this->buildSetFields();
    }


    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|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 code seems to be duplicated across your project.

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

      case static::DELETE:

This code seems to be duplicated across your project.

        $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);
  }

}