PdoOci8 - Code Metrics - Inspection of "Refactor PdoOci8 and PdoOci8Statement" - jpina/pdooci8 - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — dev-0.1.x (cbb4c7)

by Josué

created 2016-03-31 11:53 UTC

PdoOci8 B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	480
Duplicated Lines	4.58 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

84%

Importance

Changes	2
Bugs	0	Features	1

Metric	Value
wmc	54
c	2
b	0
f	1
lcom	1
cbo	6
dl	22
loc	480
ccs	189
cts	225
cp	0.84
rs	7.0642

22 Methods

Rating	Name	Duplication	Size	Complexity
B	__construct()	5	43	5
A	getCharset()	0	6	1
A	getConnection()	0	4	1
B	getOracleConnection()	0	31	3
A	getConnectionString()	0	10	1
B	getConnectionStringItems()	0	34	6
A	getDsnRegex()	0	12	1
A	beginTransaction()	0	8	2
A	commit()	0	12	2
A	errorCode()	13	13	2
A	errorInfo()	0	19	2
A	exec()	0	11	2
A	getStatementType()	0	10	1
A	getAttribute()	0	8	2
A	getAvailableDrivers()	0	4	1
A	inTransaction()	0	5	1
A	lastInsertId()	0	7	1
B	prepare()	0	24	5
B	query()	0	24	5
B	quote()	0	22	4
A	rollback()	0	20	3
A	setAttribute()	4	20	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 PdoOci8 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 PdoOci8, and based on these observations, apply Extract Interface, too.

<?php

namespace Jpina\PdoOci8;

use Jpina\Oci8\Oci8Connection;
use Jpina\Oci8\Oci8ConnectionInterface;
use Jpina\Oci8\Oci8Exception;
use Jpina\Oci8\Oci8PersistentConnection;
use Jpina\Oci8\Oci8StatementInterface;

/**
 * Custom PDO_OCI implementation via OCI8 driver
 *
 * @see http://php.net/manual/en/class.pdo.php
 */
class PdoOci8 extends \PDO
{
    const OCI_ATTR_SESSION_MODE = 8000;

    const OCI_ATTR_RETURN_LOBS = 8001;

    /**
     * @var Oci8ConnectionInterface
     */
    protected $connection;

    /**
     * @var int
     */
    private $autoCommitMode = false;


    /**
     * @var array
     */
    protected $options = array();

    // TODO Receive Oci8ConnectionInterface?
    public function __construct($dsn, $username = '', $password = '', $options = array())
    {
        $this->options = array(
            \PDO::ATTR_AUTOCOMMIT         => true,
            \PDO::ATTR_CASE               => \PDO::CASE_NATURAL,
            \PDO::ATTR_CLIENT_VERSION     => '',
            \PDO::ATTR_CONNECTION_STATUS  => '',
            \PDO::ATTR_DRIVER_NAME        => 'oci',
            \PDO::ATTR_ERRMODE            => \PDO::ERRMODE_SILENT,
            \PDO::ATTR_ORACLE_NULLS       => \PDO::NULL_NATURAL,
            \PDO::ATTR_PERSISTENT         => false,
            \PDO::ATTR_PREFETCH           => 100,
            \PDO::ATTR_SERVER_INFO        => '',
            \PDO::ATTR_SERVER_VERSION     => '',
            \PDO::ATTR_TIMEOUT            => 600,
            \PDO::ATTR_STRINGIFY_FETCHES  => false,
            \PDO::ATTR_STATEMENT_CLASS    => null,
            \PDO::ATTR_EMULATE_PREPARES   => false,
            \PDO::ATTR_DEFAULT_FETCH_MODE => \PDO::FETCH_BOTH,
            static::OCI_ATTR_SESSION_MODE => OCI_DEFAULT,
            static::OCI_ATTR_RETURN_LOBS  => false,
        );

        foreach ($options as $option => $value) {

            if (array_key_exists($option, $this->options)) {
                $this->options[$option] = $value;
            }
        }

        foreach ($options as $attribute => $value) {
            $this->setAttribute($attribute, $value);
        }

        $connection = $this->getOracleConnection($dsn, $username, $password);
        $this->setAttribute(\PDO::ATTR_CLIENT_VERSION, $connection->getClientVersion());
        $this->setAttribute(\PDO::ATTR_SERVER_VERSION, $connection->getServerVersion());

        if ($this->getAttribute(\PDO::ATTR_AUTOCOMMIT) === false) {
            $this->beginTransaction();
        }

        $this->connection = $connection;
    }

