Bdf\Prime\Sharding\ShardingConnection

Complexity

Total Complexity

49

Size/Duplication

Total Lines	391
Duplicated Lines	0 %

Test Coverage

Coverage

83.93%

Importance

Changes	1
Bugs	0	Features	0

26 Methods

Rating	Name	Duplication	Size	Complexity
A	rollBack()	0	4	2
A	useShard()	0	9	3
A	getShardIds()	0	3	1
A	executeQuery()	0	13	3
A	getSelectedShards()	0	7	2
A	commit()	0	4	2
A	lastInsertId()	0	8	2
A	beginTransaction()	0	4	2
A	isUsingShard()	0	3	1
A	getDistributionKey()	0	3	1
A	getShardConnection()	0	11	3
A	getWrappedConnection()	0	8	2
A	query()	0	15	3
A	close()	0	8	2
A	getShardChoser()	0	3	1
A	__construct()	0	17	3
A	executeUpdate()	0	9	2
A	rollbackSavepoint()	0	4	2
A	createSavepoint()	0	4	2
A	builder()	0	3	1
A	getSelectedShard()	0	3	1
A	pickShard()	0	9	2
A	getCurrentShardId()	0	3	1
A	getConnection()	0	3	1
A	releaseSavepoint()	0	4	2
A	exec()	0	9	2

<?php

namespace Bdf\Prime\Sharding;

use Bdf\Prime\Connection\SimpleConnection;
use Bdf\Prime\Connection\SubConnectionManagerInterface;
use Bdf\Prime\ConnectionManager;

Unused use statement

use Bdf\Prime\Query\Compiler\Preprocessor\PreprocessorInterface;
use Bdf\Prime\Query\Contract\Query\InsertQueryInterface;
use Bdf\Prime\Query\Contract\Query\KeyValueQueryInterface;
use Bdf\Prime\Sharding\Query\ShardingInsertQuery;
use Bdf\Prime\Sharding\Query\ShardingKeyValueQuery;
use Doctrine\Common\EventManager;
use Doctrine\DBAL\Cache\QueryCacheProfile;
use Doctrine\DBAL\Configuration;
use Doctrine\DBAL\Driver;
use Doctrine\DBAL\Sharding\ShardingException;
use LogicException;

/**
 * ShardingConnection
 *
 * The sharding connection is a global connection (that can be a shard server) and a collection of connection wrappers for shards.
 *
 * Those methods will be used by the global connection:
 *    ShardingConnection#prepare    Will connect on global but should execute on shard if one is selected
 *    ShardingConnection#quote
 *    ShardingConnection#errorCode
 *    ShardingConnection#errorInfo
 *    ShardingConnection#ping
 *
 * Can connect the global connection if no shard has been selected:
 *    ShardingConnection#lastInsertId
 *    ShardingConnection#lastInsertId
 *
 * Be aware!!
 * This connection does not managed the distribution key. If a SQL INSERT is executed without shard selection
 * the SQL will be executed on each shards.
 *
 * The shard to use can be auto guess if query builder is used.
 *
 * The method MultiStatement#fetchColumn change the interface (it will return a array of result)
 * All aggregate function executed on each shard will return a collection of result.
 * The merge should be done outside this class
 *
 * @example:

@example: tag is not allowed in class comment

 * // returns the count result of the first shard
 * $connection->from('test')->count());
 *
 * // returns an array containing all count result of each shards
 * $connection->query('select count(*) from test')->fetchColumn();
 *
 * @package Bdf\Prime\Sharding

@package tag is not allowed in class comment

 */
class ShardingConnection extends SimpleConnection implements SubConnectionManagerInterface
{
    /**
     * All shard connections
     *
     * @var SimpleConnection[]
     */
    private $connections = [];

Expected 1 blank line(s) before first member var; 0 found

    
    /**
     * The shard choser
     * 
     * @var ShardChoserInterface
     */
    private $shardChoser;

    /**
     * The id of current shard. Null means all shards
     *
     * @var string
     */
    private $currentShardId;

    /**
     * The distribution key
     *
     * @var string
     */
    private $distributionKey;

