Spiral\Database\Schemas\Prototypes\AbstractColumn

Complexity

Total Complexity

58

Size/Duplication

Total Lines	499
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes	1
Bugs	0	Features	0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	getType()	0	4	1
A	phpType()	0	11	3
A	getSize()	0	4	1
A	getPrecision()	0	4	1
A	getScale()	0	4	1
A	isNullable()	0	4	1
A	hasDefaultValue()	0	4	1
D	getDefaultValue()	0	32	9
A	getConstraints()	0	4	1
A	getEnumValues()	0	4	1
D	abstractType()	0	32	9
B	compare()	0	30	6
C	sqlStatement()	0	23	7
B	__debugInfo()	0	34	6
A	prepareEnum()	0	13	3
C	prepareDefault()	0	24	7

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

use Spiral\Database\Entities\Driver;
use Spiral\Database\Injections\Fragment;
use Spiral\Database\Injections\FragmentInterface;
use Spiral\Database\Schemas\ColumnInterface;

/**
 * Abstract column schema with read (see ColumnInterface) and write abilities. Must be implemented
 * by driver to support DBMS specific syntax and creation rules.
 *
 * Shortcuts for various column types:
 *
 * @method AbstractColumn|$this boolean()
 * @method AbstractColumn|$this integer()
 * @method AbstractColumn|$this tinyInteger()
 * @method AbstractColumn|$this bigInteger()
 * @method AbstractColumn|$this text()
 * @method AbstractColumn|$this tinyText()
 * @method AbstractColumn|$this longText()
 * @method AbstractColumn|$this double()
 * @method AbstractColumn|$this float()
 * @method AbstractColumn|$this datetime()
 * @method AbstractColumn|$this date()
 * @method AbstractColumn|$this time()
 * @method AbstractColumn|$this timestamp()
 * @method AbstractColumn|$this binary()
 * @method AbstractColumn|$this tinyBinary()
 * @method AbstractColumn|$this longBinary()
 * @method AbstractColumn|$this json()
 */
abstract class AbstractColumn extends AbstractElement implements ColumnInterface
{
    /**
     * Default datetime value.
     */
    const DATETIME_DEFAULT = '1970-01-01 00:00:00';

    /**
     * Default timestamp expression (driver specific).
     */
    const DATETIME_CURRENT = 'CURRENT_TIMESTAMP';

    /**
     * Abstract type aliases (for consistency).
     *
     * @var array
     */
    private $aliases = [
        'int'            => 'integer',
        'bigint'         => 'bigInteger',
        'incremental'    => 'primary',
        'bigIncremental' => 'bigPrimary',
        'bool'           => 'boolean',
        'blob'           => 'binary',
    ];

    /**
     * Association list between abstract types and native PHP types. Every non listed type will be
     * converted into string.
     *
     * @invisible
     *
     * @var array
     */
    private $phpMapping = [
        self::INT   => ['primary', 'bigPrimary', 'integer', 'tinyInteger', 'bigInteger'],
        self::BOOL  => ['boolean'],
        self::FLOAT => ['double', 'float', 'decimal'],
    ];

