chillerlan\Database\Drivers\MySQLi\MySQLiDriver

Complexity

Total Complexity

65

Size/Duplication

Total Lines	423
Duplicated Lines	10.4 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes	2
Bugs	0	Features	0

13 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
B	escape()	27	27	6
C	raw()	17	50	11
B	prepared()	0	39	4
B	multi()	0	21	7
D	multi_callback()	0	28	9
A	insertPreparedRow()	0	6	1
F	getResult()	0	39	12
A	getTypes()	0	13	4
A	getReferences()	0	9	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\MySQLi;

use chillerlan\Database\DBException;
use chillerlan\Database\Drivers\DBBaseDriver;
use chillerlan\Database\Drivers\DBDriverInterface;
use mysqli;
use mysqli_result;
use mysqli_sql_exception;
use mysqli_stmt;
use ReflectionClass;
use ReflectionMethod;
use stdClass;

/**
 *
 */
class MySQLiDriver extends DBBaseDriver implements DBDriverInterface{

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

	/**
	 * Establishes a database connection and returns the connection object
	 *
	 * @return mysqli the database resource object
	 * @throws DBException
	 */
	public function connect(){

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

		$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->db;
	}

	/**
	 * Closes a database connection
	 *
	 * @return $this

Should the return type not be MySQLiDriver|null?

	 */
	public function disconnect(){
		$this->db->close();
	}

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

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

	/**
	 * Sanitizer.
	 *
	 * Recursively escapes string values, optional htmlspecialchars()
	 *
	 * @param array|string $data         array or string to escape
	 * @param bool         $specialchars [optional] if true, it performs a htmlspecialchars() on each value given
	 *
	 * @return array|string array or string. escaped. obviously.
	 */
	public function escape($data, $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(is_object($data)){

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

		}
		else{

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

			$data = $this->db->real_escape_string($data);
		}

		return $data;
	}

	/**
	 * Basic SQL query for non prepared statements
	 *
	 * There is no escaping in here, so make sure, your SQL is clean/escaped.
	 * Also, your SQL should NEVER contain user input, use prepared statements in this case.
	 *
	 * If the query was successful it returns either an array of results or true
	 * if it was a void query. On errors, a false will be returned, obviously.
	 *
	 * @param string $sql         The SQL statement
	 * @param string $index       [optional] an index column to assingn as the result's keys
	 * @param bool   $assoc       [optional] If true, the fields are named with the respective column names, otherwise numbered
	 * @param bool   $fetch_array [optional] fetch the vaues as array instead of object
	 *
	 * @return array|bool array with results, true on void query success, otherwise false.
	 * @throws \chillerlan\Database\DBException
	 */
	public function raw($sql, $index = '', $assoc = true, $fetch_array = false){

		try{
			$result = $this->db->query($sql);

			$this->addStats([
				'affected_rows' => $this->db->affected_rows,
				'error'         => $this->db->error_list,
				'insert_id'     => $this->db->insert_id,
				'sql'           => $sql,
				'index'         => $index,
				'assoc'         => $assoc,
				'fetch_array'   => $fetch_array,
			]);

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

			$out = [];
			$method = 'fetch_'.($assoc ? ($fetch_array ? 'assoc' : 'object') : 'row');
			$i = 0 ;

			// ok, we have a result with one or more rows, loop out the rows and output as array
			while($row = $result->{$method}()){

This code seems to be duplicated across your project.

				$key = $i;

				if($assoc && !empty($index)){

					if($fetch_array && isset($row[$index])){
						$key = $row[$index];
					}
					elseif(isset($row->{$index})){
						$key = $row->{$index};
					}

				}

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

			$result->free();

			return $out;
		}
		catch(mysqli_sql_exception $mysqli_sql_exception){
			throw new DBException($mysqli_sql_exception->getMessage());
		}
	}

	/**
	 * Prepared statements wrapper
	 *
	 * Does everything for you: prepares the statement and fetches the results as an object or array
	 * just pass a query along with values and you're done. Not meant for multi-inserts.
	 *
	 * @param string $sql         The SQL statement to prepare
	 * @param array  $values      [optional] the value for each "?" in the statement - in the respective order, of course
	 * @param string $index       [optional] an index column to assingn as the result's keys
	 * @param bool   $assoc       [optional] If true, the fields are named with the respective column names, otherwise numbered
	 * @param bool   $fetch_array [optional] fetch the vaues as array instead of object
	 *
	 * @return array|bool Array with results, true on void query success, otherwise false
	 * @throws \chillerlan\Database\DBException
	 */
	public function prepared($sql, array $values = [], $index = '', $assoc = true, $fetch_array = false){
		$stmt = $this->db->stmt_init();

		if($stmt->prepare($sql)){
			throw new DBException('could not prepare statement ('.$sql.')');
		}

		$types = $this->getTypes($values);

		if(count($values) > 0){
			$references = $this->getReferences($values);
			array_unshift($references, $types);

			(new ReflectionMethod($stmt, 'bind_param'))->invokeArgs($stmt, $references);
		}

		$stmt->execute();

		$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,
			'fetch_array'   => $fetch_array,
		]);