    protected function getCharset($dsn)
    {
        $connectionStringItems = $this->getConnectionStringItems($dsn);

        return $connectionStringItems['charset'];
    }

    /**
     * @return Oci8ConnectionInterface
     */
    protected function getConnection()
    {
        return $this->connection;
    }

    /**
     * @param string $dsn
     * @param string $username
     * @param string $password
     * @return Oci8ConnectionInterface
     */
    protected function getOracleConnection($dsn, $username = null, $password = null)
    {
        $connectionString = $this->getConnectionString($dsn);
        $charset = $this->getCharset($dsn);
        $sessionMode = $this->getAttribute(static::OCI_ATTR_SESSION_MODE);

        $connection = null;
        try {
            if ($this->getAttribute(\PDO::ATTR_PERSISTENT)) {
                $connection = new Oci8PersistentConnection(
                    $username,
                    $password,
                    $connectionString,
                    $charset,
                    $sessionMode
                );
            } else {
                $connection = new Oci8Connection(
                    $username,
                    $password,
                    $connectionString,
                    $charset,
                    $sessionMode
                );
            }
        } catch (Oci8Exception $ex) {
            throw new PdoOci8Exception($ex->getMessage(), $ex->getCode(), $ex);
        }

        return $connection;
    }

    protected function getConnectionString($dsn)
    {
        $connectionStringItems = $this->getConnectionStringItems($dsn);
        $hostname = $connectionStringItems['hostname'];
        $port = $connectionStringItems['port'];
        $database = $connectionStringItems['database'];
        $connectionString = "//{$hostname}:{$port}/{$database}";

        return $connectionString;
    }

    protected function getConnectionStringItems($dsn)
    {
        $dsnRegex = $this->getDsnRegex();
        $matches = array();
        if (preg_match("/^{$dsnRegex}$/i", $dsn, $matches) !== 1) {
            throw new PdoOci8Exception('Invalid DSN');
        }

        // TODO Remove the variables below
        $hostname = 'localhost';
        $port     = 1521;
        $database = null;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $charset  = 'AL32UTF8';

        switch (count($matches)) {
            case 16:
                $charset  = empty($matches[15]) ? $charset : $matches[15];
                // fall through next case to get the rest of the variables
            case 14:
                $port     = empty($matches[12]) ? $port : (int)$matches[12];
                $hostname = $matches[4];
                $database = $matches[13];
                break;
            default:
                $database = $matches[1];
        }

        return array(
            'hostname' => $hostname,
            'port'     => $port,
            'database' => $database,
            'charset'  => $charset,
        );
    }

    protected function getDsnRegex()
    {
        $hostnameRegrex = "(([a-z]|[a-z][a-z0-9\-_]*[a-z0-9])\.)*([a-z]|[a-z][a-z0-9\-_]*[a-z0-9])";
        $validIpAddressRegex = "(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}" .
            "([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])";
        $hostnameOrIpAddressRegrex = "\/\/({$hostnameRegrex}|{$validIpAddressRegex})";
        $databaseRegex = "([a-z_][a-z\-_\d]*)|({$hostnameOrIpAddressRegrex}(:(\d+))?\/([a-z_][a-z\-_\d]*))";
        $charsetRegex = "(charset=([a-z\d\-_]+))?";
        $dsnRegex = "oci\:database=({$databaseRegex});?{$charsetRegex}";

        return $dsnRegex;
    }

