Ubiquity\db\traits\DatabaseOperationsTrait

Complexity

Total Complexity

47

Size/Duplication

Total Lines	239
Duplicated Lines	0 %

Test Coverage

Coverage

87.1%

Importance

Changes	8
Bugs	0	Features	3

28 Methods

Rating	Name	Duplication	Size	Complexity
A	prepareAndFetchAll()	0	2	1
A	_connect()	0	2	1
A	query()	0	2	1
A	fetchAll()	0	2	1
A	getCacheValue()	0	12	3
A	prepareAndFetchAllColumn()	0	2	1
A	prepareNamedStatement()	0	2	1
A	prepareAndFetchOne()	0	2	1
A	getDbObject()	0	2	1
A	bindValueFromStatement()	0	2	1
A	getNamedStatement()	0	2	1
A	isConnected()	0	2	2
A	execute()	0	2	1
B	prepareAndExecute()	0	14	7
A	prepareAndExecuteNoCache()	0	3	1
A	ping()	0	2	2
A	lastInserId()	0	2	1
A	storeCache()	0	2	1
A	queryColumn()	0	2	1
A	getDaoPreparedStatement()	0	3	1
B	_optExecuteAndFetch()	0	17	8
A	prepareAndFetchColumn()	0	7	2
A	count()	0	4	2
A	_optExecuteAndFetchNoCache()	0	2	1
A	prepareStatement()	0	2	1
A	getUpdateStatement()	0	2	1
A	prepareAndExecuteUpdate()	0	2	1
A	getStatement()	0	2	1

<?php
namespace Ubiquity\db\traits;

use Ubiquity\log\Logger;
use Ubiquity\cache\database\DbCache;
use Ubiquity\exceptions\CacheException;
use Ubiquity\db\SqlUtils;

/**
 * Ubiquity\db\traits$DatabaseOperationsTrait
 * This class is part of Ubiquity
 *
 * @author jcheron <myaddressmail@gmail.com>
 * @version 1.0.4
 * @property mixed $cache
 * @property array $options
 * @property \Ubiquity\db\providers\AbstractDbWrapper $wrapperObject
 */
trait DatabaseOperationsTrait {

	abstract public function getDSN();

	public function getDbObject() {
		return $this->wrapperObject->getDbInstance();
	}

	public function _connect() {
		$this->wrapperObject->connect($this->dbType, $this->dbName, $this->serverName, $this->port, $this->user, $this->password, $this->options);
	}

	/**
	 * Executes an SQL statement, returning a result set as a statement object
	 *
	 * @param string $sql
	 * @return object|boolean
	 */
	public function query($sql) {
		return $this->wrapperObject->query($sql);
	}

	/**
	 *
	 * @param string $tableName
	 * @param string $condition
	 * @param array|string $fields
	 * @param array $parameters
	 * @param boolean|null $useCache
	 * @return array
	 */
	public function prepareAndExecute($tableName, $condition, $fields, $parameters = null, $useCache = false, $one = false) {
		$cache = ((DbCache::$active && $useCache !== false) || (! DbCache::$active && $useCache === true));
		$result = false;
		if ($cache) {
			$result = $this->getCacheValue($tableName, $condition, $parameters, $cKey);
		}
		if ($result === false) {
			$quote = SqlUtils::$quote;
			$result = $this->wrapperObject->_optPrepareAndExecute("SELECT {$fields} FROM {$quote}{$tableName}{$quote} {$condition}", $parameters, $one);
			if ($cache) {
				$this->cache->store($tableName, $cKey, $result);

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

			}
		}
		return $result;
	}

	private function getCacheValue($tableName, $condition, $parameters, &$cKey) {
		$cKey = $condition;
		if (\is_array($parameters)) {
			$cKey .= \implode(',', $parameters);
		}
		try {
			$result = $this->cache->fetch($tableName, $cKey);
			Logger::info("Cache", "fetching cache for table {$tableName} with condition : {$condition}", "Database::prepareAndExecute", $parameters);
		} catch (\Exception $e) {
			throw new CacheException("Cache is not created in Database constructor");
		}
		return $result;
	}

	public function _optExecuteAndFetch($statement, $tableName, $condition, $parameters = null, $useCache = false, $one = false) {
		$cache = ((DbCache::$active && $useCache !== false) || (! DbCache::$active && $useCache === true));
		$result = false;
		if ($cache) {
			$result = $this->getCacheValue($tableName, $condition, $parameters, $cKey);
		}
		if ($result === false) {
			if ($one) {
				$result = $this->wrapperObject->_optExecuteAndFetchOne($statement, $parameters);

The method _optExecuteAndFetchOne() does not exist on Ubiquity\db\providers\AbstractDbWrapper. Did you maybe mean _optExecuteAndFetch()?

			} else {
				$result = $this->wrapperObject->_optExecuteAndFetch($statement, $parameters);

Are you sure the assignment to $result is correct as $this->wrapperObject->_optExecuteAndFetch($statement, $parameters) targeting Ubiquity\db\providers\AbstractDbWrapper::_optExecuteAndFetch() seems to always return null.

			}
			if ($cache) {
				$this->cache->store($tableName, $cKey, $result);
			}
		}
		return $result;
	}