		$result = $stmt->result_metadata();

		// void result
		if(!$result){
			return true;
		}

		return $this->getResult($stmt, $result, $assoc, $fetch_array);
	}

	/**
	 * Prepared multi line insert
	 *
	 * Prepared statement multi insert/update
	 *
	 * @param string $sql    The SQL statement to prepare
	 * @param array  $values a multidimensional array with the values, each row represents one line to insert.
	 *
	 * @return bool true query success, otherwise false
	 * @throws \chillerlan\Database\DBException
	 */
	public function multi($sql, array $values){

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

		$stmt = $this->db->stmt_init();

		if(!$stmt->prepare($sql)){
			throw new DBException('could not prepare statement ('.$sql.')');
		}

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

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

		$stmt->close();
		return true;
	}

	/**
	 * Prepared multi line insert/update with callback
	 * @see https://gist.github.com/krakjoe/6437782
	 * @see https://gist.github.com/krakjoe/9384409
	 *
	 * @param string         $sql      The SQL statement to prepare
	 * @param array          $data     an array with the (raw) data to insert, each row represents one line to insert.
	 * @param callable|array $callback a callback that processes the values for each row.
	 *
	 * @return bool true query success, otherwise false
	 * @throws \chillerlan\Database\DBException
	 */
	public function multi_callback($sql, array $data, $callback){

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

		if(!is_callable($callback) || (is_array($callback) && (!isset($callback[0]) || !is_object($callback[0])))){
			throw new DBException('invalid callback');
		}

		$stmt = $this->db->stmt_init();

		if(!$stmt->prepare($sql)){
			throw new DBException('could not prepare statement ('.$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
	 */
	protected function insertPreparedRow(mysqli_stmt &$stmt, ReflectionMethod &$reflectionMethod, array &$row){
		$references = $this->getReferences($row);
		array_unshift($references, $this->getTypes($references));
		$reflectionMethod->invokeArgs($stmt, $references);
		$stmt->execute();
	}

	/**
	 * @param \mysqli_stmt   $stmt
	 * @param \mysqli_result $result
	 * @param bool           $assoc
	 * @param bool           $fetch_array
	 *
	 * @return array|bool
	 */
	protected function getResult(mysqli_stmt &$stmt, mysqli_result &$result, $assoc, $fetch_array){
		// get the columns and their references
		// http://php.net/manual/mysqli-stmt.bind-result.php
		$cols = $refs = [];

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

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

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

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

		// fetch the data
		$output = [];
		$count = 0;

		while($stmt->fetch()){
			$row = $fetch_array || !$assoc ? [] : new stdClass;

			foreach($cols as $field => &$field){
				if($fetch_array || !$assoc){
					$row[$field] = $field;
				}
				else{
					$row->{$field} = $field;
				}
			}

			$key = !empty($index) && isset($cols[$index]) ? $cols[$index] : $count;
			$output[$key] = $row;

			$count++;
		}

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

		return $count === 0 ? true : $output;
	}

	/**
	 * 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': $types[] = 'i'; break;

The case body in a switch statement must start on the line following the statement.

Terminating statement must be on a line by itself

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

The case body in a switch statement must start on the line following the statement.

Terminating statement must be on a line by itself

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

The default body in a switch statement must start on the line following the statement.

Terminating statement must be on a line by itself

			}
		}

		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;
		}

		return $references;
	}

}