Comparator::compare() - Code Metrics - Inspection of "fix array declarations" - doctrine/dbal - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#2776)

by Alessandro

created 2017-07-10 20:38 UTC

Comparator::compare() F

↳ Parent: Comparator

Complexity

Conditions	25
Paths	> 20000

Size

Total Lines	99
Code Lines	53

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	51
CRAP Score	25

Importance

Changes

Metric	Value
dl	0
loc	99
ccs	51
cts	51
cp	1
rs	2
c	0
b	0
f	0
cc	25
eloc	53
nc	35280
nop	2
crap	25

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
     */
    static public 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 = array();

        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] = array();
                }
                $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 = array();
        foreach ($tableDifferences->addedColumns as $addedColumnName => $addedColumn) {
            foreach ($tableDifferences->removedColumns as $removedColumn) {
                if (count($this->diffColumn($addedColumn, $removedColumn)) == 0) {
                    $renameCandidates[$addedColumn->getName()][] = array($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 = array();

        // 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()][] = array($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 = array();

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

        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		static public function compareSchemas(Schema $fromSchema, Schema $toSchema)
			0 ignored issues – show Coding Style introduced 2017-06-29 19:35 UTC by Report Bug Copy Issue Report As per PSR2, the `static` declaration should come after the visibility declaration. Loading history...
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 = array();
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] = array();
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	110		public function diffTable(Table $table1, Table $table2)
205			{
206	110		$changes = 0;
207	110		$tableDifferences = new TableDiff($table1->getName());
208	110		$tableDifferences->fromTable = $table1;
209
210	110		$table1Columns = $table1->getColumns();
211	110		$table2Columns = $table2->getColumns();
212
213			/* See if all the fields in table 1 exist in table 2 */
214	110		foreach ($table2Columns as $columnName => $column) {
215	105		if ( !$table1->hasColumn($columnName)) {
216	26		$tableDifferences->addedColumns[$columnName] = $column;
217	105		$changes++;
218			}
219			}
220			/* See if there are any removed fields in table 2 */
221	110		foreach ($table1Columns as $columnName => $column) {
222			// See if column is removed in table 2.
223	105		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	86		$changedProperties = $this->diffColumn($column, $table2->getColumn($columnName));
231
232	86		if ( ! empty($changedProperties)) {
233	40		$columnDiff = new ColumnDiff($column->getName(), $table2->getColumn($columnName), $changedProperties);
234	40		$columnDiff->fromColumn = $column;
235	40		$tableDifferences->changedColumns[$column->getName()] = $columnDiff;
236	86		$changes++;
237			}
238			}
239
240	110		$this->detectColumnRenamings($tableDifferences);
241
242	110		$table1Indexes = $table1->getIndexes();
243	110		$table2Indexes = $table2->getIndexes();
244
245			/* See if all the indexes in table 1 exist in table 2 */
246	110		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	110		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	110		$this->detectIndexRenamings($tableDifferences);
275
276	110		$fromFkeys = $table1->getForeignKeys();
277	110		$toFkeys = $table2->getForeignKeys();
278
279	110		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	110		foreach ($fromFkeys as $constraint1) {
296	7		$tableDifferences->removedForeignKeys[] = $constraint1;
297	7		$changes++;
298			}
299
300	110		foreach ($toFkeys as $constraint2) {
301	2		$tableDifferences->addedForeignKeys[] = $constraint2;
302	2		$changes++;
303			}
304
305	110		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	110	View Code Duplication	private function detectColumnRenamings(TableDiff $tableDifferences)
			0 ignored issues – show Duplication introduced 2017-06-29 19:35 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	110		$renameCandidates = array();
319	110		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()][] = array($removedColumn, $addedColumn, $addedColumnName);
323			}
324			}
325			}
326
327	110		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	110		}
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	110	View Code Duplication	private function detectIndexRenamings(TableDiff $tableDifferences)
			0 ignored issues – show Duplication introduced 2017-06-29 19:35 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	110		$renameCandidates = array();
