chillerlan\Database\Drivers\DBDriverAbstract

Complexity

Total Complexity

36

Size/Duplication

Total Lines	248
Duplicated Lines	20.56 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

18 Methods

Rating	Name	Duplication	Size	Complexity
	__escape()	0	1	?
	__raw()	0	1	?
	__prepared()	0	1	?
	__multi()	0	1	?
	__multi_callback()	0	1	?
A	__construct()	0	4	1
A	getDBResource()	0	3	1
B	escape()	28	28	6
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	cacheGet()	0	8	2
A	cacheSet()	0	9	2
A	cacheKey()	0	3	1
A	rawCached()	12	12	2
A	preparedCached()	11	11	2

<?php
/**
 * @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;

/**
 * Class DBDriverAbstract
 *
 * Implements common methods of DBDriverInterface - this class shall only be extended, never instanced
 *
 * @see http://blog.mclaughlinsoftware.com/2010/02/21/php-binding-a-wildcard/ LIKE %...% -> LIKE CONCAT('%',?,'%')
 */
abstract class DBDriverAbstract implements DBDriverInterface{

	/**
	 * 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 __escape($data);

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 __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 array|string $data
	 * @param bool         $specialchars
	 *
	 * @return array|string
	 */
	public function escape($data, bool $specialchars = false){

This method seems to be duplicated in your project.

		if(is_array($data)){

			foreach($data as $key => $value){
				$data[$key] = $this->escape($value, $specialchars);
			}

		}
		else if($data instanceof \stdClass){

			foreach($data as $key => $value){
				$data->{$key} = $this->escape($value, $specialchars);
			}

		}
		else{

			if($specialchars){
				$data = htmlspecialchars($data, ENT_HTML5, 'UTF-8', false);
			}

			$data = $this->__escape($data);
		}

		return $data;

	}

	/**
	 * @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());
		}

	}

	protected function cacheGet(string $sql, array $values = []){

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

		return false;
	}

	protected function cacheSet(string $sql, array $values = [], $response):bool{

		if($this->cacheDriver){
			// @todo: TTL
			return $this->cacheDriver->set($this->cacheKey($sql, $values), $response);
		}

		return false;
	}

	protected function cacheKey(string $sql, array $values):string{
		return hash('sha256', $sql.serialize($values));
	}

	public function rawCached(string $sql, string $index = null, bool $assoc = true){

This method seems to be duplicated in your project.

		$result = $this->cacheGet($sql.$index);

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

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

		return $result;
	}

	public function preparedCached(string $sql, array $values = [], string $index = null, bool $assoc = true){

This method seems to be duplicated in your project.

		$result = $this->cacheGet($sql.$index, $values);

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

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

		return $result;
	}
}