DbQueryConstructor

Complexity

Total Complexity

71

Size/Duplication

Total Lines	452
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	7

Test Coverage

Coverage

54.24%

Importance

Changes	4
Bugs	0	Features	0

34 Methods

Rating	Name	Duplication	Size	Complexity
A	setIdField()	0	5	1
A	variables()	0	5	1
A	setAlias()	0	5	1
A	select()	0	8	1
A	from()	0	6	1
A	field()	0	14	4
A	fieldLiteral()	0	3	1
A	fieldSingleFunction()	0	3	1
A	fieldCount()	0	3	1
A	fieldIsNull()	0	3	1
A	compileGroupBy()	0	5	2
A	compileOrderBy()	0	4	2
A	compileHaving()	0	4	2
A	fieldMax()	0	3	1
A	__call()	0	20	4
A	limit()	0	5	2
A	offset()	0	5	2
B	getParamsFromStaticClass()	0	11	5
A	build()	0	9	1
A	_reset()	0	23	2
A	arrayEscape()	0	8	2
A	compileOperation()	0	11	3
A	compileSubject()	0	3	1
A	compileFrom()	0	6	2
A	compileJoin()	0	3	2
A	compileWhere()	0	4	2
A	compileLimit()	0	6	4
A	compileForUpdate()	0	8	4
A	selectFieldsToString()	0	17	4
B	processField()	0	17	5
A	__toString()	0	16	1
A	selectIterator()	0	3	1
A	selectRow()	0	5	2
A	selectValue()	0	5	2

<?php

/**
 * Class DbQueryConstructor
 *
 * @method DbQueryConstructor fields(mixed $value, int $mergeStrategy = HelperArray::MERGE_PHP)
 * @method DbQueryConstructor join(mixed $value, int $mergeStrategy = HelperArray::MERGE_PHP)
 * @method DbQueryConstructor where(array $value, int $mergeStrategy = HelperArray::MERGE_PHP)
 * @method DbQueryConstructor groupBy(array $value, int $mergeStrategy = HelperArray::MERGE_PHP)
 * @method DbQueryConstructor orderBy(array $value, int $mergeStrategy = HelperArray::MERGE_PHP)
 * @method DbQueryConstructor having(mixed $value, int $mergeStrategy = HelperArray::MERGE_PHP)
 * @method DbQueryConstructor setFetchOne(bool $fetchOne = true)
 * @method DbQueryConstructor setForUpdate(bool $forUpdate = true)
 * @method DbQueryConstructor setSkipLock(bool $skipLock = true)
 *
 */
class DbQueryConstructor extends DbSqlAware {

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

  protected static $allowedOperations = array(
    self::SELECT,
  );

  /**
   * List of array properties names that should be merged on each call of setter
   *
   * @var string[] $propListArrayMerge
   */
  protected static $propListArrayMerge = array('fields', 'join', 'where', 'groupBy', 'orderBy', 'having');
  /**
   * List of setters that will simple set property with default value TRUE
   *
   * @var string[] $propListSetDefaultTrue
   */
  protected static $propListSetDefaultTrue = array('setFetchOne', 'setForUpdate', 'setSkipLock');

  public $operation = '';

  public $table = '';
  public $alias = '';

  public $idField = '';

  /**
   * @var array
   */
  public $fields = array();

  public $join = array();

  public $where = array();
  public $groupBy = array();
  public $orderBy = array();
  public $having = array();

  public $limit = 0;
  public $offset = 0;

  public $fetchOne = false;
  public $forUpdate = false;
  public $skipLock = false;

  public $variables = array();

  protected $_compiledQuery = array();

  /**
   * @param string $fieldName
   *
   * @return $this
   */
  public function setIdField($fieldName) {
    $this->idField = $fieldName;

    return $this;
  }

  /**
   * Sets internal variables
   *
   * @param array $values
   *
   * @return $this
   */
  public function variables($values) {
    $this->variables = $values;

    return $this;
  }


  /**
   * @param string $alias
   *
   * @return $this
   */
  public function setAlias($alias) {
    $this->alias = $alias;

    return $this;
  }

  /**
   * @return $this
   */
  public function select() {
    $this->operation = DbQueryConstructor::SELECT;
//    if (empty($this->fields) && $initFields) {

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

//      $this->fields = array('*');
//    }

    return $this;
  }


  /**
   * @param string $tableName
   * @param string $alias
   *
   * @return $this
   */
  public function from($tableName, $alias = '') {
    $this->table = $tableName;
    $this->setAlias($alias);

    return $this;
  }

  /**
   * @param mixed ...
   *
   * @return $this
   */
  public function field() {
    $arguments = func_get_args();

    // Special case - call method with array of fields
    if (count($arguments) == 1 && is_array($arguments[0])) {
      $arguments = array_shift($arguments);
    }

    foreach ($arguments as $arg) {

The expression $arguments of type array|null is not guaranteed to be traversable. How about adding an additional type check?

      $this->fields[] = $arg;
    }

    return $this;
  }