    /**
     * @link http://php.net/manual/en/pdo.begintransaction.php
     * @return bool
     */
    public function beginTransaction()
    {
        if ($this->getAttribute(\PDO::ATTR_AUTOCOMMIT) === false) {
            return false;
        }

        return $this->setAttribute(\PDO::ATTR_AUTOCOMMIT, false);
    }

    /**
     * @link http://php.net/manual/en/pdo.commit.php
     * @return bool
     */
    public function commit()
    {
        try {
            $isSuccess = $this->getConnection()->commit();
        } catch (Oci8Exception $ex) {
            $isSuccess = false;
        }

        $this->setAttribute(\PDO::ATTR_AUTOCOMMIT, true);

        return $isSuccess;
    }

    /**
     * @link http://php.net/manual/en/pdo.errorcode.php
     * @return null|string
     */
    public function errorCode()

    {
        $connection = $this->getConnection();
        $driverError = $connection->getError();
        if (!$driverError) {
            return null;
        }

        $error = $this->errorInfo();
        $sqlStateErrorCode = $error[0];

        return $sqlStateErrorCode;
    }

    /**
     * @link http://php.net/manual/en/pdo.errorinfo.php
     * @return array
     */
    public function errorInfo()
    {
        $error = $this->getConnection()->getError();
        if (is_array($error)) {
            $errorInfo = array(
                OracleSqlStateCode::getSqlStateErrorCode((int)$error['code']),
                $error['message'],
                $error['code']
            );
        } else {
            $errorInfo = array(
                '00000',
                null,
                null
            );
        }

        return $errorInfo;
    }

