PHP Schema\Comparator类代码示例

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