    /**
     * Initializes a new instance of the Connection class.
     * 
     * Here's a shard connections configuration

Doc comment long description must end with a full stop

     * 
     * @example
     *
     * $conn = DriverManager::getConnection([
     *    'driver' => 'pdo_mysql',
     *    'user'     => 'user',
     *    'password' => 'password',
     *    'host'     => '127.0.0.1',
     *    'dbname'   => 'basename',
     *    'distributionKey' => 'id',
     *    'shards' => [
     *      '{shardId}' => [
     *        'user'     => 'shard1',
     *        'host'     => '...',
     *      ]
     *    ]
     * ]);
     *
     * @param array                              $params       The connection parameters.

Parameter tags must be defined first in a doc comment

     * @param \Doctrine\DBAL\Driver              $driver       The driver to use.
     * @param \Doctrine\DBAL\Configuration|null  $config       The configuration, optional.
     * @param \Doctrine\Common\EventManager|null $eventManager The event manager, optional.
     */

Missing @throws tag in function comment

    public function __construct(array $params, Driver $driver, Configuration $config = null, EventManager $eventManager = null)
    {
        if (!isset($params['shard_connections'])) {
            throw new LogicException('Sharding connection needs "shard_connections" configuration in parameters');
        }

No blank line found after control structure

        if (!isset($params['distributionKey'])) {
            throw new LogicException('Sharding connection needs distribution key in parameters');
        }

        $this->distributionKey = $params['distributionKey'];
        $this->shardChoser = $params['shardChoser'] ?? new ModuloChoser();

Operation must be bracketed

        $this->connections = $params['shard_connections'];

        parent::__construct($params, $driver, $config, $eventManager);

        $this->factory()->alias(InsertQueryInterface::class, ShardingInsertQuery::class);

The method alias() does not exist on Bdf\Prime\Query\Factory\QueryFactoryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Bdf\Prime\Query\Factory\QueryFactoryInterface.

        $this->factory()->alias(KeyValueQueryInterface::class, ShardingKeyValueQuery::class);
    }

    /**
     * Get the shard ids
     *
     * @return array
     */
    public function getShardIds()
    {
        return array_keys($this->connections);
    }

    /**
     * Get the shard choser
     *
     * @return ShardChoserInterface
     */
    public function getShardChoser()
    {
        return $this->shardChoser;
    }

    /**
     * Get the distribution key
     *
     * @return string
     */
    public function getDistributionKey()
    {
        return $this->distributionKey;
    }

    /**
     * Get the current shard
     *
     * @return string
     */
    public function getCurrentShardId()
    {
        return $this->currentShardId;
    }

    /**
     * Select a shard to use.
     *
     * @param mixed $distributionValue
     *
     * @return $this
     */
    public function pickShard($distributionValue = null)
    {
        $this->useShard(
            $distributionValue !== null
                ? $this->shardChoser->pick($distributionValue, $this)

Inline IF statements are not allowed

Inline shorthand IF statement must be declared on a single line

                : null
        );

        return $this;
    }

    /**
     * Use a shard
     *
     * @param string $shardId
     *
     * @return $this
     *
     * @throws ShardingException   If the shard id is not known

@throws comment must be on the next line

@throws tag comment must end with a full stop

     */
    public function useShard($shardId = null)
    {
        if ($shardId !== null && !isset($this->connections[$shardId])) {
            throw new ShardingException('Trying to use an unknown shard id "'.$shardId.'"');
        }

        $this->currentShardId = $shardId;

        return $this;
    }

    /**
     * Check whether the connection is using a shard
     *
     * @return boolean

Expected "bool" but found "boolean" for function return type

     */
    public function isUsingShard()
    {
        return $this->currentShardId !== null;
    }

    /**
     * Get a shard connection by its id
     * Returns all connection if id is null

Doc comment short description must be on a single line, further text should be a separate paragraph

     *
     * @param mixed $shardId
     *
     * @return SimpleConnection|SimpleConnection[]
     *
     * @throws ShardingException   If the shard id is not known

@throws comment must be on the next line

@throws tag comment must end with a full stop

     */
    public function getShardConnection($shardId = null)
    {
        if ($shardId === null) {
            return $this->connections;
        }

        if (!isset($this->connections[$shardId])) {
            throw new ShardingException('Trying to get an unknown shard id "'.$shardId.'"');
        }

        return $this->connections[$shardId];
    }

