Comparator::diffColumn() - Code Metrics - Inspection of "[WIP] Fix BC-break regarding JsonArrayType" - doctrine/dbal - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#2855)

by Luís

created 2017-10-25 18:19 UTC

Comparator::diffColumn() F

↳ Parent: Comparator

Complexity

Conditions	35
Paths	6048

Size

Total Lines	82
Code Lines	45

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	43
CRAP Score	35.1072

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
c	1
b	0
f	1
dl	0
loc	82
ccs	43
cts	45
cp	0.9556
rs	2.3705
cc	35
eloc	45
nc	6048
nop	2
crap	35.1072

How to fix Long Method Complexity

<?php
/*
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * This software consists of voluntary contributions made by many individuals
 * and is licensed under the MIT license. For more information, see
 * <http://www.doctrine-project.org>.
 */

namespace Doctrine\DBAL\Schema;

use Doctrine\DBAL\Types;

/**
 * Compares two Schemas and return an instance of SchemaDiff.
 *
 * @link   www.doctrine-project.org
 * @since  2.0
 * @author Benjamin Eberlei <[email protected]>
 */
class Comparator
{
    /**
     * @param \Doctrine\DBAL\Schema\Schema $fromSchema
     * @param \Doctrine\DBAL\Schema\Schema $toSchema
     *
     * @return \Doctrine\DBAL\Schema\SchemaDiff
     */
    public static function compareSchemas(Schema $fromSchema, Schema $toSchema)
    {
        $c = new self();

        return $c->compare($fromSchema, $toSchema);
    }

    /**
     * Returns a SchemaDiff object containing the differences between the schemas $fromSchema and $toSchema.
     *
     * The returned differences are returned in such a way that they contain the
     * operations to change the schema stored in $fromSchema to the schema that is
     * stored in $toSchema.
     *
     * @param \Doctrine\DBAL\Schema\Schema $fromSchema
     * @param \Doctrine\DBAL\Schema\Schema $toSchema
     *
     * @return \Doctrine\DBAL\Schema\SchemaDiff
     */
    public function compare(Schema $fromSchema, Schema $toSchema)
    {
        $diff = new SchemaDiff();
        $diff->fromSchema = $fromSchema;

        $foreignKeysToTable = [];

        foreach ($toSchema->getNamespaces() as $namespace) {
            if ( ! $fromSchema->hasNamespace($namespace)) {
                $diff->newNamespaces[$namespace] = $namespace;
            }
        }

        foreach ($fromSchema->getNamespaces() as $namespace) {
            if ( ! $toSchema->hasNamespace($namespace)) {
                $diff->removedNamespaces[$namespace] = $namespace;
            }
        }

        foreach ($toSchema->getTables() as $table) {
            $tableName = $table->getShortestName($toSchema->getName());
            if ( ! $fromSchema->hasTable($tableName)) {
                $diff->newTables[$tableName] = $toSchema->getTable($tableName);
            } else {
                $tableDifferences = $this->diffTable($fromSchema->getTable($tableName), $toSchema->getTable($tableName));
                if ($tableDifferences !== false) {
                    $diff->changedTables[$tableName] = $tableDifferences;
                }
            }
        }

        /* Check if there are tables removed */
        foreach ($fromSchema->getTables() as $table) {
            $tableName = $table->getShortestName($fromSchema->getName());

            $table = $fromSchema->getTable($tableName);
            if ( ! $toSchema->hasTable($tableName)) {
                $diff->removedTables[$tableName] = $table;
            }

            // also remember all foreign keys that point to a specific table
            foreach ($table->getForeignKeys() as $foreignKey) {
                $foreignTable = strtolower($foreignKey->getForeignTableName());
                if (!isset($foreignKeysToTable[$foreignTable])) {
                    $foreignKeysToTable[$foreignTable] = [];
                }
                $foreignKeysToTable[$foreignTable][] = $foreignKey;
            }
        }

        foreach ($diff->removedTables as $tableName => $table) {
            if (isset($foreignKeysToTable[$tableName])) {
                $diff->orphanedForeignKeys = array_merge($diff->orphanedForeignKeys, $foreignKeysToTable[$tableName]);

                // deleting duplicated foreign keys present on both on the orphanedForeignKey
                // and the removedForeignKeys from changedTables
                foreach ($foreignKeysToTable[$tableName] as $foreignKey) {
                    // strtolower the table name to make if compatible with getShortestName
                    $localTableName = strtolower($foreignKey->getLocalTableName());
                    if (isset($diff->changedTables[$localTableName])) {
                        foreach ($diff->changedTables[$localTableName]->removedForeignKeys as $key => $removedForeignKey) {
                            // We check if the key is from the removed table if not we skip.
                            if ($tableName !== strtolower($removedForeignKey->getForeignTableName())) {
                                continue;
                            }
                            unset($diff->changedTables[$localTableName]->removedForeignKeys[$key]);
                        }
                    }
                }
            }
        }

        foreach ($toSchema->getSequences() as $sequence) {
            $sequenceName = $sequence->getShortestName($toSchema->getName());
            if ( ! $fromSchema->hasSequence($sequenceName)) {
                if ( ! $this->isAutoIncrementSequenceInSchema($fromSchema, $sequence)) {
                    $diff->newSequences[] = $sequence;
                }
            } else {
                if ($this->diffSequence($sequence, $fromSchema->getSequence($sequenceName))) {
                    $diff->changedSequences[] = $toSchema->getSequence($sequenceName);
                }
            }
        }

        foreach ($fromSchema->getSequences() as $sequence) {
            if ($this->isAutoIncrementSequenceInSchema($toSchema, $sequence)) {
                continue;
            }

            $sequenceName = $sequence->getShortestName($fromSchema->getName());

            if ( ! $toSchema->hasSequence($sequenceName)) {
                $diff->removedSequences[] = $sequence;
            }
        }

        return $diff;
    }

