Spiral\Database\Drivers\MySQL\Schemas\MySQLColumn

Complexity

Total Complexity

19

Size/Duplication

Total Lines	232
Duplicated Lines	4.31 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	getDefaultValue()	0	8	2
A	sqlStatement()	0	18	3
C	createInstance()	10	57	10
A	prepareDefault()	0	16	4

<?php
/**
 * components
 *
 * @author    Wolfy-J
 */
namespace Spiral\Database\Drivers\MySQL\Schemas;

use Spiral\Database\Entities\Driver;
use Spiral\Database\Injections\Fragment;
use Spiral\Database\Schemas\Prototypes\AbstractColumn;

class MySQLColumn extends AbstractColumn
{
    /**
     * {@inheritdoc}
     */
    protected $mapping = [
        //Primary sequences
        'primary'     => [
            'type'          => 'int',
            'size'          => 11,
            'autoIncrement' => true,
            'nullable'      => false,
        ],
        'bigPrimary'  => [
            'type'          => 'bigint',
            'size'          => 20,
            'autoIncrement' => true,
            'nullable'      => false,
        ],

        //Enum type (mapped via method)
        'enum'        => 'enum',

        //Logical types
        'boolean'     => ['type' => 'tinyint', 'size' => 1],

        //Integer types (size can always be changed with size method), longInteger has method alias
        //bigInteger
        'integer'     => ['type' => 'int', 'size' => 11],
        'tinyInteger' => ['type' => 'tinyint', 'size' => 4],
        'bigInteger'  => ['type' => 'bigint', 'size' => 20],

        //String with specified length (mapped via method)
        'string'      => 'varchar',

        //Generic types
        'text'        => 'text',
        'tinyText'    => 'tinytext',
        'longText'    => 'longtext',

        //Real types
        'double'      => 'double',
        'float'       => 'float',

        //Decimal type (mapped via method)
        'decimal'     => 'decimal',

        //Date and Time types
        'datetime'    => 'datetime',
        'date'        => 'date',
        'time'        => 'time',
        'timestamp'   => [
            'type'         => 'timestamp',
            'defaultValue' => self::DATETIME_DEFAULT,
        ],

        //Binary types
        'binary'      => 'blob',
        'tinyBinary'  => 'tinyblob',
        'longBinary'  => 'longblob',

        //Additional types
        'json'        => 'text',
    ];

    /**
     * {@inheritdoc}
     */
    protected $reverseMapping = [
        'primary'     => [['type' => 'int', 'autoIncrement' => true]],
        'bigPrimary'  => ['serial', ['type' => 'bigint', 'autoIncrement' => true]],
        'enum'        => ['enum'],
        'boolean'     => ['bool', 'boolean', ['type' => 'tinyint', 'size' => 1]],
        'integer'     => ['int', 'integer', 'smallint', 'mediumint'],
        'tinyInteger' => ['tinyint'],
        'bigInteger'  => ['bigint'],
        'string'      => ['varchar', 'char'],
        'text'        => ['text', 'mediumtext'],
        'tinyText'    => ['tinytext'],
        'longText'    => ['longtext'],
        'double'      => ['double'],
        'float'       => ['float', 'real'],
        'decimal'     => ['decimal'],
        'datetime'    => ['datetime'],
        'date'        => ['date'],
        'time'        => ['time'],
        'timestamp'   => ['timestamp'],
        'binary'      => ['blob', 'binary', 'varbinary'],
        'tinyBinary'  => ['tinyblob'],
        'longBinary'  => ['longblob'],
    ];

    /**
     * List of types forbids default value set.
     *
     * @var array
     */
    protected $forbiddenDefaults = [
        'text',
        'mediumtext',
        'tinytext',
        'longtext',
        'blog',
        'tinyblob',
        'longblob',
    ];

    /**
     * Column is auto incremental.
     *
     * @var bool
     */
    protected $autoIncrement = false;

    /**
     * {@inheritdoc}
     */
    public function getDefaultValue()
    {
        if (in_array($this->type, $this->forbiddenDefaults)) {
            return null;
        }

        return parent::getDefaultValue();
    }

    /**
     * {@inheritdoc}
     */
    public function sqlStatement(Driver $driver): string
    {
        $defaultValue = $this->defaultValue;

        if (in_array($this->type, $this->forbiddenDefaults)) {
            //Flushing default value for forbidden types
            $this->defaultValue = null;
        }

        $statement = parent::sqlStatement($driver);

        $this->defaultValue = $defaultValue;
        if ($this->autoIncrement) {
            return "{$statement} AUTO_INCREMENT";
        }

        return $statement;
    }

    /**
     * @param string $table Table name.
     * @param array  $schema
     *
     * @return MySQLColumn
     */
    public static function createInstance(string $table, array $schema): self
    {
        $column = new self($table, $schema['Field']);

        $column->type = $schema['Type'];
        $column->nullable = strtolower($schema['Null']) == 'yes';
        $column->defaultValue = $schema['Default'];
        $column->autoIncrement = stripos($schema['Extra'], 'auto_increment') !== false;

        if (!preg_match(
            '/^(?P<type>[a-z]+)(?:\((?P<options>[^\)]+)\))?/',
            $column->type,
            $matches
        )
        ) {
            //No extra definitions
            return $column;
        }

        $column->type = $matches['type'];

        if (!empty($matches['options'])) {

This code seems to be duplicated across your project.

            $options = explode(',', $matches['options']);

            if (count($options) > 1) {
                $column->precision = (int)$options[0];
                $column->scale = (int)$options[1];
            } else {
                $column->size = (int)$options[0];
            }
        }

        //Fetching enum values
        if ($column->abstractType() == 'enum' && !empty($options)) {
            $column->enumValues = array_map(function ($value) {
                return trim($value, $value[0]);
            }, $options);

            return $column;
        }

        //Default value conversions
        if ($column->type == 'bit' && $column->hasDefaultValue()) {
            //Cutting b\ and '
            $column->defaultValue = new Fragment($column->defaultValue);
        }

        if (
            $column->abstractType() == 'timestamp'
            && $column->defaultValue == '0000-00-00 00:00:00'
        ) {
            //Normalizing default value; todo: is it needed?
            $column->defaultValue = self::DATETIME_DEFAULT;
        }

        return $column;
    }

    /**
     * {@inheritdoc}
     */
    protected function prepareDefault(Driver $driver): string
    {
        //todo: is it needed?
        if ($this->abstractType() == 'timestamp' && is_scalar($this->defaultValue)) {
            if (is_numeric($this->defaultValue)) {
                //Nothing to do
                return (int)$this->defaultValue;
            }

            $datetime = new \DateTime($this->defaultValue, $driver->getTimezone());

            return $datetime->getTimestamp();
        }

        return parent::prepareDefault($driver);
    }
}