    /**

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

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

    /**
     * Get the selected shards
     *
     * @return SimpleConnection[]
     */
    protected function getSelectedShards()
    {
        if ($this->isUsingShard()) {
            return [$this->connections[$this->currentShardId]];
        }

        return $this->connections;
    }

    /**
     * Get the selected shard
     *
     * @return SimpleConnection
     */
    protected function getSelectedShard()
    {
        return $this->connections[$this->currentShardId];
    }

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

        $this->currentShardId = null;

        foreach ($this->connections as $shard) {
            $shard->close();
        }
    }

    /**

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

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

    /**

Parameter $sql 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($sql, array $params = [], $types = [], QueryCacheProfile $qcp = null)
    {
        if ($this->isUsingShard()) {
            return $this->getSelectedShard()->executeQuery($sql, $params, $types, $qcp);
        }

        $stmt = new MultiStatement();

        foreach ($this->getSelectedShards() as $shard) {
            $stmt->add($shard->executeQuery($sql, $params, $types, $qcp));
        }

        return $stmt;
    }

    /**

Parameter $sql 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($sql, array $params = [], array $types = [])
    {
        $result = 0;

        foreach ($this->getSelectedShards() as $shard) {
            $result += $shard->executeUpdate($sql, $params, $types);
        }

        return $result;
    }

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

        if ($this->isUsingShard()) {
            return $this->getSelectedShard()->query(...$args);
        }

        $stmt = new MultiStatement();

        foreach ($this->getSelectedShards() as $shard) {
            $stmt->add($shard->query(...$args));
        }

        return $stmt;

The expression return $stmt returns the type Bdf\Prime\Sharding\MultiStatement which is incompatible with the return type mandated by Doctrine\DBAL\Driver\Connection::query() of Doctrine\DBAL\Driver\Statement.

    }

    /**

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

     * {@inheritdoc}
     */
    public function exec($statement)
    {
        $result = 0;

        foreach ($this->getSelectedShards() as $shard) {
            $result += $shard->exec($statement);
        }

        return $result;
    }

    /**
     * {@inheritdoc}
     */
    public function beginTransaction()
    {
        foreach ($this->getSelectedShards() as $shard) {
            $shard->beginTransaction();
        }
    }

    /**
     * {@inheritdoc}
     */
    public function commit()
    {
        foreach ($this->getSelectedShards() as $shard) {
            $shard->commit();
        }
    }

    /**
     * {@inheritdoc}
     */
    public function rollBack()
    {
        foreach ($this->getSelectedShards() as $shard) {
            $shard->rollBack();
        }
    }

    /**

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

     * {@inheritdoc}
     */
    public function createSavepoint($savepoint)
    {
        foreach ($this->getSelectedShards() as $shard) {
            $shard->createSavepoint($savepoint);
        }
    }

    /**

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

     * {@inheritdoc}
     */
    public function releaseSavepoint($savepoint)
    {
        foreach ($this->getSelectedShards() as $shard) {
            $shard->releaseSavepoint($savepoint);
        }
    }

    /**

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

     * {@inheritdoc}
     */
    public function rollbackSavepoint($savepoint)
    {
        foreach ($this->getSelectedShards() as $shard) {
            $shard->rollbackSavepoint($savepoint);
        }
    }

    /**

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

     * {@inheritdoc}
     */
    public function lastInsertId($seqName = null)
    {
        if ($this->isUsingShard()) {
            return $this->getSelectedShard()->lastInsertId($seqName);
        }

        // TODO doit on lever une exception ?

Comments for TODO tasks are often forgotten in the code; it might be better to use a dedicated issue tracker.

        return parent::lastInsertId($seqName);
    }

    /**
     * {@inheritdoc}
     */
    public function getWrappedConnection()
    {
        if ($this->isUsingShard()) {
            return $this->getSelectedShard()->getWrappedConnection();
        }

        // TODO doit on lever une exception ?

Comments for TODO tasks are often forgotten in the code; it might be better to use a dedicated issue tracker.

        return parent::getWrappedConnection();
    }
}