MySql::connect() - Code Metrics - darya/framework - Measure and Improve Code Quality continuously with Scrutinizer

MySql::connect() A
last analyzed 2021-02-13 01:04 UTC

↳ Parent: MySql

Complexity

Conditions	3
Paths	3

Size

Total Lines	19
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	3
eloc	11
nc	3
nop	0
dl	0
loc	19
rs	9.9
c	0
b	0
f	0

<?php
namespace Darya\Database\Connection;

use mysqli as php_mysqli;
use mysqli_result;
use mysqli_stmt;
use Darya\Database\AbstractConnection;
use Darya\Database\Error;
use Darya\Database\Result;
use Darya\Database\Query;
use Darya\Database\Query\Translator;

/**
 * Darya's MySQL database interface. Uses mysqli.
 *
 * @author Chris Andrew <[email protected]>
 */
class MySql extends AbstractConnection
{
	/**
	 * @var php_mysqli
	 */
	protected $connection;

	/**
	 * Copy a flat array. Aids copying fetched results without the mysqlnd
	 * extension installed without retaining references to array elements.
	 *
	 * Who knew references could be so awkward to get rid of?
	 *
	 * @param array $array
	 * @return array
	 */
	protected static function copyArray($array)
	{
		$copy = array();

		foreach ($array as $key => $value) {
			$copy[$key] = $value;
		}

		return $copy;
	}

	/**
	 * Fetch result data from the given MySQLi statement.
	 *
	 * Expects the statement to have been executed.
	 *
	 * Attempts to use mysqli_stmt::get_result() and mysqli_result::fetch_all(),
	 * but falls back to fetching from the statement directly if get_result()
	 * isn't found (mysqlnd isn't installed).
	 *
	 * @param mysqli_stmt $statement
	 * @return array array($data, $fields, $count)
	 */
	protected function fetchResult(mysqli_stmt $statement)
	{
		if (!method_exists($statement, 'get_result')) {
			return $this->fetchResultWithoutNativeDriver($statement);
		}

		$result = $statement->get_result();

		if (is_object($result) && $result instanceof mysqli_result) {
			return array(
				$result->fetch_all(MYSQLI_ASSOC),
				$result->fetch_fields(),
				$result->num_rows
			);
		}

		return array(array(), array(), null);
	}

	/**
	 * Method for fetching the same information in a way that doesn't require
	 * mysqlnd to be installed.
	 *
	 * Fetches directly from the statement with variable binding instead.
	 *
	 * @param mysqli_stmt $statement
	 * @return array
	 */
	protected function fetchResultWithoutNativeDriver(mysqli_stmt $statement)
	{
		$statement->store_result();

		$data = array();
		$metadata = $statement->result_metadata();

		$row = array();
		$count = 0;
		$fields = array();
		$arguments = array();

		if ($metadata) {

			while ($field = $metadata->fetch_field()) {
				$fields[] = (array) $field;
				$arguments[] = &$row[$field->name];
			}

			call_user_func_array(array($statement, 'bind_result'), $arguments);

			while ($statement->fetch()) {
				$data[] = static::copyArray($row);
				$count++;
			}

		}

		return array($data, $fields, $count);
	}

	/**
	 * Retrieve the type of a variable for binding mysqli parameters.
	 *
	 * @param mixed $parameter
	 * @return string
	 */
	protected function prepareType($parameter)
	{
		if (is_int($parameter)) {
			return 'i';
		}

		if (is_float($parameter)) {
			return 'd';
		}

		return 's';
	}

	/**
	 * Prepares an array of values as an array of references to those values.
	 *
	 * Required for PHP 5.3+ to prevent warnings when dynamically invoking
	 * mysqli_stmt::bind_param().
	 *
	 * @param array $parameters
	 * @return array
	 */
	protected function prepareReferences(array $parameters)
	{
		$references = array();

		foreach ($parameters as $key => $value) {
			$references[$key] = &$parameters[$key];
		}

		return $references;
	}

