chillerlan\Database\Drivers\MySQLiDriver

Complexity

Total Complexity

35

Size/Duplication

Total Lines	299
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
B	connect()	0	42	6
A	disconnect()	0	3	1
A	getClientInfo()	0	3	1
A	getServerInfo()	0	3	1
A	__escape()	0	3	1
A	__raw()	0	13	3
C	__prepared()	0	67	10
A	__multi()	0	14	2
A	__multi_callback()	0	16	3
A	insertPreparedRow()	0	4	1
A	getTypes()	0	19	4
A	getReferences()	0	11	2

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

namespace chillerlan\Database\Drivers;

use chillerlan\Database\DBException;
use chillerlan\Database\DBResult;
use mysqli, mysqli_result, mysqli_sql_exception, mysqli_stmt;
use ReflectionMethod, stdClass, Exception;

/**
 *
 */
class MySQLiDriver extends DBDriverAbstract{

	/**
	 * Holds the database resource object
	 *
	 * @var mysqli
	 */
	protected $db;

	/**
	 * Establishes a database connection and returns the connection object
	 *
	 * @return \chillerlan\Database\Drivers\DBDriverInterface
	 * @throws DBException
	 */
	public function connect():DBDriverInterface{

		if($this->db instanceof mysqli){
			return $this;
		}

		$this->db = mysqli_init();

It seems like mysqli_init() of type object<mysql> is incompatible with the declared type object<mysqli> of property $db.

		if(!$this->db->options(MYSQLI_OPT_CONNECT_TIMEOUT, $this->options->mysqli_timeout)){
			throw new DBException('Could not set database timeout.');
		}

		if($this->options->use_ssl){
			$this->db->ssl_set(
				$this->options->ssl_key,
				$this->options->ssl_cert,
				$this->options->ssl_ca,
				$this->options->ssl_capath,
				$this->options->ssl_cipher
			);
		}

		if(!$this->db->real_connect(
			$this->options->host,
			$this->options->username,
			$this->options->password,
			$this->options->database,
			(int)$this->options->port,
			$this->options->socket
		)){
			throw new DBException('Could not connect to the database.');
		}

		/**
		 * @see https://mathiasbynens.be/notes/mysql-utf8mb4 How to support full Unicode in MySQL
		 */
		if(!$this->db->set_charset($this->options->mysql_charset)){
			throw new DBException('Could not set database character set.');
		}

		return $this;
	}

	/**
	 * Closes a database connection
	 *
	 * @return bool
	 */
	public function disconnect():bool{
		return $this->db->close();
	}

	/**
	 * Returns info about the used php client
	 *
	 * @return string php's database client string
	 */
	public function getClientInfo():string{
		return $this->db->client_info;
	}

	/**
	 * Returns info about the database server
	 *
	 * @return string database's serverinfo string
	 */
	public function getServerInfo():string{
		return $this->db->server_info;
	}

	/**
	 * @param $data
	 *
	 * @return string
	 */
	protected function __escape($data){
		return $this->db->real_escape_string($data);
	}

	/**
	 * @param string      $sql
	 * @param string|null $index
	 * @param bool        $assoc
	 *
	 * @return bool|\chillerlan\Database\DBResult|\mysqli_result

Consider making the return type a bit more specific; maybe use boolean|DBResult.

	 */
	protected function __raw(string $sql, string $index = null, bool $assoc = true){
		$result = $this->db->query($sql);

		if(is_bool($result)){
			return $result;
		}

		$r = $this->getResult([$result, 'fetch_'.($assoc ? 'assoc' : 'row')], [], $index, $assoc);

		$result->free();

		return $r;
	}

