Drops all elements in the database of the current connection.
| public dropDatabase ( ) : void | ||
| Результат | void | |
protected function tearDown()
{
// Clean anything still idle in the UOW
$this->_em->clear();
// Clear out anything set in the db (schema is recreated on setUp()
$this->_schemaTool->dropDatabase();
}
/**
* Builds the DB Schema
*
* @return void
*/
protected function rebuildDatabase()
{
# 2. Drop the existing database schema
$this->schemaTool->dropDatabase();
# 3. Create the new database schema based on (1)
$entityMeta = $this->em->getMetadataFactory()->getAllMetadata();
$this->schemaTool->updateSchema($entityMeta);
}
protected function tearDown()
{
parent::tearDown();
$tool = new SchemaTool($this->em);
$tool->dropDatabase();
unset($this->em);
}
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 loadFixtures($client)
{
$container = $this->getContainer($client);
$registry = $container->get('doctrine');
if ($registry instanceof ManagerRegistry) {
$om = $registry->getManager();
} else {
$om = $registry->getEntityManager();
}
$cacheDriver = $om->getMetadataFactory()->getCacheDriver();
if ($cacheDriver) {
$cacheDriver->deleteAll();
}
$connection = $om->getConnection();
$params = $connection->getParams();
$name = isset($params['path']) ? $params['path'] : (isset($params['dbname']) ? $params['dbname'] : false);
if (!$name) {
throw new \InvalidArgumentException("Connection does not contain a 'path' or 'dbname' parameter and cannot be dropped.");
}
$metadatas = $om->getMetadataFactory()->getAllMetadata();
$schemaTool = new SchemaTool($om);
$schemaTool->dropDatabase($name);
if (!empty($metadatas)) {
$schemaTool->createSchema($metadatas);
}
}
/**
* {@inheritDoc}
*/
public function dropSchema()
{
$this->foreachObjectManagers(function (ObjectManager $objectManager) {
$schemaTool = new DoctrineSchemaTool($objectManager);
$schemaTool->dropDatabase();
});
}
/**
* @param EntityManager $em
* @return SchemaTool
*/
private function createSchemaTool(EntityManager $em)
{
$schemaTool = new SchemaTool($em);
$schemaTool->dropDatabase();
$schemaTool->createSchema($em->getMetadataFactory()->getAllMetadata());
return $schemaTool;
}
public function preTestSetUp(EntityManagerEventArgs $eventArgs)
{
$em = $eventArgs->getEntityManager();
$classes = array($em->getClassMetadata(__NAMESPACE__ . '\\Date'));
$schemaTool = new SchemaTool($em);
$schemaTool->dropDatabase();
$schemaTool->createSchema($classes);
}
public function testSchemaDown()
{
$schemaTool = new SchemaTool($this->entityManager);
$schemaTool->dropDatabase();
$schemaManager = $this->entityManager->getConnection()->getSchemaManager();
$tables = $schemaManager->listTableNames();
$this->assertEmpty($tables);
}
public function setUp()
{
parent::setUp();
$em = $this->client->getContainer()->get('doctrine.orm.entity_manager');
$schemaTool = new SchemaTool($em);
$schemaTool->dropDatabase();
$schemaTool->createSchema($em->getMetadataFactory()->getAllMetadata());
}
/**
* Drops all databases
*
* @return void
*/
public function dropDatabases()
{
/** @var EntityManagerInterface[] $managers */
$managers = $this->get('doctrine')->getManagers();
foreach ($managers as $manager) {
$tool = new SchemaTool($manager);
$tool->dropDatabase();
}
}
public function preTestSetUp(EntityManagerEventArgs $eventArgs)
{
$em = $eventArgs->getEntityManager();
$schemaTool = new SchemaTool($em);
$cmf = $em->getMetadataFactory();
$classes = $cmf->getAllMetadata();
$schemaTool->dropDatabase();
$schemaTool->createSchema($classes);
}
protected function initializeInMemoryDB()
{
$entityManager = $this->getEntityManager();
// try a real schema creation with the in memory sqlite driver
$classes = $entityManager->getMetadataFactory()->getAllMetadata();
$schemaTool = new SchemaTool($entityManager);
$schemaTool->dropDatabase();
$schemaTool->createSchema($classes);
}
public function setUp()
{
self::$kernel = $this->createKernel(array('environment' => 'test'));
self::$kernel->boot();
$this->container = self::$kernel->getContainer();
$em = $this->container->get('doctrine')->getEntityManager();
$metadatas = $em->getMetadataFactory()->getAllMetadata();
$schemaTool = new SchemaTool($em);
$schemaTool->dropDatabase();
$schemaTool->createSchema($metadatas);
}
private function setupDatabase()
{
$params = SqliteConfig::getParams();
$entityManager = EntityManagerFactory::create($params);
$tmpConnection = DriverManager::getConnection($params);
$tmpConnection->getSchemaManager()->createDatabase($params['path']);
$schemaTool = new SchemaTool($entityManager);
$schemaTool->dropDatabase();
$metadata = $entityManager->getMetadataFactory()->getAllMetadata();
$schemaTool->createSchema($metadata);
}
public function createTestDb()
{
$em = $this->getEntityManager();
$tool = new SchemaTool($em);
$classes = array($em->getClassMetadata('PandaTest\\ExampleBundle\\entity\\Test'));
$tool->dropDatabase();
$tool->createSchema($classes);
$testEntity = $this->newEntity('Test', array('id' => 1, 'label' => 'test'));
$em->persist($testEntity);
$em->flush();
}
/**
* @before
*/
public function resetDatabase()
{
if (!property_exists($this, 'em')) {
throw new \Exception('No \'em\' property exists for this test case.');
}
if (!$this->em instanceof EntityManager) {
throw new \Exception('The \'em\' property needs to be an entity manager');
}
$schema = new SchemaTool($this->em);
$schema->dropDatabase();
$schema->createSchema($this->em->getMetadataFactory()->getAllMetadata());
}
/**
* setupBeforeClass
*
* @throws \Doctrine\ORM\Tools\ToolsException
*/
public static function setupBeforeClass()
{
static::$kernel = static::createKernel();
static::$kernel->boot();
// Creates the database schema
$emn = static::$kernel->getContainer()->get('doctrine.orm.entity_manager');
$schemaTool = new SchemaTool($emn);
$cmf = $emn->getMetadataFactory();
$classes = $cmf->getAllMetadata();
$schemaTool->dropDatabase();
$schemaTool->createSchema($classes);
}
/**
* Подготавливаем базу
*
*/
protected function setUp()
{
/** @noinspection PhpIncludeInspection */
$this->setApplicationConfig(include TestPaths::getPathToBindObjectToWorkflowEntryIntegrationTest());
/** @var \Doctrine\ORM\EntityManager $em */
$em = $this->getApplication()->getServiceManager()->get('doctrine.entitymanager.test');
$tool = new SchemaTool($em);
$tool->dropDatabase();
$metadata = $em->getMetadataFactory()->getAllMetadata();
$tool->createSchema($metadata);
parent::setUp();
}
public static function createMysqlTestEntityManager($user, $pass, $db, $host)
{
$con = DriverManager::getConnection(array('driver' => 'pdo_mysql', 'user' => $user, 'password' => $pass, 'dbname' => $db, 'host' => $host));
$em = self::createEm($con);
$tool = new SchemaTool($em);
try {
$tool->dropDatabase();
} catch (\Exception $ex) {
// tables did not exist
}
$tool->createSchema($em->getMetadataFactory()->getAllMetadata());
return $em;
}
public function setUp()
{
$em = $this->getContainer()->get('doctrine')->getManager();
if (!isset($metadatas)) {
$metadatas = $em->getMetadataFactory()->getAllMetadata();
}
$schemaTool = new SchemaTool($em);
$schemaTool->dropDatabase();
if (!empty($metadatas)) {
$schemaTool->createSchema($metadatas);
}
$this->postFixtureSetup();
}
public static function setUpBeforeClass()
{
$isDevMode = true;
$config = Setup::createAnnotationMetadataConfiguration(array(__DIR__ . "/../../../metadata/TestEntities"), $isDevMode, null, null, false);
$connectionOptions = array('driver' => 'pdo_sqlite', 'memory' => true);
// obtaining the entity manager
self::$em = EntityManager::create($connectionOptions, $config);
$schemaTool = new SchemaTool(self::$em);
$cmf = self::$em->getMetadataFactory();
$classes = $cmf->getAllMetadata();
$schemaTool->dropDatabase();
$schemaTool->createSchema($classes);
}
public function setUp()
{
// https://github.com/liip/LiipFunctionalTestBundle#non-sqlite
$em = $this->getContainer()->get('doctrine')->getManager();
if (!isset($metadatas)) {
$metadatas = $em->getMetadataFactory()->getAllMetadata();
}
$schemaTool = new SchemaTool($em);
$schemaTool->dropDatabase();
if (!empty($metadatas)) {
$schemaTool->createSchema($metadatas);
}
}
protected function generateSchema($em)
{
// Get the metadata from the application to create the schema.
$metadatas = $this->getMetadatas($em);
if (!empty($metadatas)) {
// Create SchemaTool
$tool = new SchemaTool($em);
$tool->dropDatabase();
$tool->createSchema($metadatas);
} else {
throw \Exception('No Metadata Classes to process.');
}
}
protected function createSchema()
{
// $classes = array();
// foreach (array_unique($this->entityClasses) as $className) {
// $classes[] = $this->app['orm.em']->getClassMetadata($className);
// }
$em = $this->app['orm.em'];
$classes = array_map(function ($className) use($em) {
return $em->getClassMetadata($className);
}, array_unique($this->entityClasses));
$schemaTool = new SchemaTool($this->app['orm.em']);
$schemaTool->dropDatabase();
$schemaTool->createSchema($classes);
}
protected function resetDatabase()
{
$em = $this->getContainer()->get('doctrine')->getManager();
if (!isset($metadatas)) {
$metadatas = $em->getMetadataFactory()->getAllMetadata();
}
$schemaTool = new SchemaTool($em);
$schemaTool->dropDatabase();
if (!empty($metadatas)) {
$schemaTool->createSchema($metadatas);
}
$this->postFixtureSetup();
$this->loadFixtures(['AppBundle\\DataFixtures\\ORM\\LoadCharacterData', 'AppBundle\\DataFixtures\\ORM\\LoadShipAndFactionData']);
}
public function setUp()
{
// https://github.com/liip/LiipFunctionalTestBundle#non-sqlite
$em = $this->getContainer()->get('doctrine')->getManager();
if (!isset($metadatas)) {
$metadatas = $em->getMetadataFactory()->getAllMetadata();
}
$schemaTool = new SchemaTool($em);
$schemaTool->dropDatabase();
if (!empty($metadatas)) {
$schemaTool->createSchema($metadatas);
}
// Needed to define the PHPCR root, used in fixtures.
$this->runCommand('doctrine:phpcr:repository:init');
}
/**
* @throws \Doctrine\ORM\Tools\ToolsException
*/
public static function setUpBeforeClass()
{
parent::setUpBeforeClass();
static::$kernel = static::createKernel(array());
static::$kernel->boot();
$metadata = static::getMetadata();
$tool = new SchemaTool(static::$em);
$tool->dropDatabase();
$tool->createSchema($metadata);
$validator = new SchemaValidator(static::$em);
$errors = $validator->validateMapping();
static::assertCount(0, $errors, implode("\n\n", array_map(function ($l) {
return implode("\n\n", $l);
}, $errors)));
}
public function setUp()
{
$config = new \Doctrine\ORM\Configuration();
$config->setMetadataCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$config->setQueryCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$config->setProxyDir(__DIR__ . '/Proxies');
$config->setProxyNamespace('DoctrineExtensions\\Tests\\PHPUnit\\Proxies');
$config->setAutoGenerateProxyClasses(true);
$config->setMetadataDriverImpl($config->newDefaultAnnotationDriver(__DIR__ . '/../../Entities'));
$this->em = \Doctrine\ORM\EntityManager::create(array('driver' => 'pdo_sqlite', 'memory' => true), $config);
$schemaTool = new SchemaTool($this->em);
$schemaTool->dropDatabase();
$schemaTool->createSchema(array($this->em->getClassMetadata('DoctrineExtensions\\Tests\\Entities\\ZendDate')));
$this->em->persist(new \DoctrineExtensions\Tests\Entities\ZendDate(1, new \Zend_Date(array('year' => 2012, 'month' => 11, 'day' => 10, 'hour' => 9, 'minute' => 8, 'second' => 7))));
$this->em->flush();
}
protected function setUp()
{
$this->client = self::createClient(array("debug" => false));
$container = $this->client->getContainer();
$doctrine = $container->get('doctrine');
$em = $doctrine->getEntityManager();
$schemaTool = new SchemaTool($em);
$mdf = $em->getMetadataFactory();
$classes = $mdf->getAllMetadata();
list($msec, $sec) = explode(" ", microtime());
$start = $sec + $msec;
$schemaTool->dropDatabase();
$schemaTool->createSchema($classes);
list($msec, $sec) = explode(" ", microtime());
$stop = $sec + $msec;
echo "\nDropping and creating schema time is " . round($stop - $start, 4) . " sec\n";
ob_flush();
}