	/**
	 * Prepare the given query and parameters as a mysqli statement.
	 *
	 * @param string $query
	 * @param array  $parameters [optional]
	 * @return \mysqli_stmt
	 */
	protected function prepareStatement($query, $parameters = array())
	{
		$statement = $this->connection->stmt_init();

		if (!$statement->prepare($query)) {
			return $statement;
		}

		if (empty($parameters)) {
			return $statement;
		}

		$types = '';

		foreach ((array) $parameters as $parameter) {
			$types .= $this->prepareType($parameter);
		}

		array_unshift($parameters, $types);

		call_user_func_array(
			array($statement, 'bind_param'),
			$this->prepareReferences($parameters)
		);

		return $statement;
	}

	/**
	 * Prepare a result array using the given mysqli statement.
	 *
	 * @param mysqli_stmt $statement
	 * @return array
	 */
	protected function prepareStatementResult(mysqli_stmt $statement)
	{
		list($data, $fields, $count) = $this->fetchResult($statement);

		$result = array(
			'data'      => $data,
			'fields'    => $fields,
			'affected'  => $statement->affected_rows,
			'num_rows'  => $count,
			'insert_id' => $statement->insert_id
		);

		$statement->free_result();

		return $result;
	}

	/**
	 * Initiate the connection.
	 *
	 * @return bool
	 */
	public function connect()
	{
		if ($this->connected()) {
			return true;
		}

		$this->connection = new php_mysqli(
			$this->details['host'],
			$this->details['user'],
			$this->details['pass'],
			$this->details['name'],
			$this->details['port']
		);

		if ($this->connection->connect_errno) {
			return false;
		}

		return $this->connected = true;
	}

	/**
	 * Determine whether the connection is currently active.
	 *
	 * @return bool
	 */
	public function connected()
	{
		return $this->connected && !$this->connection->connect_errno;
	}

	/**
	 * Close the connection.
	 */
	public function disconnect()
	{
		$this->connection->close();
		$this->connected = false;
	}

	/**
	 * Retrieve the query translator.
	 *
	 * @return Translator
	 */
	public function translator()
	{
		if (!$this->translator) {
			$this->translator = new Translator\MySql;
		}

		return $this->translator;
	}

	/**
	 * Query the database with the given query and optional parameters.
	 *
	 * TODO: Simplify this.
	 *
	 * @param Query|string $query
	 * @param array        $parameters [optional]
	 * @return Result
	 */
	public function query($query, array $parameters = array())
	{
		if (!($query instanceof Query)) {
			$query = new Query((string) $query, $parameters);
		}

		$this->lastResult = null;

		$this->connect();

		if (!$this->connected()) {
			$this->lastResult = new Result($query, array(), array(), $this->error());

			$this->event('mysql.query', array($this->lastResult));

			return $this->lastResult;
		}

		$this->event('mysql.prequery', array($query));

		$statement = $this->prepareStatement($query->string, $query->parameters);

		if ($statement->errno) {
			$error = new Error($statement->errno, $statement->error);
			$this->lastResult = new Result($query, array(), array(), $error);

			$this->event('mysql.query', array($this->lastResult));

			return $this->lastResult;
		}

		$statement->execute();

		$error = $this->error();

		if ($error) {

			$this->lastResult = new Result($query, array(), array(), $error);

			$this->event('mysql.query', array($this->lastResult));

			return $this->lastResult;
		}

		$result = $this->prepareStatementResult($statement);

		if ($statement->errno) {
			$error = new Error($statement->errno, $statement->error);
			$this->lastResult = new Result($query, array(), array(), $error);

			$this->event('mysql.query', array($this->lastResult));

			return $this->lastResult;
		}

		$statement->close();

		$info = array(
			'count'     => $result['num_rows'],
			'fields'    => $result['fields'],
			'affected'  => $result['affected'],
			'insert_id' => $result['insert_id']
		);

		$this->lastResult = new Result($query, $result['data'], $info, $error);

		$this->event('mysql.query', array($this->lastResult));

		return $this->lastResult;
	}

