Darya\Database\Connection\Sqlite

Complexity

Total Complexity

18

Size/Duplication

Total Lines	144
Duplicated Lines	9.72 %

Coupling/Cohesion

Components	2
Dependencies	5

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	2
A	connect()	0	18	3
A	disconnect()	0	4	1
A	translator()	0	8	2
B	query()	0	30	3
A	error()	14	14	4
A	connectionError()	0	14	3

<?php
namespace Darya\Database\Connection;

use PDO;
use Darya\Database\AbstractConnection;
use Darya\Database\Error;
use Darya\Database\Result;
use Darya\Database\Query;
use Darya\Database\Query\Translator;

/**
 * Darya's SQLite database interface. Uses PDO.
 * 
 * @author Chris Andrew <chris@hexus.io>
 */
class Sqlite extends AbstractConnection
{
	/**
	 * Create a new SQLite database connection.
	 * 
	 * Creates an in-memory database if no path is given.
	 * 
	 * @param string $path    [optional] The path to the SQLite database file
	 * @param array  $options [optional] Options for the SQLite PDO connection
	 */
	public function __construct($path = null, array $options = array())
	{
		$this->details['path'] = $path ?: ':memory:';
		$this->options = array_merge(array(

The property options does not exist. Did you maybe forget to declare it?

			'persistent' => false
		), $options);
	}
	
	/**
	 * Initiate the connection.
	 */
	public function connect()
	{
		if ($this->connected()) {
			return true;
		}
		
		$path = $this->details['path'];
		
		$this->connection = new PDO("sqlite:{$path}", null, null, array(
			PDO::ATTR_PERSISTENT => $this->options['persistent']
		));
		
		if ($this->connection->errorCode()) {
			return false;
		}
		
		$this->connected = true;
	}
	
	/**
	 * Close the connection.
	 */
	public function disconnect()
	{
		$this->connection = null;
	}
	
	/**
	 * Retrieve the query translator.
	 * 
	 * @return Translator
	 */
	public function translator()
	{
		if (!$this->translator) {
			$this->translator = new Translator\MySql;
		}
		
		return $this->translator;
	}
	
	/**
	 * Query the database.
	 * 
	 * @param Query|string $query
	 * @param array        $parameters [optional]
	 */
	public function query($query, array $parameters = array())
	{
		if (!($query instanceof Query)) {
			$query = new Query((string) $query, $parameters);
		}
		
		$this->connect();
		
		$statement = $this->connection->prepare($query->string);
		
		$error = $this->error();
		
		if ($error) {
			$this->lastResult = new Result($query, array(), array(), $error);
			
			return $this->lastResult;
		}
		
		$statement->execute($query->parameters);
		
		$data = $statement->fetchAll(PDO::FETCH_ASSOC);
		
		$info = array(
			'count' => $statement->rowCount(),
		);
		
		$this->lastResult = new Result($query, $data, $info);
		
		return $this->lastResult;
	}
	
	/**
	 * Retrieve error information regarding the last query or connection
	 * attempt.
	 * 
	 * Returns null if there is no error.
	 * 
	 * @return Error
	 */
	public function error()

This method seems to be duplicated in your project.

	{
		$connectionError = $this->connectionError();
		
		if ($connectionError) {
			return $connectionError;
		}
		
		if ($this->lastResult && $this->lastResult->error) {
			return $this->lastResult->error;
		}
		
		return null;
	}
	
	/**
	 * Retrieve error information from the PDO connection object.
	 * 
	 * Returns null if there is no error.
	 * 
	 * @return Error
	 */
	protected function connectionError()
	{
		if (!$this->connection) {
			return null;
		}
		
		$errorInfo = $this->connection->errorInfo();
		
		if (empty($errorInfo[1])) {
			return null;
		}
		
		return new Error($errorInfo[1], $errorInfo[2]);
	}
}