Bdf\Prime\Connection\SimpleConnection

Complexity

Total Complexity

40

Size/Duplication

Total Lines	402
Duplicated Lines	0 %

Test Coverage

Coverage

95.83%

Importance

Changes	2
Bugs	0	Features	0

29 Methods

Rating	Name	Duplication	Size	Complexity
A	make()	0	3	1
A	execute()	0	16	3
A	exec()	0	6	1
A	getName()	0	3	1
A	prepare()	0	4	1
A	from()	0	3	1
A	executeQuery()	0	6	1
A	__construct()	0	14	1
A	schema()	0	7	2
A	setName()	0	5	1
A	factory()	0	3	1
A	isConnected()	0	3	1
A	toDatabase()	0	3	1
A	select()	0	10	1
A	delete()	0	3	1
A	query()	0	8	1
A	insert()	0	3	1
A	platform()	0	10	2
A	executeUpdate()	0	6	1
A	builder()	0	3	1
A	fromDatabase()	0	3	1
A	update()	0	3	1
A	beginTransaction()	0	5	1
A	runOrReconnect()	0	16	3
A	commit()	0	5	1
A	prepareLogger()	0	6	3
A	close()	0	5	1
A	executePrepared()	0	26	4
A	rollBack()	0	5	1

<?php

namespace Bdf\Prime\Connection;

use Bdf\Prime\Connection\Event\ConnectionClosedListenerInterface;
use Bdf\Prime\Connection\Extensions\LostConnection;
use Bdf\Prime\Connection\Extensions\SchemaChanged;
use Bdf\Prime\Connection\Result\PdoResultSet;
use Bdf\Prime\Connection\Result\ResultSetInterface;

Unused use statement

use Bdf\Prime\Connection\Result\UpdateResultSet;
use Bdf\Prime\Platform\Sql\SqlPlatform;
use Bdf\Prime\Query\Compiler\Preprocessor\PreprocessorInterface;
use Bdf\Prime\Query\Compiler\SqlCompiler;
use Bdf\Prime\Query\Contract\Compilable;
use Bdf\Prime\Query\Contract\Query\InsertQueryInterface;
use Bdf\Prime\Query\Contract\Query\KeyValueQueryInterface;
use Bdf\Prime\Query\Custom\BulkInsert\BulkInsertQuery;
use Bdf\Prime\Query\Custom\BulkInsert\BulkInsertSqlCompiler;
use Bdf\Prime\Query\Custom\KeyValue\KeyValueQuery;
use Bdf\Prime\Query\Custom\KeyValue\KeyValueSqlCompiler;
use Bdf\Prime\Query\Factory\DefaultQueryFactory;
use Bdf\Prime\Query\Factory\QueryFactoryInterface;

Unused use statement

use Bdf\Prime\Query\Query;
use Bdf\Prime\Schema\SchemaManager;
use Doctrine\Common\EventManager;
use Doctrine\DBAL\Cache\QueryCacheProfile;
use Doctrine\DBAL\Configuration;
use Doctrine\DBAL\Connection as BaseConnection;
use Doctrine\DBAL\DBALException;
use Doctrine\DBAL\Driver;
use Doctrine\DBAL\Statement;
use PDO;

/**
 * Connection
 *
 * @package Bdf\Prime

@package tag is not allowed in class comment

 */
class SimpleConnection extends BaseConnection implements ConnectionInterface
{
    use LostConnection;
    use SchemaChanged;

    /**
     * The connection name.
     *
     * @var string
     */
    protected $name;
    
    /**
     * The schema manager.
     *
     * @var SchemaManager
     */
    private $schema;

    /**
     * @var SqlPlatform
     */
    private $platform;

    /**
     * @var QueryFactoryInterface
     */
    private $factory;

    /**
     * SimpleConnection constructor.
     *
     * @param array $params

Tag value for @param tag indented incorrectly; expected 2 spaces but found 1

     * @param Driver $driver

Tag value for @param tag indented incorrectly; expected 2 spaces but found 1

     * @param Configuration|null $config

Tag value for @param tag indented incorrectly; expected 2 spaces but found 1

     * @param EventManager|null $eventManager

Tag value for @param tag indented incorrectly; expected 2 spaces but found 1

     * @throws DBALException

Tag @throws cannot be grouped with parameter tags in a doc comment

Separate the @param and @throws sections by a blank line.

Comment missing for @throws tag in function comment

     */
    public function __construct(array $params, Driver $driver, Configuration $config = null, EventManager $eventManager = null)
    {
        parent::__construct($params, $driver, $config, $eventManager);

        $this->factory = new DefaultQueryFactory(
            $this,
            new SqlCompiler($this),
            [
                KeyValueQuery::class   => KeyValueSqlCompiler::class,
                BulkInsertQuery::class => BulkInsertSqlCompiler::class,
            ],
            [
                KeyValueQueryInterface::class => KeyValueQuery::class,
                InsertQueryInterface::class   => BulkInsertQuery::class,
            ]
        );
    }