	/**
	 * Escape the given string for a MySQL query.
	 *
	 * @param string $string
	 * @return string
	 */
	public function escape($string)
	{
		$this->connect();

		return $this->connection->real_escape_string($string);
	}

	/**
	 * Retrieve error information regarding the last query or connection
	 * attempt.
	 *
	 * Returns null if there is no error.
	 *
	 * @return Error
	 */
	public function error()
	{
		$connectionError = $this->connectionError();

		if ($connectionError) {

			return $connectionError;
		}

		if ($this->lastResult && $this->lastResult->error) {
			return $this->lastResult->error;
		}

		return null;
	}

	/**
	 * Retrieve error information from the mysqli connection object.
	 *
	 * Checks for general errors first, then connection errors.
	 *
	 * Returns null if there is no error.
	 *
	 * @return Error
	 */
	protected function connectionError()
	{
		if (!$this->connection) {
			return null;
		}

		if ($this->connection->errno) {
			return new Error($this->connection->errno, $this->connection->error);
		}

		if ($this->connection->connect_errno) {
			return new Error($this->connection->connect_errno, $this->connection->connect_error);
		}

		return null;
	}
}


1			<?php
2			namespace Darya\Database\Connection;
3
4			use mysqli as php_mysqli;
5			use mysqli_result;
6			use mysqli_stmt;
7			use Darya\Database\AbstractConnection;
8			use Darya\Database\Error;
9			use Darya\Database\Result;
10			use Darya\Database\Query;
11			use Darya\Database\Query\Translator;
12
13			/**
14			* Darya's MySQL database interface. Uses mysqli.
15			*
16			* @author Chris Andrew <[email protected]>
17			*/
18			class MySql extends AbstractConnection
19			{
20			/**
21			* @var php_mysqli
22			*/
23			protected $connection;
24
25			/**
26			* Copy a flat array. Aids copying fetched results without the mysqlnd
27			* extension installed without retaining references to array elements.
28			*
29			* Who knew references could be so awkward to get rid of?
30			*
31			* @param array $array
32			* @return array
33			*/
34			protected static function copyArray($array)
35			{
36			$copy = array();
37
38			foreach ($array as $key => $value) {
39			$copy[$key] = $value;
40			}
41
42			return $copy;
43			}
44
45			/**
46			* Fetch result data from the given MySQLi statement.
47			*
48			* Expects the statement to have been executed.
49			*
50			* Attempts to use mysqli_stmt::get_result() and mysqli_result::fetch_all(),
51			* but falls back to fetching from the statement directly if get_result()
52			* isn't found (mysqlnd isn't installed).
53			*
54			* @param mysqli_stmt $statement
55			* @return array array($data, $fields, $count)
56			*/
57			protected function fetchResult(mysqli_stmt $statement)
58			{
59			if (!method_exists($statement, 'get_result')) {
60			return $this->fetchResultWithoutNativeDriver($statement);
61			}
62
63			$result = $statement->get_result();
64
65			if (is_object($result) && $result instanceof mysqli_result) {
66			return array(
67			$result->fetch_all(MYSQLI_ASSOC),
68			$result->fetch_fields(),
69			$result->num_rows
70			);
71			}
72
73			return array(array(), array(), null);
74			}
75
76			/**
77			* Method for fetching the same information in a way that doesn't require
78			* mysqlnd to be installed.
79			*
80			* Fetches directly from the statement with variable binding instead.
81			*
82			* @param mysqli_stmt $statement
83			* @return array
84			*/
85			protected function fetchResultWithoutNativeDriver(mysqli_stmt $statement)
86			{
87			$statement->store_result();
88
89			$data = array();
90			$metadata = $statement->result_metadata();
91
92			$row = array();
93			$count = 0;
94			$fields = array();
95			$arguments = array();
96
97			if ($metadata) {
			0 ignored issues – show introduced 2020-08-04 03:10 UTC by Report Bug Copy Issue Report `$metadata` is of type `mysqli_result`, thus it always evaluated to `true`. Loading history...
98			while ($field = $metadata->fetch_field()) {
99			$fields[] = (array) $field;
100			$arguments[] = &$row[$field->name];
101			}
102
103			call_user_func_array(array($statement, 'bind_result'), $arguments);
104
105			while ($statement->fetch()) {
106			$data[] = static::copyArray($row);
107			$count++;
108			}
109
110			}
111
112			return array($data, $fields, $count);
113			}
114
115			/**
116			* Retrieve the type of a variable for binding mysqli parameters.
117			*
118			* @param mixed $parameter
119			* @return string
120			*/
121			protected function prepareType($parameter)
122			{
123			if (is_int($parameter)) {
124			return 'i';
125			}
126
127			if (is_float($parameter)) {
128			return 'd';
129			}
130
131			return 's';
132			}
133
134			/**
135			* Prepares an array of values as an array of references to those values.
136			*
137			* Required for PHP 5.3+ to prevent warnings when dynamically invoking
138			* mysqli_stmt::bind_param().
139			*
140			* @param array $parameters
141			* @return array
142			*/
143			protected function prepareReferences(array $parameters)
144			{
145			$references = array();
146
147			foreach ($parameters as $key => $value) {
148			$references[$key] = &$parameters[$key];
149			}
150
151			return $references;
152			}
153
154			/**
155			* Prepare the given query and parameters as a mysqli statement.
156			*
157			* @param string $query
158			* @param array $parameters [optional]
159			* @return \mysqli_stmt
160			*/
161			protected function prepareStatement($query, $parameters = array())
162			{
163			$statement = $this->connection->stmt_init();
164
165			if (!$statement->prepare($query)) {
166			return $statement;
167			}
168
169			if (empty($parameters)) {
170			return $statement;
171			}
172
173			$types = '';
174
175			foreach ((array) $parameters as $parameter) {
176			$types .= $this->prepareType($parameter);
177			}
178
179			array_unshift($parameters, $types);
180
181			call_user_func_array(
182			array($statement, 'bind_param'),
183			$this->prepareReferences($parameters)
184			);
185
186			return $statement;
187			}
188
189			/**
190			* Prepare a result array using the given mysqli statement.
191			*
192			* @param mysqli_stmt $statement
193			* @return array
194			*/
195			protected function prepareStatementResult(mysqli_stmt $statement)
196			{
197			list($data, $fields, $count) = $this->fetchResult($statement);
198
199			$result = array(
200			'data' => $data,
201			'fields' => $fields,
202			'affected' => $statement->affected_rows,
203			'num_rows' => $count,
204			'insert_id' => $statement->insert_id
205			);
206
207			$statement->free_result();
208
209			return $result;
210			}
211
212			/**
213			* Initiate the connection.
214			*
215			* @return bool
216			*/
217			public function connect()
218			{
219			if ($this->connected()) {
220			return true;
221			}
222
223			$this->connection = new php_mysqli(
224			$this->details['host'],
225			$this->details['user'],
226			$this->details['pass'],
227			$this->details['name'],
228			$this->details['port']
229			);
230
231			if ($this->connection->connect_errno) {
232			return false;
233			}
234
235			return $this->connected = true;
236			}
237
238			/**
239			* Determine whether the connection is currently active.
240			*
241			* @return bool
242			*/
243			public function connected()
244			{
245			return $this->connected && !$this->connection->connect_errno;
246			}
247
248			/**
249			* Close the connection.
250			*/
251			public function disconnect()
252			{
253			$this->connection->close();
254			$this->connected = false;
255			}
256
257			/**
258			* Retrieve the query translator.
259			*
260			* @return Translator
261			*/
262			public function translator()
263			{
264			if (!$this->translator) {
265			$this->translator = new Translator\MySql;
266			}
267
268			return $this->translator;
269			}
270
271			/**
272			* Query the database with the given query and optional parameters.
273			*
274			* TODO: Simplify this.
275			*
276			* @param Query\|string $query
277			* @param array $parameters [optional]
278			* @return Result
279			*/
280			public function query($query, array $parameters = array())
281			{
282			if (!($query instanceof Query)) {
283			$query = new Query((string) $query, $parameters);
284			}
285
286			$this->lastResult = null;
287
288			$this->connect();
289
290			if (!$this->connected()) {
291			$this->lastResult = new Result($query, array(), array(), $this->error());
292
293			$this->event('mysql.query', array($this->lastResult));
294
295			return $this->lastResult;
296			}
297
298			$this->event('mysql.prequery', array($query));
299
300			$statement = $this->prepareStatement($query->string, $query->parameters);
301
302			if ($statement->errno) {
303			$error = new Error($statement->errno, $statement->error);
304			$this->lastResult = new Result($query, array(), array(), $error);
305
306			$this->event('mysql.query', array($this->lastResult));
307
308			return $this->lastResult;
309			}
310
311			$statement->execute();
312
313			$error = $this->error();
314
315			if ($error) {
			0 ignored issues – show introduced 2020-08-04 03:10 UTC by Report Bug Copy Issue Report `$error` is of type `Darya\Database\Error`, thus it always evaluated to `true`. Loading history...
316			$this->lastResult = new Result($query, array(), array(), $error);
317
318			$this->event('mysql.query', array($this->lastResult));
319
320			return $this->lastResult;
321			}
322
323			$result = $this->prepareStatementResult($statement);
324
325			if ($statement->errno) {
326			$error = new Error($statement->errno, $statement->error);
327			$this->lastResult = new Result($query, array(), array(), $error);
328
329			$this->event('mysql.query', array($this->lastResult));
330
331			return $this->lastResult;
332			}
333
334			$statement->close();
335
336			$info = array(
337			'count' => $result['num_rows'],
338			'fields' => $result['fields'],
339			'affected' => $result['affected'],
340			'insert_id' => $result['insert_id']
341			);
342
343			$this->lastResult = new Result($query, $result['data'], $info, $error);
344
345			$this->event('mysql.query', array($this->lastResult));
346
347			return $this->lastResult;
348			}
349
350			/**
351			* Escape the given string for a MySQL query.
352			*
353			* @param string $string
354			* @return string
355			*/
356			public function escape($string)
357			{
358			$this->connect();
359
360			return $this->connection->real_escape_string($string);
361			}
362
363			/**
364			* Retrieve error information regarding the last query or connection
365			* attempt.
366			*
367			* Returns null if there is no error.
368			*
369			* @return Error
370			*/
371			public function error()
372			{
373			$connectionError = $this->connectionError();
374
375			if ($connectionError) {
			0 ignored issues – show introduced 2020-08-04 03:10 UTC by Report Bug Copy Issue Report `$connectionError` is of type `Darya\Database\Error`, thus it always evaluated to `true`. Loading history...
376			return $connectionError;
377			}
378
379			if ($this->lastResult && $this->lastResult->error) {
380			return $this->lastResult->error;
381			}
382
383			return null;
384			}
385
386			/**
387			* Retrieve error information from the mysqli connection object.
388			*
389			* Checks for general errors first, then connection errors.
390			*
391			* Returns null if there is no error.
392			*
393			* @return Error
394			*/
395			protected function connectionError()
396			{
397			if (!$this->connection) {
398			return null;
399			}
400
401			if ($this->connection->errno) {
402			return new Error($this->connection->errno, $this->connection->error);
403			}
404
405			if ($this->connection->connect_errno) {
406			return new Error($this->connection->connect_errno, $this->connection->connect_error);
407			}
408
409			return null;
410			}
411			}
412

darya / framework

MySql::connect() A last analyzed 2021-02-13 01:04 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

MySql::connect() A
last analyzed 2021-02-13 01:04 UTC