    /**
     * Mapping between abstract type and internal database type with it's options. Multiple abstract
     * types can map into one database type, this implementation allows us to equalize two columns
     * if they have different abstract types but same database one. Must be declared by DBMS
     * specific implementation.
     *
     * Example:
     * integer => array('type' => 'int', 'size' => 1),
     * boolean => array('type' => 'tinyint', 'size' => 1)
     *
     * @invisible
     *
     * @var array
     */
    protected $mapping = [
        //Primary sequences
        'primary'     => null,
        'bigPrimary'  => null,

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

        //Logical types
        'boolean'     => null,

        //Integer types (size can always be changed with size method), longInteger has method alias
        //bigInteger
        'integer'     => null,
        'tinyInteger' => null,
        'bigInteger'  => null,

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

        //Generic types
        'text'        => null,
        'tinyText'    => null,
        'longText'    => null,

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

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

        //Date and Time types
        'datetime'    => null,
        'date'        => null,
        'time'        => null,
        'timestamp'   => null,

        //Binary types
        'binary'      => null,
        'tinyBinary'  => null,
        'longBinary'  => null,

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

    /**
     * Reverse mapping is responsible for generating abstact type based on database type and it's
     * options. Multiple database types can be mapped into one abstract type.
     *
     * @invisible
     *
     * @var array
     */
    protected $reverseMapping = [
        'primary'     => [],
        'bigPrimary'  => [],
        'enum'        => [],
        'boolean'     => [],
        'integer'     => [],
        'tinyInteger' => [],
        'bigInteger'  => [],
        'string'      => [],
        'text'        => [],
        'tinyText'    => [],
        'longText'    => [],
        'double'      => [],
        'float'       => [],
        'decimal'     => [],
        'datetime'    => [],
        'date'        => [],
        'time'        => [],
        'timestamp'   => [],
        'binary'      => [],
        'tinyBinary'  => [],
        'longBinary'  => [],
        'json'        => [],
    ];

    /**
     * DBMS specific column type.
     *
     * @var string
     */
    protected $type = '';

    /**
     * Indicates that column can contain null values.
     *
     * @var bool
     */
    protected $nullable = true;

    /**
     * Default column value, may not be applied to some datatypes (for example to primary keys),
     * should follow type size and other options.
     *
     * @var mixed
     */
    protected $defaultValue = null;

    /**
     * Column type size, can have different meanings for different datatypes.
     *
     * @var int
     */
    protected $size = 0;

    /**
     * Precision of column, applied only for "decimal" type.
     *
     * @var int
     */
    protected $precision = 0;

    /**
     * Scale of column, applied only for "decimal" type.
     *
     * @var int
     */
    protected $scale = 0;

    /**
     * List of allowed enum values.
     *
     * @var array
     */
    protected $enumValues = [];

    /**
     * {@inheritdoc}
     */
    public function getType(): string
    {
        return $this->type;
    }

    /**
     * {@inheritdoc}
     */
    public function phpType(): string
    {
        $schemaType = $this->abstractType();
        foreach ($this->phpMapping as $phpType => $candidates) {
            if (in_array($schemaType, $candidates)) {
                return $phpType;
            }
        }

        return self::STRING;
    }

    /**
     * {@inheritdoc}
     */
    public function getSize(): int
    {
        return $this->size;
    }

    /**
     * {@inheritdoc}
     */
    public function getPrecision(): int
    {
        return $this->precision;
    }

    /**
     * {@inheritdoc}
     */
    public function getScale(): int
    {
        return $this->scale;
    }

    /**
     * {@inheritdoc}
     */
    public function isNullable(): bool
    {
        return $this->nullable;
    }

    /**
     * {@inheritdoc}
     */
    public function hasDefaultValue(): bool
    {
        return !is_null($this->defaultValue);
    }

    /**
     * {@inheritdoc}
     */
    public function getDefaultValue()
    {
        if (!$this->hasDefaultValue()) {
            return null;
        }

        if ($this->defaultValue instanceof FragmentInterface) {
            return $this->defaultValue;
        }

        if (in_array($this->abstractType(), ['time', 'date', 'datetime', 'timestamp'])) {
            //Driver specific now expression
            if (strtolower($this->defaultValue) == strtolower(static::DATETIME_CURRENT)) {
                return new Fragment($this->defaultValue);
            }
        }

        switch ($this->phpType()) {
            case 'int':
                return (int)$this->defaultValue;
            case 'float':
                return (float)$this->defaultValue;
            case 'bool':
                if (strtolower($this->defaultValue) == 'false') {
                    return false;
                }

                return (bool)$this->defaultValue;
        }

        return (string)$this->defaultValue;
    }

    /**
     * Get every associated column constraint names.
     *
     * @return array
     */
    public function getConstraints(): array
    {
        return [];
    }

    /**
     * Get allowed enum values.
     *
     * @return array
     */
    public function getEnumValues(): array
    {
        return $this->enumValues;
    }

    /**
     * DBMS specific reverse mapping must map database specific type into limited set of abstract
     * types.
     *
     * @return string
     */
    public function abstractType(): string
    {
        foreach ($this->reverseMapping as $type => $candidates) {
            foreach ($candidates as $candidate) {
                if (is_string($candidate)) {
                    if (strtolower($candidate) == strtolower($this->type)) {
                        return $type;
                    }

                    continue;
                }

                if (strtolower($candidate['type']) != strtolower($this->type)) {
                    continue;
                }

                foreach ($candidate as $option => $required) {
                    if ($option == 'type') {
                        continue;
                    }

                    if ($this->{$option} != $required) {
                        continue 2;
                    }
                }

                return $type;
            }
        }

        return 'unknown';
    }

    //--- MODIFICATIONS IS HERE

    /**
     * {@inheritdoc}
     */
    public function compare(ColumnInterface $initial): bool
    {
        $normalized = clone $initial;

        if ($this == $normalized) {
            return true;
        }

        $columnVars = get_object_vars($this);
        $dbColumnVars = get_object_vars($normalized);

        $difference = [];
        foreach ($columnVars as $name => $value) {
            if ($name == 'defaultValue') {

                //Default values has to compared using type-casted value
                if ($this->getDefaultValue() != $initial->getDefaultValue()) {
                    $difference[] = $name;
                }

                continue;
            }

            if ($value != $dbColumnVars[$name]) {
                $difference[] = $name;
            }
        }

        return empty($difference);
    }

    /**
     * {@inheritdoc}
     */
    public function sqlStatement(Driver $driver): string
    {
        $statement = [$driver->identifier($this->name), $this->type];

        if ($this->abstractType() == 'enum') {
            //Enum specific column options
            if (!empty($enumDefinition = $this->prepareEnum($driver))) {
                $statement[] = $enumDefinition;
            }
        } elseif (!empty($this->precision)) {
            $statement[] = "({$this->precision}, {$this->scale})";
        } elseif (!empty($this->size)) {
            $statement[] = "({$this->size})";
        }

        $statement[] = $this->nullable ? 'NULL' : 'NOT NULL';

        if ($this->defaultValue !== null) {
            $statement[] = "DEFAULT {$this->prepareDefault($driver)}";
        }

        return implode(' ', $statement);
    }


    /**
     * Simplified way to dump information.
     *
     * @return array
     */
    public function __debugInfo()
    {
        $column = [
            'name' => $this->name,
            'type' => [
                'database' => $this->type,
                'schema'   => $this->abstractType(),
                'php'      => $this->phpType(),
            ],
        ];

        if (!empty($this->size)) {
            $column['size'] = $this->size;
        }

        if ($this->nullable) {
            $column['nullable'] = true;
        }

        if ($this->defaultValue !== null) {
            $column['defaultValue'] = $this->getDefaultValue();
        }

        if ($this->abstractType() == 'enum') {
            $column['enumValues'] = $this->enumValues;
        }

        if ($this->abstractType() == 'decimal') {
            $column['precision'] = $this->precision;
            $column['scale'] = $this->scale;
        }

        return $column;
    }

    /**
     * Get database specific enum type definition options.
     *
     * @param Driver $driver
     *
     * @return string.

The doc-type string. could not be parsed: Unknown type name "string." at position 0. (view supported doc-types)

     */
    protected function prepareEnum(Driver $driver): string
    {
        $enumValues = [];
        foreach ($this->enumValues as $value) {
            $enumValues[] = $driver->quote($value);
        }

        if (!empty($enumValues)) {
            return '(' . implode(', ', $enumValues) . ')';
        }

        return '';
    }

    /**
     * Must return driver specific default value.
     *
     * @param Driver $driver
     *
     * @return string
     */
    protected function prepareDefault(Driver $driver): string
    {
        if (($defaultValue = $this->getDefaultValue()) === null) {
            return 'NULL';
        }

        if ($defaultValue instanceof FragmentInterface) {
            return $defaultValue->sqlStatement();
        }

        if ($this->phpType() == 'bool') {
            return $defaultValue ? 'TRUE' : 'FALSE';
        }

        if ($this->phpType() == 'float') {
            return sprintf('%F', $defaultValue);
        }

        if ($this->phpType() == 'int') {
            return $defaultValue;
        }

        return $driver->quote($defaultValue);
    }
}