    /**
     * @param \Doctrine\DBAL\Schema\Schema   $schema
     * @param \Doctrine\DBAL\Schema\Sequence $sequence
     *
     * @return boolean
     */
    private function isAutoIncrementSequenceInSchema($schema, $sequence)
    {
        foreach ($schema->getTables() as $table) {
            if ($sequence->isAutoIncrementsFor($table)) {
                return true;
            }
        }

        return false;
    }

    /**
     * @param \Doctrine\DBAL\Schema\Sequence $sequence1
     * @param \Doctrine\DBAL\Schema\Sequence $sequence2
     *
     * @return boolean
     */
    public function diffSequence(Sequence $sequence1, Sequence $sequence2)
    {
        if ($sequence1->getAllocationSize() != $sequence2->getAllocationSize()) {
            return true;
        }

        if ($sequence1->getInitialValue() != $sequence2->getInitialValue()) {
            return true;
        }

        return false;
    }

    /**
     * Returns the difference between the tables $table1 and $table2.
     *
     * If there are no differences this method returns the boolean false.
     *
     * @param \Doctrine\DBAL\Schema\Table $table1
     * @param \Doctrine\DBAL\Schema\Table $table2
     *
     * @return boolean|\Doctrine\DBAL\Schema\TableDiff
     */
    public function diffTable(Table $table1, Table $table2)
    {
        $changes = 0;
        $tableDifferences = new TableDiff($table1->getName());
        $tableDifferences->fromTable = $table1;

        $table1Columns = $table1->getColumns();
        $table2Columns = $table2->getColumns();

        /* See if all the fields in table 1 exist in table 2 */
        foreach ($table2Columns as $columnName => $column) {
            if ( !$table1->hasColumn($columnName)) {
                $tableDifferences->addedColumns[$columnName] = $column;
                $changes++;
            }
        }
        /* See if there are any removed fields in table 2 */
        foreach ($table1Columns as $columnName => $column) {
            // See if column is removed in table 2.
            if ( ! $table2->hasColumn($columnName)) {
                $tableDifferences->removedColumns[$columnName] = $column;
                $changes++;
                continue;
            }

            // See if column has changed properties in table 2.
            $changedProperties = $this->diffColumn($column, $table2->getColumn($columnName));

            if ( ! empty($changedProperties)) {
                $columnDiff = new ColumnDiff($column->getName(), $table2->getColumn($columnName), $changedProperties);
                $columnDiff->fromColumn = $column;
                $tableDifferences->changedColumns[$column->getName()] = $columnDiff;
                $changes++;
            }
        }

        $this->detectColumnRenamings($tableDifferences);

        $table1Indexes = $table1->getIndexes();
        $table2Indexes = $table2->getIndexes();

        /* See if all the indexes in table 1 exist in table 2 */
        foreach ($table2Indexes as $indexName => $index) {
            if (($index->isPrimary() && $table1->hasPrimaryKey()) || $table1->hasIndex($indexName)) {
                continue;
            }

            $tableDifferences->addedIndexes[$indexName] = $index;
            $changes++;
        }
        /* See if there are any removed indexes in table 2 */
        foreach ($table1Indexes as $indexName => $index) {
            // See if index is removed in table 2.
            if (($index->isPrimary() && ! $table2->hasPrimaryKey()) ||
                ! $index->isPrimary() && ! $table2->hasIndex($indexName)
            ) {
                $tableDifferences->removedIndexes[$indexName] = $index;
                $changes++;
                continue;
            }

            // See if index has changed in table 2.
            $table2Index = $index->isPrimary() ? $table2->getPrimaryKey() : $table2->getIndex($indexName);

            if ($this->diffIndex($index, $table2Index)) {
                $tableDifferences->changedIndexes[$indexName] = $table2Index;
                $changes++;
            }
        }

        $this->detectIndexRenamings($tableDifferences);

        $fromFkeys = $table1->getForeignKeys();
        $toFkeys = $table2->getForeignKeys();

        foreach ($fromFkeys as $key1 => $constraint1) {
            foreach ($toFkeys as $key2 => $constraint2) {
                if ($this->diffForeignKey($constraint1, $constraint2) === false) {
                    unset($fromFkeys[$key1]);
                    unset($toFkeys[$key2]);
                } else {
                    if (strtolower($constraint1->getName()) == strtolower($constraint2->getName())) {
                        $tableDifferences->changedForeignKeys[] = $constraint2;
                        $changes++;
                        unset($fromFkeys[$key1]);
                        unset($toFkeys[$key2]);
                    }
                }
            }
        }

        foreach ($fromFkeys as $constraint1) {
            $tableDifferences->removedForeignKeys[] = $constraint1;
            $changes++;
        }

        foreach ($toFkeys as $constraint2) {
            $tableDifferences->addedForeignKeys[] = $constraint2;
            $changes++;
        }

        return $changes ? $tableDifferences : false;
    }

