Merge remote-tracking branch 'origin/2.3' into 2.3

lib/Doctrine/DBAL/Platforms/PostgreSqlPlatform.php

@@ -407,6 +407,11 @@ class PostgreSqlPlatform extends AbstractPlatform
             if ($columnDiff->hasChanged('comment') && $comment = $this->getColumnComment($column)) {
                 $commentsSQL[] = $this->getCommentOnColumnSQL($diff->name, $column->getName(), $comment);
             }
+
+            if ($columnDiff->hasChanged('length')) {
+                $query = 'ALTER ' . $column->getName() . ' TYPE ' . $column->getType()->getSqlDeclaration($column->toArray(), $this);
+                $sql[] = 'ALTER TABLE ' . $diff->name . ' ' . $query;
+            }
         }
 
         foreach ($diff->renamedColumns as $oldColumnName => $column) {

lib/Doctrine/DBAL/Platforms/SQLServerPlatform.php

@@ -631,13 +631,7 @@ class SQLServerPlatform extends AbstractPlatform
      */
     protected function _getCommonIntegerTypeDeclarationSQL(array $columnDef)
     {
-        $autoinc = '';
-        if (!empty($columnDef['autoincrement'])) {
-            $autoinc = ' IDENTITY';
-        }
-        $unsigned = (isset($columnDef['unsigned']) && $columnDef['unsigned']) ? ' UNSIGNED' : '';
-
-        return $unsigned . $autoinc;
+        return (!empty($columnDef['autoincrement'])) ? ' IDENTITY' : '';
     }
 
     /**

lib/Doctrine/DBAL/Schema/Comparator.php

@@ -46,7 +46,7 @@ class Comparator
     /**
      * Returns a SchemaDiff object containing the differences between the schemas $fromSchema and $toSchema.
      *
-     * The returned diferences are returned in such a way that they contain the
+     * 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.
      *
@@ -95,6 +95,18 @@ class Comparator
         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) {
+                            unset($diff->changedTables[$localTableName]->removedForeignKeys[$key]);
+                        }
+                    }
+                }
             }
         }
 
@@ -262,7 +274,7 @@ class Comparator
 
     /**
      * Try to find columns that only changed their name, rename operations maybe cheaper than add/drop
-     * however ambiguouties between different possibilites should not lead to renaming at all.
+     * however ambiguities between different possibilities should not lead to renaming at all.
      *
      * @param TableDiff $tableDifferences
      */

tests/Doctrine/Tests/DBAL/Functional/MasterSlaveConnectionTest.php

@@ -27,9 +27,12 @@ class MasterSlaveConnectionTest extends DbalFunctionalTestCase
             $sm = $this->_conn->getSchemaManager();
             $sm->createTable($table);
 
-            $this->_conn->insert('master_slave_table', array('test_int' => 1));
+
         } catch(\Exception $e) {
         }
+
+        $this->_conn->executeUpdate('DELETE FROM master_slave_table');
+        $this->_conn->insert('master_slave_table', array('test_int' => 1));
     }
 
     public function createMasterSlaveConnection($keepSlave = false)

tests/Doctrine/Tests/DBAL/Schema/ComparatorTest.php

@@ -781,6 +781,36 @@ class ComparatorTest extends \PHPUnit_Framework_TestCase
         $this->assertCount(0, $diff->removedSequences);
     }
 
+
+    /**
+     * You can get multiple drops for a FK when a table referenced by a foreign
+     * key is deleted, as this FK is referenced twice, once on the orphanedForeignKeys
+     * array because of the dropped table, and once on changedTables array. We
+     * now check that the key is present once.
+     */
+    public function testAvoidMultipleDropForeignKey()
+    {
+        $oldSchema = new Schema();
+
+        $tableForeign = $oldSchema->createTable('foreign');
+        $tableForeign->addColumn('id', 'integer');
+
+        $table = $oldSchema->createTable('foo');
+        $table->addColumn('fk', 'integer');
+        $table->addForeignKeyConstraint($tableForeign, array('fk'), array('id'));
+
+
+        $newSchema = new Schema();
+        $table = $newSchema->createTable('foo');
+
+        $c = new Comparator();
+        $diff = $c->compare($oldSchema, $newSchema);
+
+        $this->assertCount(0, $diff->changedTables['foo']->removedForeignKeys);
+        $this->assertCount(1, $diff->orphanedForeignKeys);
+    }
+
+
     /**
      * @param SchemaDiff $diff
      * @param int $newTableCount