chillerlan\Database\Drivers\DBDriverAbstract

Complexity

Total Complexity

30

Size/Duplication

Total Lines	248
Duplicated Lines	10.48 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

16 Methods

Rating	Name	Duplication	Size	Complexity
	__raw()	0	1	?
	__prepared()	0	1	?
	__multi()	0	1	?
	__multi_callback()	0	1	?
A	__construct()	0	4	1
A	getDBResource()	0	3	1
B	getResult()	0	17	5
A	raw()	0	10	2
A	prepared()	0	10	2
B	multi()	0	14	6
A	multi_callback()	0	18	4
A	cacheKey()	0	3	1
A	cacheGet()	8	8	2
A	cacheSet()	8	8	2
A	rawCached()	5	11	2
A	preparedCached()	5	11	2

<?php
/**
 * Class DBDriverAbstract
 *
 * @filesource   DBDriverAbstract.php
 * @created      04.11.2015
 * @package      chillerlan\Database\Drivers
 * @author       Smiley <smiley@chillerlan.net>
 * @copyright    2015 Smiley
 * @license      MIT
 */

namespace chillerlan\Database\Drivers;

use chillerlan\Database\DBException;
use chillerlan\Database\DBOptions;
use chillerlan\Database\DBResult;
use Psr\SimpleCache\CacheInterface;

/**
  * @see http://blog.mclaughlinsoftware.com/2010/02/21/php-binding-a-wildcard/ LIKE %...% -> LIKE CONCAT('%',?,'%')
 */
abstract class DBDriverAbstract implements DBDriverInterface{

	const CACHEKEY_HASH_ALGO = 'sha256';
	/**
	 * Holds the database resource object
	 *
	 * @var resource
	 */
	protected $db;

	/**
	 * Holds the settings
	 *
	 * @var \chillerlan\Database\DBOptions
	 */
	protected $options;

	/**
	 * @var \Psr\SimpleCache\CacheInterface
	 */
	protected $cacheDriver;

	abstract protected function __raw(string $sql, string $index = null, bool $assoc = true);

For interfaces and abstract methods it is generally a good practice to add a @return annotation even if it is just @return void or @return null, so that implementors know what to do in the overridden method.

	abstract protected function __prepared(string $sql, array $values = [], string $index = null, bool $assoc = true);

For interfaces and abstract methods it is generally a good practice to add a @return annotation even if it is just @return void or @return null, so that implementors know what to do in the overridden method.

	abstract protected function __multi(string $sql, array $values);

For interfaces and abstract methods it is generally a good practice to add a @return annotation even if it is just @return void or @return null, so that implementors know what to do in the overridden method.

	abstract protected function __multi_callback(string $sql, array $data, $callback);

For interfaces and abstract methods it is generally a good practice to add a @return annotation even if it is just @return void or @return null, so that implementors know what to do in the overridden method.

	/**
	 * Constructor.
	 *
	 * @param \chillerlan\Database\DBOptions       $options
	 * @param \Psr\SimpleCache\CacheInterface|null $cacheDriver
	 */
	public function __construct(DBOptions $options, CacheInterface $cacheDriver = null){
		$this->options     = $options;
		$this->cacheDriver = $cacheDriver;
	}

	/**
	 * Returns the plain connection object
	 *
	 * @return resource the database resource object
	 */
	public function getDBResource(){
		return $this->db;
	}

	/**
	 * @param             $callable
	 * @param array       $args
	 * @param string|null $index
	 * @param bool        $assoc
	 *
	 * @return bool|\chillerlan\Database\DBResult
	 */
	protected function getResult($callable, array $args, string $index = null, bool $assoc){
		$out = new DBResult;
		$i   = 0;

		while($row = call_user_func_array($callable, $args)){
			$key = $i;

			if($assoc && !empty($index)){
				$key = $row[$index];
			}

			$out[$key] = $row;
			$i++;
		}

		return $i === 0 ? true : $out;
	}

	/**
	 * @param string      $sql
	 * @param string|null $index
	 * @param bool        $assoc
	 *
	 * @return mixed
	 * @throws \chillerlan\Database\DBException
	 */
	public function raw(string $sql, string $index = null, bool $assoc = true){

		try{
			return $this->__raw($sql, $index, $assoc);
		}
		catch(\Exception $e){
			throw new DBException('sql error: [raw]'.$e->getMessage());
		}

	}