	public function _optExecuteAndFetchNoCache($statement, $parameters = null, $one = false) {
		return $this->wrapperObject->_optExecuteAndFetch($statement, $parameters, $one);

Are you sure the usage of $this->wrapperObject->_optExecuteAndFetch($statement, $parameters, $one) targeting Ubiquity\db\providers\AbstractDbWrapper::_optExecuteAndFetch() seems to always return null.

	}

	public function getDaoPreparedStatement($tableName, $condition, $fields) {
		$quote = SqlUtils::$quote;
		return $this->wrapperObject->prepareStatement("SELECT {$fields} FROM {$quote}{$tableName}{$quote} {$condition}");
	}

	public function prepareAndExecuteNoCache($tableName, $condition, $fields, $parameters = null) {
		$quote = SqlUtils::$quote;
		return $this->wrapperObject->_optPrepareAndExecute("SELECT {$fields} FROM {$quote}{$tableName}{$quote} {$condition}", $parameters);
	}

	public function storeCache() {
		$this->cache->storeDeferred();
	}

	public function prepareAndFetchAll($sql, $parameters = null, $mode = null) {
		return $this->wrapperObject->fetchAll($this->wrapperObject->_getStatement($sql), $parameters, $mode);
	}

	public function prepareAndFetchOne($sql, $parameters = null, $mode = null) {
		return $this->wrapperObject->fetchOne($this->wrapperObject->_getStatement($sql), $parameters, $mode);
	}

	public function prepareAndFetchAllColumn($sql, $parameters = null, $column = null) {
		return $this->wrapperObject->fetchAllColumn($this->wrapperObject->_getStatement($sql), $parameters, $column);
	}

	public function prepareAndFetchColumn($sql, $parameters = null, $columnNumber = null) {
		$statement = $this->wrapperObject->_getStatement($sql);
		if ($statement->execute($parameters)) {
			Logger::info("Database", $sql, "prepareAndFetchColumn", $parameters);
			return $statement->fetchColumn($columnNumber);
		}
		return false;
	}

	/**
	 *
	 * @param string $sql
	 * @return object statement
	 */
	private function getStatement($sql) {
		return $this->wrapperObject->_getStatement($sql);
	}

	/**
	 *
	 * @param string $sql
	 * @return object statement
	 */
	public function getUpdateStatement($sql) {
		return $this->wrapperObject->_getStatement($sql);
	}

	/**
	 * Prepares a statement and execute a query for update (INSERT, UPDATE, DELETE...)
	 *
	 * @param string $sql
	 * @param array|null $parameters
	 * @return boolean
	 */
	public function prepareAndExecuteUpdate($sql, $parameters = null) {
		return $this->getUpdateStatement($sql)->execute($parameters);
	}

	/**
	 * Execute an SQL statement and return the number of affected rows (INSERT, UPDATE or DELETE)
	 *
	 * @param string $sql
	 * @return int the number of rows that were modified or deleted by the SQL statement you issued
	 */
	public function execute($sql) {
		return $this->wrapperObject->execute($sql);
	}

	/**
	 * Prepares a statement for execution and returns a statement object
	 *
	 * @param String $sql
	 * @return object|boolean
	 */
	public function prepareStatement($sql) {
		return $this->wrapperObject->prepareStatement($sql);
	}

	/**
	 * Prepares and returns a statement for execution and gives it a name.
	 *
	 * @param
	 *        	$name
	 * @param String $sql
	 * @return mixed
	 */

The doc comment $name at position 0 could not be parsed: Unknown type name '$name' at position 0 in $name.

	public function prepareNamedStatement(string $name, string $sql) {
		return $this->wrapperObject->prepareNamedStatement($name, $sql);
	}

	/**
	 * Returns the statement corresponding to the name.
	 *
	 * @param string $name
	 * @param ?string $sql
	 * @return mixed
	 */
	public function getNamedStatement(string $name, ?string $sql = null) {
		return $this->wrapperObject->getNamedStatement($name, $sql);
	}

	/**
	 * Sets $value to $parameter
	 *
	 * @param mixed $statement
	 * @param String $parameter
	 * @param mixed $value
	 * @return boolean
	 */
	public function bindValueFromStatement($statement, $parameter, $value) {
		return $this->wrapperObject->bindValueFromStatement($statement, $parameter, $value);
	}

	/**
	 * Returns the last insert id
	 *
	 * @return string
	 */
	public function lastInserId($name = null) {
		return $this->wrapperObject->lastInsertId($name);
	}

	/**
	 * Returns the number of records in $tableName matching with the condition passed as a parameter
	 *
	 * @param string $tableName
	 * @param string $condition
	 *        	Part following the WHERE of an SQL statement
	 */
	public function count($tableName, $condition = '') {
		if ($condition != '')
			$condition = " WHERE " . $condition;
		return $this->wrapperObject->queryColumn("SELECT COUNT(*) FROM " . $tableName . $condition);
	}

	public function queryColumn($query, $columnNumber = null) {
		return $this->wrapperObject->queryColumn($query, $columnNumber);
	}

	public function fetchAll($query, $mode = null) {
		return $this->wrapperObject->queryAll($query, $mode);
	}

	public function isConnected() {
		return ($this->wrapperObject !== null && $this->ping());
	}

	public function ping() {
		return ($this->wrapperObject && $this->wrapperObject->ping());
	}
}