    /**
     * Try to find columns that only changed their name, rename operations maybe cheaper than add/drop
     * however ambiguities between different possibilities should not lead to renaming at all.
     *
     * @param \Doctrine\DBAL\Schema\TableDiff $tableDifferences
     *
     * @return void
     */
    private function detectColumnRenamings(TableDiff $tableDifferences)

    {
        $renameCandidates = [];
        foreach ($tableDifferences->addedColumns as $addedColumnName => $addedColumn) {
            foreach ($tableDifferences->removedColumns as $removedColumn) {
                if (count($this->diffColumn($addedColumn, $removedColumn)) == 0) {
                    $renameCandidates[$addedColumn->getName()][] = [$removedColumn, $addedColumn, $addedColumnName];
                }
            }
        }

        foreach ($renameCandidates as $candidateColumns) {
            if (count($candidateColumns) == 1) {
                list($removedColumn, $addedColumn) = $candidateColumns[0];
                $removedColumnName = strtolower($removedColumn->getName());
                $addedColumnName = strtolower($addedColumn->getName());

                if ( ! isset($tableDifferences->renamedColumns[$removedColumnName])) {
                    $tableDifferences->renamedColumns[$removedColumnName] = $addedColumn;
                    unset($tableDifferences->addedColumns[$addedColumnName]);
                    unset($tableDifferences->removedColumns[$removedColumnName]);
                }
            }
        }
    }

    /**
     * Try to find indexes that only changed their name, rename operations maybe cheaper than add/drop
     * however ambiguities between different possibilities should not lead to renaming at all.
     *
     * @param \Doctrine\DBAL\Schema\TableDiff $tableDifferences
     *
     * @return void
     */
    private function detectIndexRenamings(TableDiff $tableDifferences)

    {
        $renameCandidates = [];

        // Gather possible rename candidates by comparing each added and removed index based on semantics.
        foreach ($tableDifferences->addedIndexes as $addedIndexName => $addedIndex) {
            foreach ($tableDifferences->removedIndexes as $removedIndex) {
                if (! $this->diffIndex($addedIndex, $removedIndex)) {
                    $renameCandidates[$addedIndex->getName()][] = [$removedIndex, $addedIndex, $addedIndexName];
                }
            }
        }

        foreach ($renameCandidates as $candidateIndexes) {
            // If the current rename candidate contains exactly one semantically equal index,
            // we can safely rename it.
            // Otherwise it is unclear if a rename action is really intended,
            // therefore we let those ambiguous indexes be added/dropped.
            if (count($candidateIndexes) === 1) {
                list($removedIndex, $addedIndex) = $candidateIndexes[0];

                $removedIndexName = strtolower($removedIndex->getName());
                $addedIndexName = strtolower($addedIndex->getName());

                if (! isset($tableDifferences->renamedIndexes[$removedIndexName])) {
                    $tableDifferences->renamedIndexes[$removedIndexName] = $addedIndex;
                    unset($tableDifferences->addedIndexes[$addedIndexName]);
                    unset($tableDifferences->removedIndexes[$removedIndexName]);
                }
            }
        }
    }

    /**
     * @param \Doctrine\DBAL\Schema\ForeignKeyConstraint $key1
     * @param \Doctrine\DBAL\Schema\ForeignKeyConstraint $key2
     *
     * @return boolean
     */
    public function diffForeignKey(ForeignKeyConstraint $key1, ForeignKeyConstraint $key2)
    {
        if (array_map('strtolower', $key1->getUnquotedLocalColumns()) != array_map('strtolower', $key2->getUnquotedLocalColumns())) {
            return true;
        }

        if (array_map('strtolower', $key1->getUnquotedForeignColumns()) != array_map('strtolower', $key2->getUnquotedForeignColumns())) {
            return true;
        }

        if ($key1->getUnqualifiedForeignTableName() !== $key2->getUnqualifiedForeignTableName()) {
            return true;
        }

        if ($key1->onUpdate() != $key2->onUpdate()) {
            return true;
        }

        if ($key1->onDelete() != $key2->onDelete()) {
            return true;
        }

        return false;
    }