	/**
	 * @param string      $sql
	 * @param array       $values
	 * @param string|null $index
	 * @param bool        $assoc
	 *
	 * @return mixed
	 * @throws \chillerlan\Database\DBException
	 */
	public function prepared(string $sql, array $values = [], string $index = null, bool $assoc = true){

		try{
			return $this->__prepared($sql, $values, $index, $assoc);
		}
		catch(\Exception $e){
			throw new DBException('sql error: [prepared] '.$e->getMessage());
		}

	}

	/**
	 * @param string $sql
	 * @param array  $values
	 *
	 * @return mixed
	 * @throws \chillerlan\Database\DBException
	 */
	public function multi(string $sql, array $values){

		if(!is_array($values) || count($values) < 1 || !is_array($values[0]) || count($values[0]) < 1){
			throw new DBException('invalid data');
		}

		try{
			return $this->__multi($sql, $values);
		}
		catch(\Exception $e){
			throw new DBException('sql error: [multi] '.$e->getMessage());
		}

	}

	/**
	 * @param string         $sql
	 * @param array          $data
	 * @param array|callable $callback
	 *
	 * @return mixed
	 * @throws \chillerlan\Database\DBException
	 */
	public function multi_callback(string $sql, array $data, $callback){

		if(count($data) < 1){
			throw new DBException('invalid data');
		}

		if(!is_callable($callback)){
			throw new DBException('invalid callback');
		}

		try{
			return $this->__multi_callback($sql, $data, $callback);
		}
		catch(\Exception $e){
			throw new DBException('sql error: [multi_callback] '.$e->getMessage());
		}

	}

	/**
	 * @param string      $sql
	 * @param array|null  $values
	 * @param string|null $index
	 *
	 * @return string
	 */
	public function cacheKey(string $sql, array $values = [], string $index = null):string{
		return hash(self::CACHEKEY_HASH_ALGO, serialize([$sql, $values, $index]));
	}

	/**
	 * @param string      $sql
	 * @param array       $values
	 * @param string|null $index
	 *
	 * @return bool|mixed
	 */
	protected function cacheGet(string $sql, array $values = [], string $index = null){

This method seems to be duplicated in your project.

		if($this->cacheDriver){
			return $this->cacheDriver->get($this->cacheKey($sql, $values, $index));
		}

		return false; // @codeCoverageIgnore
	}

	/**
	 * @param string      $sql
	 * @param array       $values
	 * @param string|null $index
	 * @param             $response
	 * @param int|null    $ttl
	 *
	 * @return bool
	 */
	protected function cacheSet(string $sql, array $values = [], string $index = null, $response, int $ttl = null):bool{

This method seems to be duplicated in your project.

		if($this->cacheDriver){
			return $this->cacheDriver->set($this->cacheKey($sql, $values, $index), $response, $ttl);
		}

		return false; // @codeCoverageIgnore
	}


	/**
	 * @param string      $sql
	 * @param string|null $index
	 * @param bool        $assoc
	 * @param int|null    $ttl
	 *
	 * @return bool|mixed
	 */
	public function rawCached(string $sql, string $index = null, bool $assoc = true, int $ttl = null){
		$result = $this->cacheGet($sql, [], $index);

		if(!$result){

This code seems to be duplicated across your project.

			$result = $this->raw($sql, $index, $assoc);

			$this->cacheSet($sql, [], $index, $result, $ttl);
		}

		return $result;
	}

	/**
	 * @param string      $sql
	 * @param array       $values
	 * @param string|null $index
	 * @param bool        $assoc
	 * @param int|null    $ttl
	 *
	 * @return bool|mixed
	 */
	public function preparedCached(string $sql, array $values = [], string $index = null, bool $assoc = true, int $ttl = null){
		$result = $this->cacheGet($sql, $values, $index);

		if(!$result){

This code seems to be duplicated across your project.

			$result = $this->prepared($sql, $values, $index, $assoc);

			$this->cacheSet($sql, $values, $index, $result, $ttl);
		}

		return $result;
	}
}