    /**

Parameter $name should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */
    public function setName($name)
    {
        $this->name = $name;
        
        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function getName()
    {
        return $this->name;
    }

    /**
     * {@inheritdoc}
     */
    public function isConnected()
    {
        return $this->_conn !== null;
    }

    /**
     * {@inheritdoc}
     */
    public function schema()
    {
        if ($this->schema === null) {
            $this->schema = new SchemaManager($this);
        }

        return $this->schema;
    }

    /**
     * {@inheritdoc}
     */
    public function platform()
    {
        if ($this->platform === null) {
            $this->platform = new SqlPlatform(
                $this->getDatabasePlatform(),
                $this->getConfiguration()->getTypes()

The method getTypes() does not exist on Doctrine\DBAL\Configuration. Are you sure you never get this type here, but always one of the subclasses?

            );
        }

        return $this->platform;
    }

    /**

Parameter $value should have a doc-comment as per coding-style.

Parameter $type should have a doc-comment as per coding-style.

Parameter $fieldOptions should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */
    public function fromDatabase($value, $type, array $fieldOptions = [])
    {
        return $this->platform()->types()->fromDatabase($value, $type, $fieldOptions);

The method fromDatabase() does not exist on Bdf\Prime\Types\TypesRegistryInterface. It seems like you code against a sub-type of said class. However, the method does not exist in Bdf\Prime\Types\TypesRegistry. Are you sure you never get one of those?

    }

    /**

Parameter $value should have a doc-comment as per coding-style.

Parameter $type should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */
    public function toDatabase($value, $type = null)
    {
        return $this->platform()->types()->toDatabase($value, $type);

The method toDatabase() does not exist on Bdf\Prime\Types\TypesRegistryInterface. It seems like you code against a sub-type of said class. However, the method does not exist in Bdf\Prime\Types\TypesRegistry. Are you sure you never get one of those?

    }

    /**

Parameter $preprocessor should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */
    public function builder(PreprocessorInterface $preprocessor = null)
    {
        return $this->factory->make(Query::class, $preprocessor);
    }

    /**

Parameter $query should have a doc-comment as per coding-style.

Parameter $preprocessor should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */
    public function make($query, PreprocessorInterface $preprocessor = null)
    {
        return $this->factory->make($query, $preprocessor);
    }

    /**
     * {@inheritdoc}
     */
    public function factory()
    {
        return $this->factory;
    }

    /**

Parameter $table should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */
    public function from($table)
    {
        return $this->builder()->from($table);
    }

    /**

Parameter $table should have a doc-comment as per coding-style.

Parameter $identifier should have a doc-comment as per coding-style.

Parameter $types should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */
    public function delete($table, array $identifier, array $types = array())

The method parameter $types is never used

Short array syntax must be used to define arrays

    {
        return $this->from($table)->where($identifier)->delete();

The method where() does not exist on Bdf\Prime\Query\CommandInterface. It seems like you code against a sub-type of Bdf\Prime\Query\CommandInterface such as Bdf\Prime\Query\Contract\Query\KeyValueQueryInterface or Bdf\Prime\Query\QueryInterface or Bdf\Prime\Query\AbstractReadCommand.

    }
    
    /**

Parameter $table should have a doc-comment as per coding-style.

Parameter $data should have a doc-comment as per coding-style.

Parameter $identifier should have a doc-comment as per coding-style.

Parameter $types should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */
    public function update($table, array $data, array $identifier, array $types = array())

Short array syntax must be used to define arrays

    {
        return $this->from($table)->where($identifier)->update($data, $types);
    }

    /**

Parameter $table should have a doc-comment as per coding-style.

Parameter $data should have a doc-comment as per coding-style.

Parameter $types should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */
    public function insert($table, array $data, array $types = array())

Short array syntax must be used to define arrays

    {
        return $this->from($table)->insert($data, $types);

The method insert() does not exist on Bdf\Prime\Query\CommandInterface. It seems like you code against a sub-type of Bdf\Prime\Query\CommandInterface such as Bdf\Prime\Query\QueryInterface or Bdf\Prime\Query\AbstractReadCommand or Bdf\Prime\Sharding\Query\ShardingKeyValueQuery or Bdf\Prime\Query\Custom\KeyValue\KeyValueQuery.

    }

    /**
     * Executes select query and returns array of object
     * 
     * @param string $query
     * @param array  $bindings
     * @param array  $types
     * 
     * @return array
     */
    public function select($query, array $bindings = [], array $types = [])
    {
        $stmt = $this->executeQuery($query, $bindings, $types);
        $stmt->setFetchMode(PDO::FETCH_OBJ);

        $result = $stmt->fetchAll();

        $stmt->closeCursor();
        
        return $result;
    }

    /**

Parameter $query should have a doc-comment as per coding-style.

Parameter $params should have a doc-comment as per coding-style.

Parameter $types should have a doc-comment as per coding-style.

Parameter $qcp should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */
    public function executeQuery($query, array $params = [], $types = [], QueryCacheProfile $qcp = null)
    {
        $this->prepareLogger();

        return $this->runOrReconnect(function() use ($query, $params, $types, $qcp) {

Expected 1 space after FUNCTION keyword; 0 found

            return parent::executeQuery($query, $params, $types, $qcp);
        });
    }

    /**

Parameter $query should have a doc-comment as per coding-style.

Parameter $params should have a doc-comment as per coding-style.

Parameter $types should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */
    public function executeUpdate($query, array $params = [], array $types = [])
    {
        $this->prepareLogger();

        return $this->runOrReconnect(function() use ($query, $params, $types) {

Expected 1 space after FUNCTION keyword; 0 found

            return parent::executeUpdate($query, $params, $types);
        });
    }

    /**
     * {@inheritdoc}
     */
    public function query()
    {
        $this->prepareLogger();
        
        $args = func_get_args();

        return $this->runOrReconnect(function() use ($args) {

Expected 1 space after FUNCTION keyword; 0 found

            return parent::query(...$args);
        });
    }
    
    /**

Parameter $statement should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */
    public function exec($statement)
    {
        $this->prepareLogger();
        
        return $this->runOrReconnect(function() use ($statement) {

Expected 1 space after FUNCTION keyword; 0 found

            return parent::exec($statement);
        });
    }

    /**

Parameter $statement should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */
    public function prepare($statement)
    {
        return $this->runOrReconnect(function() use ($statement) {

Expected 1 space after FUNCTION keyword; 0 found

            return parent::prepare($statement);
        });
    }

    /**

Parameter $query should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */
    public function execute(Compilable $query)
    {
        $statement = $query->compile();

        if ($statement instanceof Statement) {
            return $this->executePrepared($statement, $query);
        }

        // $statement is a SQL query
        if ($query->type() === Compilable::TYPE_SELECT) {
            $stmt = $this->executeQuery($statement, $query->getBindings());

            return new PdoResultSet($stmt);
        }

        return new UpdateResultSet($this->executeUpdate($statement, $query->getBindings()));
    }

    /**
     * Execute a prepared statement
     *
     * @param Statement $statement
     * @param Compilable $query
     *
     * @return ResultSetInterface The query result
     * @throws DBALException

Separate the @return and @throws sections by a blank line.

Comment missing for @throws tag in function comment

     */
    protected function executePrepared(Statement $statement, Compilable $query)
    {
        $bindings = $query->getBindings();

        $this->prepareLogger();

        try {
            $statement->execute($bindings);
        } catch (DBALException $exception) {
            // Prepared query on SQLite for PHP < 7.2 invalidates the query when schema change
            // This process may be removed on PHP 7.2
            if ($this->causedBySchemaChange($exception)) {
                $statement = $query->compile(true);
                $statement->execute($query->getBindings());
            } elseif ($this->causedByLostConnection($exception->getPrevious())) { // If the connection is lost, the query must be recompiled

Usage of ELSEIF not allowed; use ELSE IF instead

There should be no white space after an opening "{"

Comments may not appear after statements

                $this->close();
                $this->connect();

                $statement = $query->compile(true);
                $statement->execute($query->getBindings());
            } else {
                throw $exception;
            }
        }

        return new PdoResultSet($statement);
    }

    /**
     * {@inheritdoc}
     */
    public function beginTransaction()
    {
        $this->prepareLogger();

        parent::beginTransaction();
    }

    /**
     * {@inheritdoc}
     */
    public function commit()
    {
        $this->prepareLogger();
        
        parent::commit();
    }
    
    /**
     * {@inheritdoc}
     */
    public function rollBack()
    {
        $this->prepareLogger();
        
        return parent::rollBack();

Are you sure the usage of parent::rollBack() targeting Doctrine\DBAL\Connection::rollBack() seems to always return null.

    }

    /**
     * {@inheritdoc}
     */
    public function close()
    {
        parent::close();

        $this->_eventManager->dispatchEvent(ConnectionClosedListenerInterface::EVENT_NAME);
    }
    
    /**
     * Log a query
     * 
     * @param string $query

Superfluous parameter comment

Doc comment for parameter $query does not match actual variable name <undefined>

     * @param int    $seconds

Superfluous parameter comment

Expected "integer" but found "int" for parameter type

     * @param array  $bindings

Superfluous parameter comment

     * @param array  $types

Superfluous parameter comment

     */
    protected function prepareLogger()
    {
        $logger = $this->getConfiguration()->getSQLLogger();

        if ($logger && $logger instanceof ConnectionAwareInterface) {
            $logger->setConnection($this);
        }
    }

    /**
     * Execute a query. Try to reconnect if needed
     *
     * @param \Closure $callback
     *
     * @return mixed  The query result
     *
     * @throws DBALException

Comment missing for @throws tag in function comment

     */
    protected function runOrReconnect($callback)

Type hint "\Closure" missing for $callback

    {
        try {
            return $callback();
        } catch (DBALException $exception) {
            if ($this->causedByLostConnection($exception->getPrevious())) {
                // Should check for active transaction.
                // Only reconnect the start transaction.
                // Should raise exception during transaction.
                $this->close();
                $this->connect();

                return $callback();
            }

            throw $exception;
        }
    }
}