    /**
     * Returns the difference between the fields $field1 and $field2.
     *
     * If there are differences this method returns $field2, otherwise the
     * boolean false.
     *
     * @param \Doctrine\DBAL\Schema\Column $column1
     * @param \Doctrine\DBAL\Schema\Column $column2
     *
     * @return array
     */
    public function diffColumn(Column $column1, Column $column2)
    {
        $properties1 = $column1->toArray();
        $properties2 = $column2->toArray();

        $changedProperties = [];

        foreach (['type', 'notnull', 'unsigned', 'autoincrement'] as $property) {
            if ($properties1[$property] != $properties2[$property]) {
                $changedProperties[] = $property;
            }
        }

        // This is a very nasty hack to make comparator work with the legacy json_array type, which should be killed in v3
        if (($properties1['type']->getName() === Types\Type::JSON && $properties2['type']->getName() === Types\Type::JSON_ARRAY)
            || ($properties1['type']->getName() === Types\Type::JSON_ARRAY && $properties2['type']->getName() === Types\Type::JSON)) {
            array_shift($changedProperties);

            $changedProperties[] = 'comment';
        }

        if ($properties1['default'] != $properties2['default'] ||
            // Null values need to be checked additionally as they tell whether to create or drop a default value.
            // null != 0, null != false, null != '' etc. This affects platform's table alteration SQL generation.
            (null === $properties1['default'] && null !== $properties2['default']) ||
            (null === $properties2['default'] && null !== $properties1['default'])
        ) {
            $changedProperties[] = 'default';
        }

        if (($properties1['type'] instanceof Types\StringType && ! $properties1['type'] instanceof Types\GuidType) ||
            $properties1['type'] instanceof Types\BinaryType
        ) {
            // check if value of length is set at all, default value assumed otherwise.
            $length1 = $properties1['length'] ?: 255;
            $length2 = $properties2['length'] ?: 255;
            if ($length1 != $length2) {
                $changedProperties[] = 'length';
            }

            if ($properties1['fixed'] != $properties2['fixed']) {
                $changedProperties[] = 'fixed';
            }
        } elseif ($properties1['type'] instanceof Types\DecimalType) {
            if (($properties1['precision'] ?: 10) != ($properties2['precision'] ?: 10)) {
                $changedProperties[] = 'precision';
            }
            if ($properties1['scale'] != $properties2['scale']) {
                $changedProperties[] = 'scale';
            }
        }

        // A null value and an empty string are actually equal for a comment so they should not trigger a change.
        if ($properties1['comment'] !== $properties2['comment'] &&
            ! (null === $properties1['comment'] && '' === $properties2['comment']) &&
            ! (null === $properties2['comment'] && '' === $properties1['comment'])
        ) {
            $changedProperties[] = 'comment';
        }

        $customOptions1 = $column1->getCustomSchemaOptions();
        $customOptions2 = $column2->getCustomSchemaOptions();

        foreach (array_merge(array_keys($customOptions1), array_keys($customOptions2)) as $key) {
            if ( ! array_key_exists($key, $properties1) || ! array_key_exists($key, $properties2)) {
                $changedProperties[] = $key;
            } elseif ($properties1[$key] !== $properties2[$key]) {
                $changedProperties[] = $key;
            }
        }

        $platformOptions1 = $column1->getPlatformOptions();
        $platformOptions2 = $column2->getPlatformOptions();

        foreach (array_keys(array_intersect_key($platformOptions1, $platformOptions2)) as $key) {
            if ($properties1[$key] !== $properties2[$key]) {
                $changedProperties[] = $key;
            }
        }

        return array_unique($changedProperties);
    }

    /**
     * Finds the difference between the indexes $index1 and $index2.
     *
     * Compares $index1 with $index2 and returns $index2 if there are any
     * differences or false in case there are no differences.
     *
     * @param \Doctrine\DBAL\Schema\Index $index1
     * @param \Doctrine\DBAL\Schema\Index $index2
     *
     * @return boolean
     */
    public function diffIndex(Index $index1, Index $index2)
    {
        if ($index1->isFullfilledBy($index2) && $index2->isFullfilledBy($index1)) {
            return false;
        }

        return true;
    }
}


