Database::getDrivers() - Code Metrics - biurad/cycle-bridge - Measure and Improve Code Quality continuously with Scrutinizer

Database::getDrivers() A
last analyzed 2020-12-15 07:02 UTC

↳ Parent: Database
Complexity

Conditions	2
Paths	2
Size

Total Lines	16
Code Lines	8
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	2
eloc	8
c	1
b	0
f	0
nc	2
nop	0
dl	0
loc	16
rs	10
<?php

declare(strict_types=1);

/*
 * This file is part of Biurad opensource projects.
 *
 * PHP version 7.2 and above required
 *
 * @author    Divine Niiquaye Ibok <[email protected]>
 * @copyright 2019 Biurad Group (https://biurad.com/)
 * @license   https://opensource.org/licenses/BSD-3-Clause License
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Biurad\Cycle;

use Biurad\DependencyInjection\FactoryInterface;
use Closure;
use Psr\Container\ContainerExceptionInterface;
use Psr\Log\LoggerAwareInterface;
use Psr\Log\LoggerAwareTrait;
use Psr\Log\NullLogger;
use Spiral\Core\Container\Autowire;
use Spiral\Database\Config\DatabaseConfig;
use Spiral\Database\Config\DatabasePartial;
use Spiral\Database\Database as SpiralDatabase;
use Spiral\Database\DatabaseInterface;
use Spiral\Database\DatabaseProviderInterface;
use Spiral\Database\Driver\DriverInterface;
use Spiral\Database\Exception\DBALException;

/**
 * Automatic factory and configurator for Drivers and Databases.
 *
 * Example:
 * $config = [
 *  'default'     => 'default',
 *  'aliases'     => [
 *      'default'  => 'primary',
 *      'database' => 'primary',
 *      'db'       => 'primary',
 *  ],
 *  'databases'   => [
 *      'primary'   => [
 *          'connection'  => 'mysql',
 *          'tablePrefix' => 'db_'
 *      ],
 *      'secondary' => [
 *          'connection'  => 'postgres',
 *          'tablePrefix' => '',
 *      ],
 *  ],
 *  'connections' => [
 *      'mysql'     => [
 *          'driver'     => Driver\MySQL\MySQLDriver::class,
 *          'options' => [
 *              'connection' => 'mysql:host=127.0.0.1;dbname=database',
 *              'username'   => 'mysql',
 *              'password'   => 'mysql',
 *           ],
 *      ],
 *      'postgres'  => [
 *          'driver'     => Driver\Postgres\PostgresDriver::class,
 *          'options' => [
 *              'connection' => 'pgsql:host=127.0.0.1;dbname=database',
 *              'username'   => 'postgres',
 *              'password'   => 'postgres',
 *           ],
 *      ],
 *      'runtime'   => [
 *          'driver'     => Driver\SQLite\SQLiteDriver::class,
 *          'options' => [
 *              'connection' => 'sqlite:' . directory('runtime') . 'runtime.db',
 *              'username'   => 'sqlite',
 *           ],
 *      ],
 *      'sqlServer' => [
 *          'driver'     => Driver\SQLServer\SQLServerDriver::class,
 *          'options' => [
 *              'connection' => 'sqlsrv:Server=OWNER;Database=DATABASE',
 *              'username'   => 'sqlServer',
 *              'password'   => 'sqlServer',
 *           ],
 *      ],
 *   ]
 * ];
 *
 * $manager = new DatabaseManager(new DatabaseConfig($config));
 *
 * echo $manager->database('runtime')->select()->from('users')->count();
 */
final class Database implements DatabaseProviderInterface
{
    use LoggerAwareTrait;

    /** @var DatabaseConfig */
    private $config;

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

    /** @var SpiralDatabase[] */
    private $databases = [];

    /** @var DriverInterface[] */
    private $drivers = [];

    /**
     * @param DatabaseConfig   $config
     * @param FactoryInterface $factory
     */
    public function __construct(DatabaseConfig $config, FactoryInterface $factory)
    {
        $this->config  = $config;
        $this->factory = $factory;
    }

