/**
* Compare the tables of the fromDatabase and the toDatabase,
* and modifies the inner databaseDiff if necessary.
* Returns the number of differences.
*
* @param boolean $caseInsensitive Whether the comparison is case insensitive.
* False by default.
*
* @return integer The number of table differences
*/
public function compareTables($caseInsensitive = false)
{
$fromDatabaseTables = $this->fromDatabase->getTables();
$toDatabaseTables = $this->toDatabase->getTables();
$databaseDifferences = 0;
// check for new tables in $toDatabase
foreach ($toDatabaseTables as $table) {
if (!$this->fromDatabase->hasTable($table->getName(), $caseInsensitive) && !$table->isSkipSql()) {
$this->databaseDiff->addAddedTable($table->getName(), $table);
$databaseDifferences++;
}
}
// check for removed tables in $toDatabase
foreach ($fromDatabaseTables as $table) {
if (!$this->toDatabase->hasTable($table->getName(), $caseInsensitive) && !$table->isSkipSql()) {
$this->databaseDiff->addRemovedTable($table->getName(), $table);
$databaseDifferences++;
}
}
// check for table differences
foreach ($fromDatabaseTables as $fromTable) {
if ($this->toDatabase->hasTable($fromTable->getName(), $caseInsensitive)) {
$toTable = $this->toDatabase->getTable($fromTable->getName(), $caseInsensitive);
$databaseDiff = TableComparator::computeDiff($fromTable, $toTable, $caseInsensitive);
if ($databaseDiff) {
$this->databaseDiff->addModifiedTable($fromTable->getName(), $databaseDiff);
$databaseDifferences++;
}
}
}
// check for table renamings
foreach ($this->databaseDiff->getAddedTables() as $addedTableName => $addedTable) {
foreach ($this->databaseDiff->getRemovedTables() as $removedTableName => $removedTable) {
if (!TableComparator::computeDiff($addedTable, $removedTable, $caseInsensitive)) {
// no difference except the name, that's probably a renaming
$this->databaseDiff->addRenamedTable($removedTableName, $addedTableName);
$this->databaseDiff->removeAddedTable($addedTableName);
$this->databaseDiff->removeRemovedTable($removedTableName);
$databaseDifferences--;
}
}
}
return $databaseDifferences;
}
public function testCompareSeveralRenamedSameColumns()
{
$t1 = new Table();
$c1 = new Column('col1');
$c1->getDomain()->copy($this->platform->getDomainForType('VARCHAR'));
$c1->getDomain()->replaceSize(255);
$t1->addColumn($c1);
$c2 = new Column('col2');
$c2->getDomain()->copy($this->platform->getDomainForType('VARCHAR'));
$c2->getDomain()->replaceSize(255);
$t1->addColumn($c2);
$c3 = new Column('col3');
$c3->getDomain()->copy($this->platform->getDomainForType('VARCHAR'));
$c3->getDomain()->replaceSize(255);
$t1->addColumn($c3);
$t2 = new Table();
$c4 = new Column('col4');
$c4->getDomain()->copy($this->platform->getDomainForType('VARCHAR'));
$c4->getDomain()->replaceSize(255);
$t2->addColumn($c4);
$c5 = new Column('col5');
$c5->getDomain()->copy($this->platform->getDomainForType('VARCHAR'));
$c5->getDomain()->replaceSize(255);
$t2->addColumn($c5);
$c6 = new Column('col3');
$c6->getDomain()->copy($this->platform->getDomainForType('VARCHAR'));
$c6->getDomain()->replaceSize(255);
$t2->addColumn($c6);
// col1 and col2 were renamed
$tc = new TableComparator();
$tc->setFromTable($t1);
$tc->setToTable($t2);
$nbDiffs = $tc->compareColumns();
$tableDiff = $tc->getTableDiff();
$this->assertEquals(2, $nbDiffs);
$this->assertEquals([[$c1, $c4], [$c2, $c5]], $tableDiff->getRenamedColumns());
$this->assertEquals([], $tableDiff->getAddedColumns());
$this->assertEquals([], $tableDiff->getRemovedColumns());
$this->assertEquals([], $tableDiff->getModifiedColumns());
}
public function providerForTestGetModifyTableForeignKeysSkipSql2DDL()
{
$schema1 = <<<EOF
<database name="test" identifierQuoting="true">
<table name="foo1">
<column name="id" primaryKey="true" type="INTEGER" autoIncrement="true" />
<column name="bar" type="INTEGER" />
<foreign-key name="foo1_fk_1" foreignTable="foo2" skipSql="true">
<reference local="bar" foreign="bar" />
</foreign-key>
</table>
<table name="foo2">
<column name="id" primaryKey="true" type="INTEGER" autoIncrement="true" />
<column name="bar" type="INTEGER" />
</table>
</database>
EOF;
$schema2 = <<<EOF
<database name="test" identifierQuoting="true">
<table name="foo1">
<column name="id" primaryKey="true" type="INTEGER" autoIncrement="true" />
<column name="bar" type="INTEGER" />
</table>
<table name="foo2">
<column name="id" primaryKey="true" type="INTEGER" autoIncrement="true" />
<column name="bar" type="INTEGER" />
</table>
</database>
EOF;
$t1 = $this->getDatabaseFromSchema($schema1)->getTable('foo1');
$t2 = $this->getDatabaseFromSchema($schema2)->getTable('foo1');
$tc = new TableComparator();
$tc->setFromTable($t1);
$tc->setToTable($t2);
$tc->compareForeignKeys();
return [[$tc->getTableDiff()]];
}
public function testCompareSeveralTableDifferences()
{
$d1 = new Database();
$t1 = new Table('Foo_Table');
$c1 = new Column('Foo');
$c1->getDomain()->copy($this->platform->getDomainForType('DOUBLE'));
$c1->getDomain()->replaceScale(2);
$c1->getDomain()->replaceSize(3);
$c1->setNotNull(true);
$c1->getDomain()->setDefaultValue(new ColumnDefaultValue(123, ColumnDefaultValue::TYPE_VALUE));
$t1->addColumn($c1);
$d1->addTable($t1);
$t2 = new Table('Bar');
$c2 = new Column('Bar_Column');
$c2->getDomain()->copy($this->platform->getDomainForType('DOUBLE'));
$t2->addColumn($c2);
$d1->addTable($t2);
$t11 = new Table('Baz');
$d1->addTable($t11);
$d2 = new Database();
$t3 = new Table('Foo_Table');
$c3 = new Column('Foo1');
$c3->getDomain()->copy($this->platform->getDomainForType('DOUBLE'));
$c3->getDomain()->replaceScale(2);
$c3->getDomain()->replaceSize(3);
$c3->setNotNull(true);
$c3->getDomain()->setDefaultValue(new ColumnDefaultValue(123, ColumnDefaultValue::TYPE_VALUE));
$t3->addColumn($c3);
$d2->addTable($t3);
$t4 = new Table('Bar2');
$c4 = new Column('Bar_Column');
$c4->getDomain()->copy($this->platform->getDomainForType('DOUBLE'));
$t4->addColumn($c4);
$d2->addTable($t4);
$t5 = new Table('Biz');
$c5 = new Column('Biz_Column');
$c5->getDomain()->copy($this->platform->getDomainForType('INTEGER'));
$t5->addColumn($c5);
$d2->addTable($t5);
// Foo_Table was modified, Bar was renamed, Baz was removed, Biz was added
$dc = new DatabaseComparator();
$dc->setFromDatabase($d1);
$dc->setToDatabase($d2);
$nbDiffs = $dc->compareTables();
$databaseDiff = $dc->getDatabaseDiff();
$this->assertEquals(4, $nbDiffs);
$this->assertEquals(array('Bar' => 'Bar2'), $databaseDiff->getRenamedTables());
$this->assertEquals(array('Biz' => $t5), $databaseDiff->getAddedTables());
$this->assertEquals(array('Baz' => $t11), $databaseDiff->getRemovedTables());
$tableDiff = TableComparator::computeDiff($t1, $t3);
$this->assertEquals(array('Foo_Table' => $tableDiff), $databaseDiff->getModifiedTables());
}
public function testCompareModifiedFks()
{
$db1 = new Database();
$db1->setPlatform($this->platform);
$c1 = new Column('Foo');
$c2 = new Column('Bar');
$fk1 = new ForeignKey();
$fk1->addReference($c1, $c2);
$t1 = new Table('Baz');
$t1->addForeignKey($fk1);
$db1->addTable($t1);
$t1->doNaming();
$db2 = new Database();
$db2->setPlatform($this->platform);
$c3 = new Column('Foo');
$c4 = new Column('Bar2');
$fk2 = new ForeignKey();
$fk2->addReference($c3, $c4);
$t2 = new Table('Baz');
$t2->addForeignKey($fk2);
$db2->addTable($t2);
$t2->doNaming();
$tc = new TableComparator();
$tc->setFromTable($t1);
$tc->setToTable($t2);
$nbDiffs = $tc->compareForeignKeys();
$tableDiff = $tc->getTableDiff();
$this->assertEquals(1, $nbDiffs);
$this->assertEquals(1, count($tableDiff->getModifiedFks()));
$this->assertEquals(array('Baz_FK_1' => array($fk1, $fk2)), $tableDiff->getModifiedFks());
}
public function testCompareModifiedIndices()
{
$t1 = new Table();
$c1 = new Column('Foo');
$c1->getDomain()->copy($this->platform->getDomainForType('VARCHAR'));
$c1->getDomain()->replaceSize(255);
$c1->setNotNull(false);
$t1->addColumn($c1);
$i1 = new Index('Foo_Index');
$i1->addColumn($c1);
$t1->addIndex($i1);
$t2 = new Table();
$c2 = new Column('Foo');
$c2->getDomain()->copy($this->platform->getDomainForType('DOUBLE'));
$c2->getDomain()->replaceScale(2);
$c2->getDomain()->replaceSize(3);
$c2->setNotNull(true);
$c2->getDomain()->setDefaultValue(new ColumnDefaultValue(123, ColumnDefaultValue::TYPE_VALUE));
$t2->addColumn($c2);
$i2 = new Unique('Foo_Index');
$i2->addColumn($c2);
$t2->addIndex($i2);
$tc = new TableComparator();
$tc->setFromTable($t1);
$tc->setToTable($t2);
$nbDiffs = $tc->compareIndices();
$tableDiff = $tc->getTableDiff();
$this->assertEquals(1, $nbDiffs);
$this->assertEquals(1, count($tableDiff->getModifiedIndices()));
$this->assertEquals(array('Foo_Index' => array($i1, $i2)), $tableDiff->getModifiedIndices());
}
public function testCompareSeveralColumnDifferences()
{
$t1 = new Table();
$c1 = new Column('col1');
$c1->getDomain()->copy($this->platform->getDomainForType('VARCHAR'));
$c1->getDomain()->replaceSize(255);
$c1->setNotNull(false);
$t1->addColumn($c1);
$c2 = new Column('col2');
$c2->getDomain()->copy($this->platform->getDomainForType('INTEGER'));
$c2->setNotNull(true);
$t1->addColumn($c2);
$c3 = new Column('col3');
$c3->getDomain()->copy($this->platform->getDomainForType('VARCHAR'));
$c3->getDomain()->replaceSize(255);
$t1->addColumn($c3);
$t2 = new Table();
$c4 = new Column('col1');
$c4->getDomain()->copy($this->platform->getDomainForType('DOUBLE'));
$c4->getDomain()->replaceScale(2);
$c4->getDomain()->replaceSize(3);
$c4->setNotNull(true);
$c4->getDomain()->setDefaultValue(new ColumnDefaultValue(123, ColumnDefaultValue::TYPE_VALUE));
$t2->addColumn($c4);
$c5 = new Column('col22');
$c5->getDomain()->copy($this->platform->getDomainForType('INTEGER'));
$c5->setNotNull(true);
$t2->addColumn($c5);
$c6 = new Column('col4');
$c6->getDomain()->copy($this->platform->getDomainForType('LONGVARCHAR'));
$c6->getDomain()->setDefaultValue(new ColumnDefaultValue('123', ColumnDefaultValue::TYPE_VALUE));
$t2->addColumn($c6);
// col1 was modified, col2 was renamed, col3 was removed, col4 was added
$tc = new TableComparator();
$tc->setFromTable($t1);
$tc->setToTable($t2);
$nbDiffs = $tc->compareColumns();
$tableDiff = $tc->getTableDiff();
$this->assertEquals(4, $nbDiffs);
$this->assertEquals(array(array($c2, $c5)), $tableDiff->getRenamedColumns());
$this->assertEquals(array('col4' => $c6), $tableDiff->getAddedColumns());
$this->assertEquals(array('col3' => $c3), $tableDiff->getRemovedColumns());
$columnDiff = ColumnComparator::computeDiff($c1, $c4);
$this->assertEquals(array('col1' => $columnDiff), $tableDiff->getModifiedColumns());
}
public function testCompareSeveralRenamedSamePrimaryKeys()
{
$t1 = new Table();
$c1 = new Column('col1');
$c1->getDomain()->copy($this->platform->getDomainForType('INTEGER'));
$c1->setNotNull(true);
$c1->setPrimaryKey(true);
$t1->addColumn($c1);
$c2 = new Column('col2');
$c2->getDomain()->copy($this->platform->getDomainForType('INTEGER'));
$c2->setNotNull(true);
$c2->setPrimaryKey(true);
$t1->addColumn($c2);
$c3 = new Column('col3');
$c3->getDomain()->copy($this->platform->getDomainForType('INTEGER'));
$c3->setNotNull(true);
$c3->setPrimaryKey(true);
$t1->addColumn($c3);
$t2 = new Table();
$c4 = new Column('col4');
$c4->getDomain()->copy($this->platform->getDomainForType('INTEGER'));
$c4->setNotNull(true);
$c4->setPrimaryKey(true);
$t2->addColumn($c4);
$c5 = new Column('col5');
$c5->getDomain()->copy($this->platform->getDomainForType('INTEGER'));
$c5->setNotNull(true);
$c5->setPrimaryKey(true);
$t2->addColumn($c5);
$c6 = new Column('col3');
$c6->getDomain()->copy($this->platform->getDomainForType('INTEGER'));
$c6->setNotNull(true);
$c6->setPrimaryKey(true);
$t2->addColumn($c6);
// col1 and col2 were renamed
$tc = new TableComparator();
$tc->setFromTable($t1);
$tc->setToTable($t2);
$nbDiffs = $tc->comparePrimaryKeys();
$tableDiff = $tc->getTableDiff();
$this->assertEquals(2, $nbDiffs);
$this->assertEquals([[$c1, $c4], [$c2, $c5]], $tableDiff->getRenamedPkColumns());
$this->assertEquals([], $tableDiff->getAddedPkColumns());
$this->assertEquals([], $tableDiff->getRemovedPkColumns());
}