In any way when an exception is thrown it is supressed since drop was
issued for all classes of the schema and some probably just don't exist.
public dropSchema ( array $classes ) : void | ||
$classes | array | |
리턴 | void |
public function createSchema($table) { foreach (self::$classes as $meta) { if ($table === $meta->getTableName() || ".{$table}" === substr($meta->getTableName(), -strlen(".{$table}"))) { self::$tool->dropSchema([$meta]); self::$tool->createSchema([$meta]); } } }
public static function setUpBeforeClass() { $em = self::getEntityManager(); $metaData = $em->getMetadataFactory()->getAllMetadata(); self::$schemaTool = new SchemaTool($em); self::$schemaTool->dropSchema($metaData); self::$schemaTool->createSchema($metaData); static::prepareTestData($em); }
/** * {@inheritdoc} */ public static function doSetUpBeforeClass() { static::$schemaTool = new SchemaTool(static::$em); static::$schemaTool->dropSchema(static::getTablesMetadata()); static::$schemaTool->createSchema(static::getTablesMetadata()); static::$encoder = static::$container->get('security.encoder_factory'); static::$user = new User(); static::$user->setEmail('*****@*****.**'); static::$user->setPassword(static::$encoder->getEncoder(static::$user)->encodePassword('1234', static::$user->getSalt())); static::$user->setUsername('testUser'); $entityPermissionCategory = new PermissionCategory(); $entityPermissionCategory->setName('backend_user'); $entityPermissionCategory->setTechnicalName('backend_user'); static::$em->persist($entityPermissionCategory); $entityPermission = new Permission(); $entityPermission->setRoleName('IS_AUTHENTICATED_FULLY'); $entityPermission->setDescription('IS_AUTHENTICATED_FULLY'); $entityPermission->setName('IS_AUTHENTICATED_FULLY'); $entityPermission->setCategory($entityPermissionCategory); $entityPermission2 = new Permission(); $entityPermission2->setRoleName('ROLE_MANAGE_PERMISSIONS'); $entityPermission2->setDescription('ROLE_MANAGE_PERMISSIONS'); $entityPermission2->setName('ROLE_MANAGE_PERMISSIONS'); $entityPermission2->setCategory($entityPermissionCategory); $entityPermission3 = new Permission(); $entityPermission3->setRoleName('ROLE_ACCESS_BACKEND_TOOLS_SECURITY_SECTION'); $entityPermission3->setDescription('ROLE_ACCESS_BACKEND_TOOLS_SECURITY_SECTION'); $entityPermission3->setName('ROLE_ACCESS_BACKEND_TOOLS_SECURITY_SECTION'); $entityPermission3->setCategory($entityPermissionCategory); $entityPermission4 = new Permission(); $entityPermission4->setRoleName('ROLE_MANAGE_USER_PROFILES'); $entityPermission4->setDescription('ROLE_MANAGE_USER_PROFILES'); $entityPermission4->setName('ROLE_MANAGE_USER_PROFILES'); $entityPermission4->setCategory($entityPermissionCategory); static::$em->persist($entityPermission); static::$em->persist($entityPermission2); static::$em->persist($entityPermission3); static::$em->persist($entityPermission4); static::$em->flush(); $group = new Group(); $group->setRefName('BACKEND-USER'); $group->setName('backend-user'); $group->addPermission($entityPermission); $group->addPermission($entityPermission2); $group->addPermission($entityPermission3); $group->addPermission($entityPermission4); static::$user->addToGroup($group); static::$em->persist($group); static::$em->persist(static::$user); static::$em->flush(); }
/** * @inheritdoc */ protected function setUp() { parent::setUp(); $this->client = $this->createClient(['debug' => false]); $container = static::$kernel->getContainer(); /** @var EntityManagerInterface[] $managers */ $managers = $container->get('doctrine')->getManagers(); foreach ($managers as $manager) { $metadata = $manager->getMetadataFactory()->getAllMetadata(); if (!empty($metadata)) { $tool = new SchemaTool($manager); $tool->dropSchema($metadata); $tool->createSchema($metadata); } } $class = $container->getParameter('tree_house.keystone.model.user.class'); $salt = uniqid(); /** @var UserInterface $user */ $user = new $class(); $user->setEnabled(true); $user->setUsername('test'); $user->addRole('ROLE_USER'); $user->setSalt($salt); /** @var EncoderFactoryInterface $encoder */ $encoder = $container->get('security.encoder_factory'); $password = $encoder->getEncoder($class)->encodePassword(static::$password, $user->getSalt()); $user->setPassword($password); /** @var ManagerRegistry $doctrine */ $doctrine = static::$kernel->getContainer()->get('doctrine'); $manager = $doctrine->getManagerForClass($class); $manager->persist($user); $manager->flush($user); $manager->refresh($user); $this->user = $user; }
public static function clean(EntityManager $entityManager) { $metadatas = $entityManager->getMetadataFactory()->getAllMetadata(); $database = new SchemaTool($entityManager); $database->dropSchema($metadatas); $database->createSchema($metadatas); }
public function adminRefreshDatabaseAction(Request $request, Application $app) { $conn = $app['db']; $em = $app['doctrine.orm.entity_manager']; $params = $conn->getParams(); $name = isset($params['path']) ? $params['path'] : (isset($params['dbname']) ? $params['dbname'] : false); try { $conn->getSchemaManager()->dropDatabase($name); $conn->getSchemaManager()->createDatabase($name); $conn->close(); } catch (\Exception $e) { return 1; } $classes = []; foreach ($app['authbucket_oauth2.model'] as $class) { $classes[] = $em->getClassMetadata($class); } PersistentObject::setObjectManager($em); $tool = new SchemaTool($em); $tool->dropSchema($classes); $tool->createSchema($classes); $purger = new ORMPurger(); $executor = new ORMExecutor($em, $purger); $loader = new Loader(); $loader->loadFromDirectory(__DIR__ . '/../DataFixtures/ORM'); $executor->execute($loader->getFixtures()); return $app->redirect($app['url_generator']->generate('index')); }
protected function setUp() { if (!class_exists('Symfony\\Component\\Form\\Form')) { $this->markTestSkipped('The "Form" component is not available'); } if (!class_exists('Doctrine\\DBAL\\Platforms\\MySqlPlatform')) { $this->markTestSkipped('Doctrine DBAL is not available.'); } if (!class_exists('Doctrine\\Common\\Version')) { $this->markTestSkipped('Doctrine Common is not available.'); } if (!class_exists('Doctrine\\ORM\\EntityManager')) { $this->markTestSkipped('Doctrine ORM is not available.'); } $this->em = DoctrineOrmTestCase::createTestEntityManager(); parent::setUp(); $schemaTool = new SchemaTool($this->em); $classes = array($this->em->getClassMetadata(self::ENTITY_CLASS)); try { $schemaTool->dropSchema($classes); } catch (\Exception $e) { } try { $schemaTool->createSchema($classes); } catch (\Exception $e) { } $ids = range(1, 300); foreach ($ids as $id) { $name = 65 + chr($id % 57); $this->em->persist(new SingleIdentEntity($id, $name)); } $this->em->flush(); }
private function createDatabaseSchema(EntityManager $em) { $tool = new SchemaTool($em); $allMetadata = $em->getMetadataFactory()->getAllMetadata(); $tool->dropSchema($allMetadata); $tool->createSchema($allMetadata); }
/** * Execute the console command. * * @return void */ public function fire() { $sql = $this->tool->getDropSchemaSQL($this->metadata->getAllMetadata()); if (empty($sql)) { $this->info('Current models do not exist in schema.'); return; } if ($this->option('sql')) { $this->info('Outputting drop query:'); $this->info(implode(';' . PHP_EOL, $sql)); } else { $this->info('Dropping database schema....'); $this->tool->dropSchema($this->metadata->getAllMetadata()); $this->info('Schema has been dropped!'); } }
/** * Test setup */ protected function setUp() { // setup entity aliases $this->em = DoctrineTestHelper::createTestEntityManager(); $entityManagerNamespaces = $this->em->getConfiguration()->getEntityNamespaces(); $entityManagerNamespaces['WebtownPhpBannerBundle'] = 'WebtownPhp\\BannerBundle\\Entity'; $this->em->getConfiguration()->setEntityNamespaces($entityManagerNamespaces); // setup schema $schemaTool = new SchemaTool($this->em); $classes = []; foreach ($this->getEntities() as $entityClass) { $classes[] = $this->em->getClassMetadata($entityClass); } try { $schemaTool->dropSchema($classes); } catch (\Exception $e) { } try { $schemaTool->createSchema($classes); } catch (\Exception $e) { } $registry = \Mockery::mock('Doctrine\\Bundle\\DoctrineBundle\\Registry'); $registry->shouldReceive('getManager')->andReturn($this->em); $this->bm = new ORMManager($registry, new EventDispatcher()); }
/** * Initializes the database (once). * * @throws \Doctrine\DBAL\DBALException * @throws \Doctrine\ORM\ORMException * @throws \Doctrine\ORM\Tools\ToolsException */ protected function setUp() { if (null === static::$_conn) { $dbPath = __DIR__ . '/../../../db.sqlite'; if (file_exists($dbPath)) { unlink($dbPath); } $params = ['driver' => 'pdo_sqlite', 'path' => $dbPath]; static::$_conn = DriverManager::getConnection($params); static::$_conn->getConfiguration()->setSQLLogger(null); } if (null === static::$_em) { $paths = [__DIR__ . '/../../../../../src/Ekyna/Commerce/Bridge/Doctrine/ORM/Resources/mapping']; $isDevMode = true; $config = Setup::createXMLMetadataConfiguration($paths, $isDevMode); $em = EntityManager::create(static::$_conn, $config); $classes = []; foreach (static::$_classes as $class) { array_push($classes, $em->getClassMetadata($class)); } $schemaTool = new SchemaTool($em); $schemaTool->dropSchema($classes); $schemaTool->createSchema($classes); // Load fixtures $loader = new Loader(); $loader->loadFromDirectory(__DIR__ . '/../../../../../src/Ekyna/Commerce/Bridge/Doctrine/Fixtures'); $purger = new ORMPurger(); $executor = new ORMExecutor($em, $purger); $executor->execute($loader->getFixtures()); static::$_em = $em; } }
function testCreateSchema() { /* @var $em \Doctrine\ORM\EntityManager */ $em = $this->app["orm.em"]; $tool = new SchemaTool($em); //@note @doctrine générer les fichiers de classe à partir de métadonnées /* generate entity classes */ $dmf = new DisconnectedClassMetadataFactory(); $dmf->setEntityManager($em); $metadatas = $dmf->getAllMetadata(); //print_r($metadatas); $generator = new EntityGenerator(); $generator->setGenerateAnnotations(TRUE); $generator->setGenerateStubMethods(TRUE); $generator->setRegenerateEntityIfExists(TRUE); $generator->setUpdateEntityIfExists(TRUE); $generator->generate($metadatas, ROOT_TEST_DIR); $generator->setNumSpaces(4); $this->assertFileExists(ROOT_TEST_DIR . "/Entity/Post.php"); /* @note @doctrine générer la base de donnée à partir des métadonnées */ /* @see Doctrine\ORM\Tools\Console\Command\SchemaTool\CreateCommand */ /* generate database */ $tool->dropSchema($metadatas); $tool->createSchema($metadatas); $post = new \Entity\Post(); $post->setTitle("the title"); $em->persist($post); $em->flush(); $this->assertInternalType("int", $post->getId()); }
protected function initOrm(EntityManagerInterface $entityManager) { $schemaTool = new SchemaTool($entityManager); $metadatas = $entityManager->getMetadataFactory()->getAllMetadata(); $schemaTool->dropSchema($metadatas); $schemaTool->createSchema($metadatas); }
protected function executeSchemaCommand(InputInterface $input, OutputInterface $output, SchemaTool $schemaTool, array $metadatas) { $isFullDatabaseDrop = $input->getOption('full-database'); if ($input->getOption('dump-sql') === true) { if ($isFullDatabaseDrop) { $sqls = $schemaTool->getDropDatabaseSQL(); } else { $sqls = $schemaTool->getDropSchemaSQL($metadatas); } $output->write(implode(';' . PHP_EOL, $sqls) . PHP_EOL); } else { if ($input->getOption('force') === true) { $output->write('Dropping database schema...' . PHP_EOL); if ($isFullDatabaseDrop) { $schemaTool->dropDatabase(); } else { $schemaTool->dropSchema($metadatas); } $output->write('Database schema dropped successfully!' . PHP_EOL); } else { $output->write('ATTENTION: This operation should not be executed in a production environment.' . PHP_EOL . PHP_EOL); if ($isFullDatabaseDrop) { $sqls = $schemaTool->getDropDatabaseSQL(); } else { $sqls = $schemaTool->getDropSchemaSQL($metadatas); } if (count($sqls)) { $output->write('Schema-Tool would execute ' . count($sqls) . ' queries to drop 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 drop. The database is empty!' . PHP_EOL); } } } }
protected function setUp() { if (!class_exists('Symfony\\Component\\Form\\Form')) { $this->markTestSkipped('The "Form" component is not available'); } if (!class_exists('Doctrine\\DBAL\\Platforms\\MySqlPlatform')) { $this->markTestSkipped('Doctrine DBAL is not available.'); } if (!class_exists('Doctrine\\Common\\Version')) { $this->markTestSkipped('Doctrine Common is not available.'); } if (!class_exists('Doctrine\\ORM\\EntityManager')) { $this->markTestSkipped('Doctrine ORM is not available.'); } $this->em = DoctrineOrmTestCase::createTestEntityManager(); $this->emRegistry = $this->createRegistryMock('default', $this->em); parent::setUp(); $schemaTool = new SchemaTool($this->em); $classes = array($this->em->getClassMetadata(self::ITEM_GROUP_CLASS), $this->em->getClassMetadata(self::SINGLE_IDENT_CLASS), $this->em->getClassMetadata(self::SINGLE_STRING_IDENT_CLASS), $this->em->getClassMetadata(self::COMPOSITE_IDENT_CLASS), $this->em->getClassMetadata(self::COMPOSITE_STRING_IDENT_CLASS)); try { $schemaTool->dropSchema($classes); } catch (\Exception $e) { } try { $schemaTool->createSchema($classes); } catch (\Exception $e) { } }
protected function setUp() { parent::setUp(); if (!class_exists('Symfony\\Component\\Form\\Form')) { $this->markTestSkipped('The "Form" component is not available'); } if (!class_exists('Doctrine\\DBAL\\Platforms\\MySqlPlatform')) { $this->markTestSkipped('Doctrine DBAL is not available.'); } if (!class_exists('Doctrine\\Common\\Version')) { $this->markTestSkipped('Doctrine Common is not available.'); } if (!class_exists('Doctrine\\ORM\\EntityManager')) { $this->markTestSkipped('Doctrine ORM is not available.'); } $this->em = DoctrineTestHelper::createTestEntityManager(); $this->emRegistry = $this->createRegistryMock('default', $this->em); $this->items = array(); $schemaTool = new SchemaTool($this->em); $classes = array($this->em->getClassMetadata(self::SINGLE_INT_ID_CLASS)); try { $schemaTool->dropSchema($classes); } catch (\Exception $e) { } try { $schemaTool->createSchema($classes); } catch (\Exception $e) { } $this->createEntities(); $this->factory = Forms::createFormFactoryBuilder()->addExtensions($this->getExtensions())->addTypeExtension(new ChoiceSelect2TypeExtension($this->dispatcher, $this->requestStack, $this->router, $this->getExtensionTypeName(), 10))->addType(new EntityType($this->emRegistry))->addTypeExtension(new EntitySelect2TypeExtension())->getFormFactory(); $this->builder = new FormBuilder(null, null, $this->dispatcher, $this->factory); }
/** * do the thing here. */ protected function execute(InputInterface $input, OutputInterface $output) { $driver = new DoctrineAdapter(); $driver->init(); $em = $driver->getManager(); $schema = new SchemaTool($em); $models = []; $model_name = $input->getArgument('model_name'); $full_name = Config::getInstance()->get('root-namespace') . '\\Models' . '\\' . $model_name . 'Model'; $schemaManager = $em->getConnection()->getSchemaManager(); try { $metadata = $em->getClassMetadata($full_name); $table_name = $metadata->getTableName(); if ($schemaManager->tablesExist([$table_name]) == true) { $models[] = $metadata; } if (count($models) > 0) { $schema->dropSchema($models); } else { $output->writeln('O model ' . $full_name . ' nao esta registrado no banco de dados.'); } } catch (\Doctrine\ORM\Mapping\MappingException $e) { $output->writeln('Erro encontrado:'); $output->writeln($e->getMessage()); return; } $output->writeln('Tabela ' . $table_name . ' removida com sucesso.'); }
/** * do the thing here. */ protected function execute(InputInterface $input, OutputInterface $output) { $driver = new DoctrineAdapter(); $driver->init(); $em = $driver->getManager(); $classes = loadAppModels(); $schema = new SchemaTool($em); $models = []; try { $schemaManager = $em->getConnection()->getSchemaManager(); foreach ($classes as $class) { $metadata = $em->getClassMetadata($class); $table_name = $metadata->getTableName(); if ($schemaManager->tablesExist([$table_name]) == true) { array_push($models, $metadata); } } if (count($models) > 0) { $schema->dropSchema($models); } else { $output->writeln('Nao ha models exportados para o banco de dados'); } } catch (\Doctrine\ORM\Mapping\MappingException $e) { $output->writeln('Erro encontrado:'); $output->writeln($e->getMessage()); return; } $output->writeln('Tabelas removidas com sucesso.'); }
public function rebuildSchema() { $metadatas = $this->em->getMetadataFactory()->getAllMetadata(); $tool = new SchemaTool($this->em); $tool->dropSchema($metadatas); $tool->updateSchema($metadatas, false); }
private function dropAndCreateSchema() { $schemaTool = new SchemaTool($this->getEntityManager()); $metadata = $this->getEntityManager()->getMetadataFactory()->getAllMetadata(); $schemaTool->dropSchema($metadata); $schemaTool->createSchema($metadata); }
/** * Creates schema for doctrine entities * * @throws \Doctrine\ORM\Tools\ToolsException */ protected function createDoctrineSchema() { $metadata = $this->entityManager->getMetadataFactory()->getAllMetadata(); $tool = new SchemaTool($this->entityManager); $tool->dropSchema($metadata); $tool->createSchema($metadata); }
public function testReferenceReconstruction() { $em = $this->getMockSqliteEntityManager(); $referenceRepository = new ProxyReferenceRepository($em); $listener = new ORMReferenceListener($referenceRepository); $em->getEventManager()->addEventSubscriber($listener); $schemaTool = new SchemaTool($em); $schemaTool->dropSchema(array()); $schemaTool->createSchema(array($em->getClassMetadata(self::TEST_ENTITY_ROLE))); $roleFixture = new TestFixtures\RoleFixture(); $roleFixture->setReferenceRepository($referenceRepository); $roleFixture->load($em); // first test against managed state $ref = $referenceRepository->getReference('admin-role'); $this->assertNotInstanceOf('Doctrine\\ORM\\Proxy\\Proxy', $ref); // test reference reconstruction from serialized data (was managed) $serializedData = $referenceRepository->serialize(); $proxyReferenceRepository = new ProxyReferenceRepository($em); $proxyReferenceRepository->unserialize($serializedData); $ref = $proxyReferenceRepository->getReference('admin-role'); $this->assertInstanceOf('Doctrine\\ORM\\Proxy\\Proxy', $ref); // now test reference reconstruction from identity $em->clear(); $ref = $referenceRepository->getReference('admin-role'); $this->assertInstanceOf('Doctrine\\ORM\\Proxy\\Proxy', $ref); // test reference reconstruction from serialized data (was identity) $serializedData = $referenceRepository->serialize(); $proxyReferenceRepository = new ProxyReferenceRepository($em); $proxyReferenceRepository->unserialize($serializedData); $ref = $proxyReferenceRepository->getReference('admin-role'); $this->assertInstanceOf('Doctrine\\ORM\\Proxy\\Proxy', $ref); }
protected function setUp() { if (!class_exists('Doctrine\\Common\\Version')) { $this->markTestSkipped('Doctrine is not available.'); } $this->em = DoctrineOrmTestCase::createTestEntityManager(); parent::setUp(); $schemaTool = new SchemaTool($this->em); $classes = array( $this->em->getClassMetadata(self::SINGLE_IDENT_CLASS), $this->em->getClassMetadata(self::SINGLE_STRING_IDENT_CLASS), $this->em->getClassMetadata(self::COMPOSITE_IDENT_CLASS), $this->em->getClassMetadata(self::COMPOSITE_STRING_IDENT_CLASS), ); try { $schemaTool->dropSchema($classes); } catch(\Exception $e) { } try { $schemaTool->createSchema($classes); } catch(\Exception $e) { } }
public static function initDatabase() { $classes = self::getEntityManager()->getMetadataFactory()->getAllMetadata(); $schemaTool = new SchemaTool(self::getEntityManager()); $schemaTool->dropSchema($classes); $schemaTool->createSchema($classes); }
public function dropDb() { $em = $this->getEntityManager(); $tool = new SchemaTool($em); $tool->dropSchema($em->getMetadataFactory()->getAllMetadata()); $em->clear(); self::$hasDb = false; }
protected function rebuildDatabase() { $em = $this->getEntityManager(); $metadata = $em->getMetadataFactory()->getAllMetadata(); $schemaTool = new SchemaTool($em); $schemaTool->dropSchema($metadata); $schemaTool->createSchema($metadata); }
public function tearDown() { /** * @desc Despite throwing an exception in {@link self::setUp()}, PHPUnit * will still end up in this function. */ if ($this->em !== null) { if (false === $this->isTravis) { $this->em->getConnection()->close(); unset($this->em); return; } $this->tool->dropSchema($this->classes); $this->em->getConnection()->close(); unset($this->em); } }
protected function setUp() { $this->em = $this->getEntityManager(); $schemaTool = new SchemaTool($this->em); $classes = $this->em->getMetaDataFactory()->getAllMetadata(); $schemaTool->dropSchema($classes); $schemaTool->createSchema($classes); }
/** * @param string|null $managerName * * @throws \Doctrine\ORM\Tools\ToolsException */ public function resetDoctrineSchema($managerName = null) { $manager = $this->doctrine->getManager($managerName); $metadata = $manager->getMetadataFactory()->getAllMetadata(); $schemaTool = new SchemaTool($manager); $schemaTool->dropSchema($metadata); $schemaTool->createSchema($metadata); }
protected function setUp() { if (!class_exists('Symfony\\Component\\Form\\Form')) { $this->markTestSkipped('The "Form" component is not available'); } if (!class_exists('Doctrine\\DBAL\\Platforms\\MySqlPlatform')) { $this->markTestSkipped('Doctrine DBAL is not available.'); } if (!class_exists('Doctrine\\Common\\Version')) { $this->markTestSkipped('Doctrine Common is not available.'); } if (!class_exists('Doctrine\\ORM\\EntityManager')) { $this->markTestSkipped('Doctrine ORM is not available.'); } $this->em = DoctrineTestHelper::createTestEntityManager(); $schemaTool = new SchemaTool($this->em); $classes = array($this->em->getClassMetadata($this->getEntityClass())); try { $schemaTool->dropSchema($classes); } catch (\Exception $e) { } try { $schemaTool->createSchema($classes); } catch (\Exception $e) { } list($this->obj1, $this->obj2, $this->obj3, $this->obj4) = $this->createObjects(); $this->em->persist($this->obj1); $this->em->persist($this->obj2); $this->em->persist($this->obj3); $this->em->persist($this->obj4); $this->em->flush(); parent::setUp(); }