Bdf\Prime\Connection\SimpleConnection

Complexity

Total Complexity

43

Size/Duplication

Total Lines	411
Duplicated Lines	0 %

Test Coverage

Coverage

94.35%

Importance

Changes	2
Bugs	0	Features	0

29 Methods

Rating	Name	Duplication	Size	Complexity
A	beginTransaction()	0	5	1
A	make()	0	3	1
A	runOrReconnect()	0	20	4
A	execute()	0	19	4
A	exec()	0	6	1
A	getName()	0	3	1
A	commit()	0	5	1
A	prepare()	0	4	1
A	prepareLogger()	0	6	3
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	close()	0	5	1
A	isConnected()	0	3	1
A	executePrepared()	0	26	4
A	toDatabase()	0	3	1
A	select()	0	10	1
A	rollBack()	0	5	1
A	delete()	0	3	1
A	query()	0	8	1
A	insert()	0	3	1
A	platform()	0	11	3
A	executeUpdate()	0	6	1
A	builder()	0	3	1
A	fromDatabase()	0	3	1
A	update()	0	3	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;
use Bdf\Prime\Connection\Result\UpdateResultSet;
use Bdf\Prime\Exception\DBALException;
use Bdf\Prime\Exception\PrimeException;
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;
use Bdf\Prime\Query\Query;
use Bdf\Prime\Schema\SchemaManager;
use Closure;
use Doctrine\Common\EventManager;
use Doctrine\DBAL\Cache\QueryCacheProfile;
use Doctrine\DBAL\Configuration;
use Doctrine\DBAL\Connection as BaseConnection;
use Doctrine\DBAL\DBALException as DoctrineDBALException;
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
     * @param Driver $driver
     * @param Configuration|null $config
     * @param EventManager|null $eventManager
     * @throws DoctrineDBALException

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

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}
     */

Missing @throws tag in function comment

    public function platform()
    {
        if ($this->platform === null) {
            try {
                $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?

            } catch (DoctrineDBALException $e) {
                throw new DBALException($e->getMessage(), $e->getCode(), $e);
            }
        }

        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.

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

     * {@inheritdoc}
     */
    public function from($table, string $alias = null)
    {
        return $this->builder()->from($table, $alias);
    }

    /**

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}
     *
     * @throws PrimeException

Comment missing for @throws tag in function comment

     */
    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}
     *
     * @throws PrimeException

Comment missing for @throws tag in function comment

     */
    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}
     */

Missing @throws tag in function comment

    public function execute(Compilable $query)
    {
        try {
            $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()));
        } catch (DoctrineDBALException $e) {
            throw new DBALException('Error on execute : '.$e->getMessage(), $e->getCode(), $e);
        }
    }

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

Comment missing for @throws tag in function comment

     * @throws PrimeException

Comment missing for @throws tag in function comment

     */

Expected 1 @throws tag(s) in function comment; 2 found

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

        $this->prepareLogger();

        try {
            $statement->execute($bindings);
        } catch (DoctrineDBALException $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);
    }

    /**
     * Setup the logger by setting the connection
     */
    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

     */

Expected 2 @throws tag(s) in function comment; 1 found

    protected function runOrReconnect(Closure $callback)
    {
        try {
            try {
                return $callback();
            } catch (DoctrineDBALException $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;
            }
        } catch (DoctrineDBALException $e) {
            throw new DBALException('Error on execute : '.$e->getMessage(), $e->getCode(), $e);
        }
    }
}