/**
* @param LoggerInterface $logger
* @param bool $dryRun
*/
protected function runActivityLists(LoggerInterface $logger, $dryRun = false)
{
// @todo: this workaround should be removed in BAP-9156
$this->configManager->clear();
$targetEntities = $this->provider->getTargetEntityClasses(false);
$toSchema = clone $this->schema;
$hasSchemaChanges = false;
foreach ($targetEntities as $targetEntity) {
$associationName = ExtendHelper::buildAssociationName($targetEntity, ActivityListEntityConfigDumperExtension::ASSOCIATION_KIND);
$relationTableName = $this->nameGenerator->generateManyToManyJoinTableName(ActivityListEntityConfigDumperExtension::ENTITY_CLASS, $associationName, $targetEntity);
if (!$toSchema->hasTable($relationTableName)) {
$hasSchemaChanges = true;
$this->activityListExtension->addActivityListAssociation($toSchema, $this->metadataHelper->getTableNameByEntityClass($targetEntity));
}
}
if ($hasSchemaChanges) {
$comparator = new Comparator();
$platform = $this->connection->getDatabasePlatform();
$schemaDiff = $comparator->compare($this->schema, $toSchema);
$queries = $schemaDiff->toSql($platform);
foreach ($queries as $query) {
$this->logQuery($logger, $query);
if (!$dryRun) {
$this->connection->executeQuery($query);
}
}
}
}
public function execute(InputInterface $input, OutputInterface $output)
{
$dumpSql = $input->getOption('dump-sql');
$force = $input->getOption('force');
$manager = $this->connection->getSchemaManager();
$this->connection->connect();
$fromSchema = $manager->createSchema();
$toSchema = new Schema();
$comparator = new Comparator();
$schemaDiff = $comparator->compare($fromSchema, $toSchema);
$sql = $schemaDiff->toSaveSql($this->connection->getDatabasePlatform());
if (!$dumpSql && !$force) {
$output->writeln(sprintf('%d sql statements would be executed. Use `--dump-sql` to show them and `--force` to execute them on the database.', count($sql)));
return;
}
if ($dumpSql) {
foreach ($sql as $line) {
$output->writeln($line);
}
}
if ($force) {
$output->writeln('Updating database schema');
foreach ($sql as $line) {
$this->connection->exec($line);
}
$output->writeln(sprintf('%d sql statements executed.', count($sql)));
}
}
/**
* Execute the console command.
*
* @return mixed
*/
public function handle()
{
$this->info('Retrieving schema differences...' . PHP_EOL);
$this->createInMemoryDatabase();
$defaultSm = $this->getSchemaManager();
$inMemorySm = $this->getSchemaManager(self::CONNECTION_NAME);
$fromSchema = $defaultSm->createSchema();
$toSchema = $inMemorySm->createSchema();
$comparator = new Comparator();
$schemaDiff = $comparator->compare($fromSchema, $toSchema);
$diffStatements = $schemaDiff->toSql($this->getDatabasePlatform());
if (count($diffStatements) > 0) {
$this->info('Statements that will be executed:' . PHP_EOL);
foreach ($diffStatements as $statement) {
$this->info('- ' . $statement);
}
} else {
$this->info('The schema is up to date with the migrations.' . PHP_EOL);
}
if ($this->option('force')) {
DB::transaction(function () use($diffStatements) {
foreach ($diffStatements as $statement) {
DB::statement($statement);
}
});
} else {
$this->info(PHP_EOL . 'To apply diff statements use the --force option');
}
}
/**
* Updates DB Schema. Changes from Diamante only will be applied for current schema. Other bundles updating skips
* @throws \Exception if there are no changes in entities
*/
protected function updateDbSchema()
{
/**
* @var $em \Doctrine\ORM\EntityManager
*/
$em = $this->getContainer()->get('doctrine.orm.entity_manager');
$event = $em->getEventManager();
$sm = $em->getConnection()->getSchemaManager();
$allMetadata = $em->getMetadataFactory()->getAllMetadata();
$schemaTool = new SchemaTool($em);
$entitiesMetadata = array($em->getClassMetadata(\Diamante\DeskBundle\Entity\Branch::getClassName()), $em->getClassMetadata(\Diamante\DeskBundle\Entity\Ticket::getClassName()), $em->getClassMetadata(\Diamante\DeskBundle\Entity\Comment::getClassName()), $em->getClassMetadata(\Diamante\DeskBundle\Entity\Attachment::getClassName()), $em->getClassMetadata(\Diamante\DeskBundle\Entity\BranchEmailConfiguration::getClassName()), $em->getClassMetadata(\Diamante\DeskBundle\Entity\MessageReference::getClassName()), $em->getClassMetadata(\Diamante\DeskBundle\Entity\TicketHistory::getClassName()), $em->getClassMetadata(\Diamante\DeskBundle\Entity\WatcherList::getClassName()), $em->getClassMetadata(\Diamante\DeskBundle\Entity\TicketTimeline::getClassName()), $em->getClassMetadata(\Diamante\DeskBundle\Entity\Audit::getClassName()), $em->getClassMetadata(\Diamante\DeskBundle\Entity\AuditField::getClassName()), $em->getClassMetadata(\Diamante\DeskBundle\Entity\Article::getClassName()));
$event->disableListeners();
$currentSchema = $sm->createSchema();
$schemaFromMetadata = $schemaTool->getSchemaFromMetadata($allMetadata);
$entitiesSchema = $schemaTool->getSchemaFromMetadata($entitiesMetadata);
$entitiesTables = $entitiesSchema->getTables();
$entitiesTableName = array_keys($entitiesTables);
$currentDiamanteSchema = $this->getTargetSchema($currentSchema, $entitiesTableName);
$diamanteSchemaFromMetadata = $this->getTargetSchema($schemaFromMetadata, $entitiesTableName);
$comparator = new Comparator();
$diff = $comparator->compare($currentDiamanteSchema, $diamanteSchemaFromMetadata);
$toUpdate = $diff->toSql($em->getConnection()->getDatabasePlatform());
if (empty($toUpdate)) {
throw new \Exception('No new updates found. DiamanteDesk is up to date!');
}
$conn = $em->getConnection();
foreach ($toUpdate as $sql) {
$conn->executeQuery($sql);
}
}
/**
* Updates DB Schema.
* @throws \Exception if there are no changes in entities
*/
protected function updateDbSchema()
{
/**
* @var $em \Doctrine\ORM\EntityManager
*/
$em = $this->getContainer()->get('doctrine.orm.entity_manager');
$event = $em->getEventManager();
$sm = $em->getConnection()->getSchemaManager();
$allMetadata = $em->getMetadataFactory()->getAllMetadata();
$schemaTool = new SchemaTool($em);
$entitiesMetadata = array($em->getClassMetadata(ApiUser::getClassName()), $em->getClassMetadata(DiamanteUser::getClassName()));
$event->disableListeners();
$currentSchema = $sm->createSchema();
$schemaFromMetadata = $schemaTool->getSchemaFromMetadata($allMetadata);
$entitiesSchema = $schemaTool->getSchemaFromMetadata($entitiesMetadata);
$entitiesTables = $entitiesSchema->getTables();
$entitiesTableName = array_keys($entitiesTables);
$currentDiamanteSchema = $this->getTargetSchema($currentSchema, $entitiesTableName);
$diamanteSchemaFromMetadata = $this->getTargetSchema($schemaFromMetadata, $entitiesTableName);
$comparator = new Comparator();
$diff = $comparator->compare($currentDiamanteSchema, $diamanteSchemaFromMetadata);
$toUpdate = $diff->toSql($em->getConnection()->getDatabasePlatform());
if (empty($toUpdate)) {
throw new \Exception('No new updates found. Diamante Api Bundle is up to date!');
}
$conn = $em->getConnection();
foreach ($toUpdate as $sql) {
$conn->executeQuery($sql);
}
}
/**
* @param array $classes
*
* @return \Doctrine\DBAL\Schema\SchemaDiff
* @throws \Doctrine\ORM\ORMException
*/
protected function getSchemaDiff(array $classes)
{
$sm = $this->getConnection()->getSchemaManager();
$fromSchema = $sm->createSchema();
$toSchema = $this->getSchemaFromMetadata($classes);
$comparator = new Comparator();
return $comparator->compare($fromSchema, $toSchema);
}
/**
* Makes sure oro_session table is up-to-date
*
* @param Schema $schema
* @param QueryBag $queries
*/
public function oroSessionTable(Schema $schema, QueryBag $queries)
{
if (!$schema->hasTable('oro_session')) {
$this->createOroSessionTable($schema);
} else {
$currentSchema = new Schema([clone $schema->getTable('oro_session')]);
$requiredSchema = new Schema();
$this->createOroSessionTable($requiredSchema);
$comparator = new Comparator();
$changes = $comparator->compare($currentSchema, $requiredSchema)->toSql($this->platform);
if ($changes) {
// force to recreate oro_session table as a result of dropTable/createTable pair
// might be "ALTER TABLE" query rather than "DROP/CREATE" queries
$dropTableSql = $comparator->compare($currentSchema, new Schema())->toSql($this->platform);
$createTableSql = $comparator->compare(new Schema(), $requiredSchema)->toSql($this->platform);
$queries->addQuery(new SqlMigrationQuery($dropTableSql));
$queries->addQuery(new SqlMigrationQuery($createTableSql));
}
}
}
/**
* {@inheritdoc}
*/
public function getUpdateSchema(Schema $toSchema, $noDrops = false)
{
$comparator = new Comparator();
$sm = $this->conn->getSchemaManager();
$fromSchema = $sm->createSchema();
$schemaDiff = $comparator->compare($fromSchema, $toSchema);
if ($noDrops) {
return $schemaDiff->toSaveSql($this->platform);
}
return $schemaDiff->toSql($this->platform);
}
/**
* {@inheritdoc}
*/
public function execute(InputInterface $input, OutputInterface $output)
{
$url = $input->getArgument('url');
$filename = $input->getArgument('filename');
$apply = $input->getOption('apply');
$dbmanager = new DatabaseManager();
$databaseConfig = $dbmanager->getDatabaseConfig($url);
$config = $databaseConfig->getConnectionConfig('default');
$dsn = sprintf('%s:host=%s;port=%d', $config->getDriver(), $config->getHost(), $config->getPort());
$dbname = $config->getDatabaseName();
try {
$pdo = new PDO($dsn, $config->getUsername(), $config->getPassword());
} catch (\Exception $e) {
throw new RuntimeException("Can't connect to server with provided address and credentials");
}
$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
$stmt = $pdo->query("SELECT COUNT(*) FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME = '" . $dbname . "'");
if (!$stmt->fetchColumn()) {
$output->writeln("<info>Creating database</info>");
$stmt = $pdo->query("CREATE DATABASE " . $dbname . "");
} else {
$output->writeln("<error>Database exists...</error>");
}
$loader = LoaderFactory::getInstance()->getLoader($filename);
$toSchema = $loader->loadSchema($filename);
$config = new Configuration();
$connectionParams = array('url' => $dbmanager->getUrlByDatabaseName($url));
$connection = DriverManager::getConnection($connectionParams, $config);
$connection->getDatabasePlatform()->registerDoctrineTypeMapping('enum', 'string');
$output->writeln(sprintf('<info>Loading file <comment>`%s`</comment> into database <comment>`%s`</comment></info>', $filename, $url));
$schemaManager = $connection->getSchemaManager();
$fromSchema = $schemaManager->createSchema();
$comparator = new Comparator();
$schemaDiff = $comparator->compare($fromSchema, $toSchema);
$platform = $connection->getDatabasePlatform();
$queries = $schemaDiff->toSaveSql($platform);
if (!count($queries)) {
$output->writeln("<info>No schema changes required</info>");
return;
}
if ($apply) {
$output->writeln("<info>APPLYING...</info>");
foreach ($queries as $query) {
$output->writeln(sprintf('<info>Running: <comment>%s</comment></info>', $query));
$stmt = $connection->query($query);
}
} else {
$output->writeln("<info>CHANGES: The following SQL statements need to be executed to synchronise the schema (use <comment>--apply</comment>)</info>");
foreach ($queries as $query) {
$output->writeln($query);
}
}
}
/**
* Update database schema
* @param bool $sqlOnly
* @return array|null
*/
public function updateSchema($sqlOnly = false)
{
$comparator = new Comparator();
$schemaDiff = $comparator->compare($this->getCurrentSchema(), $this->getDesiredSchema());
$sqls = $schemaDiff->toSql($this->getDBALPlatform());
if ($sqlOnly) {
return $sqls;
}
foreach ($sqls as $sql) {
$this->connection->exec($sql);
}
}
/**
* Update all tables.
*
* @param array $metadata
* @param boolean $saveMode
* @return array
*/
public function update(array $metadata, $saveMode = false)
{
$fromSchema = $this->schemaManager->createSchema();
$toSchema = $this->getSchemaFromMetadata($metadata);
$comparator = new Comparator();
$schemaDiff = $comparator->compare($fromSchema, $toSchema);
if ($saveMode) {
$statements = $schemaDiff->toSaveSql($this->platform);
} else {
$statements = $schemaDiff->toSql($this->platform);
}
$this->build($statements);
return $statements;
}
/**
* {@inheritdoc}
*/
protected function execute(InputInterface $input, OutputInterface $output)
{
$sm = $this->connection->getSchemaManager();
$schema = $this->schema->getSchema();
$existing = new DoctrineSchema($sm->listTables(), []);
$comparator = new Comparator();
$difference = $comparator->compare($existing, $schema);
$count = 0;
if ($statements = $difference->toSql($sm->getDatabasePlatform())) {
foreach ($statements as $statement) {
$this->connection->exec($statement);
$count++;
}
$output->writeln(sprintf('Executed <info>%d</info> queries', $count));
} else {
$output->writeln('<comment>Schema is already up to date.</comment>');
}
}
protected function execute(InputInterface $input, OutputInterface $output)
{
$seed = base64_encode(hash('sha512', $input->getArgument('phrase'), true));
if ($this->getContainer()->has('security.util.secure_random_seed_provider')) {
$this->getContainer()->get('security.util.secure_random_seed_provider')->updateSeed($seed);
$output->writeln('The CSPRNG has been initialized successfully.');
} elseif ($this->getContainer()->has('security.util.secure_random_connection')) {
if ($input->getOption('force') === $input->getOption('dump-sql')) {
throw new \InvalidArgumentException('This command needs to be run with one of these options: --force, or --dump-sql');
}
$con = $this->getContainer()->get('security.util.secure_random_connection');
$schema = $this->getContainer()->get('security.util.secure_random_schema');
$comparator = new Comparator();
$execute = $input->getOption('force');
foreach ($comparator->compare($con->getSchemaManager()->createSchema(), $schema)->toSaveSql($con->getDatabasePlatform()) as $sql) {
if ($execute) {
$con->executeQuery($sql);
} else {
$output->writeln($sql);
}
}
$table = $this->getContainer()->getParameter('security.util.secure_random_table');
$sql = $con->getDatabasePlatform()->getTruncateTableSQL($table);
if ($execute) {
$con->executeQuery($sql);
} else {
$output->writeln($sql);
}
$sql = "INSERT INTO {$table} VALUES (:seed, :updatedAt)";
if ($execute) {
$con->executeQuery($sql, array(':seed' => $seed, ':updatedAt' => new \DateTime()), array(':updatedAt' => Type::DATETIME));
} else {
$output->writeln($sql);
}
if ($execute) {
$output->writeln('The CSPRNG has been initialized successfully.');
}
} else {
throw new \RuntimeException('No seed provider has been configured under path "security.util.secure_random".');
}
}
protected function execute(InputInterface $input, OutputInterface $output)
{
$schema_file = Schema::getFile($input->getArgument('schema'));
$dumpSql = true === $input->getOption('dump-sql');
$force = true === $input->getOption('force');
if (empty($schema_file)) {
throw new RuntimeException("Schema file not found.");
}
$config = new Config($schema_file);
$db = $this->getDb($config);
$toSchema = $config->getSchema($db);
$comparator = new \Doctrine\DBAL\Schema\Comparator();
$schemaDiff = $comparator->compare($db->getSchemaManager($db)->createSchema(), $toSchema);
$sqls = $schemaDiff->toSql($db->getDatabasePlatform());
if (0 == count($sqls)) {
$output->writeln('Nothing to update - your database is already in sync with the current entity metadata.');
return;
}
if ($dumpSql && $force) {
throw new \InvalidArgumentException('You can pass either the --dump-sql or the --force option (but not both simultaneously).');
}
if ($dumpSql) {
$output->writeln(implode(';' . PHP_EOL, $sqls));
} elseif ($force) {
$output->writeln('Updating database schema...');
foreach ($schemaDiff->toSql($db->getDatabasePlatform()) as $sql) {
$db->exec($sql);
}
$output->writeln(sprintf('Database schema updated successfully! "<info>%s</info>" queries were executed', count($sqls)));
} else {
$output->writeln('<comment>ATTENTION</comment>: This operation should not be executed in a production environment.');
$output->writeln(' Use the incremental update to detect changes during development and use');
$output->writeln(' the SQL provided to manually update your database in production.');
$output->writeln('');
$output->writeln(sprintf('The Schema-Tool would execute <info>"%s"</info> queries to update the database.', count($sqls)));
$output->writeln('Please run the operation by passing one of the following options:');
$output->writeln(sprintf(' <info>%s --force</info> to execute the command', $this->getName()));
$output->writeln(sprintf(' <info>%s --dump-sql</info> to dump the SQL statements to the screen', $this->getName()));
}
}
/**
* Executes UP method for the given migrations
*
* @param Migration[] $migrations
* @param bool $dryRun
* @throws InvalidNameException if invalid table or column name is detected
*/
public function executeUp(array $migrations, $dryRun = false)
{
$platform = $this->queryExecutor->getConnection()->getDatabasePlatform();
$sm = $this->queryExecutor->getConnection()->getSchemaManager();
$fromSchema = $this->createSchemaObject($sm->listTables(), $platform->supportsSequences() ? $sm->listSequences() : [], $sm->createSchemaConfig());
$queryBag = new QueryBag();
foreach ($migrations as $migration) {
$this->logger->notice(sprintf('> %s', get_class($migration)));
$toSchema = clone $fromSchema;
$this->setExtensions($migration);
$migration->up($toSchema, $queryBag);
$comparator = new Comparator();
$schemaDiff = $comparator->compare($fromSchema, $toSchema);
$this->checkTables($schemaDiff, $migration);
$this->checkIndexes($schemaDiff, $migration);
$queries = array_merge($queryBag->getPreQueries(), $schemaDiff->toSql($platform), $queryBag->getPostQueries());
$fromSchema = $toSchema;
$queryBag->clear();
foreach ($queries as $query) {
$this->queryExecutor->execute($query, $dryRun);
}
}
}
public function testExplicitRename()
{
$this->markTestSkipped('evauate concept for explicit field rename with doctrine2 schema tool');
$em = Setup_SchemaTool::getEntityManager('Inventory');
$sm = $em->getConnection()->getSchemaManager();
// NOTE: the DBAL schema is stateless and 'just' describes a schema in a plattform independend way
// thus, all schema upgrade is based on schema comparisim
$fromSchema = $sm->createSchema();
$toSchema = clone $fromSchema;
$table = $toSchema->getTable('tine20_inventory_item');
// workaround -> might have problems?!
$col = $table->getColumn('id');
$table->dropColumn('id');
$table->addColumn('ident', $col->getType()->getName(), $col->toArray());
// better create, copy, delete?
// @TODO ask some insider
// ? Schema tool can't rename cols, but schema diff with compare (at least with mysql plattform) alters table name correctly when col is renamed in annotations
// non rename updates are a lot more easy
$table->changeColumn('name', array('length' => 200));
$comparator = new Comparator();
$schemaDiff = $comparator->compare($fromSchema, $toSchema);
$updateSql = $schemaDiff->toSql($em->getConnection()->getDatabasePlatform());
// print_r($updateSql);
}
/**
* @group DBAL-112
*/
public function testChangedSequence()
{
$schema = new Schema();
$sequence = $schema->createSequence('baz');
$schemaNew = clone $schema;
/* @var $schemaNew Schema */
$schemaNew->getSequence('baz')->setAllocationSize(20);
$c = new \Doctrine\DBAL\Schema\Comparator();
$diff = $c->compare($schema, $schemaNew);
$this->assertSame($diff->changedSequences[0], $schemaNew->getSequence('baz'));
}
protected function getDiff(Schema $targetSchema, \Doctrine\DBAL\Connection $connection)
{
$connection->getConfiguration()->setFilterSchemaAssetsExpression('/^' . $this->config->getSystemValue('dbtableprefix', 'oc_') . '/');
$sourceSchema = $connection->getSchemaManager()->createSchema();
// remove tables we don't know about
/** @var $table \Doctrine\DBAL\Schema\Table */
foreach ($sourceSchema->getTables() as $table) {
if (!$targetSchema->hasTable($table->getName())) {
$sourceSchema->dropTable($table->getName());
}
}
// remove sequences we don't know about
foreach ($sourceSchema->getSequences() as $table) {
if (!$targetSchema->hasSequence($table->getName())) {
$sourceSchema->dropSequence($table->getName());
}
}
$comparator = new Comparator();
return $comparator->compare($sourceSchema, $targetSchema);
}
/**
* Gets the sequence of SQL statements that need to be performed in order
* to bring the given class mappings in-synch with the relational schema.
* If $saveMode is set to true the command is executed in the Database,
* else SQL is returned.
*
* @param array $classes The classes to consider.
* @param boolean $saveMode True for writing to DB, false for SQL string.
*
* @return array The sequence of SQL statements.
*/
public function getUpdateSchemaSql(array $classes, $saveMode = false)
{
$sm = $this->em->getConnection()->getSchemaManager();
$fromSchema = $sm->createSchema();
$toSchema = $this->getSchemaFromMetadata($classes);
foreach ($toSchema->getTables() as $table) {
foreach ($table->getColumns() as $column) {
if ($column->getAutoincrement()) {
continue;
}
if (!preg_match('/^(?P<column>(?P<table>.*)_id)$/', $column->getName(), $matches)) {
continue;
}
$referencedTable = 'oc_' . $matches['table'];
if (!$toSchema->hasTable($referencedTable)) {
continue;
}
if ($toSchema->getTable($referencedTable) === $table) {
continue;
}
$table->addForeignKeyConstraint($toSchema->getTable($referencedTable), [$matches['column']], [$matches['column']]);
}
}
$comparator = new Comparator();
$schemaDiff = $comparator->compare($fromSchema, $toSchema);
foreach ($schemaDiff->changedTables as $changedTable) {
$changedTable->changedColumns = [];
}
if ($saveMode) {
return $schemaDiff->toSaveSql($this->platform);
}
return $schemaDiff->toSql($this->platform);
}
/**
* Gets the sequence of SQL statements that need to be performed in order
* to bring the given class mappings in-synch with the relational schema.
* If $saveMode is set to true the command is executed in the Database,
* else SQL is returned.
*
* @param array $classes The classes to consider.
* @param boolean $saveMode True for writing to DB, false for SQL string.
*
* @return array The sequence of SQL statements.
*/
public function getUpdateSchemaSql(array $classes, $saveMode = false)
{
$sm = $this->em->getConnection()->getSchemaManager();
$fromSchema = $sm->createSchema();
$toSchema = $this->getSchemaFromMetadata($classes);
$comparator = new Comparator();
$schemaDiff = $comparator->compare($fromSchema, $toSchema);
if ($saveMode) {
return $schemaDiff->toSaveSql($this->platform);
}
return $schemaDiff->toSql($this->platform);
}
/**
* @param Schema $targetSchema
* @param \Doctrine\DBAL\Connection $connection
* @return \Doctrine\DBAL\Schema\SchemaDiff
* @throws DBALException
*/
protected function getDiff(Schema $targetSchema, \Doctrine\DBAL\Connection $connection)
{
// adjust varchar columns with a length higher then getVarcharMaxLength to clob
foreach ($targetSchema->getTables() as $table) {
foreach ($table->getColumns() as $column) {
if ($column->getType() instanceof StringType) {
if ($column->getLength() > $connection->getDatabasePlatform()->getVarcharMaxLength()) {
$column->setType(Type::getType('text'));
$column->setLength(null);
}
}
}
}
$filterExpression = $this->getFilterExpression();
$this->connection->getConfiguration()->setFilterSchemaAssetsExpression($filterExpression);
$sourceSchema = $connection->getSchemaManager()->createSchema();
// remove tables we don't know about
/** @var $table \Doctrine\DBAL\Schema\Table */
foreach ($sourceSchema->getTables() as $table) {
if (!$targetSchema->hasTable($table->getName())) {
$sourceSchema->dropTable($table->getName());
}
}
// remove sequences we don't know about
foreach ($sourceSchema->getSequences() as $table) {
if (!$targetSchema->hasSequence($table->getName())) {
$sourceSchema->dropSequence($table->getName());
}
}
$comparator = new Comparator();
return $comparator->compare($sourceSchema, $targetSchema);
}
protected function getDiff(Schema $targetSchema, \Doctrine\DBAL\Connection $connection)
{
$sourceSchema = $connection->getSchemaManager()->createSchema();
// remove tables we don't know about
/** @var $table \Doctrine\DBAL\Schema\Table */
foreach ($sourceSchema->getTables() as $table) {
if (!$targetSchema->hasTable($table->getName())) {
$sourceSchema->dropTable($table->getName());
}
}
// remove sequences we don't know about
foreach ($sourceSchema->getSequences() as $table) {
if (!$targetSchema->hasSequence($table->getName())) {
$sourceSchema->dropSequence($table->getName());
}
}
$comparator = new Comparator();
return $comparator->compare($sourceSchema, $targetSchema);
}
/**
* @group DBAL-204
*/
public function testFqnSchemaComparisionNoSchemaSame()
{
$config = new SchemaConfig();
$config->setName("foo");
$oldSchema = new Schema(array(), array(), $config);
$oldSchema->createTable('bar');
$newSchema = new Schema();
$newSchema->createTable('bar');
$c = new Comparator();
$diff = $c->compare($oldSchema, $newSchema);
$this->assertEquals(new SchemaDiff(), $c->compare($oldSchema, $newSchema));
}
public function testSequencesCaseInsenstive()
{
$schemaA = new Schema();
$schemaA->createSequence('foo');
$schemaA->createSequence('BAR');
$schemaA->createSequence('Baz');
$schemaA->createSequence('new');
$schemaB = new Schema();
$schemaB->createSequence('FOO');
$schemaB->createSequence('Bar');
$schemaB->createSequence('baz');
$schemaB->createSequence('old');
$c = new Comparator();
$diff = $c->compare($schemaA, $schemaB);
$this->assertSchemaSequenceChangeCount($diff, 1, 0, 1);
}
/**
* @param LoggerInterface $logger
* @param bool $dryRun
*/
protected function addActivityContactColumns(LoggerInterface $logger, $dryRun = false)
{
$hasSchemaChanges = false;
$toSchema = clone $this->schema;
$contactingActivityClasses = $this->activityContactProvider->getSupportedActivityClasses();
$entities = $this->getConfigurableEntitiesData($logger);
foreach ($entities as $entityClassName => $config) {
if (isset($config['extend']['is_extend'], $config['activity']['activities']) && $config['extend']['is_extend'] == true && $config['activity']['activities'] && array_intersect($contactingActivityClasses, $config['activity']['activities'])) {
if (isset($config['extend']['schema']['doctrine'][$entityClassName]['table'])) {
$tableName = $config['extend']['schema']['doctrine'][$entityClassName]['table'];
} else {
$tableName = $this->metadataHelper->getTableNameByEntityClass($entityClassName);
}
// Process only existing tables
if (!$toSchema->hasTable($tableName)) {
continue;
}
$table = $toSchema->getTable($tableName);
$tableColumns = $table->getColumns();
/**
* Check if entity already has all needed columns.
* If at least one is not present we should check and add it.
*/
if (false === (bool) array_diff(array_keys(ActivityScope::$fieldsConfiguration), array_intersect(array_keys($tableColumns), array_keys(ActivityScope::$fieldsConfiguration)))) {
continue;
}
foreach (ActivityScope::$fieldsConfiguration as $fieldName => $fieldConfig) {
if (!$table->hasColumn($fieldName)) {
$hasSchemaChanges = true;
$table->addColumn($fieldName, $fieldConfig['type'], ['notnull' => false, OroOptions::KEY => array_merge([ExtendOptionsManager::MODE_OPTION => $fieldConfig['mode']], $fieldConfig['options'])]);
}
}
}
}
if ($hasSchemaChanges) {
// Run schema related SQLs manually because this query run when diff is already calculated by schema tool
$comparator = new Comparator();
$platform = $this->connection->getDatabasePlatform();
$schemaDiff = $comparator->compare($this->schema, $toSchema);
foreach ($schemaDiff->toSql($platform) as $query) {
$this->logQuery($logger, $query);
if (!$dryRun) {
$this->connection->query($query);
}
}
}
}
/**
* @param Schema $schema
* @param AbstractPlatform $platform
* @param Migration $migration
* @param bool $dryRun
*
* @return bool
*/
public function executeUpMigration(Schema &$schema, AbstractPlatform $platform, Migration $migration, $dryRun = false)
{
$result = true;
$this->logger->notice(sprintf('> %s', get_class($migration)));
$toSchema = clone $schema;
$this->setExtensions($migration);
try {
$queryBag = new QueryBag();
$migration->up($toSchema, $queryBag);
$comparator = new Comparator();
$schemaDiff = $comparator->compare($schema, $toSchema);
$this->checkTables($schemaDiff, $migration);
$this->checkIndexes($schemaDiff, $migration);
$queries = array_merge($queryBag->getPreQueries(), $schemaDiff->toSql($platform), $queryBag->getPostQueries());
$schema = $toSchema;
foreach ($queries as $query) {
$this->queryExecutor->execute($query, $dryRun);
}
} catch (\Exception $ex) {
$result = false;
$this->logger->error(sprintf(' ERROR: %s', $ex->getMessage()));
}
return $result;
}
protected function getDiffSchema($fromSchema, $toSchema)
{
$comparator = new Comparator();
$diffSchema = $comparator->compare($fromSchema, $toSchema);
return $diffSchema;
}
/**
* 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 \Doctrine\DBAL\Schema\Schema $fromSchema
* @param \Doctrine\DBAL\Platforms\AbstractPlatform $platform
*
* @return array
*/
public function getMigrateFromSql(Schema $fromSchema, AbstractPlatform $platform)
{
$comparator = new Comparator();
$schemaDiff = $comparator->compare($fromSchema, $this);
return $schemaDiff->toSql($platform);
}
/**
* @group DBAL-669
*/
public function testComparesNamespaces()
{
$comparator = new Comparator();
$fromSchema = $this->getMock('Doctrine\\DBAL\\Schema\\Schema', array('getNamespaces', 'hasNamespace'));
$toSchema = $this->getMock('Doctrine\\DBAL\\Schema\\Schema', array('getNamespaces', 'hasNamespace'));
$fromSchema->expects($this->once())->method('getNamespaces')->will($this->returnValue(array('foo', 'bar')));
$fromSchema->expects($this->at(0))->method('hasNamespace')->with('bar')->will($this->returnValue(true));
$fromSchema->expects($this->at(1))->method('hasNamespace')->with('baz')->will($this->returnValue(false));
$toSchema->expects($this->once())->method('getNamespaces')->will($this->returnValue(array('bar', 'baz')));
$toSchema->expects($this->at(1))->method('hasNamespace')->with('foo')->will($this->returnValue(false));
$toSchema->expects($this->at(2))->method('hasNamespace')->with('bar')->will($this->returnValue(true));
$expected = new SchemaDiff();
$expected->fromSchema = $fromSchema;
$expected->newNamespaces = array('baz' => 'baz');
$expected->removedNamespaces = array('foo' => 'foo');
$this->assertEquals($expected, $comparator->compare($fromSchema, $toSchema));
}
