Gets the metadata factory used to gather the metadata of classes.
public getMetadataFactory ( ) : Doctrine\ORM\Mapping\ClassMetadataFactory | ||
Результат | Doctrine\ORM\Mapping\ClassMetadataFactory |
public static function getMetadata() { /** @var EntityManagerInterface $em */ static::$em = static::$kernel->getContainer()->get('doctrine')->getManager(); $metadata = static::$em->getMetadataFactory()->getAllMetadata(); return $metadata; }
public function convert($cacheDir) { $fs = new Filesystem(); $targetDir = $cacheDir . '/js_entities'; $webDir = $this->kernel->getRootDir() . '/../web/js'; $fs->mkdir($targetDir); $fs->mkdir($webDir); $namespaces = []; $metas = $this->entityManager->getMetadataFactory()->getAllMetadata(); foreach ($metas as $metadata) { $meta = $this->convertMetadata($metadata); $directory = $targetDir . '/' . $meta->namespace; $fs->mkdir($directory); $meta->filename = $directory . '/' . $meta->functionName . '.js'; $this->generator->generateEntity($meta); if (!isset($namespaces[$meta->namespace])) { $namespaces[$meta->namespace] = array(); } $namespaces[$meta->namespace][] = $meta; } foreach ($namespaces as $namespace => $metas) { $targetFile = $targetDir . '/' . $namespace . '.js'; $webFile = $webDir . '/' . $namespace . '.js'; $this->generator->generateNamespace($namespace, $metas, $targetFile); $fs->copy($targetFile, $webFile); } }
/** * @param LoadClassMetadataEventArgs $args */ public function loadClassMetadata(LoadClassMetadataEventArgs $args) { $this->em = $args->getEntityManager(); $this->meta = $args->getClassMetadata(); if (!$this->em->getConnection()->getWrappedConnection() instanceof AbstractConnection) { return; } if ($this->meta->customPersisterClassName === null) { $this->meta->setCustomPersisterClass(EntityPersister::class); } $this->markIndex(); foreach ($this->meta->fieldMappings as $property => &$mapping) { $this->remapIdentifier($property, $mapping); $this->remapVersion($property, $mapping); $this->markField($property, $mapping); } foreach ($this->meta->associationMappings as $property => &$mapping) { $this->remapAnyToOneAssociation($property, $mapping); $this->remapAnyToManyAssociation($property, $mapping); $this->remapManyToManyAssociation($property, $mapping); } if ($cache = $this->em->getMetadataFactory()->getCacheDriver()) { $cache->save($this->meta->name . '$CLASSMETADATA', $this->meta, null); } }
/** * Reads extension metadata * * @param ClassMetadataInfo $meta * @return array - the metatada configuration */ public function getExtensionMetadata(ClassMetadataInfo $meta) { if ($meta->isMappedSuperclass) { return; // ignore mappedSuperclasses for now } $config = array(); // collect metadata from inherited classes foreach (array_reverse(class_parents($meta->name)) as $parentClass) { // read only inherited mapped classes if ($this->_em->getMetadataFactory()->hasMetadataFor($parentClass)) { $this->_driver->readExtendedMetadata($this->_em->getClassMetadata($parentClass), $config); } } $this->_driver->readExtendedMetadata($meta, $config); $this->_driver->validateFullMetadata($meta, $config); if ($config) { // cache the metadata $cacheId = self::getCacheId($meta->name, $this->_extensionNamespace); if ($cacheDriver = $this->_em->getMetadataFactory()->getCacheDriver()) { $cacheDriver->save($cacheId, $config, null); } } return $config; }
/** * @throws \Doctrine\ORM\ORMException */ public function boot() { $this->serializer = SerializerBuilder::create()->setDebug($this->devMode)->build(); $this->entityFolder->create(); AnnotationRegistry::registerAutoloadNamespace('JMS\\Serializer\\Annotation', __DIR__ . '/../../../../vendor/jms/serializer/src'); $proxyDoctrineFolder = new Folder(sys_get_temp_dir() . '/doctrine'); $config = Setup::createAnnotationMetadataConfiguration([$this->entityFolder->absolute()], $this->isDevMode(), $proxyDoctrineFolder->absolute()); if ($this->cache !== null) { $config->setQueryCacheImpl($this->getCache()); $config->setResultCacheImpl($this->getCache()); } $this->entityManager = $this->createEntityManager($config); $debugStack = new DebugStack(); $this->entityManager->getConnection()->getConfiguration()->setSQLLogger($debugStack); if ($this->getFileCreation()->getContent() == 1) { return; } if ($proxyDoctrineFolder->isFolder()) { $proxyDoctrineFolder->removeFiles(); } $tool = new SchemaTool($this->entityManager); $metadatas = $this->entityManager->getMetadataFactory()->getAllMetadata(); $proxyDoctrineFolder->create(); $this->entityManager->getProxyFactory()->generateProxyClasses($metadatas, $proxyDoctrineFolder->absolute()); if ($this->cloudFoundryBoot->isInCloudFoundry()) { $tool->updateSchema($metadatas); } else { $tool->createSchema($metadatas); } $this->getFileCreation()->setContent(1); }
public function resetDatabase() { $metadatas = $this->em->getMetadataFactory()->getAllMetadata(); $tool = new \Doctrine\ORM\Tools\SchemaTool($this->em); $tool->dropDatabase(); $tool->createSchema($metadatas); }
public function __construct(EntityManager $em, $currencyClassName) { $this->em = $em; $this->currencyClassName = $currencyClassName; if (!$currencyClassName || !$this->em->getMetadataFactory()->hasMetadataFor($currencyClassName) && !$this->em->getClassMetadata($currencyClassName)) { throw new \Exception("Class for currency \"{$currencyClassName}\" not found"); } }
protected function init() { $this->em = $this->app['em']; $this->connection = $this->em->getConnection(); $this->schemaManager = $this->em->getConnection()->getSchemaManager(); $this->schemaTool = new \Doctrine\ORM\Tools\SchemaTool($this->em); $this->validator = new \Doctrine\ORM\Tools\SchemaValidator($this->em); $this->metadatas = $this->em->getMetadataFactory()->getAllMetadata(); }
/** * @return null */ protected function generateSchema() { $metadatas = $this->em->getMetadataFactory()->getAllMetadata(); if (!empty($metadatas)) { $tool = new \Doctrine\ORM\Tools\SchemaTool($this->em); $tool->dropSchema($metadatas); $tool->createSchema($metadatas); } }
private function createSchema() { $this->getProvider()->deleteDatabase($this->getDatabaseName()); $schemaTool = new SchemaTool($this->entityManager); $schemaTool->createSchema($this->entityManager->getMetadataFactory()->getAllMetadata()); $this->loadFixtures(); $this->getProvider()->backupDatabase($this->getDatabaseName()); self::$schemaExists = true; }
/** * @return array */ protected function getEntityClassesFromEntityManager() { $entityClasses = []; $metaData = $this->entityManager->getMetadataFactory()->getAllMetadata(); foreach ($metaData as $classMetaData) { $entityClasses[] = $classMetaData->getName(); } return $entityClasses; }
/** * @return ChoiceQuestion */ protected function getManagedEntities() { $metadata = $this->em->getMetadataFactory()->getAllMetadata(); $entities = []; /** @var ClassMetadata $meta */ foreach ($metadata as $index => $meta) { $entities[$index] = $meta->getReflectionClass()->getName(); } return $entities; }
public function setUp() { $dbParams = array('dbname' => 'metamodel_test', 'memory' => 'true', 'driver' => 'pdo_sqlite'); $config = Setup::createAnnotationMetadataConfiguration(array(__DIR__ . "/Fixture"), true); $this->em = EntityManager::create($dbParams, $config); $tool = new SchemaTool($this->em); $tool->createSchema($this->em->getMetadataFactory()->getAllMetadata()); $this->metaModel = new MetaModel(); $this->metaModel->addObjectManager(new EntityManagerBridge($this->em)); }
/** * Returns a list of all registered entities, converted to the ExtJS naming scheme (. instead of \) * * @return array */ public function getEntities() { $entities = array(); $meta = $this->em->getMetadataFactory()->getAllMetadata(); foreach ($meta as $m) { /** @var ClassMetadata $m */ $entities[] = $this->convertPHPToExtJSClassName($m->getName()); } return $entities; }
protected function setUp() { parent::setUp(); if (!isset(static::$_sharedConn)) { static::$_sharedConn = $this->_getDefaultConnection(); } $this->_em = $this->_getTestEntityManager(static::$_sharedConn); $this->_schemaTool = new \Doctrine\ORM\Tools\SchemaTool($this->_em); $this->_schemaTool->createSchema($this->_em->getMetadataFactory()->getAllMetadata()); }
public function getTargetAssociationMapping($target) { $className = get_class($className); $associations = $this->em->getMetadataFactory()->getMetadataFor($this->class); foreach ($associations as $name => $mapping) { if ($className === $mapping['targetEntity']) { return $mapping['targetEntity']; } } throw new \OutOfBoundsException("Could not find target entity association mapping for {$className}"); }
protected function getEntityManager() { if ($this->entityManager === null) { $config = Setup::createAnnotationMetadataConfiguration(array(__DIR__ . '/../../../Entity/'), true, null, null, false); $conn = array('driver' => 'pdo_sqlite', 'memory' => true); $this->entityManager = EntityManager::create($conn, $config); $schemaTool = new SchemaTool($this->entityManager); $schemaTool->createSchema($this->entityManager->getMetadataFactory()->getAllMetadata()); } return $this->entityManager; }
protected function setUp() { parent::setUp(); $this->containerBuilder = new ContainerBuilder(); $loader = new LexikFixturesMapperExtension(); $loader->load(array(), $this->containerBuilder); $this->em = $this->getMockSqliteEntityManager(); $schemaTool = new \Doctrine\ORM\Tools\SchemaTool($this->em); $schemaTool->dropSchema(array()); $schemaTool->createSchema($this->em->getMetadataFactory()->getAllMetadata()); }
/** * @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; }
public function testYamlClosureMapping() { $meta = $this->em->getClassMetadata(self::YAML_CLOSURE_CATEGORY); $cacheId = ExtensionMetadataFactory::getCacheId(self::YAML_CLOSURE_CATEGORY, 'Gedmo\\Tree'); $config = $this->em->getMetadataFactory()->getCacheDriver()->fetch($cacheId); $this->assertArrayHasKey('parent', $config); $this->assertEquals('parent', $config['parent']); $this->assertArrayHasKey('strategy', $config); $this->assertEquals('closure', $config['strategy']); $this->assertArrayHasKey('closure', $config); $this->assertEquals('Tree\\Fixture\\Closure\\CategoryClosure', $config['closure']); }
protected function setUp() { $config = Setup::createAnnotationMetadataConfiguration([__DIR__ . '/../Entity/'], true, null, null, false); $this->manager = EntityManager::create(['driver' => 'pdo_sqlite', 'memory' => true], $config); (new SchemaTool($this->manager))->createSchema($this->manager->getMetadataFactory()->getAllMetadata()); $this->manager->persist(new Person('john', 'John', 11, null)); $this->manager->persist(new Person('jane', 'Jane', 21, '*****@*****.**')); $this->manager->persist(new Person('joey', 'Joey', 31, '')); $this->manager->flush(); $this->manager->clear(); $this->transformer = SQLTransformerBuilder::make()->build(); }
/** * @param Bundle $bundle * @return ClassMetadata[] */ protected function getBundleMetadata(Bundle $bundle) { $bundleMetadata = []; $metadata = $this->em->getMetadataFactory()->getAllMetadata(); /** @var ClassMetadata $meta */ foreach ($metadata as $meta) { if (strpos($meta->getName(), $bundle->getNamespace()) !== false) { $bundleMetadata[] = $meta; } } return $bundleMetadata; }
/** * @param string $itemClass * @return bool */ public function supports($itemClass) { $itemClass = ltrim($itemClass, '\\'); /** @var ClassMetadata[] $metadata */ $metadata = $this->em->getMetadataFactory()->getAllMetadata(); foreach ($metadata as $meta) { if ($meta->name == $itemClass) { return true; } } return false; }
/** * @throws \Doctrine\DBAL\DBALException * @throws \Doctrine\ORM\ORMException * @throws \Doctrine\ORM\Tools\ToolsException * @author Andreas Glaser */ protected function setUp() { $conn = DriverManager::getConnection(['driver' => 'pdo_sqlite', 'dbname' => ':memory:', 'memory' => true]); $config = ORM\Tools\Setup::createAnnotationMetadataConfiguration([__DIR__ . '/../Entity'], true, null, null, false); $this->em = EntityManager::create($conn, $config); $schemaTools = new ORM\Tools\SchemaTool($this->em); $schemaTools->createSchema($this->em->getMetadataFactory()->getAllMetadata()); $loader = new DataFixtures\Loader(); $loader->addFixture(new Fixtures\ORM()); $executor = new DataFixtures\Executor\ORMExecutor($this->em, new DataFixtures\Purger\ORMPurger()); $executor->execute($loader->getFixtures()); }
protected function getConnection() { if (is_null($this->app)) { $this->app = $this->getApplication(); } $this->em = EntityManagerFactory::initializeTestEntityManager($this->app); $pdo = $this->em->getConnection()->getWrappedConnection(); $this->em->clear(); $tool = new \Doctrine\ORM\Tools\SchemaTool($this->em); $classes = $this->em->getMetadataFactory()->getAllMetadata(); $tool->dropSchema($classes); $tool->createSchema($classes); return $this->createDefaultDBConnection($pdo, 'fcms_test'); }
/** * @param string $className * @return array */ public function getResultByClassName($className) { $catalogNumberByClassName = []; $metadata = $this->em->getMetadataFactory()->getMetadataFor($this->getFullClassName($className)); $identifier = strtoupper(key(array_flip($metadata->getIdentifier()))); if (count($this->resultSet)) { foreach ($this->resultSet as $item) { if (!is_null($item[$identifier])) { $catalogNumberByClassName[] = $item['CATALOGNUMBER']; } } } return array_unique($catalogNumberByClassName); }
/** * Set up test env * * @return void */ public function setUp() { $this->eventDispatcher = new EventDispatcher(); $this->params = new CollectorParamBag(); $setup = Setup::createAnnotationMetadataConfiguration([ENTITIES], true); $this->em = EntityManager::create(['driver' => 'pdo_mysql', 'user' => 'user', 'password' => '', 'dbname' => 'warden'], $setup); // Setup Param Bag $this->params->add('query_limit', ['type' => 'integer', 'default' => 5, 'limit' => 5, 'value' => null, 'expression' => 'value >= limit']); // Sync the schema $this->schema = new SchemaTool($this->em); $this->schema->updateSchema($this->em->getMetadataFactory()->getAllMetadata(), true); // Events $this->start = new StartEvent(); $this->stop = new StopEvent($this->params); }
/** * @return array * @throws \Exception */ public function getEntityList() { $entityList = array(); /** @var ClassMetadata $entityMetadata */ foreach ($this->_entityManager->getMetadataFactory()->getAllMetadata() as $entityMetadata) { $entityClass = $entityMetadata->getName(); if (!$this->getEntityHasAdmin($entityClass)) { $entityList[] = $entityClass; } } if (!$entityList) { throw new \Exception("There is no doctrine entities without admin class in the system"); } return $entityList; }
public function testYamlClosureMapping() { if (!extension_loaded('apc') || !ini_get('apc.enable_cli')) { $this->markTestSkipped('APC extension is not loaded.'); } $meta = $this->em->getClassMetadata(self::YAML_CLOSURE_CATEGORY); $cacheId = ExtensionMetadataFactory::getCacheId(self::YAML_CLOSURE_CATEGORY, 'Gedmo\\Tree'); $config = $this->em->getMetadataFactory()->getCacheDriver()->fetch($cacheId); $this->assertArrayHasKey('parent', $config); $this->assertEquals('parent', $config['parent']); $this->assertArrayHasKey('strategy', $config); $this->assertEquals('closure', $config['strategy']); $this->assertArrayHasKey('closure', $config); $this->assertEquals('Tree\\Fixture\\Closure\\CategoryClosure', $config['closure']); }
/** * {@inheritdoc} */ public function purge() { $classes = array(); $metadatas = $this->em->getMetadataFactory()->getAllMetadata(); foreach ($metadatas as $metadata) { if (!$metadata->isMappedSuperclass) { $classes[] = $metadata; } } $commitOrder = $this->getCommitOrder($this->em, $classes); // Drop association tables first $orderedTables = $this->getAssociationTables($commitOrder); // Get platform parameters $platform = $this->em->getConnection()->getDatabasePlatform(); // Drop tables in reverse commit order for ($i = count($commitOrder) - 1; $i >= 0; --$i) { $class = $commitOrder[$i]; if ($class->isInheritanceTypeSingleTable() && $class->name != $class->rootEntityName || $class->isMappedSuperclass) { continue; } $orderedTables[] = $class->getQuotedTableName($platform); } $orderedTables = array_diff($orderedTables, $this->excludedTables); foreach ($orderedTables as $tbl) { if ($this->purgeMode === self::PURGE_MODE_DELETE) { $this->em->getConnection()->executeUpdate("DELETE FROM " . $tbl); } else { $this->em->getConnection()->executeUpdate($platform->getTruncateTableSQL($tbl, true)); } } }