  public function fieldLiteral($field = '0', $alias = DbSqlLiteral::SQL_LITERAL_ALIAS_NONE) {

The parameter $alias is not used and could be removed.

    return $this->field(DbSqlLiteral::build($this->db)->literal($field));
  }

  public function fieldSingleFunction($functionName, $field = '*', $alias = DbSqlLiteral::SQL_LITERAL_ALIAS_NONE) {
    return $this->field(DbSqlLiteral::build($this->db)->buildSingleArgument($functionName, $field, $alias));
  }

  public function fieldCount($field = '*', $alias = DbSqlLiteral::SQL_LITERAL_ALIAS_NONE) {
    return $this->field(DbSqlLiteral::build($this->db)->count($field, $alias));
  }

  public function fieldIsNull($field = '*', $alias = DbSqlLiteral::SQL_LITERAL_ALIAS_NONE) {
    return $this->field(DbSqlLiteral::build($this->db)->isNull($field, $alias));
  }

  public function fieldMax($field = '*', $alias = DbSqlLiteral::SQL_LITERAL_ALIAS_NONE) {
    return $this->field(DbSqlLiteral::build($this->db)->max($field, $alias));
  }

  /**
   * @param string  $name
   * @param mixed[] $arguments
   *
   * @return $this
   */
  public function __call($name, $arguments) {
    if (in_array($name, self::$propListArrayMerge)) {
//      array_unshift($arguments, '');

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

//      $arguments[0] = &$this->$name;
//      call_user_func_array('HelperArray::merge', $arguments);
      HelperArray::merge($this->$name, $arguments[0], HelperArray::keyExistsOr($arguments, 1, HelperArray::MERGE_PHP));
    } elseif (in_array($name, self::$propListSetDefaultTrue)) {
      $varName = lcfirst(substr($name, 3));
      if (!array_key_exists(0, $arguments)) {
        $arguments[0] = true;
      }
      $this->$varName = $arguments[0];
    }
    // TODO - make all setters protected ??

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

//    elseif(method_exists($this, $name)) {
//      call_user_func_array(array($this, $name), $arguments);
//    }

    return $this;
  }

  /**
   * @param int $limit
   *
   * @return $this
   */
  public function limit($limit) {
    $this->limit = is_numeric($limit) ? $limit : 0;

It seems like is_numeric($limit) ? $limit : 0 can also be of type double or string. However, the property $limit is declared as type integer. Maybe add an additional type check?

    return $this;
  }

  /**
   * @param int $offset
   *
   * @return $this
   */
  public function offset($offset) {
    $this->offset = is_numeric($offset) ? $offset : 0;

It seems like is_numeric($offset) ? $offset : 0 can also be of type double or string. However, the property $offset is declared as type integer. Maybe add an additional type check?

    return $this;
  }

  /**
   * @param string $className
   *
   * @return $this
   */
  // TODO - rewrite
  public function getParamsFromStaticClass($className) {
    if (is_string($className) && $className && class_exists($className)) {
      if(method_exists($className, 'getDb')) {
        $this->setDb($className::getDb());
      }
      $this->from($className::$_table);
      $this->setIdField($className::$_idField);
    }

    return $this;
  }

  /**
   * @param db_mysql|null $db
   * @param string|object|DBStaticRecord|DbSqlAware $className
   *
   * @return static
   */
  public static function build($db = null, $className = '') {
    /**
     * @var static $result
     */
    $result = parent::build(null);
    $result->getParamsFromStaticClass($className);

    return $result;
  }

  /**
   * Resets statement
   *
   * @param bool $full
   *
   * @return static
   */
  protected function _reset($full = true) {
    if ($full) {
      $this->operation = '';
      $this->table = '';
      $this->alias = '';
      $this->idField = '';
    }

    $this->fields = array();
    $this->where = array();
    $this->groupBy = array();
    $this->orderBy = array();
    $this->having = array();

    $this->limit = 0;
    $this->offset = 0;

    $this->fetchOne = false;
    $this->forUpdate = false;
    $this->skipLock = false;

    return $this;
  }


  /**
   * @param array $array
   *
   * @return array
   */
  protected function arrayEscape(&$array) {
    $result = array();
    foreach ($array as $key => &$value) {
      $result[$key] = $this->escapeString($value);
    }

    return $result;
  }

  protected function compileOperation() {
    if (empty($this->operation)) {
      throw new ExceptionDbOperationEmpty();
    }

    if (!in_array($this->operation, self::$allowedOperations)) {
      throw new ExceptionDbOperationRestricted();
    }

    $this->_compiledQuery[] = $this->escapeString($this->operation);
  }

