/**
  * @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);
             }
         }
     }
 }

 /**
  * 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);
     }
 }

 /**
  * Generates code for creating or updating a database table.
  * @param Doctrine\DBAL\Schema\Table $updatedTable Specifies the updated table schema.
  * @param Doctrine\DBAL\Schema\Table $existingTable Specifies the existing table schema, if applicable.
  * @param string $newTableName An updated name of the theme. 
  * @return string|boolean Returns the migration up() and down() methods code. 
  * Returns false if there the table was not changed.
  */
 public function createOrUpdateTable($updatedTable, $existingTable, $newTableName)
 {
     $tableDiff = false;
     if ($existingTable !== null) {
         // The table already exists
         //
         $comparator = new Comparator();
         $tableDiff = $comparator->diffTable($existingTable, $updatedTable);
         if ($newTableName !== $existingTable->getName()) {
             if (!$tableDiff) {
                 $tableDiff = new TableDiff($existingTable->getName());
             }
             $tableDiff->newName = $newTableName;
         }
     } else {
         // The table doesn't exist
         //
         $tableDiff = new TableDiff($updatedTable->getName(), $updatedTable->getColumns(), [], [], $updatedTable->getIndexes());
         $tableDiff->fromTable = $updatedTable;
     }
     if (!$tableDiff) {
         return false;
     }
     if (!$this->tableHasNameOrColumnChanges($tableDiff) && !$this->tableHasPrimaryKeyChanges($tableDiff)) {
         return false;
     }
     return $this->generateCreateOrUpdateCode($tableDiff, !$existingTable, $updatedTable);
 }

 /**
  * 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);
     }
 }

 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');
     }
 }

 /**
  * @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);
 }

 public function getSchemaDiff()
 {
     $diff = new SchemaDiff();
     $comparator = new Comparator();
     $tableDiff = $comparator->diffTable($this->conn->getSchemaManager()->createSchema()->getTable($this->tableName), $this->schema->getTable($this->tableName));
     if (false !== $tableDiff) {
         $diff->changedTables[$this->tableName] = $tableDiff;
     }
     return $diff;
 }

 /**
  * {@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);
 }

 public function testSearchPathSchemaChanges()
 {
     $table = new Table("dbal510tbl");
     $table->addColumn('id', 'integer');
     $table->setPrimaryKey(array('id'));
     $this->_conn->getSchemaManager()->createTable($table);
     $onlineTable = $this->_conn->getSchemaManager()->listTableDetails('dbal510tbl');
     $comparator = new Comparator();
     $diff = $comparator->diffTable($onlineTable, $table);
     $this->assertFalse($diff);
 }

 /**
  * {@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>');
     }
 }

 public function up(Schema $schema)
 {
     \Database::query('UPDATE Config SET configNamespace="" WHERE configNamespace IS NULL');
     $config = $schema->getTable('Config');
     $fromConfig = clone $config;
     $db = \Database::get();
     $platform = $db->getDatabasePlatform();
     $config->dropPrimaryKey();
     $config->setPrimaryKey(array('configNamespace', 'configGroup', 'configItem'));
     $comparator = new Comparator();
     $diff = $comparator->diffTable($fromConfig, $config);
     $sql = $platform->getAlterTableSQL($diff);
     if (is_array($sql) && count($sql)) {
         foreach ($sql as $q) {
             $db->query($q);
         }
     }
 }

 /**
  * 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));
         }
     }
 }

 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);
         }
     }
 }

 /**
  * @group DBAL-472
  * @group DBAL-1001
  */
 public function testAlterTableColumnNotNull()
 {
     $comparator = new Schema\Comparator();
     $tableName = 'list_table_column_notnull';
     $table = new Schema\Table($tableName);
     $table->addColumn('id', 'integer');
     $table->addColumn('foo', 'integer');
     $table->addColumn('bar', 'string');
     $table->setPrimaryKey(array('id'));
     $this->_sm->dropAndCreateTable($table);
     $columns = $this->_sm->listTableColumns($tableName);
     $this->assertTrue($columns['id']->getNotnull());
     $this->assertTrue($columns['foo']->getNotnull());
     $this->assertTrue($columns['bar']->getNotnull());
     $diffTable = clone $table;
     $diffTable->changeColumn('foo', array('notnull' => false));
     $diffTable->changeColumn('bar', array('length' => 1024));
     $this->_sm->alterTable($comparator->diffTable($table, $diffTable));
     $columns = $this->_sm->listTableColumns($tableName);
     $this->assertTrue($columns['id']->getNotnull());
     $this->assertFalse($columns['foo']->getNotnull());
     $this->assertTrue($columns['bar']->getNotnull());
 }