    /**
     * Get all databases.
     *
     * @throws DatabaseException
     *
     * @return DatabaseInterface[]
     */
    public function getDatabases(): array
    {
        $names = \array_unique(
            \array_merge(
                \array_keys($this->databases),
                \array_keys($this->config->getDatabases())
            )
        );

        $result = [];

        foreach ($names as $name) {
            $result[] = $this->database($name);
        }

        return $result;
    }

    /**
     * Get Database associated with a given database alias or automatically created one.
     *
     * @param null|string $database
     *
     * @throws DBALException
     *
     * @return DatabaseInterface
     */
    public function database(string $database = null): DatabaseInterface
    {
        if ($database === null) {
            $database = $this->config->getDefaultDatabase();
        }

        //Spiral support ability to link multiple virtual databases together using aliases
        $database = $this->config->resolveAlias($database);

        if (isset($this->databases[$database])) {
            return $this->databases[$database];
        }

        if (!$this->config->hasDatabase($database)) {
            throw new DBALException(
                "Unable to create Database, no presets for '{$database}' found"
            );
        }

        return $this->databases[$database] = $this->makeDatabase(
            $this->config->getDatabase($database)
        );
    }

    /**
     * Add new database.
     *
     * @param SpiralDatabase $database
     *
     * @throws DBALException
     */
    public function addDatabase(SpiralDatabase $database): void
    {
        if (isset($this->databases[$database->getName()])) {
            throw new DBALException("Database '{$database->getName()}' already exists");
        }

        $this->databases[$database->getName()] = $database;
    }

    /**
     * Get instance of every available driver/connection.
     *
     * @throws DBALException
     *
     * @return DriverInterface[]
     */
    public function getDrivers(): array
    {
        $names = \array_unique(
            \array_merge(
                \array_keys($this->drivers),
                \array_keys($this->config->getDrivers())
            )
        );

        $result = [];

        foreach ($names as $name) {
            $result[] = $this->driver($name);
        }

        return $result;
    }

    /**
     * Get driver instance by it's name or automatically create one.
     *
     * @param string $driver
     *
     * @throws DBALException
     *
     * @return DriverInterface
     */
    public function driver(string $driver): DriverInterface
    {
        if (isset($this->drivers[$driver])) {
            return $this->drivers[$driver];
        }

        $factory = clone $this->factory;

        try {
            $driverObject = Closure::bind(
                static function (Autowire $autowire) use ($factory): DriverInterface {
                    return $factory->createInstance($autowire->alias, $autowire->parameters);

                },
                null,
                Autowire::class
            );
            $driverObject = $driverObject($this->config->getDriver($driver));

            $this->drivers[$driver] = $driverObject;

            if ($driverObject instanceof LoggerAwareInterface) {
                if (!$this->logger instanceof NullLogger) {
                    $driverObject->setLogger($this->logger);
                }
            }

            return $this->drivers[$driver];
        } catch (ContainerExceptionInterface $e) {
            throw new DBALException($e->getMessage(), $e->getCode(), $e);
            throw new DBALException($e->getMessage(), $e->/** @scrutinizer ignore-call */ getCode(), $e);
        }
    }

    /**
     * Manually set connection instance.
     *
     * @param string          $name
     * @param DriverInterface $driver
     *
     * @throws DBALException
     *
     * @return self
     */
    public function addDriver(string $name, DriverInterface $driver): Database
    {
        if (isset($this->drivers[$name])) {
            throw new DBALException("Connection '{$name}' already exists");
        }

        $this->drivers[$name] = $driver;

        return $this;
    }

    /**
     * @param DatabasePartial $database
     *
     * @throws DBALException
     *
     * @return SpiralDatabase
     */
    protected function makeDatabase(DatabasePartial $database): SpiralDatabase
    {
        return new SpiralDatabase(
            $database->getName(),
            $database->getPrefix(),
            $this->driver($database->getDriver()),
            $database->getReadDriver() ? $this->driver($database->getReadDriver()) : null
        );
    }
}

biurad / cycle-bridge

Database::getDrivers() A last analyzed 2020-12-15 07:02 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Database::getDrivers() A
last analyzed 2020-12-15 07:02 UTC