1			<?php
2			/*
3			* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
4			* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
5			* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
6			* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
7			* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
8			* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
9			* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
10			* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
11			* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
12			* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
13			* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
14			*
15			* This software consists of voluntary contributions made by many individuals
16			* and is licensed under the MIT license. For more information, see
17			* <http://www.doctrine-project.org>.
18			*/
19
20			namespace Doctrine\DBAL\Schema;
21
22			use Doctrine\DBAL\Types;
23
24			/**
25			* Compares two Schemas and return an instance of SchemaDiff.
26			*
27			* @link www.doctrine-project.org
28			* @since 2.0
29			* @author Benjamin Eberlei <[email protected]>
30			*/
31			class Comparator
32			{
33			/**
34			* @param \Doctrine\DBAL\Schema\Schema $fromSchema
35			* @param \Doctrine\DBAL\Schema\Schema $toSchema
36			*
37			* @return \Doctrine\DBAL\Schema\SchemaDiff
38			*/
39	17		public static function compareSchemas(Schema $fromSchema, Schema $toSchema)
40			{
41	17		$c = new self();
42
43	17		return $c->compare($fromSchema, $toSchema);
44			}
45
46			/**
47			* Returns a SchemaDiff object containing the differences between the schemas $fromSchema and $toSchema.
48			*
49			* The returned differences are returned in such a way that they contain the
50			* operations to change the schema stored in $fromSchema to the schema that is
51			* stored in $toSchema.
52			*
53			* @param \Doctrine\DBAL\Schema\Schema $fromSchema
54			* @param \Doctrine\DBAL\Schema\Schema $toSchema
55			*
56			* @return \Doctrine\DBAL\Schema\SchemaDiff
57			*/
58	27		public function compare(Schema $fromSchema, Schema $toSchema)
59			{
60	27		$diff = new SchemaDiff();
61	27		$diff->fromSchema = $fromSchema;
62
63	27		$foreignKeysToTable = [];
64
65	27		foreach ($toSchema->getNamespaces() as $namespace) {
66	2		if ( ! $fromSchema->hasNamespace($namespace)) {
67	2		$diff->newNamespaces[$namespace] = $namespace;
68			}
69			}
70
71	27		foreach ($fromSchema->getNamespaces() as $namespace) {
72	2		if ( ! $toSchema->hasNamespace($namespace)) {
73	2		$diff->removedNamespaces[$namespace] = $namespace;
74			}
75			}
76
77	27		foreach ($toSchema->getTables() as $table) {
78	21		$tableName = $table->getShortestName($toSchema->getName());
79	21		if ( ! $fromSchema->hasTable($tableName)) {
80	5		$diff->newTables[$tableName] = $toSchema->getTable($tableName);
81			} else {
82	19		$tableDifferences = $this->diffTable($fromSchema->getTable($tableName), $toSchema->getTable($tableName));
83	19		if ($tableDifferences !== false) {
84	21		$diff->changedTables[$tableName] = $tableDifferences;
85			}
86			}
87			}
88
89			/* Check if there are tables removed */
90	27		foreach ($fromSchema->getTables() as $table) {
91	20		$tableName = $table->getShortestName($fromSchema->getName());
92
93	20		$table = $fromSchema->getTable($tableName);
94	20		if ( ! $toSchema->hasTable($tableName)) {
95	5		$diff->removedTables[$tableName] = $table;
96			}
97
98			// also remember all foreign keys that point to a specific table
99	20		foreach ($table->getForeignKeys() as $foreignKey) {
100	2		$foreignTable = strtolower($foreignKey->getForeignTableName());
101	2		if (!isset($foreignKeysToTable[$foreignTable])) {
102	2		$foreignKeysToTable[$foreignTable] = [];
103			}
104	20		$foreignKeysToTable[$foreignTable][] = $foreignKey;
105			}
106			}
107
108	27		foreach ($diff->removedTables as $tableName => $table) {
109	5		if (isset($foreignKeysToTable[$tableName])) {
110	2		$diff->orphanedForeignKeys = array_merge($diff->orphanedForeignKeys, $foreignKeysToTable[$tableName]);
111
112			// deleting duplicated foreign keys present on both on the orphanedForeignKey
113			// and the removedForeignKeys from changedTables
114	2		foreach ($foreignKeysToTable[$tableName] as $foreignKey) {
115			// strtolower the table name to make if compatible with getShortestName
116	2		$localTableName = strtolower($foreignKey->getLocalTableName());
117	2		if (isset($diff->changedTables[$localTableName])) {
118	2		foreach ($diff->changedTables[$localTableName]->removedForeignKeys as $key => $removedForeignKey) {
119			// We check if the key is from the removed table if not we skip.
120	2		if ($tableName !== strtolower($removedForeignKey->getForeignTableName())) {
121	1		continue;
122			}
123	5		unset($diff->changedTables[$localTableName]->removedForeignKeys[$key]);
124			}
125			}
126			}
127			}
128			}
129
130	27		foreach ($toSchema->getSequences() as $sequence) {
131	4		$sequenceName = $sequence->getShortestName($toSchema->getName());
132	4		if ( ! $fromSchema->hasSequence($sequenceName)) {
133	3		if ( ! $this->isAutoIncrementSequenceInSchema($fromSchema, $sequence)) {
134	3		$diff->newSequences[] = $sequence;
135			}
136			} else {
137	2		if ($this->diffSequence($sequence, $fromSchema->getSequence($sequenceName))) {
138	4		$diff->changedSequences[] = $toSchema->getSequence($sequenceName);
139			}
140			}
141			}
142
143	27		foreach ($fromSchema->getSequences() as $sequence) {
144	4		if ($this->isAutoIncrementSequenceInSchema($toSchema, $sequence)) {
145	1		continue;
146			}
147
148	3		$sequenceName = $sequence->getShortestName($fromSchema->getName());
149
150	3		if ( ! $toSchema->hasSequence($sequenceName)) {
151	3		$diff->removedSequences[] = $sequence;
152			}
153			}
154
155	27		return $diff;
156			}
157
158			/**
159			* @param \Doctrine\DBAL\Schema\Schema $schema
160			* @param \Doctrine\DBAL\Schema\Sequence $sequence
161			*
162			* @return boolean
163			*/
164	6		private function isAutoIncrementSequenceInSchema($schema, $sequence)
165			{
166	6		foreach ($schema->getTables() as $table) {
167	2		if ($sequence->isAutoIncrementsFor($table)) {
168	2		return true;
169			}
170			}
171
172	4		return false;
173			}
174
175			/**
176			* @param \Doctrine\DBAL\Schema\Sequence $sequence1
177			* @param \Doctrine\DBAL\Schema\Sequence $sequence2
178			*
179			* @return boolean
180			*/
181	3		public function diffSequence(Sequence $sequence1, Sequence $sequence2)
182			{
183	3		if ($sequence1->getAllocationSize() != $sequence2->getAllocationSize()) {
184	2		return true;
185			}
186
187	2		if ($sequence1->getInitialValue() != $sequence2->getInitialValue()) {
188	1		return true;
189			}
190
191	1		return false;
192			}
193
194			/**
195			* Returns the difference between the tables $table1 and $table2.
196			*
197			* If there are no differences this method returns the boolean false.
198			*
199			* @param \Doctrine\DBAL\Schema\Table $table1
200			* @param \Doctrine\DBAL\Schema\Table $table2
201			*
202			* @return boolean\|\Doctrine\DBAL\Schema\TableDiff
203			*/
204	112		public function diffTable(Table $table1, Table $table2)
205			{
206	112		$changes = 0;
207	112		$tableDifferences = new TableDiff($table1->getName());
208	112		$tableDifferences->fromTable = $table1;
209
210	112		$table1Columns = $table1->getColumns();
211	112		$table2Columns = $table2->getColumns();
212
213			/* See if all the fields in table 1 exist in table 2 */
214	112		foreach ($table2Columns as $columnName => $column) {
215	107		if ( !$table1->hasColumn($columnName)) {
216	26		$tableDifferences->addedColumns[$columnName] = $column;
217	107		$changes++;
218			}
219			}
220			/* See if there are any removed fields in table 2 */
221	112		foreach ($table1Columns as $columnName => $column) {
222			// See if column is removed in table 2.
223	107		if ( ! $table2->hasColumn($columnName)) {
224	27		$tableDifferences->removedColumns[$columnName] = $column;
225	27		$changes++;
226	27		continue;
227			}
228
229			// See if column has changed properties in table 2.
230	88		$changedProperties = $this->diffColumn($column, $table2->getColumn($columnName));
231
232	88		if ( ! empty($changedProperties)) {
233	41		$columnDiff = new ColumnDiff($column->getName(), $table2->getColumn($columnName), $changedProperties);
234	41		$columnDiff->fromColumn = $column;
235	41		$tableDifferences->changedColumns[$column->getName()] = $columnDiff;
236	88		$changes++;
237			}
238			}
239
240	112		$this->detectColumnRenamings($tableDifferences);
241
242	112		$table1Indexes = $table1->getIndexes();
243	112		$table2Indexes = $table2->getIndexes();
244
245			/* See if all the indexes in table 1 exist in table 2 */
246	112		foreach ($table2Indexes as $indexName => $index) {
247	42		if (($index->isPrimary() && $table1->hasPrimaryKey()) \|\| $table1->hasIndex($indexName)) {
248	29		continue;
249			}
250
251	13		$tableDifferences->addedIndexes[$indexName] = $index;
252	13		$changes++;
253			}
254			/* See if there are any removed indexes in table 2 */
255	112		foreach ($table1Indexes as $indexName => $index) {
256			// See if index is removed in table 2.
257	40		if (($index->isPrimary() && ! $table2->hasPrimaryKey()) \|\|
258	40		! $index->isPrimary() && ! $table2->hasIndex($indexName)
259			) {
260	15		$tableDifferences->removedIndexes[$indexName] = $index;
261	15		$changes++;
262	15		continue;
263			}
264
265			// See if index has changed in table 2.
266	29		$table2Index = $index->isPrimary() ? $table2->getPrimaryKey() : $table2->getIndex($indexName);
267
268	29		if ($this->diffIndex($index, $table2Index)) {
269	11		$tableDifferences->changedIndexes[$indexName] = $table2Index;
270	29		$changes++;
271			}
272			}
273
274	112		$this->detectIndexRenamings($tableDifferences);
275
276	112		$fromFkeys = $table1->getForeignKeys();
277	112		$toFkeys = $table2->getForeignKeys();
278
279	112		foreach ($fromFkeys as $key1 => $constraint1) {
280	10		foreach ($toFkeys as $key2 => $constraint2) {
281	4		if ($this->diffForeignKey($constraint1, $constraint2) === false) {
282	1		unset($fromFkeys[$key1]);
283	1		unset($toFkeys[$key2]);
284			} else {
285	3		if (strtolower($constraint1->getName()) == strtolower($constraint2->getName())) {
286	2		$tableDifferences->changedForeignKeys[] = $constraint2;
287	2		$changes++;
288	2		unset($fromFkeys[$key1]);
289	10		unset($toFkeys[$key2]);
290			}
291			}
292			}
293			}
294
295	112		foreach ($fromFkeys as $constraint1) {
296	7		$tableDifferences->removedForeignKeys[] = $constraint1;
297	7		$changes++;
298			}
299
300	112		foreach ($toFkeys as $constraint2) {
301	2		$tableDifferences->addedForeignKeys[] = $constraint2;
302	2		$changes++;
303			}
304
305	112		return $changes ? $tableDifferences : false;
306			}
307
308			/**
309			* Try to find columns that only changed their name, rename operations maybe cheaper than add/drop
310			* however ambiguities between different possibilities should not lead to renaming at all.
311			*
312			* @param \Doctrine\DBAL\Schema\TableDiff $tableDifferences
313			*
314			* @return void
315			*/
316	112	View Code Duplication	private function detectColumnRenamings(TableDiff $tableDifferences)
			0 ignored issues – show Duplication introduced 2017-07-31 14:44 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
317			{
318	112		$renameCandidates = [];
319	112		foreach ($tableDifferences->addedColumns as $addedColumnName => $addedColumn) {
320	26		foreach ($tableDifferences->removedColumns as $removedColumn) {
321	21		if (count($this->diffColumn($addedColumn, $removedColumn)) == 0) {
322	26		$renameCandidates[$addedColumn->getName()][] = [$removedColumn, $addedColumn, $addedColumnName];
323			}
324			}
325			}
326
327	112		foreach ($renameCandidates as $candidateColumns) {
328	21		if (count($candidateColumns) == 1) {
329	20		list($removedColumn, $addedColumn) = $candidateColumns[0];
330	20		$removedColumnName = strtolower($removedColumn->getName());
331	20		$addedColumnName = strtolower($addedColumn->getName());
332
333	20		if ( ! isset($tableDifferences->renamedColumns[$removedColumnName])) {
334	20		$tableDifferences->renamedColumns[$removedColumnName] = $addedColumn;
335	20		unset($tableDifferences->addedColumns[$addedColumnName]);
336	21		unset($tableDifferences->removedColumns[$removedColumnName]);
337			}
338			}
339			}
340	112		}
341
342			/**
343			* Try to find indexes that only changed their name, rename operations maybe cheaper than add/drop
344			* however ambiguities between different possibilities should not lead to renaming at all.
345			*
346			* @param \Doctrine\DBAL\Schema\TableDiff $tableDifferences
347			*
348			* @return void
349			*/
350	112	View Code Duplication	private function detectIndexRenamings(TableDiff $tableDifferences)
			0 ignored issues – show Duplication introduced 2017-07-31 14:44 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
351			{
352	112		$renameCandidates = [];
353
354			// Gather possible rename candidates by comparing each added and removed index based on semantics.
355	112		foreach ($tableDifferences->addedIndexes as $addedIndexName => $addedIndex) {
356	13		foreach ($tableDifferences->removedIndexes as $removedIndex) {
357	6		if (! $this->diffIndex($addedIndex, $removedIndex)) {
358	13		$renameCandidates[$addedIndex->getName()][] = [$removedIndex, $addedIndex, $addedIndexName];
359			}
360			}
361			}
362
363	112		foreach ($renameCandidates as $candidateIndexes) {
364			// If the current rename candidate contains exactly one semantically equal index,
365			// we can safely rename it.
366			// Otherwise it is unclear if a rename action is really intended,
367			// therefore we let those ambiguous indexes be added/dropped.
368	3		if (count($candidateIndexes) === 1) {
369	2		list($removedIndex, $addedIndex) = $candidateIndexes[0];
370
371	2		$removedIndexName = strtolower($removedIndex->getName());
372	2		$addedIndexName = strtolower($addedIndex->getName());
373
374	2		if (! isset($tableDifferences->renamedIndexes[$removedIndexName])) {
375	2		$tableDifferences->renamedIndexes[$removedIndexName] = $addedIndex;
376	2		unset($tableDifferences->addedIndexes[$addedIndexName]);
377	3		unset($tableDifferences->removedIndexes[$removedIndexName]);
378			}
379			}
380			}
381	112		}
382
383			/**
384			* @param \Doctrine\DBAL\Schema\ForeignKeyConstraint $key1
385			* @param \Doctrine\DBAL\Schema\ForeignKeyConstraint $key2
386			*
387			* @return boolean
388			*/
389	7		public function diffForeignKey(ForeignKeyConstraint $key1, ForeignKeyConstraint $key2)
390			{
391	7		if (array_map('strtolower', $key1->getUnquotedLocalColumns()) != array_map('strtolower', $key2->getUnquotedLocalColumns())) {
392	1		return true;
393			}
394
395	6		if (array_map('strtolower', $key1->getUnquotedForeignColumns()) != array_map('strtolower', $key2->getUnquotedForeignColumns())) {
396			return true;
397			}
398
399	6		if ($key1->getUnqualifiedForeignTableName() !== $key2->getUnqualifiedForeignTableName()) {
400	1		return true;
401			}
402
403	5		if ($key1->onUpdate() != $key2->onUpdate()) {
404	1		return true;
405			}
406
407	4		if ($key1->onDelete() != $key2->onDelete()) {
408			return true;
409			}
410
411	4		return false;
412			}
413
414			/**
415			* Returns the difference between the fields $field1 and $field2.
416			*
417			* If there are differences this method returns $field2, otherwise the
418			* boolean false.
419			*
420			* @param \Doctrine\DBAL\Schema\Column $column1
421			* @param \Doctrine\DBAL\Schema\Column $column2
422			*
423			* @return array
424			*/
425	129		public function diffColumn(Column $column1, Column $column2)
426			{
427	129		$properties1 = $column1->toArray();
428	129		$properties2 = $column2->toArray();
429
430	129		$changedProperties = [];
431
432	129		foreach (['type', 'notnull', 'unsigned', 'autoincrement'] as $property) {
433	129		if ($properties1[$property] != $properties2[$property]) {
434	129		$changedProperties[] = $property;
435			}
436			}
437
438			// This is a very nasty hack to make comparator work with the legacy json_array type, which should be killed in v3
439	129		if (($properties1['type']->getName() === Types\Type::JSON && $properties2['type']->getName() === Types\Type::JSON_ARRAY)
440	129		\|\| ($properties1['type']->getName() === Types\Type::JSON_ARRAY && $properties2['type']->getName() === Types\Type::JSON)) {
441	1		array_shift($changedProperties);
442
443	1		$changedProperties[] = 'comment';
444			}
445
446	129		if ($properties1['default'] != $properties2['default'] \|\|
447			// Null values need to be checked additionally as they tell whether to create or drop a default value.
448			// null != 0, null != false, null != '' etc. This affects platform's table alteration SQL generation.
449	126		(null === $properties1['default'] && null !== $properties2['default']) \|\|
450	129		(null === $properties2['default'] && null !== $properties1['default'])
451			) {
452	4		$changedProperties[] = 'default';
453			}
454
455	129		if (($properties1['type'] instanceof Types\StringType && ! $properties1['type'] instanceof Types\GuidType) \|\|
456	129		$properties1['type'] instanceof Types\BinaryType
457			) {
458			// check if value of length is set at all, default value assumed otherwise.
459	25		$length1 = $properties1['length'] ?: 255;
460	25		$length2 = $properties2['length'] ?: 255;
461	25		if ($length1 != $length2) {
462	12		$changedProperties[] = 'length';
463			}
464
465	25		if ($properties1['fixed'] != $properties2['fixed']) {
466	25		$changedProperties[] = 'fixed';
467			}
468	114		} elseif ($properties1['type'] instanceof Types\DecimalType) {
469	2		if (($properties1['precision'] ?: 10) != ($properties2['precision'] ?: 10)) {
470			$changedProperties[] = 'precision';
471			}
472	2		if ($properties1['scale'] != $properties2['scale']) {
473			$changedProperties[] = 'scale';
474			}
475			}
476
477			// A null value and an empty string are actually equal for a comment so they should not trigger a change.
478	129		if ($properties1['comment'] !== $properties2['comment'] &&
479	129		! (null === $properties1['comment'] && '' === $properties2['comment']) &&
480	129		! (null === $properties2['comment'] && '' === $properties1['comment'])
481			) {
482	44		$changedProperties[] = 'comment';
483			}
484
485	129		$customOptions1 = $column1->getCustomSchemaOptions();
486	129		$customOptions2 = $column2->getCustomSchemaOptions();
487
488	129		foreach (array_merge(array_keys($customOptions1), array_keys($customOptions2)) as $key) {
489	2		if ( ! array_key_exists($key, $properties1) \|\| ! array_key_exists($key, $properties2)) {
490	1		$changedProperties[] = $key;
491	2		} elseif ($properties1[$key] !== $properties2[$key]) {
492	2		$changedProperties[] = $key;
493			}
494			}
495
496	129		$platformOptions1 = $column1->getPlatformOptions();
497	129		$platformOptions2 = $column2->getPlatformOptions();
498
499	129		foreach (array_keys(array_intersect_key($platformOptions1, $platformOptions2)) as $key) {
500	2		if ($properties1[$key] !== $properties2[$key]) {
501	2		$changedProperties[] = $key;
502			}
503			}
504
505	129		return array_unique($changedProperties);
506			}
507
508			/**
509			* Finds the difference between the indexes $index1 and $index2.
510			*
511			* Compares $index1 with $index2 and returns $index2 if there are any
512			* differences or false in case there are no differences.
513			*
514			* @param \Doctrine\DBAL\Schema\Index $index1
515			* @param \Doctrine\DBAL\Schema\Index $index2
516			*
517			* @return boolean
518			*/
519	35		public function diffIndex(Index $index1, Index $index2)
520			{
521	35		if ($index1->isFullfilledBy($index2) && $index2->isFullfilledBy($index1)) {
522	21		return false;
523			}
524
525	14		return true;
526			}
527			}
528

doctrine / dbal

Pull Request — master (#2855)

Comparator::diffColumn() F

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like