    /**
     * @param string $statement
     *
     * @link http://php.net/manual/en/pdo.exec.php
     * @return bool|int
     */
    public function exec($statement)
    {
        $statement = $this->prepare($statement, $this->options);
        $type      = $this->getStatementType($statement);
        if ($type === 'SELECT') {
            return false;
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());
}
        }
        $statement->execute();

        return $statement->rowCount();
    }

    /**
     * @param $statement
     * @return PdoOci8Statement
     */
    protected function getStatementType($statement)
    {
        $class = new \ReflectionClass($statement);
        $property = $class->getProperty('statement');
        $property->setAccessible(true);
        /** @var Oci8StatementInterface $rawStatement */
        $oci8Statement = $property->getValue($statement);

        return $oci8Statement->getType();
    }

    /**
     * @param int $attribute
     *
     * @link http://php.net/manual/en/pdo.getattribute.php
     * @return mixed
     */
    public function getAttribute($attribute)
    {
        if (array_key_exists($attribute, $this->options)) {
            return $this->options[$attribute];
        }

        return null;
    }

    /**
     * @link http://php.net/manual/en/pdo.getavailabledrivers.php
     * @return array
     */
    public static function getAvailableDrivers()
    {
        return array('oci');
    }

    /**
     * @link http://php.net/manual/en/pdo.intransaction.php
     * @return bool
     */
    public function inTransaction()
    {
        $inTransaction = !$this->getAttribute(\PDO::ATTR_AUTOCOMMIT);
        return $inTransaction;
    }

    /**
     * @param string $name
     *
     * @link http://php.net/manual/en/pdo.lastinsertid.php
     * @return string
     */
    public function lastInsertId($name = null)
    {
        $statement = $this->query("select {$name}.currval from dual");
        $lastInsertedId = $statement->fetch();

        return $lastInsertedId;
    }

    /**
     * @param string $statement
     * @param array $driver_options
     *
     * @link http://php.net/manual/en/pdo.prepare.php
     * @return bool|PdoOci8Statement
     */
    public function prepare($statement, $driver_options = array())
    {
        // TODO Use $driver_options, eg. configure a cursor
        $exception = null;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        try {
            return new PdoOci8Statement($this->getConnection(), $statement, $driver_options);
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());
}
        } catch (\Exception $ex) {
            $exception = new PdoOci8Exception($ex->getMessage(), $ex->getCode(), $ex);
        }

        // TODO Create error handler
        $errorMode = $this->getAttribute(\PDO::ATTR_ERRMODE);
        switch ($errorMode) {
            case \PDO::ERRMODE_EXCEPTION:
                throw $exception;
            case \PDO::ERRMODE_WARNING:
                trigger_error($exception->getMessage(), E_WARNING);
                break;
            case \PDO::ERRMODE_SILENT:
            default:
        }

        return false;
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());
}
    }

    /**
     * @param string $statement
     * @param int $mode
     * @param int|string|object $arg3
     * @param array $ctorargs
     *
     * @link http://php.net/manual/en/pdo.query.php
     * @return bool|PdoOci8Statement
     */
    public function query($statement, $mode = \PDO::ATTR_DEFAULT_FETCH_MODE, $arg3 = null, $ctorargs = array())
    {
        $result = false;
        try {
            $statement = $this->prepare($statement);
            switch ($mode) {
                case \PDO::FETCH_CLASS:
                    $statement->setFetchMode($mode, $arg3, $ctorargs);
                    break;
                case \PDO::FETCH_INTO:
                    $statement->setFetchMode($mode, $arg3);
                    break;
                case \PDO::FETCH_COLUMN:
                default:
                    $statement->setFetchMode($mode);
            }
            $statement->execute();
            $result = $statement;
        } catch (\PDOException $ex) {
            //TODO Handle Exception
        }

        return $result;
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());
}
    }

    /**
     * @param string $string
     * @param int $parameter_type
     *
     * @link http://php.net/manual/en/pdo.quote.php
     * @return bool|string
     */
    public function quote($string, $parameter_type = \PDO::PARAM_STR)
    {
        if (!is_scalar($string)) {
            return false;
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());
}
        }

        try {
            if ($parameter_type !== \PDO::PARAM_STR) {
                $quotedString = (string)$string;
                $quotedString = "'" . $quotedString . "'";
                return $quotedString;
            }
        } catch (\Exception $ex) {
function fx() {
    try {
        doSomething();
        return true;
    }
    catch (\Exception $e) {
        return false;
    }

    return false;
}
            return false;
        }

        $quotedString = str_replace("\'", "'", $string);
        $quotedString = str_replace("'", "''", $quotedString);
        $quotedString = "'" . $quotedString . "'";

        return $quotedString;
    }

    /**
     * @link http://php.net/manual/en/pdo.rollback.php
     * @return bool
     */
    public function rollback()
    {
        if (!$this->inTransaction()) {
            throw new PdoOci8Exception('There is no active transaction');
        }

        try {
            $isSuccess = $this->getConnection()->rollback();
        } catch (Oci8Exception $ex) {
            $isSuccess = false;
        }

        // TODO Restore autocommit mode
        // If the database was set to autocommit mode
        // this function will restore autocommit mode after
        // it has rolled back the transaction
        $this->setAttribute(\PDO::ATTR_AUTOCOMMIT, true);

        return $isSuccess;
    }

    /**
     * @param int $attribute
     * @param mixed $value
     *
     * @link http://php.net/manual/en/pdo.setattribute.php
     * @return bool
     */
    public function setAttribute($attribute, $value)
    {
        $readOnlyAttributes = array(
            \PDO::ATTR_CLIENT_VERSION,
            \PDO::ATTR_CONNECTION_STATUS,
            \PDO::ATTR_DRIVER_NAME,
            \PDO::ATTR_PERSISTENT,
            \PDO::ATTR_SERVER_INFO,
            \PDO::ATTR_SERVER_VERSION,
        );

        if (array_search($attribute, $readOnlyAttributes) !== false ||

            !array_key_exists($attribute, $this->options)) {
            return false;
        }

        $this->options[$attribute] = $value;

        return true;
    }
}


jpina / pdooci8