BaseConnection - Code Metrics - Inspection of "Update README.md" - gamernetwork/yolk-database - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( d28428...d28428 )

by Simon

created 2016-05-11 09:13 UTC

BaseConnection C

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	437
Duplicated Lines	18.99 %

Coupling/Cohesion

Components	1
Dependencies	13

Importance

Changes	8
Bugs	1	Features	2

Metric	Value
wmc	67
c	8
b	1
f	2
lcom	1
cbo	13
dl	83
loc	437
rs	5.2808

31 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	13	3
B	connect()	0	30	3
A	disconnect()	0	4	1
A	isConnected()	0	3	1
A	select()	0	3	1
A	insert()	0	3	1
A	update()	0	3	1
A	replace()	0	3	1
A	delete()	0	3	1
A	prepare()	0	18	3
B	query()	0	36	5
A	execute()	0	4	1
A	getAll()	14	14	2
A	getAssoc()	0	16	3
A	getAssocMulti()	0	20	4
A	getRow()	14	14	2
A	getCol()	15	15	2
A	getOne()	14	14	2
A	begin()	0	12	2
A	commit()	13	13	3
A	rollback()	13	13	3
A	inTransaction()	0	3	2
A	insertId()	0	5	2
A	quote()	0	4	1
A	quoteIdentifier()	0	17	3
A	rawExec()	0	12	2
A	dump()	0	4	2
A	bindParams()	0	17	4
A	getResult()	0	13	1
A	getOption()	0	3	2
A	setCharacterSet()	0	15	3

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like BaseConnection often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use BaseConnection, and based on these observations, apply Extract Interface, too.

<?php
/*
 * This file is part of Yolk - Gamer Network's PHP Framework.
 *
 * Copyright (c) 2014 Gamer Network Ltd.
 * 
 * Distributed under the MIT License, a copy of which is available in the
 * LICENSE file that was bundled with this package, or online at:
 * https://github.com/gamernetwork/yolk-database
 */

namespace yolk\database;

use yolk\contracts\database\DatabaseConnection;
use yolk\contracts\profiler\ProfilerAwareTrait;
use yolk\contracts\profiler\ProfilerAware;
use yolk\contracts\support\Dumpable;

use yolk\database\exceptions\DatabaseException;
use yolk\database\exceptions\ConnectionException;
use yolk\database\exceptions\NotConnectedException;
use yolk\database\exceptions\QueryException;
use yolk\database\exceptions\TransactionException;

/**
 * A wrapper for PDO that provides some handy extra functions and streamlines everything else.
 */
abstract class BaseConnection implements DatabaseConnection, ProfilerAware, Dumpable {

	use ProfilerAwareTrait;

	/**
	 * Connection details.
	 * @var DSN
	 */
	protected $dsn = null;

	/**
	 * Underlying PDO object.
	 * @var \PDO
	 */
	protected $pdo = null;

	/**
	 * Prepared statement cache.
	 * @var array
	 */
	protected $statements = [];

	/**
	 * Create a new database connection.
	 *
	 * @param DSN $dsn a DSN instance describing the database connection details
	 */
	public function __construct( DSN $dsn ) {

		$this->dsn = $dsn;

		// check for PDO extension
		if( !extension_loaded('pdo') )
			throw new DatabaseException('The PDO extension is required but the extension is not loaded');

		// check the PDO driver is available
		elseif( !in_array($this->dsn->type, \PDO::getAvailableDrivers()) )
			throw new DatabaseException("The {$this->dsn->type} PDO driver is not currently installed");

	}

	public function connect() {

		if( $this->pdo instanceof \PDO )
			return true;

		try {

			$this->pdo = new \PDO(
				$this->dsn->getConnectionString(),
				$this->dsn->user,
				$this->dsn->pass,
				$this->dsn->options
			);

			$this->pdo->setAttribute(\PDO::ATTR_DEFAULT_FETCH_MODE, \PDO::FETCH_ASSOC);
			$this->pdo->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION);           // always use exceptions

			$this->setCharacterSet(
				$this->getOption('charset', 'UTF8'),
				$this->getOption('collation')
			);

		}
		catch( \PDOException $e ) {
			throw new ConnectionException($e->getMessage(), $e->getCode(), $e);
		}

