PHP SchemaTool::getUpdateSchemaSql方法代码示例

 protected function executeSchemaCommand(InputInterface $input, OutputInterface $output, SchemaTool $schemaTool, array $metadatas)
 {
     // Defining if update is complete or not (--complete not defined means $saveMode = true)
     $saveMode = $input->getOption('complete') !== true;
     if ($input->getOption('dump-sql') === true) {
         $sqls = $schemaTool->getUpdateSchemaSql($metadatas, $saveMode);
         $output->write(implode(';' . PHP_EOL, $sqls) . PHP_EOL);
     } else {
         if ($input->getOption('force') === true) {
             $output->write('Updating database schema...' . PHP_EOL);
             $schemaTool->updateSchema($metadatas, $saveMode);
             $output->write('Database schema updated successfully!' . PHP_EOL);
         } else {
             $output->write('ATTENTION: This operation should not be executed in a production environment.' . PHP_EOL);
             $output->write('Use the incremental update to detect changes during development and use' . PHP_EOL);
             $output->write('this SQL DDL to manually update your database in production.' . PHP_EOL . PHP_EOL);
             $sqls = $schemaTool->getUpdateSchemaSql($metadatas, $saveMode);
             if (count($sqls)) {
                 $output->write('Schema-Tool would execute ' . count($sqls) . ' queries to update the database.' . PHP_EOL);
                 $output->write('Please run the operation with --force to execute these queries or use --dump-sql to see them.' . PHP_EOL);
             } else {
                 $output->write('Nothing to update. The database is in sync with the current entity metadata.' . PHP_EOL);
             }
         }
     }
 }

 public function execute()
 {
     $d = $this->factory()->appDoctrine();
     $this->app->dataStorage->clearStorage('CyantreeDoctrineModule/Proxies');
     $this->app->cacheStorage->clearStorage('CyantreeDoctrineModule');
     $tool = new SchemaTool($d);
     $queries = $tool->getUpdateSchemaSql($d->getMetadataFactory()->getAllMetadata());
     if ($queries) {
         $hash = '';
         foreach ($queries as $query) {
             $hash = md5($hash . $query);
         }
         $code = substr($hash, 0, 8);
         if ($transferredCode = $this->request->args->get('code')) {
             if ($transferredCode == $code) {
                 $tool->updateSchema($d->getMetadataFactory()->getAllMetadata());
                 $this->result->showSuccess('Schema has been updated.');
                 return;
             } else {
                 $this->result->showError('Passed invalid code.');
             }
         }
         $this->result->showWarning('Schema is not up to date. The following queries would be executed:');
         foreach ($queries as $query) {
             $this->result->showInfo($query);
         }
         $this->result->showWarning("Execute with -code={$code} to update the database schema.");
     } else {
         $this->result->showSuccess('Schema is up to date.');
     }
 }

 protected function executeSchemaCommand(InputInterface $input, OutputInterface $output, SchemaTool $schemaTool, array $metadatas)
 {
     // Defining if update is complete or not (--complete not defined means $saveMode = true)
     $saveMode = $input->getOption('complete') !== true;
     $sqls = $schemaTool->getUpdateSchemaSql($metadatas, $saveMode);
     if (0 == count($sqls)) {
         $output->writeln('Nothing to update - your database is already in sync with the current entity metadata.');
         return;
     }
     $dumpSql = true === $input->getOption('dump-sql');
     $force = true === $input->getOption('force');
     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));
     } else {
         if ($force) {
             $output->writeln('Updating database schema...');
             $schemaTool->updateSchema($metadatas, $saveMode);
             $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 DDL 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()));
         }
     }
 }

 public function updateAction()
 {
     $console = $this->getServiceLocator()->get('console');
     // Make sure that we are running in a console and the user has not tricked our
     // application into running this action from a public web server.
     $request = $this->getRequest();
     if (!$request instanceof ConsoleRequest) {
         throw new RuntimeException('You can only use this action from a console.');
     }
     $classes = array();
     $metas = $this->getAuditObjectManager()->getMetadataFactory()->getAllMetadata();
     foreach ($metas as $meta) {
         $classes[] = $meta;
     }
     $schemaTool = new SchemaTool($this->getAuditObjectManager());
     try {
         $result = $schemaTool->getUpdateSchemaSql($classes, false);
     } catch (\Exception $e) {
         $console->write($e->getCode() . ": " . $e->getMessage());
         $console->write("\nExiting now");
         return;
     }
     foreach ($result as $sql) {
         $console->write($sql . ";\n");
     }
 }

 /**
  * Runs command
  *
  * @param  InputInterface  $input
  * @param  OutputInterface $output
  * @return int|null|void
  */
 public function execute(InputInterface $input, OutputInterface $output)
 {
     $output->writeln($this->getDescription());
     /** @var EntityManager $em */
     $em = $this->getContainer()->get('doctrine.orm.entity_manager');
     /** @var ConfigManager $configManager */
     $configManager = $this->getContainer()->get('oro_entity_config.config_manager');
     $metadata = array_filter($em->getMetadataFactory()->getAllMetadata(), function ($doctrineMetadata) use($configManager) {
         /** @var ClassMetadataInfo $doctrineMetadata */
         return $this->isExtendEntity($doctrineMetadata->getReflectionClass()->getName(), $configManager);
     });
     $schemaTool = new SchemaTool($em);
     $sqls = $schemaTool->getUpdateSchemaSql($metadata, true);
     if (0 === count($sqls)) {
         $output->writeln('Nothing to update - a database is already in sync with the current entity metadata.');
     } else {
         if ($input->getOption('dry-run')) {
             $output->writeln(implode(';' . PHP_EOL, $sqls) . ';');
         } else {
             $output->writeln('Updating database schema...');
             $schemaTool->updateSchema($metadata, true);
             $output->writeln(sprintf('Database schema updated successfully! "<info>%s</info>" queries were executed', count($sqls)));
         }
     }
     if (!$input->getOption('dry-run')) {
         /** @var EnumSynchronizer $enumSynchronizer */
         $enumSynchronizer = $this->getContainer()->get('oro_entity_extend.enum_synchronizer');
         $enumSynchronizer->sync();
     }
 }

 /**
  * main method
  *
  * @return void
  */
 public function main()
 {
     static $em;
     if ($em === null) {
         $wd = getcwd();
         $zf = $this->project->getProperty('zf');
         $application = (require $zf);
         if (!$application instanceof Application) {
             throw new BuildException(sprintf('zf bootstrap file "%s" should return an instance of Zend\\Mvc\\Application', $zf));
         }
         chdir($wd);
         $em = $application->getServiceManager()->get($this->em);
     }
     $metadatas = $em->getMetadataFactory()->getAllMetadata();
     if (!empty($metadatas)) {
         $tool = new SchemaTool($em);
         $sqls = $tool->getUpdateSchemaSql($metadatas, false);
         if (0 === count($sqls)) {
             $this->log('Nothing to update - your database is already in sync with the current entity metadata.');
         } else {
             $this->log('Updating database schema...');
             $tool->updateSchema($metadatas, false);
             $this->log(sprintf('Database schema updated successfully! %s queries were executed', count($sqls)));
         }
     } else {
         $this->log('No metadata classes to process');
     }
 }

 public function setUp()
 {
     $this->_oldEntityManager = \SoliantEntityAudit\Module::getModuleOptions()->getEntityManager();
     $this->_oldAuditedClassNames = \SoliantEntityAudit\Module::getModuleOptions()->getAuditedClassNames();
     $this->_oldJoinClasses = \SoliantEntityAudit\Module::getModuleOptions()->resetJoinClasses();
     $isDevMode = false;
     $config = Setup::createConfiguration($isDevMode, null, null);
     $chain = new DriverChain();
     // Use ZFC User for authentication tests
     $chain->addDriver(new XmlDriver(__DIR__ . '/../../../vendor/zf-commons/zfc-user-doctrine-orm/config/xml/zfcuser'), 'ZfcUser\\Entity');
     $chain->addDriver(new XmlDriver(__DIR__ . '/../../../vendor/zf-commons/zfc-user-doctrine-orm/config/xml/zfcuserdoctrineorm'), 'ZfcUserDoctrineORM\\Entity');
     $chain->addDriver(new StaticPHPDriver(__DIR__ . "/../Models"), 'SoliantEntityAuditTest\\Models\\LogRevision');
     $chain->addDriver(new AuditDriver('.'), 'SoliantEntityAudit\\Entity');
     $config->setMetadataDriverImpl($chain);
     // Replace entity manager
     $moduleOptions = \SoliantEntityAudit\Module::getModuleOptions();
     $conn = array('driver' => 'pdo_sqlite', 'memory' => true);
     $moduleOptions->setAuditedClassNames(array('SoliantEntityAuditTest\\Models\\LogRevision\\Album' => array(), 'SoliantEntityAuditTest\\Models\\LogRevision\\Performer' => array(), 'SoliantEntityAuditTest\\Models\\LogRevision\\Song' => array(), 'SoliantEntityAuditTest\\Models\\LogRevision\\SingleCoverArt' => array()));
     $entityManager = EntityManager::create($conn, $config);
     $moduleOptions->setEntityManager($entityManager);
     $schemaTool = new SchemaTool($entityManager);
     // Add auditing listener
     $entityManager->getEventManager()->addEventSubscriber(new LogRevision());
     $sql = $schemaTool->getUpdateSchemaSql($entityManager->getMetadataFactory()->getAllMetadata());
     #print_r($sql);die();
     $schemaTool->createSchema($entityManager->getMetadataFactory()->getAllMetadata());
     $this->_em = $entityManager;
 }

 private function getUpdateBundleSqlSchema()
 {
     $sql = array();
     foreach ($this->_application->getBundles() as $bundle) {
         $classes = $this->_getBundleSchema($bundle);
         $sql = array_merge($sql, $this->_schemaTool->getUpdateSchemaSql($classes, true));
     }
     return $sql;
 }

 /**
  * Execute the console command.
  *
  * @return void
  */
 public function fire()
 {
     $this->info('Checking if database needs updating....');
     $clean = $this->option('clean');
     $sql = $this->tool->getUpdateSchemaSql($this->metadata->getAllMetadata(), !$clean);
     if (empty($sql)) {
         $this->info('No updates found.');
         return;
     }
     if ($this->option('sql')) {
         $this->info('Outputting update query:');
         $this->info(implode(';' . PHP_EOL, $sql));
     } else {
         $this->info('Updating database schema....');
         $this->tool->updateSchema($this->metadata->getAllMetadata(), !$clean);
         $this->info('Schema has been updated!');
     }
 }

 /**
  * @return string[]
  */
 protected function getUpdateQueries()
 {
     $cache = $this->entityManager->getConfiguration()->getMetadataCacheImpl();
     if ($cache instanceof ClearableCache) {
         $cache->deleteAll();
     }
     $schemaTool = new SchemaTool($this->entityManager);
     $metadata = $this->entityManager->getMetadataFactory()->getAllMetadata();
     $queries = $schemaTool->getUpdateSchemaSql($metadata, TRUE);
     return $queries;
 }

 /**
  * @group DDC-1657
  */
 public function testUpdateSchemaWithPostgreSQLSchema()
 {
     $classes = array($this->_em->getClassMetadata(__NAMESPACE__ . '\\DDC1657Screen'), $this->_em->getClassMetadata(__NAMESPACE__ . '\\DDC1657Avatar'));
     $tool = new SchemaTool($this->_em);
     $tool->createSchema($classes);
     $sql = $tool->getUpdateSchemaSql($classes);
     $sql = array_filter($sql, function ($sql) {
         return strpos($sql, "DROP SEQUENCE stonewood.") === 0;
     });
     $this->assertCount(0, $sql, implode("\n", $sql));
 }

 public function fire()
 {
     $this->info('Checking if database needs updating....');
     $sql = $this->tool->getUpdateSchemaSql($this->metadata->getAllMetadata(), $this->option('clean'));
     if (empty($sql)) {
         $this->info('No updates found.');
         return;
     }
     if ($this->option('sql')) {
         $this->info('Outputting update query:');
         $this->info(implode(';' . PHP_EOL, $sql) . ';');
     } else {
         if ($this->option('commit')) {
             $this->info('Updating database schema....');
             $this->tool->updateSchema($this->metadata->getAllMetadata());
             $this->info('Schema has been updated!');
         } else {
             $this->comment("Warning: this command can cause data loss. Run with --sql or --commit.");
         }
     }
 }

 protected function executeSchemaCommand(InputInterface $input, OutputInterface $output, SchemaTool $schemaTool, array $metadatas)
 {
     // Defining if update is complete or not (--complete not defined means $saveMode = true)
     $saveMode = $input->getOption('complete') === true;
     if ($input->getOption('dump-sql') === true) {
         $sqls = $schemaTool->getUpdateSchemaSql($metadatas, $saveMode);
         $output->write(implode(';' . PHP_EOL, $sqls) . PHP_EOL);
     } else {
         $output->write('Updating database schema...' . PHP_EOL);
         $schemaTool->updateSchema($metadatas, $saveMode);
         $output->write('Database schema updated successfully!' . PHP_EOL);
     }
 }

 protected function executeSchemaCommand(InputInterface $input, OutputInterface $output, SchemaTool $schemaTool, array $metadatas)
 {
     // Defining if update is complete or not (--complete not defined means $saveMode = true)
     $saveMode = $input->getOption('complete') !== true;
     if ($input->getOption('dump-sql') === true) {
         $sqls = $schemaTool->getUpdateSchemaSql($metadatas, $saveMode);
         $output->write(implode(';' . PHP_EOL, $sqls) . PHP_EOL);
     } else {
         if ($input->getOption('force') === true) {
             $output->write('Updating database schema...' . PHP_EOL);
             $schemaTool->updateSchema($metadatas, $saveMode);
             $output->write('Database schema updated successfully!' . PHP_EOL);
         } else {
             $sqls = $schemaTool->getUpdateSchemaSql($metadatas, $saveMode);
             if (count($sqls)) {
                 $output->write('Schema-Tool would execute ' . count($sqls) . ' queries to update the database.' . PHP_EOL);
                 $output->write('Please run the operation with --force to execute these queries or use --dump-sql to see them.' . PHP_EOL);
             } else {
                 $output->write('Nothing to update. The database is in sync with the current entity metadata.' . PHP_EOL);
             }
         }
     }
 }

 private function checkThatNewConstraintsCanBeApplied(EntityManager $em)
 {
     $tool = new SchemaTool($em);
     $metas = $em->getMetadataFactory()->getAllMetadata();
     // Bad ordering of Indexes changes in Doctrine DBAL-2.5
     $sqls = $tool->getUpdateSchemaSql($metas, true);
     foreach ($sqls as $sql) {
         if ('DROP INDEX usr_id ON Sessions' === $sql) {
             $em->getConnection()->executeQuery($sql);
         }
     }
     // End patching DBAL-2.5
     $tool->updateSchema($metas, true);
 }