  protected function compileSubject() {
    $this->_compiledQuery[] = $this->selectFieldsToString($this->fields);
  }

  protected function compileFrom() {
    $this->_compiledQuery[] = 'FROM `{{' . $this->escapeString($this->table) . '}}`';
    if (!empty($this->alias)) {
      $this->_compiledQuery[] = 'AS `' . $this->escapeString($this->alias) . '`';
    }
  }

  protected function compileJoin() {
    !empty($this->join) ? $this->_compiledQuery[] = implode(' ', $this->join) : false;
  }

  protected function compileWhere() {
    // TODO - fields should be escaped !!
    !empty($this->where) ? $this->_compiledQuery[] = 'WHERE ' . implode(' AND ', $this->where) : false;
  }

  protected function compileGroupBy() {
    // TODO - fields should be escaped !!

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

//    !empty($this->groupBy) ? $this->_compiledQuery[] = 'GROUP BY ' . implode(',', $this->arrayEscape($this->groupBy)) : false;
    !empty($this->groupBy) ? $this->_compiledQuery[] = 'GROUP BY ' . $this->selectFieldsToString($this->groupBy) : false;
  }

  protected function compileOrderBy() {
    // TODO - fields should be escaped !!
    !empty($this->orderBy) ? $this->_compiledQuery[] = 'ORDER BY ' . implode(',', $this->arrayEscape($this->orderBy)) : false;
  }

  protected function compileHaving() {
    // TODO - fields should be escaped !!
    !empty($this->having) ? $this->_compiledQuery[] = 'HAVING ' . implode(' AND ', $this->having) : false;
  }

  protected function compileLimit() {
    // TODO - fields should be escaped !!
    if ($limit = $this->fetchOne ? 1 : $this->limit) {
      $this->_compiledQuery[] = 'LIMIT ' . $limit . (!empty($this->offset) ? ' OFFSET ' . $this->offset : '');
    }
  }

  protected function compileForUpdate() {
    $this->_compiledQuery[] =
      // forUpdate flag forces select with row locking - didn't look at skipLock flag
      $this->forUpdate
      ||
      // Also row locked when transaction is up and skipLock flag is not set
      (classSupernova::db_transaction_check(false) && !$this->skipLock) ? 'FOR UPDATE' : '';
  }

  /**
   * @param array|mixed $fields
   *
   * @return string
   * @throws ExceptionDBFieldEmpty
   */
  protected function selectFieldsToString($fields) {
    HelperArray::makeArrayRef($fields);

    $result = array();
    foreach ($fields as $fieldName) {
      $string = $this->processField($fieldName);
      if ($string !== '') {
        $result[] = $string;
      }
    }

    if (empty($result)) {
      throw new ExceptionDBFieldEmpty();
    }

    return implode(',', $result);
  }

  /**
   * @param mixed $fieldName
   *
   * @return string
   */
  protected function processField($fieldName) {
    if (is_bool($fieldName)) {
      $result = (string)intval($fieldName);
    } elseif (is_numeric($fieldName)) {
      $result = $fieldName;
    } elseif (is_null($fieldName)) {
      $result = 'NULL';
    } else {
      // Field has other type - string or should be convertible to string
      $result = (string)$fieldName;
      if (!$fieldName instanceof DbSqlLiteral) {
        $result = $this->quoteField($fieldName);

It seems like $fieldName defined by parameter $fieldName on line 396 can also be of type array or object; however, DbSqlAware::quoteField() does only seem to accept string, maybe add an additional type check?

      }
    }

    return $result;
  }


  /**
   * @return string
   * @throws ExceptionDbOperationEmpty
   * @throws ExceptionDbOperationRestricted
   */
  public function __toString() {
    $this->_compiledQuery = array();

    $this->compileOperation();
    $this->compileSubject();
    $this->compileFrom();
    $this->compileJoin();
    $this->compileWhere();
    $this->compileGroupBy();
    $this->compileOrderBy();
    $this->compileHaving();
    $this->compileLimit();
    $this->compileForUpdate();

    return implode(' ', $this->_compiledQuery);
  }

  /**
   * @param bool $skip_query_check
   *
   * @return DbEmptyIterator|DbMysqliResultIterator
   */
  public function selectIterator($skip_query_check = false) {
    return $this->getDb()->doQueryIterator($this->select()->__toString(), $skip_query_check);
  }

  /**
   * @param bool $skip_query_check
   *
   * @return array
   */
  public function selectRow($skip_query_check = false) {
    $result = $this->getDb()->doQueryFetch($this->select()->setFetchOne()->__toString(), $skip_query_check);

    return is_array($result) ? $result : array();
  }

  /**
   * @param bool $skip_query_check
   *
   * @return mixed|null
   */
  public function selectValue($skip_query_check = false) {
    $result = $this->selectRow($skip_query_check);

    return is_array($result) ? reset($result) : null;
  }

}