353
354			// Gather possible rename candidates by comparing each added and removed index based on semantics.
355	110		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()][] = array($removedIndex, $addedIndex, $addedIndexName);
359			}
360			}
361			}
362
363	110		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	110		}
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	127		public function diffColumn(Column $column1, Column $column2)
426			{
427	127		$properties1 = $column1->toArray();
428	127		$properties2 = $column2->toArray();
429
430	127		$changedProperties = array();
431
432	127		foreach (array('type', 'notnull', 'unsigned', 'autoincrement') as $property) {
433	127		if ($properties1[$property] != $properties2[$property]) {
434	127		$changedProperties[] = $property;
435			}
436			}
437
438	127		if ($properties1['default'] != $properties2['default'] \|\|
439			// Null values need to be checked additionally as they tell whether to create or drop a default value.
440			// null != 0, null != false, null != '' etc. This affects platform's table alteration SQL generation.
441	124		(null === $properties1['default'] && null !== $properties2['default']) \|\|
442	127		(null === $properties2['default'] && null !== $properties1['default'])
443			) {
444	4		$changedProperties[] = 'default';
445			}
446
447	127		if (($properties1['type'] instanceof Types\StringType && ! $properties1['type'] instanceof Types\GuidType) \|\|
448	127		$properties1['type'] instanceof Types\BinaryType
449			) {
450			// check if value of length is set at all, default value assumed otherwise.
451	25		$length1 = $properties1['length'] ?: 255;
452	25		$length2 = $properties2['length'] ?: 255;
453	25		if ($length1 != $length2) {
454	12		$changedProperties[] = 'length';
455			}
456
457	25		if ($properties1['fixed'] != $properties2['fixed']) {
458	25		$changedProperties[] = 'fixed';
459			}
460	112		} elseif ($properties1['type'] instanceof Types\DecimalType) {
461	2		if (($properties1['precision'] ?: 10) != ($properties2['precision'] ?: 10)) {
462			$changedProperties[] = 'precision';
463			}
464	2		if ($properties1['scale'] != $properties2['scale']) {
465			$changedProperties[] = 'scale';
466			}
467			}
468
469			// A null value and an empty string are actually equal for a comment so they should not trigger a change.
470	127		if ($properties1['comment'] !== $properties2['comment'] &&
471	127		! (null === $properties1['comment'] && '' === $properties2['comment']) &&
472	127		! (null === $properties2['comment'] && '' === $properties1['comment'])
473			) {
474	44		$changedProperties[] = 'comment';
475			}
476
477	127		$customOptions1 = $column1->getCustomSchemaOptions();
478	127		$customOptions2 = $column2->getCustomSchemaOptions();
479
480	127		foreach (array_merge(array_keys($customOptions1), array_keys($customOptions2)) as $key) {
481	2		if ( ! array_key_exists($key, $properties1) \|\| ! array_key_exists($key, $properties2)) {
482	1		$changedProperties[] = $key;
483	2		} elseif ($properties1[$key] !== $properties2[$key]) {
484	2		$changedProperties[] = $key;
485			}
486			}
487
488	127		$platformOptions1 = $column1->getPlatformOptions();
489	127		$platformOptions2 = $column2->getPlatformOptions();
490
491	127		foreach (array_keys(array_intersect_key($platformOptions1, $platformOptions2)) as $key) {
492	2		if ($properties1[$key] !== $properties2[$key]) {
493	2		$changedProperties[] = $key;
494			}
495			}
496
497	127		return array_unique($changedProperties);
498			}
499
500			/**
501			* Finds the difference between the indexes $index1 and $index2.
502			*
503			* Compares $index1 with $index2 and returns $index2 if there are any
504			* differences or false in case there are no differences.
505			*
506			* @param \Doctrine\DBAL\Schema\Index $index1
507			* @param \Doctrine\DBAL\Schema\Index $index2
508			*
509			* @return boolean
510			*/
511	35		public function diffIndex(Index $index1, Index $index2)
512			{
513	35		if ($index1->isFullfilledBy($index2) && $index2->isFullfilledBy($index1)) {
514	21		return false;
515			}
516
517	14		return true;
518			}
519			}
520

doctrine / dbal

Pull Request — master (#2776)

Comparator::compare() F

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like