	/**
	 * @param string      $sql
	 * @param array       $values
	 * @param string|null $index
	 * @param bool        $assoc
	 *
	 * @return bool|\chillerlan\Database\DBResult
	 */
	protected function __prepared(string $sql, array $values = [], string $index = null, bool $assoc = true){
		$stmt = $this->db->stmt_init();

		$stmt->prepare($sql);

		if(count($values) > 0){
			(new ReflectionMethod($stmt, 'bind_param'))->invokeArgs($stmt, $this->getReferences($values));
		}

		$stmt->execute();

		$result = $stmt->result_metadata();

		if(is_bool($result)){
			return true; // @todo: returning $result causes trouble on prepared INSERT first line. why???
		}

		// get the columns and their references
		// http://php.net/manual/mysqli-stmt.bind-result.php
		$cols = [];
		$refs = [];

		foreach($result->fetch_fields() as $k => &$field){

The expression $result->fetch_fields() cannot be used as a reference.

			$refs[] = &$cols[$assoc ? $field->name : $k];
		}

		(new ReflectionMethod($stmt, 'bind_result'))->invokeArgs($stmt, $refs);

		// fetch the data
		$output = new DBResult;
		$i      = 0;

		while($stmt->fetch()){
			$row = [];
			$key = $i;

			foreach($cols as $field => &$data){
				$row[$field] = $data;
			}

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

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

		// KTHXBYE!
		$stmt->free_result();
		$stmt->close();

		return $i === 0 ? true : $output;

		/*

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

				$this->addStats([
					'affected_rows' => $stmt->affected_rows,
					'error'         => $stmt->error_list,
					'insert_id'     => $stmt->insert_id,
					'sql'           => $sql,
					'values'        => $values,
					'types'         => $types,
					'index'         => $index,
					'assoc'         => $assoc,
				]);
		*/
	}

	/**
	 * @param string $sql
	 * @param array  $values
	 *
	 * @return bool
	 */
	protected function __multi(string $sql, array $values){
		$stmt = $this->db->stmt_init();
		$stmt->prepare($sql);

		$reflectionMethod = new ReflectionMethod($stmt, 'bind_param');

		foreach($values as $row){
			$this->insertPreparedRow($stmt, $reflectionMethod, $row);
		}

		$stmt->close();

		return true;
	}

	/**
	 * @param string $sql
	 * @param array  $data
	 * @param        $callback
	 *
	 * @return bool
	 */
	protected function __multi_callback(string $sql, array $data, $callback){
		$stmt = $this->db->stmt_init();
		$stmt->prepare($sql);

		$reflectionMethod = new ReflectionMethod($stmt, 'bind_param');

		foreach($data as $row){
			if($row = call_user_func_array($callback, [$row])){
				$this->insertPreparedRow($stmt, $reflectionMethod, $row);
			}
		}

		$stmt->close();

		return true;
	}

	/**
	 * @param \mysqli_stmt      $stmt
	 * @param \ReflectionMethod $reflectionMethod
	 * @param array             $row
	 *
	 * @return void
	 */
	protected function insertPreparedRow(mysqli_stmt &$stmt, ReflectionMethod &$reflectionMethod, array &$row){
		$reflectionMethod->invokeArgs($stmt, $this->getReferences($row));
		$stmt->execute();
	}

	/**
	 * Returns a string of types for the given values
	 *
	 * @link http://php.net/manual/mysqli-stmt.bind-param.php
	 *
	 * @param array $values
	 *
	 * @return string
	 * @internal
	 */
	protected function getTypes(array &$values){

		$types = [];
		foreach($values as &$v){
			switch(gettype($v)){
				case 'integer':

case statements should be defined using a colon.

					$types[] = 'i';
					break;
				case 'double':

case statements should be defined using a colon.

					$types[] = 'd';
					break;
				default:
					$types[] = 's';
					break;
			}
		}

		return implode($types);
	}

	/**
	 * Copies an array to an array of referenced values
	 *
	 * @param array $row
	 *
	 * @return array
	 * @see http://php.net/manual/mysqli-stmt.bind-param.php
	 */
	protected function getReferences(array &$row){
		$references = [];

		foreach($row as &$field){
			$references[] = &$field;
		}

		array_unshift($references, $this->getTypes($row));

		return $references;
	}

}