		return true;

	}

	public function disconnect() {
		$this->pdo = null;
		return true;
	}

	public function isConnected() {
		return $this->pdo instanceof \PDO;
	}

	public function select() {
		return new query\Select($this);
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
	}

	public function insert() {
		return new query\Insert($this);
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
	}

	public function update() {
		return new query\Update($this);
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
	}

	public function replace() {
		return new query\Replace($this);
	}

	public function delete() {
		return new query\Delete($this);
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
	}

	public function prepare( $statement ) {

		if( ! $statement instanceof \PDOStatement  ) {

			$this->connect();

			$statement = trim($statement);

			if( !isset($this->statements[$statement]) )
				$this->statements[$statement] = $this->pdo->prepare($statement);

			$statement = $this->statements[$statement];

		}

		return $statement;

	}

	public function query( $statement, $params = [] ) {

		$this->connect();

		// TODO: profiler start
		$this->profiler && $this->profiler->start('Query');

		try {

			$statement = $this->prepare($statement);

			// single parameters don't have to be passed in an array - do that here
			if( !is_array($params) )
				$params = array($params);

			$this->bindParams($statement, $params);

			$start = microtime(true);
			$statement->execute();
			$duration = microtime(true) - $start;
			
		}
		catch( \PDOException $e ) {
			throw new QueryException($e->getMessage(), $e->getCode(), $e);
		}

		// TODO: profiler stop + record
		if( $this->profiler ) {
			$this->profiler->stop('Query');
			// remove all whitespace at start of lines
			$this->profiler->query(preg_replace("/^\s*/m", "", trim($statement->queryString)), $params, $duration);
		}

		return $statement;

	}

	public function execute( $statement, $params = [] ) {
		$statement = $this->query($statement, $params);
		return $statement->rowCount();
	}

	public function getAll( $statement, $params = [], $expires = 0, $key = '' ) {

		return $this->getResult(
			$statement,
			$params,
			$expires,
			$key,
			function( \PDOStatement $statement ) {
				$result = $statement->fetchAll();
				if( $result === false )
					$result = [];
				return $result;
			}
		);
	}

	public function getAssoc( $statement, $params = [], $expires = 0, $key = '' ) {
		return $this->getResult(
			$statement,
			$params,
			$expires,
			$key,
			function( \PDOStatement $statement ) {
				$result = [];
				while( $row = $statement->fetch() ) {
					$key = array_shift($row);
					$result[$key] = count($row) == 1 ? array_shift($row) : $row;
				}
				return $result;
			}
		);
	}

	public function getAssocMulti( $statement, $params = [], $expires = 0, $key = '' ) {
		return $this->getResult(
			$statement,
			$params,
			$expires,
			$key,
			function( \PDOStatement $statement ) {
				$result = [];
				while( $row = $statement->fetch() ) {
					$k1 = array_shift($row);
					$k2 = array_shift($row);
					$v  = count($row) == 1 ? array_shift($row) : $row;
					if( !isset($result[$k1]) )
						$result[$k1] = [];
					$result[$k1][$k2] = $v;
				}
				return $result;
			}
		);
	}

	public function getRow( $statement, $params = [], $expires = 0, $key = '' ) {

		return $this->getResult(
			$statement,
			$params,
			$expires,
			$key,
			function( \PDOStatement $statement ) {
				$result = $statement->fetch();
				if( $result === false )
					$result = [];
				return $result;
			}
		);
	}

	public function getCol( $statement, $params = [], $expires = 0, $key = '' ) {

		return $this->getResult(
			$statement,
			$params,
			$expires,
			$key,
			function( \PDOStatement $statement ) {
				$result = [];
				while( $row = $statement->fetch() ) {
					$result[] = array_shift($row);
				}
				return $result;
			}
		);
	}

	public function getOne( $statement, $params = [], $expires = 0, $key = '' ) {

		return $this->getResult(
			$statement,
			$params,
			$expires,
			$key,
			function( \PDOStatement $statement ) {
				$result = $statement->fetchColumn();
				if( $result === false )
					$result = null;
				return $result;
			}
		);
	}

	public function begin() {

		$this->connect();

		try {
			return $this->pdo->beginTransaction();
		}
		catch( \PDOException $e ) {
			throw new TransactionException($e->getMessage(), $e->getCode(), $e);
		}

	}

	public function commit() {


		if( !$this->isConnected() )
			throw new NotConnectedException();

		try {
			return $this->pdo->commit();
		}
		catch( \PDOException $e ) {
			throw new TransactionException($e->getMessage(), $e->getCode(), $e);
		}

	}

	public function rollback() {


		if( !$this->isConnected() )
			throw new NotConnectedException();

		try {
			return $this->pdo->rollBack();
		}
		catch( \PDOException $e ) {
			throw new TransactionException($e->getMessage(), $e->getCode(), $e);
		}

	}

	public function inTransaction() {
		return $this->isConnected() ? $this->pdo->inTransaction() : false;
	}

	public function insertId( $name = '' ) {
		if( !$this->isConnected() )
			throw new NotConnectedException();
		return $this->pdo->lastInsertId($name);
	}

	public function quote( $value, $type = \PDO::PARAM_STR ) {
		$this->connect();
		return $this->pdo->quote($value, $type);
	}

	public function quoteIdentifier( $name ) {

		$name = trim($name);

        if( $name == '*' )
            return $name;

		// ANSI-SQL (everything else) says to use double quotes to quote identifiers
        $char = '"';

		// MySQL uses backticks cos it's special
		if( $this->dsn->isMySQL() )
        	$char = '`';

		return $char. $name. $char;

	}

	/**
	 * Execute a raw SQL string and return the number of affected rows.
	 * Primarily used for DDL queries. Do not use this with:
	 * - Anything (data/parameters/etc) that comes from userland
	 * - Select queries - the answer will always be 0 as no rows are affected.
	 * - Everyday queries - use query() or execute()
	 * @param  string $sql  the SQL statement to exexcute
	 * @return integer   the number of rows affected by the statement
	 */
	public function rawExec( $sql ) {

		$this->connect();

		try {
			return $this->pdo->exec($sql);
		}
		catch( \PDOException $e ) {
			throw new QueryException($e->getMessage(), $e->getCode(), $e);
		}

	}

	public function dump( $dumper = '\\yolk\\debug\\TextDumper', $depth = 1 ) {
		if( $depth > 1 )
			return $this->dsn->toString();
	}

	/**
	 * Bind named and positional parameters to a PDOStatement.
	 * @param  PDOStatement $statement
	 * @param  array        $params
	 * @return void
	 */
	protected function bindParams( \PDOStatement $statement, array $params ) {
		foreach( $params as $name => $value ) {

			if( is_int($value) ) {
				$type = \PDO::PARAM_INT;
			}
			else {
				$type = \PDO::PARAM_STR;
			}

			// handle positional (?) and named (:name) parameters

			$name = is_numeric($name) ? (int) $name + 1 : ":{$name}";

			$statement->bindValue($name, $value, $type);

		}
	}

	/**
	 * Perform a select query and use a callback to extract a result.
	 * @param  \PDOStatement|string $statement   an existing PDOStatement object or a SQL string.
	 * @param  array $params        an array of parameters to pass into the query.
	 * @param  integer $expires     number of seconds to cache the result for if caching is enabled
	 * @param  string  $key         cache key used to store the result
	 * @param  \Closure $callback   function to yield a result from the executed statement
	 * @return array
	 */
	protected function getResult( $statement, $params, $expires, $key, \Closure $callback ) {


		// TODO: check cache

		$statement = $this->query($statement, $params);

		$result = $callback($statement);

		// TODO: store in cache

		return $result;

	}

	protected function getOption( $option, $default = null ) {
		return isset($this->dsn->options[$option]) ? $this->dsn->options[$option] : $default;
	}

	/**
	 * Make sure the connection is using the correct character set
	 * 
	 * @param string $charset   the character set to use for the connection
	 * @param string $collation the collation method to use for the connection
	 * @return self
	 */
	protected function setCharacterSet( $charset, $collation = '' ) {

		if( !$charset ) 
			throw new DatabaseException('No character set specified');

		$sql = 'SET NAMES '. $this->pdo->quote($charset);

		if( $collation )
			$sql .= ' COLLATE '. $this->pdo->quote($collation);

		$this->pdo->exec($sql);

		return $this;

	}

}

// EOF

gamernetwork / yolk-database