Spiral\Database\Drivers\SQLite\SQLiteHandler

Complexity

Total Complexity

17

Size/Duplication

Total Lines	222
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	dropTable()	0	4	1
B	syncTable()	0	38	3
A	createColumn()	0	4	1
A	dropColumn()	0	4	1
A	alterColumn()	0	7	1
A	createForeign()	0	4	1
A	dropForeign()	0	4	1
A	alterForeign()	0	7	1
A	requiresRebuild()	0	19	1
A	createTemporary()	0	15	2
B	copyData()	0	30	1
A	createMapping()	0	11	3

<?php
/**
 * Spiral Framework, Core Components
 *
 * @author    Wolfy-J
 */
namespace Spiral\Database\Drivers\SQLite;

use Spiral\Database\Entities\AbstractHandler;
use Spiral\Database\Exceptions\HandlerException;
use Spiral\Database\Schemas\Prototypes\AbstractColumn;
use Spiral\Database\Schemas\Prototypes\AbstractReference;
use Spiral\Database\Schemas\Prototypes\AbstractTable;

class SQLiteHandler extends AbstractHandler
{
    /**
     * Drop table from database.
     *
     * @param AbstractTable $table
     *
     * @throws HandlerException
     */
    public function dropTable(AbstractTable $table)
    {
        parent::dropTable($table);
    }

    /**
     * {@inheritdoc}
     */
    public function syncTable(AbstractTable $table, int $behaviour = self::DO_ALL)
    {
        if (!$this->requiresRebuild($table)) {
            //Nothing special, can be handled as usually
            parent::syncTable($table, $behaviour);

            return;
        }

        //Now we have to work with temporary table in order to perform every change
        $this->log('Rebuilding table {table} to apply required modifications.', [
            'table' => $this->identify($table)
        ]);

        $initial = clone $table;
        $initial->resetState();

        //Temporary table is required to copy data over
        $temporary = $this->createTemporary($table);

        //Moving data over
        $this->copyData(
            $initial->getName(),
            $temporary->getName(),
            $this->createMapping($initial, $temporary)
        );

        //We can drop initial table now
        $this->dropTable($table);

        //Renaming temporary table (should automatically handle table renaming)
        $this->renameTable($temporary->getName(), $initial->getName());

        //Not all databases support adding index while table creation, so we can do it after
        foreach ($table->getIndexes() as $index) {
            $this->createIndex($table, $index);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function createColumn(AbstractTable $table, AbstractColumn $column)
    {
        //Not supported
    }

    /**
     * {@inheritdoc}
     */
    public function dropColumn(AbstractTable $table, AbstractColumn $column)
    {
        //Not supported
    }

    /**
     * {@inheritdoc}
     */
    public function alterColumn(
        AbstractTable $table,
        AbstractColumn $initial,
        AbstractColumn $column
    ) {
        //Not supported
    }

    /**
     * {@inheritdoc}
     */
    public function createForeign(AbstractTable $table, AbstractReference $foreign)
    {
        //Not supported
    }

    /**
     * {@inheritdoc}
     */
    public function dropForeign(AbstractTable $table, AbstractReference $foreign)
    {
        //Not supported
    }

    /**
     * {@inheritdoc}
     */
    public function alterForeign(
        AbstractTable $table,
        AbstractReference $initial,
        AbstractReference $foreign
    ) {
        //Not supported
    }

    /**
     * Rebuild is required when columns or foreign keys are altered.
     *
     * @param AbstractTable $table
     *
     * @return bool
     */
    private function requiresRebuild(AbstractTable $table): bool
    {
        $comparator = $table->getComparator();

//        if ($comparator->isRenamed()) {

58% of this comment could be valid code. Did you maybe forget this after debugging?

//            return true;
//        }

        $difference = [
            count($comparator->addedColumns()),
            count($comparator->droppedColumns()),
            count($comparator->alteredColumns()),
            count($comparator->addedForeigns()),
            count($comparator->droppedForeigns()),
            count($comparator->alteredForeigns()),
        ];

        return array_sum($difference) != 0;
    }

    /**
     * Temporary table based on parent.
     *
     * @param AbstractTable $table
     *
     * @return AbstractTable
     */
    protected function createTemporary(AbstractTable $table): AbstractTable
    {
        //Temporary table is required to copy data over
        $temporary = clone $table;
        $temporary->setName('spiral_temp_' . $table->getName() . '_' . uniqid());

        //We don't need any indexes in temporary table
        foreach ($temporary->getIndexes() as $index) {
            $temporary->dropIndex($index->getColumns());
        }

        $this->createTable($temporary);

        return $temporary;
    }

    /**
     * Copy table data to another location.
     *
     * @see http://stackoverflow.com/questions/4007014/alter-column-in-sqlite
     *
     * @param string $source
     * @param string $to
     * @param array  $mapping (destination => source)
     *
     * @throws HandlerException
     */
    private function copyData(string $source, string $to, array $mapping)
    {
        $sourceColumns = array_keys($mapping);
        $targetColumns = array_values($mapping);

        $this->log(
            'Copying table data from {source} to {to} using mapping ({columns}) => ({target}).',
            [
                'source'  => $this->identify($source),
                'to'      => $this->identify($to),
                'columns' => implode(', ', $sourceColumns),
                'target'  => implode(', ', $targetColumns),
            ]
        );

        //Preparing mapping
        $sourceColumns = array_map([$this, 'identify'], $sourceColumns);
        $targetColumns = array_map([$this, 'identify'], $targetColumns);

        $query = \Spiral\interpolate('INSERT INTO {to} ({target}) SELECT {columns} FROM {source}',
            [
                'source'  => $this->identify($source),
                'to'      => $this->identify($to),
                'columns' => implode(', ', $sourceColumns),
                'target'  => implode(', ', $targetColumns),
            ]
        );

        $this->run($query);
    }

    /**
     * Get mapping between new and initial columns.
     *
     * @param AbstractTable $source
     * @param AbstractTable $target
     *
     * @return array
     */
    private function createMapping(AbstractTable $source, AbstractTable $target)
    {
        $mapping = [];
        foreach ($target->getColumns() as $name => $column) {
            if ($source->hasColumn($name)) {
                $mapping[$name] = $column->getName();
            }
        }

        return $mapping;
    }
}