Maphper\DataSource\DatabaseSelect

Complexity

Total Complexity

38

Size/Duplication

Total Lines	135
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	updateCache()	0	4	3
A	clearIDCache()	0	2	2
A	selectQuery()	0	2	1
B	findById()	0	21	7
A	clearResultCache()	0	2	2
A	__construct()	0	8	1
A	determineAggregateResult()	0	8	4
B	findByField()	0	27	7
A	cacheUpdateRequired()	0	10	5
A	findAggregate()	0	14	4
A	deleteIDFromCache()	0	4	2

<?php
namespace Maphper\DataSource;

class DatabaseSelect {
    private $resultCache = [];
    private $idCache = [];
    private $idCacheTime = [];
    private $selectBuilder;
    private $whereBuilder;
    private $adapter;
    private $databaseModify;
    private $defaultSort;
    private $table;

    public function __construct(DatabaseAdapter $adapter, DatabaseModify $databaseModify, $table, $defaultSort, $cacheMode) {
        $this->adapter = $adapter;
        $this->databaseModify = $databaseModify;
        $this->selectBuilder = new \Maphper\Lib\SelectBuilder();
        $this->whereBuilder = new \Maphper\Lib\Sql\WhereBuilder();
        $this->defaultSort = $defaultSort;
        $this->cacheMode = $cacheMode;

The property cacheMode does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->table = $table;
    }

    private function cacheUpdateRequired($id) {
      if ($this->cacheMode > 0) {
        if (!isset($this->idCacheTime[$id])) return true; // Cache time has not been set for first time

        if (time() - $this->idCacheTime[$id] > $this->cacheMode) return true; // Cache time has expired
      }

      if (!isset($this->idCache[$id])) return true; // Cache has not been set for first time

      return false;
    }

  public function findById($id, $pk) {
		if ($this->cacheMode < 0 || $this->cacheUpdateRequired($id)) {
			try {
				$result = $this->selectQuery($this->selectBuilder->select($this->table, $pk . ' = :id', [':id' => $id], ['limit' => 1]));
			}
			catch (\Exception $e) {
                // Don't issue an error if it cannot be found since we return null
			}

			if (isset($result[0])) $result = $result[0];
			else return null;
		}

    if ($this->cacheMode < 0) return $result; // Cache mode is off

The variable $result does not seem to be defined for all execution paths leading up to this point.

    if ($this->cacheUpdateRequired()) {

The call to Maphper\DataSource\DatabaseSelect::cacheUpdateRequired() has too few arguments starting with id.

      $this->idCache[$id] = $result;
      $this->idCacheTime[$id] = time();
    }

		return $this->idCache[$id];
	}

  public function findByField(array $fields, $options = []) {
		$cacheId = md5(serialize(func_get_args()));

    if ($this->cacheMode < 0 || $this->cacheUpdateRequired($cacheId)) {
			$query = $this->whereBuilder->createSql($fields);

			if (!isset($options['order'])) $options['order'] = $this->defaultSort;

			try {
				$result = $this->selectQuery($this->selectBuilder->select($this->table, $query['sql'], $query['args'], $options));
				$this->databaseModify->addIndex(array_keys($query['args']));
				$this->databaseModify->addIndex(explode(',', $options['order']));
			}
			catch (\Exception $e) {
				$this->errors[] = $e;

The property errors does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

				$result = [];
			}
		}

    if ($this->cacheMode < 0) return $result; // Cache mode is off

The variable $result does not seem to be defined for all execution paths leading up to this point.

    if ($this->cacheUpdateRequired($cacheId)) {
      $this->idCache[$cacheId] = $result;
      $this->idCacheTime[$cacheId] = time();
    }

		return $this->idCache[$cacheId];
	}

    public function findAggregate($function, $field, $group = null, array $criteria = [], array $options = []) {

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

		//Cannot count/sum/max multiple fields, pick the first one. This should only come into play when trying to count() a mapper with multiple primary keys
		if (is_array($field)) $field = $field[0];
		$query = $this->whereBuilder->createSql($criteria);

		try {
			$this->databaseModify->addIndex(array_keys($query['args']));
			$this->databaseModify->addIndex(explode(',', $group));
			$result = $this->selectQuery($this->selectBuilder->aggregate($this->table, $function, $field, $query['sql'], $query['args'], $group));

			return $this->determineAggregateResult($result, $group, $field);
		}
		catch (\Exception $e) {
			return $group ? [] : 0;
		}
	}

    private function determineAggregateResult($result, $group, $field) {
        if ($group != null) {
            $ret = [];
            foreach ($result as $res) $ret[$res->$field] = $res->val;
            return $ret;
        }
        else if (isset($result[0])) return $result[0]->val;
        else return 0;
    }

    private function selectQuery(\Maphper\Lib\Query $query) {
        return $this->adapter->query($query)->fetchAll(\PDO::FETCH_OBJ);
    }

    public function clearResultCache() {
        if ($this->cacheMode >= 0) $this->resultCache = [];
    }

    public function clearIDCache() {
        if ($this->cacheMode >= 0) $this->idCache = [];
    }

    public function updateCache($data, $pkValue) {
        if ($this->cacheMode >= 0) {
  		    if (isset($this->cache[$pkValue])) $this->cache[$pkValue] = (object) array_merge((array)$this->cache[$pkValue], (array)$data);

The property cache does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

  		    else $this->cache[$pkValue] = $data;
        }
    }

    public function deleteIDFromCache($id) {
        if ($this->cacheMode >= 0) {
          unset($this->idCache[$id]);
          unset($this->idCacheTime[$id]);
        }
    }
}