FlexPHP\Database\Builder

Complexity

Total Complexity

17

Size/Duplication

Total Lines	155
Duplicated Lines	0 %

Test Coverage

Coverage

98.39%

Importance

Changes	1
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	14	2
A	createUser()	0	6	1
A	createDatabase()	0	5	1
A	getCollateDatabase()	0	9	2
A	isSQLSrvPlatform()	0	3	1
A	getPrettyTable()	0	16	2
A	createTable()	0	26	4
A	toSql()	0	18	4

<?php declare(strict_types=1);
/*
 * This file is part of FlexPHP.
 *
 * (c) Freddie Gar <freddie.gar@outlook.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace FlexPHP\Database;

use Doctrine\DBAL\Platforms\AbstractPlatform;
use Doctrine\DBAL\Schema\Schema as DBALSchema;
use Doctrine\DBAL\Schema\SchemaConfig as DBALSchemaConfig;
use FlexPHP\Schema\SchemaInterface;

final class Builder
{
    public const PLATFORM_MYSQL = 'MySQL';

    public const PLATFORM_SQLSRV = 'SQLSrv';

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

    /**
     * @var AbstractPlatform
     */
    private $DBALPlatform;

    /**
     * @var DBALSchema
     */
    private $DBALSchema;

    /**
     * @var array<int, string>
     */
    private $databases = [];

    /**
     * @var array<int, string>
     */
    private $users = [];

    /**
     * @var array<int, string>
     */
    private $tables = [];

    /**
     * @var array<string, string>
     */
    private $platformSupport = [
        self::PLATFORM_MYSQL => 'MySQL57',
        self::PLATFORM_SQLSRV => 'SQLServer2012',
    ];

    public function __construct(string $platform)
    {
        if (empty($this->platformSupport[$platform])) {
            throw new \InvalidArgumentException(\sprintf(
                'Platform %s not supported, try: %s',
                $platform,
                \implode(', ', \array_keys($this->platformSupport))
            ));
        }

        $fqdnPlatform = \sprintf('\Doctrine\DBAL\Platforms\%sPlatform', $this->platformSupport[$platform]);

        $this->platform = $platform;
        $this->DBALPlatform = new $fqdnPlatform();
    }

    public function createDatabase(string $name): void
    {
        $this->databases[] = $this->DBALPlatform->getCreateDatabaseSQL($name)
            . ' ' . $this->getCollateDatabase()
            . ';';
    }

    public function createUser(string $name, string $password, string $host = ''): void
    {
        $user = new User($name, $password, $host);
        $user->setPlatform($this->platform);

        $this->users[] = $user->toSqlCreate();
    }

    public function createTable(SchemaInterface $schema): void
    {
        $table = new Table($schema);

        $DBALSchemaConfig = new DBALSchemaConfig();
        $DBALSchemaConfig->setDefaultTableOptions($table->getOptions());

        $this->DBALSchema = new DBALSchema([], [], $DBALSchemaConfig);

        $DBALTable = $this->DBALSchema->createTable($table->getName());

        foreach ($table->getColumns() as $column) {
            $DBALTable->addColumn($column->getName(), $column->getType(), $column->getOptions());

            if ($column->isPrimaryKey()) {
                $DBALTable->setPrimaryKey([$column->getName()]);
            }

            if ($column->isForeingKey()) {
                $fkRel = $schema->fkRelations()[$column->getName()];

                $DBALTable->addForeignKeyConstraint($fkRel['pkTable'], [$fkRel['pkId']], [$fkRel['fkId']]);
            }
        }

        $this->tables[] = $this->getPrettyTable(\implode(";\n\n", $this->DBALSchema->toSql($this->DBALPlatform))) . ';';
    }

    public function toSql(): string
    {
        $sql = [];
        $glue = \str_repeat("\n", 2);

        if (\count($this->databases)) {
            $sql[] = \implode($glue, $this->databases);
        }

        if (\count($this->users)) {
            $sql[] = \implode($glue, $this->users);
        }

        if (\count($this->tables)) {
            $sql[] = \implode($glue, $this->tables);
        }

        return \implode($glue, $sql);
    }

    private function getCollateDatabase(): string
    {
        $collate = 'CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci';

        if ($this->isSQLSrvPlatform()) {
            $collate = 'COLLATE latin1_general_100_ci_ai_sc';
        }

        return $collate;
    }

    private function isSQLSrvPlatform(): bool
    {
        return $this->platform === self::PLATFORM_SQLSRV;
    }

    private function getPrettyTable(string $sql): string
    {
        $tag = '<columns>';
        $regExpColumns = "/\((?$tag.*)\)/";
        $prettySql = $sql;

        \preg_match($regExpColumns, $sql, $matches);

        if (!empty($matches['columns'])) {
            $columns = $matches['columns'];
            $table = \str_replace($columns, "\n    $tag\n", $sql);

            $prettySql = \str_replace($tag, \str_replace(', ', ",\n    ", $columns), $table);
        }

        return $prettySql;
    }
}