Factory method to create EntityManager instances.
public static create ( mixed $conn, Doctrine\ORM\Configuration $config, Doctrine\Common\EventManager $eventManager = null ) : |
||
$conn | mixed | An array with the connection parameters or an existing Connection instance. |
$config | Doctrine\ORM\Configuration | The Configuration instance to use. |
$eventManager | Doctrine\Common\EventManager | The EventManager instance to use. |
Результат | The created EntityManager. |
/** * Because the EntityManager gets closed when there's an error, it needs to * be created again * * @return EntityManager * @throws ORMException */ protected function getEntityManager() { if (!$this->em) { $this->em = $this->getContainer()->get('doctrine.orm.entity_manager'); } if (!$this->em->isOpen()) { $this->em = $this->em->create($this->em->getConnection(), $this->em->getConfiguration()); } return $this->em; }
public function hydrate(Jarvis $app) { $app['doctrine.cache'] = function () { return new VoidCache(); }; $app['doctrine.annotation.driver'] = function () { return new AnnotationDriver(new AnnotationReader()); }; $app['entyMgr'] = function (Jarvis $app) : EntityManagerInterface { $settings = $app['doctrine.settings']; $cache = $app['doctrine.cache']; $config = Setup::createConfiguration($settings['debug'], $settings['proxies_dir'], $cache); $driver = $app['doctrine.annotation.driver']; if (isset($settings['entities_paths'])) { $driver->addPaths((array) $settings['entities_paths']); } AnnotationRegistry::registerLoader('class_exists'); $config->setMetadataDriverImpl($driver); $config->setAutoGenerateProxyClasses($settings['debug']); $config->setMetadataCacheImpl($cache); $config->setResultCacheImpl($cache); $config->setQueryCacheImpl($cache); $entyMgr = EntityManager::create($settings['dbal'], $config); if (isset($app['doctrine.orm.entyMgr.decorator']) && is_string($fqcn = $app['doctrine.orm.entyMgr.decorator']) && is_subclass_of($fqcn, EntityManagerDecorator::class)) { $entyMgr = new $fqcn($entyMgr); } $entyMgr->getEventManager()->addEventListener([Events::preRemove, Events::postRemove, Events::prePersist, Events::postPersist, Events::preUpdate, Events::postUpdate, Events::postLoad, Events::preFlush, Events::onFlush, Events::postFlush, Events::onClear], new EventListener($app)); $app->broadcast(DoctrineReadyEvent::READY_EVENT, new DoctrineReadyEvent($entyMgr)); return $entyMgr; }; $app['db_conn'] = function ($app) { $app['entyMgr']->getConnection(); }; $app->lock(['entyMgr', 'db_conn', 'doctrine.annotation.driver']); }
protected function getMockEntityManager() { $driver = $this->getMock('Doctrine\DBAL\Driver'); $driver->expects($this->once()) ->method('getDatabasePlatform') ->will($this->returnValue($this->getMock('Doctrine\DBAL\Platforms\MySqlPlatform'))); $conn = $this->getMock('Doctrine\DBAL\Connection', array(), array(array(), $driver)); $conn->expects($this->once()) ->method('getEventManager') ->will($this->returnValue($this->getMock('Doctrine\Common\EventManager'))); $config = $this->getMock('Doctrine\ORM\Configuration'); $config->expects($this->once()) ->method('getProxyDir') ->will($this->returnValue('test')); $config->expects($this->once()) ->method('getProxyNamespace') ->will($this->returnValue('Proxies')); $config->expects($this->once()) ->method('getMetadataDriverImpl') ->will($this->returnValue($this->getMock('Doctrine\ORM\Mapping\Driver\DriverChain'))); $em = EntityManager::create($conn, $config); return $em; }
public function __construct() { try { $conn = array("driver" => "pdo_mysql", "host" => "localhost", "port" => "3306", "user" => "root", "password" => "", "dbname" => "controle_gastos"); /* var_dump(__DIR__); var_dump(PP); exit; */ $loader = new \Doctrine\Common\ClassLoader("Entities", __DIR__); $loader->register(); $config = Setup::createAnnotationMetadataConfiguration(array("../../" . __DIR__ . "/app/models"), false); $em = EntityManager::create($conn, $config); $cmf = new DisconnectedClassMetadataFactory(); $cmf->setEntityManager($em); $em->getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping('set', 'string'); $em->getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping('enum', 'string'); $driver = new DatabaseDriver($em->getConnection()->getSchemaManager()); $em->getConfiguration()->setMetadataDriverImpl($driver); $metadata = $cmf->getAllMetadata(); $generator = new EntityGenerator(); $generator->setGenerateAnnotations(true); $generator->setGenerateStubMethods(true); $generator->setRegenerateEntityIfExists(true); $generator->setUpdateEntityIfExists(true); $generator->generate($metadata, "../../" . __DIR__ . "/app/models"); } catch (\Exception $e) { throw $e; } }
public function _initDoctrineEntityManager() { $this->bootstrap(array('classLoaders')); $zendConfig = $this->getOptions(); // parameters required for connecting to the database. // the required attributes are driver, host, user, password and dbname $connectionParameters = $zendConfig['doctrine']['connectionParameters']; // now initialize the configuration object $configuration = new DoctrineConfiguration(); // the metadata cache is used to avoid parsing all mapping information every time // the framework is initialized. //$configuration->setMetadataCacheImpl($this->getResource('doctrineCache')); //// for performance reasons, it is also recommended to use a result cache //$configuration->setResultCacheImpl($this->getResource('doctrineCache')); // if you set this option to true, Doctrine 2 will generate proxy classes for your entities // on the fly. This has of course impact on the performance and should therefore be disabled // in the production environment $configuration->setAutoGenerateProxyClasses($zendConfig['doctrine']['autoGenerateProxyClasses']); // the directory, where your proxy classes live $configuration->setProxyDir($zendConfig['doctrine']['proxyPath']); // the proxy classes' namespace $configuration->setProxyNamespace($zendConfig['doctrine']['proxyNamespace']); // the next option tells doctrine which description language we want to use for the mapping // information $configuration->setMetadataDriverImpl($configuration->newDefaultAnnotationDriver($zendConfig['doctrine']['entityPath'])); // next, we create an event manager $eventManager = new DoctrineEventManager(); // now we have everything required to initialize the entity manager $entityManager = DoctrineEntityManager::create($connectionParameters, $configuration, $eventManager); Zend_Registry::set('em', $entityManager); return $entityManager; }
/** * @return EntityManager * @throws ServiceNotRegisteredException */ public static function getEntityManager() { if (ServiceLocator::$entityManager === null) { ServiceLocator::$entityManager = EntityManager::create(['driver' => Config::DB_DRIVER, 'host' => Config::DB_HOST, 'dbname' => Config::DB_NAME, 'user' => Config::DB_USER, 'password' => Config::DB_PASS], Setup::createAnnotationMetadataConfiguration([__DIR__ . '/../Models'], Config::DEV_MODE, null, null, false)); } return ServiceLocator::checkAndReturn(ServiceLocator::$entityManager); }
public function register() { $this->container['object_manager'] = function () { $development = false; if (defined('ENVIRONMENT') && ENVIRONMENT === 'development') { $development = true; } $config = new Configuration(); if ($development) { $cache = new ArrayCache(); } else { $cache = new ApcCache(); } $config->setMetadataCacheImpl($cache); $mappings = $this->container->get('config')['orm']['mappings']; $config->setMetadataDriverImpl(new XmlDriver($mappings)); $proxyDir = $this->container->get('config')['orm']['proxy_dir']; $config->setProxyDir($proxyDir); $config->setQueryCacheImpl($cache); $config->setProxyNamespace('Jirro\\ORM\\Proxies'); if ($development) { $config->setAutoGenerateProxyClasses(true); } else { $config->setAutoGenerateProxyClasses(false); } $dbConnection = $this->container->get('db_connection'); $objectManager = ObjectManager::create($dbConnection, $config); return $objectManager; }; $this->container->inflector('Jirro\\Component\\ORM\\ObjectManagerAwareInterface')->invokeMethod('setObjectManager', ['object_manager']); }
public function createService(ServiceLocatorInterface $serviceLocator) { $config = $serviceLocator->get('config'); // The parameters in Doctrine 2 and ZF2 are slightly different. // Below is an example how we can reuse the db settings $doctrineDbConfig = (array) $config['db']; $doctrineDbConfig['driver'] = strtolower($doctrineDbConfig['driver']); if (!isset($doctrineDbConfig['dbname'])) { $doctrineDbConfig['dbname'] = $doctrineDbConfig['database']; } if (!isset($doctrineDbConfig['host'])) { $doctrineDbConfig['host'] = $doctrineDbConfig['hostname']; } if (!isset($doctrineDbConfig['user'])) { $doctrineDbConfig['user'] = $doctrineDbConfig['username']; } $doctrineConfig = Setup::createAnnotationMetadataConfiguration($config['doctrine']['entity_path'], true); $entityManager = DoctrineEntityManager::create($doctrineDbConfig, $doctrineConfig); if (isset($config['doctrine']['initializers'])) { $eventManager = $entityManager->getEventManager(); foreach ($config['doctrine']['initializers'] as $initializer) { $eventClass = new DoctrineEvent(new $initializer(), $serviceLocator); $eventManager->addEventListener(\Doctrine\ORM\Events::postLoad, $eventClass); } } if ($serviceLocator->has('doctrine-profiler')) { $profiler = $serviceLocator->get('doctrine-profiler'); $entityManager->getConfiguration()->setSQLLogger($profiler); } return $entityManager; }
/** * Creates a new EntityManager instance based on the provided configuration. * * $factory = new Doctrine_EMFactory; * $em = $factory->entity_manager(); * * @param string $db_group the name of the Kohana database config group to get connection information from * * @return \Doctrine\ORM\EntityManager */ public function entity_manager($db_group = 'default') { $config = $this->config->load('doctrine'); // Ensure the composer autoloader is registered require_once $config['composer_vendor_path'] . 'autoload.php'; // Create the Configuration class $orm_config = new Configuration(); // Create the metadata driver $driver = $this->create_annotation_driver(); $orm_config->setMetadataDriverImpl($driver); // Configure the proxy directory and namespace $orm_config->setProxyDir($config['proxy_dir']); $orm_config->setProxyNamespace($config['proxy_namespace']); if ($config->get('use_underscore_naming_strategy')) { $naming_strategy = new UnderscoreNamingStrategy($config->get('case_underscore_naming_strategy')); $orm_config->setNamingStrategy($naming_strategy); } // Configure environment-specific options if ($this->environment === Kohana::DEVELOPMENT) { $orm_config->setAutoGenerateProxyClasses(TRUE); $cache = new ArrayCache(); } else { $orm_config->setAutoGenerateProxyClasses(FALSE); $cache = new ApcCache(); } // Set the cache drivers $orm_config->setMetadataCacheImpl($cache); $orm_config->setQueryCacheImpl($cache); // Create the Entity Manager with the database connection information $em = EntityManager::create($this->get_connection_config($db_group), $orm_config); $this->register_custom_types($config); return $em; }
/** * @return \Doctrine\ORM\EntityManager */ protected function createEntityManager() { // event manager used to create schema before tests $eventManager = new EventManager(); $eventManager->addEventListener(array("preTestSetUp"), new SchemaSetupListener()); // doctrine xml configs and namespaces $configPathList = array(); if (is_dir(__DIR__ . '/../Resources/config/doctrine')) { $dir = __DIR__ . '/../Resources/config/doctrine'; $configPathList[] = $dir; $prefixList[$dir] = 'Kitpages\\DataGridBundle\\Entities'; } if (is_dir(__DIR__ . '/_doctrine/config')) { $dir = __DIR__ . '/_doctrine/config'; $configPathList[] = $dir; $prefixList[$dir] = 'Kitpages\\DataGridBundle\\Tests\\TestEntities'; } // create drivers (that reads xml configs) $driver = new \Symfony\Bridge\Doctrine\Mapping\Driver\XmlDriver($configPathList); $driver->setNamespacePrefixes($prefixList); // create config object $config = new Configuration(); $config->setMetadataCacheImpl(new ArrayCache()); $config->setMetadataDriverImpl($driver); $config->setProxyDir(__DIR__ . '/TestProxies'); $config->setProxyNamespace('Kitpages\\DataGridBundle\\Tests\\TestProxies'); $config->setAutoGenerateProxyClasses(true); //$config->setSQLLogger(new \Doctrine\DBAL\Logging\EchoSQLLogger()); // create entity manager $em = EntityManager::create(array('driver' => 'pdo_sqlite', 'path' => "/tmp/sqlite-test.db"), $config, $eventManager); return $em; }
private function loadDoctrineOrm(Application $app) { $self = $this; $app['db.orm.em'] = $app->share(function () use($self, $app) { return EntityManager::create($app['db'], $app['db.orm.config']); }); }
/** * @param array $database * @throws \Exception */ public function __construct($database = []) { $this->db = $database; foreach ($this->db as $key => $db) { $this->allDb[$key] = function () use($db) { $db['dev'] = isset($db['dev']) && $db['dev'] ? true : false; if (isset($db['db_url'])) { $dbParams = array('url' => $db['db_url']); } else { if (!isset($db['driver']) || !isset($db['user']) || !isset($db['pass']) || !isset($db['host']) || !isset($db['db'])) { throw new \Exception('Missing arguments for doctrine constructor'); } $dbParams = array('driver' => $this->getDriver($db['driver']), 'user' => $db['user'], 'password' => $db['pass'], 'host' => $db['host'], 'dbname' => $db['db'], 'charset' => isset($db['charset']) ? $db['charset'] : 'utf8'); } $evm = new EventManager(); if (isset($db['prefix'])) { $tablePrefix = new TablePrefix($db['prefix']); $evm->addEventListener(Events::loadClassMetadata, $tablePrefix); } $config = Setup::createAnnotationMetadataConfiguration($db['path'], $db['dev']); if (!$db['dev']) { $config->setQueryCacheImpl($db['cache']); $config->setResultCacheImpl($db['cache']); $config->setMetadataCacheImpl($db['cache']); } if (isset($db['functions']) && !empty($db['functions'])) { $config->setCustomDatetimeFunctions($db['functions']['customDatetimeFunctions']); $config->setCustomNumericFunctions($db['functions']['customNumericFunctions']); $config->setCustomStringFunctions($db['functions']['customStringFunctions']); } return EntityManager::create($dbParams, $config, $evm); }; } }
public function __construct($setConfigFiles = true) { if ($setConfigFiles) { $this->configFile = __DIR__ . '/../../../config.php'; $this->localConfigFile = __DIR__ . '/../../../config.local.php'; } parent::__construct(); $isDevMode = false; $cache = new \Doctrine\Common\Cache\FilesystemCache(__DIR__ . '/../../tmp'); $config = Setup::createConfiguration($isDevMode, __DIR__ . '/../../tmp', $cache); $config->setProxyDir(__DIR__ . '/../../tmp'); $config->setProxyNamespace('MyProject\\Proxies'); $config->setAutoGenerateProxyClasses(true); $paths = [__DIR__ . '/../Entity']; $driver = new \Doctrine\ORM\Mapping\Driver\AnnotationDriver(new AnnotationReader(), $paths); \Doctrine\Common\Annotations\AnnotationRegistry::registerLoader('class_exists'); $config->setMetadataDriverImpl($driver); //$config->setSQLLogger(new \Doctrine\DBAL\Logging\EchoSQLLogger()); $conn = ['driver' => 'mysqli', 'host' => '127.0.0.1', 'user' => $this->databaseFactory->getUserName(), 'password' => $this->databaseFactory->getPassword(), 'dbname' => $this->databaseFactory->getDatabaseName()]; $this->entityManager = EntityManager::create($conn, $config); $this->entityManager->getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping('enum', 'string'); \Doctrine\DBAL\Types\Type::addType('enum', StringType::class); $this->entityManager->getConfiguration()->addCustomStringFunction('DATE', DateFunction::class); $this->user = $this->entityManager->createQueryBuilder()->select('u')->from(Sources\Tests\Entity\User::class, 'u'); }
public function register(Application $app) { $dbConnection = array('driver' => 'pdo_mysql', 'host' => 'localhost', 'user' => 'root', 'password' => 'password', 'dbname' => 'icfs'); $config = \Doctrine\ORM\Tools\Setup::createAnnotationMetadataConfiguration(array(__DIR__ . "/Model"), true); $app['db.em'] = \Doctrine\ORM\EntityManager::create($dbConnection, $config); $app->register(new \Silex\Provider\DoctrineServiceProvider(), array('db.options' => $dbConnection)); }
/** * @param array $settings * @param bool $debug * @return EntityManager * @throws \Doctrine\ORM\ORMException */ public static function factory($settings, $debug = true) { if ($debug || !function_exists('apc_fetch')) { $cache = new ArrayCache(); } else { $cache = new ApcCache(); } $dbSettings = $settings['doctrine']; $config = new Configuration(); $config->setMetadataCacheImpl($cache); // Do not use default Annotation driver $driverImpl = new AnnotationDriver(new AnnotationReader(), $dbSettings['entities']); // Allow all annotations AnnotationRegistry::registerLoader('class_exists'); $config->setMetadataDriverImpl($driverImpl); $config->setQueryCacheImpl($cache); $config->setProxyDir($dbSettings['proxy_path']); $config->setProxyNamespace('Zaralab\\Doctrine\\Proxies'); if ($debug) { $config->setAutoGenerateProxyClasses(true); } else { $config->setAutoGenerateProxyClasses(false); } $connectionOptions = $dbSettings['dbal']; return EntityManager::create($connectionOptions, $config); }
/** * @param ServiceLocatorInterface $serviceLocator * @return \Doctrine\ORM\EntityManager * @throws \Doctrine\ORM\ORMException */ public function createService(ServiceLocatorInterface $serviceLocator) { $config = $serviceLocator->get('config'); //set the Doctrine configuration array $doctrineDbSettings = (array) $config['db']; $doctrineDbSettings['driver'] = strtolower($config['db']['driver']); $doctrineDbSettings['dbname'] = isset($config['db']['database']) ? $config['db']['database'] : null; $doctrineDbSettings['host'] = isset($config['db']['hostname']) ? $config['db']['hostname'] : null; $doctrineDbSettings['user'] = isset($config['db']['username']) ? $config['db']['username'] : null; $proxyPath = isset($config['doctrine']['proxy_dir']) ? $config['doctrine']['proxy_dir'] : null; $isDevMode = isset($config['doctrine']['is_dev_mode']) ? $config['doctrine']['is_dev_mode'] : false; $doctrineConfig = Setup::createAnnotationMetadataConfiguration($config['doctrine']['entity_path'], $isDevMode, $proxyPath); $doctrineConfig->setAutoGenerateProxyClasses(true); $doctrineEntityManager = DocEManager::create($doctrineDbSettings, $doctrineConfig); if (isset($config['doctrine']['initializers'])) { $eventManager = $doctrineEntityManager->getEventManager(); foreach ($config['doctrine']['initializers'] as $initializer) { $eventClass = new DoctrineEvent(new $initializer(), $serviceLocator); $eventManager->addEventListener(\Doctrine\ORM\Events::postLoad, $eventClass); } } if ($doctrineDbSettings['driver'] == 'pdo_sqlite') { //it is very important to make sure foreign keys are on with SQLite $query = $doctrineEntityManager->createNativeQuery("pragma foreign_keys=1", new \Doctrine\ORM\Query\ResultSetMapping()); $query->execute(); } return $doctrineEntityManager; }
public static function createEntityManager($database) { $config = new Doctrine\ORM\Configuration(); // annotations $annotationDriver = $config->newDefaultAnnotationDriver(array(APP_DIR . '/Model', NEURON_DIR . '/Model')); $config->setMetadataDriverImpl($annotationDriver); // proxy $config->setProxyNamespace('Neuron\\Proxy'); $config->setProxyDir(TEMP_DIR); // cache $cache = Environment::isProduction() ? new NetteDoctrineCache() : new Doctrine\Common\Cache\ArrayCache(); $config->setMetadataCacheImpl($cache); $config->setQueryCacheImpl($cache); // debugbar $config->setSQLLogger(Doctrine2Panel::getAndRegister()); // entity manager $em = Doctrine\ORM\EntityManager::create((array) $database, $config); $evm = $em->getEventManager(); $evm->addEventSubscriber(new Doctrine\DBAL\Event\Listeners\MysqlSessionInit("utf8", "utf8_czech_ci")); $evm->addEventSubscriber(new ValidationSubscriber()); $evm->addEventSubscriber(new CacheSubscriber()); $neonParser = new \Nette\NeonParser(); $aliases = $neonParser->parse(file_get_contents(APP_DIR . "/entityClassAliases.neon")); $evm->addEventSubscriber(new \Neuron\Model\Doctrine\EntityClassAliasesSubscriber($aliases)); return $em; }
protected static function getEntityManager($options) { $config = new \Doctrine\ORM\Configuration(); // Handling for class names specified as platform types. if ($options['conn']['platform']) { $class_obj = new \ReflectionClass($options['conn']['platform']); $options['conn']['platform'] = $class_obj->newInstance(); } // Special handling for the utf8mb4 type. if ($options['conn']['driver'] == 'pdo_mysql' && $options['conn']['charset'] == 'utf8mb4') { $options['conn']['platform'] = new \DF\Doctrine\Platform\MysqlUnicode(); } $metadata_driver = $config->newDefaultAnnotationDriver($options['modelPath']); $config->setMetadataDriverImpl($metadata_driver); $cache = new \DF\Doctrine\Cache(); // $cache->setNamespace('doctrine_'); $config->setMetadataCacheImpl($cache); $config->setQueryCacheImpl($cache); $config->setResultCacheImpl($cache); $config->setProxyDir($options['proxyPath']); $config->setProxyNamespace($options['proxyNamespace']); if (isset($options['conn']['debug']) && $options['conn']['debug']) { $config->setSQLLogger(new \DF\Doctrine\Logger\EchoSQL()); } $config->addFilter('softdelete', '\\DF\\Doctrine\\Filter\\SoftDelete'); $config->addCustomNumericFunction('RAND', '\\DF\\Doctrine\\Functions\\Rand'); $evm = new \Doctrine\Common\EventManager(); $em = \Doctrine\ORM\EntityManager::create($options['conn'], $config, $evm); $em->getFilters()->enable("softdelete"); // Try the connection before rendering the page. $em->getConnection()->connect(); return $em; }
public function __construct($configDir, $environment = 'dev') { if (!@file_exists("{$configDir}/config.yml")) { throw new \Exception("File: {$configDir}/config.yml does not exist."); } if (!@file_exists("{$configDir}/config_{$environment}.yml")) { throw new \Exception("File: {$configDir}/config_{$environment}.yml does not exist."); } try { $config = Yaml\Yaml::parse("{$configDir}/config.yml"); $configEnv = Yaml\Yaml::parse("{$configDir}/config_{$environment}.yml"); } catch (Yaml\Exception\ParseException $e) { throw new \Exception($e->getMessage()); } $this->config = Arr::merge($config, $configEnv); $entityPaths = Arr::get($this->config, 'doctrine.entity.paths', array()); $proxiesPath = Arr::get($this->config, 'doctrine.proxy.path', ''); $proxiesNamespace = Arr::get($this->config, 'doctrine.proxy.namespace', ''); $database = Arr::get($this->config, 'doctrine.database', array()); $isDevMode = Arr::get($this->config, 'doctrine.isDevMode', TRUE); $this->cache = new \Doctrine\Common\Cache\ArrayCache(); $this->reader = new AnnotationReader(); $this->driver = new \Doctrine\ORM\Mapping\Driver\AnnotationDriver($this->reader, $entityPaths); $this->config = Setup::createAnnotationMetadataConfiguration($entityPaths, $isDevMode); $this->config->setMetadataCacheImpl($this->cache); $this->config->setQueryCacheImpl($this->cache); $this->config->setMetadataDriverImpl($this->driver); $this->config->setProxyDir($proxiesPath); $this->config->setProxyNamespace($proxiesNamespace); $this->config->setAutoGenerateProxyClasses($isDevMode); $this->entityManager = EntityManager::create($database, $this->config); $this->platform = $this->entityManager->getConnection()->getDatabasePlatform(); $this->platform->registerDoctrineTypeMapping('enum', 'string'); }
protected function setUp() { parent::setUp(); $this->connection = DriverManager::getConnection(['driver' => 'pdo_sqlite', 'path' => self::SQLITE_PATH], new Configuration()); $config = Setup::createAnnotationMetadataConfiguration([__DIR__ . '/../..'], true); $this->entityManager = EntityManager::create($this->connection, $config); }
public function __construct(Configuration $configuration) { $driver = new PHPDriver(__DIR__ . '/../Mapping/'); $config = Setup::createConfiguration($configuration['debug']); $config->setMetadataDriverImpl($driver); $this->entityManager = EntityManager::create($configuration['database']['write_connection'], $config); }
public function register(Application $app) { //Load Doctrine Configuration $app['db.configuration'] = $app->share(function () use($app) { AnnotationRegistry::registerAutoloadNamespace("Doctrine\\ORM\\Mapping", __DIR__ . '/../../../../../doctrine/orm/lib'); $config = new ORMConfiguration(); $cache = $app['debug'] == false ? new ApcCache() : new ArrayCache(); $config->setMetadataCacheImpl($cache); $config->setQueryCacheImpl($cache); $chain = new DriverChain(); foreach ((array) $app['db.orm.entities'] as $entity) { switch ($entity['type']) { case 'annotation': $reader = new AnnotationReader(); $driver = new AnnotationDriver($reader, (array) $entity['path']); $chain->addDriver($driver, $entity['namespace']); break; /*case 'yml': $driver = new YamlDriver((array)$entity['path']); $driver->setFileExtension('.yml'); $chain->addDriver($driver, $entity['namespace']); break; case 'xml': $driver = new XmlDriver((array)$entity['path'], $entity['namespace']); $driver->setFileExtension('.xml'); $chain->addDriver($driver, $entity['namespace']); break;*/ /*case 'yml': $driver = new YamlDriver((array)$entity['path']); $driver->setFileExtension('.yml'); $chain->addDriver($driver, $entity['namespace']); break; case 'xml': $driver = new XmlDriver((array)$entity['path'], $entity['namespace']); $driver->setFileExtension('.xml'); $chain->addDriver($driver, $entity['namespace']); break;*/ default: throw new \InvalidArgumentException(sprintf('"%s" is not a recognized driver', $type)); break; } } $config->setMetadataDriverImpl($chain); $config->setProxyDir($app['db.orm.proxies_dir']); $config->setProxyNamespace($app['db.orm.proxies_namespace']); $config->setAutoGenerateProxyClasses($app['db.orm.auto_generate_proxies']); return $config; }); //Set Defaut Configuration $defaults = array('entities' => array(array('type' => 'annotation', 'path' => 'Entity', 'namespace' => 'Entity')), 'proxies_dir' => 'cache/doctrine/Proxy', 'proxies_namespace' => 'DoctrineProxy', 'auto_generate_proxies' => true); foreach ($defaults as $key => $value) { if (!isset($app['db.orm.' . $key])) { $app['db.orm.' . $key] = $value; } } $self = $this; $app['db.orm.em'] = $app->share(function () use($self, $app) { return EntityManager::create($app['db'], $app['db.configuration']); }); }
public function register(Application $app) { $app['orm.em.paths'] = $app->share(function () { return array(); }); $app['orm.event_manager'] = $app->share(function () use($app) { return new EventManager(); }); $app['orm.config'] = $app->share(function () use($app) { return Setup::createConfiguration($app['debug']); }); $app['orm.anotation_reader'] = $app->share(function () use($app) { $annotationReader = new AnnotationReader(); $cache = $app['orm.config']->getMetadataCacheImpl(); return new CachedReader($annotationReader, $cache); }); $app['orm.default_anotation_driver'] = $app->share(function () use($app) { AnnotationRegistry::registerFile($app['vendor_dir'] . '/doctrine/orm/lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php'); return new AnnotationDriver($app['orm.anotation_reader'], $app['orm.em.paths']); }); $app['orm.em'] = $app->share(function () use($app) { $annotationReader = $app['orm.anotation_reader']; $eventManager = $app['orm.event_manager']; $driverChain = new MappingDriverChain(); $driverChain->setDefaultDriver($app['orm.default_anotation_driver']); DoctrineExtensions::registerMappingIntoDriverChainORM($driverChain, $annotationReader); $loggableListener = new LoggableListener(); $loggableListener->setAnnotationReader($annotationReader); $loggableListener->setUsername('admin'); $eventManager->addEventSubscriber($loggableListener); $config = $app['orm.config']; $config->setMetadataDriverImpl($driverChain); return EntityManager::create($app['db.default_options'], $config, $eventManager); }); }
public function __invoke(ContainerInterface $container) { if (!$container->has(Configuration::class) || !$container->has(EventManager::class) || !$container->has(Connection::class)) { throw new ContainerNotRegisteredException('Doctrine\\Common\\EventManager::class, Doctrine\\ORM\\Configuration::class and Doctrine\\DBAL\\Connection::class must be registered in the container'); } $config = $container->has('config') ? $container->get('config') : []; $underscoreNamingStrategy = isset($config['doctrine']['orm']['underscore_naming_strategy']) ? $config['doctrine']['orm']['underscore_naming_strategy'] : false; /** @var Configuration $configuration */ $configuration = $container->get(Configuration::class); $configuration->setProxyDir(isset($config['doctrine']['orm']['proxy_dir']) ? $config['doctrine']['orm']['proxy_dir'] : 'data/cache/EntityProxy'); $configuration->setProxyNamespace(isset($config['doctrine']['orm']['proxy_namespace']) ? $config['doctrine']['orm']['proxy_namespace'] : 'EntityProxy'); $configuration->setAutoGenerateProxyClasses(isset($config['doctrine']['orm']['auto_generate_proxy_classes']) ? $config['doctrine']['orm']['auto_generate_proxy_classes'] : false); // ORM mapping by Annotation AnnotationRegistry::registerFile('vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php'); $driver = new AnnotationDriver(new AnnotationReader(), ['data/cache/doctrine']); $configuration->setMetadataDriverImpl($driver); // Cache $cache = $container->get(Cache::class); $configuration->setQueryCacheImpl($cache); $configuration->setResultCacheImpl($cache); $configuration->setMetadataCacheImpl($cache); return EntityManager::create($container->get(Connection::class), $configuration, $container->get(EventManager::class)); }
/** * Initialize Doctrine * @return Doctrine_Manager */ public function _initDoctrine() { // include and register Doctrine's class loader require_once 'Doctrine/Common/ClassLoader.php'; $classLoader = new \Doctrine\Common\ClassLoader('Doctrine', APPLICATION_PATH . '/../library/'); $classLoader->register(); // create the Doctrine configuration $config = new \Doctrine\ORM\Configuration(); // setting the cache ( to ArrayCache. Take a look at // the Doctrine manual for different options ! ) $cache = new \Doctrine\Common\Cache\ArrayCache(); $config->setMetadataCacheImpl($cache); $config->setQueryCacheImpl($cache); // choosing the driver for our database schema // we'll use annotations $driver = $config->newDefaultAnnotationDriver(APPLICATION_PATH . '/models'); $config->setMetadataDriverImpl($driver); // set the proxy dir and set some options $config->setProxyDir(APPLICATION_PATH . '/models/Proxies'); $config->setAutoGenerateProxyClasses(true); $config->setProxyNamespace('App\\Proxies'); // now create the entity manager and use the connection // settings we defined in our application.ini $connectionSettings = $this->getOption('doctrine'); $conn = array('driver' => $connectionSettings['conn']['driv'], 'user' => $connectionSettings['conn']['user'], 'password' => $connectionSettings['conn']['pass'], 'dbname' => $connectionSettings['conn']['dbname'], 'host' => $connectionSettings['conn']['host']); $entityManager = \Doctrine\ORM\EntityManager::create($conn, $config); // push the entity manager into our registry for later use $registry = Zend_Registry::getInstance(); $registry->entitymanager = $entityManager; return $entityManager; }
public function __construct() { // load database configuration from CodeIgniter require_once APPPATH . 'config/development/database.php'; // Set up class loading. You could use different autoloaders, provided by your favorite framework, // if you want to. require_once APPPATH . 'libraries/Doctrine/Common/ClassLoader.php'; $doctrineClassLoader = new ClassLoader('Doctrine', APPPATH . 'libraries'); $doctrineClassLoader->register(); $entitiesClassLoader = new ClassLoader('models', rtrim(APPPATH, "/")); $entitiesClassLoader->register(); $proxiesClassLoader = new ClassLoader('Proxies', APPPATH . 'models/proxies'); $proxiesClassLoader->register(); // Set up caches $config = new Configuration(); $cache = new ArrayCache(); $config->setMetadataCacheImpl($cache); $driverImpl = $config->newDefaultAnnotationDriver(array(APPPATH . 'models/Entities')); $config->setMetadataDriverImpl($driverImpl); $config->setQueryCacheImpl($cache); $config->setQueryCacheImpl($cache); // Proxy configuration $config->setProxyDir(APPPATH . '/models/proxies'); $config->setProxyNamespace('Proxies'); // Set up logger $logger = new EchoSQLLogger(); $config->setSQLLogger($logger); $config->setAutoGenerateProxyClasses(TRUE); // Database connection information $connectionOptions = array('driver' => 'pdo_mysql', 'user' => $db['default']['username'], 'password' => $db['default']['password'], 'host' => $db['default']['hostname'], 'dbname' => $db['default']['database']); // Create EntityManager $this->em = EntityManager::create($connectionOptions, $config); }
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; }
public function register(Application $app) { $paths = array(realpath($app['config']['doctrine']['paths']['entity'])); $isDevMode = $app['config']['doctrine']['devMode']; $config = Setup::createAnnotationMetadataConfiguration($paths, $isDevMode, null, null, false); $app['doctrine'] = EntityManager::create($app['config']['doctrine']['db'], $config); }
private function initDB() { require_once APPPATH . 'config/database.php'; // Database connection information $dbParams = array('driver' => 'pdo_mysql', 'user' => "helpie38_neo", 'password' => "x#rnoPA;P}74", 'host' => "localhost", 'dbname' => "helpie38_main"); $path = array(APPPATH . 'BusinessLogic/Models/Entities'); $config = Doctrine\ORM\Tools\Setup::createAnnotationMetadataConfiguration($path, true); $config->addEntityNamespace("Entities", 'BusinessLogic\\Models\\Entities'); // $config->setResultCacheImpl(new \Doctrine\Common\Cache\ApcCache()); // $config->setQueryCacheImpl(new \Doctrine\Common\Cache\ApcCache()); // $config->setMetadataCacheImpl(new \Doctrine\Common\Cache\ApcCache()); //$config->setProxyDir("NeoMvc/Proxy"); //$config->setProxyNamespace("Proxy"); // $config->setResultCacheImpl(new \Doctrine\Common\Cache\ArrayCache()); // $config->setQueryCacheImpl(new \Doctrine\Common\Cache\ArrayCache()); // $config->setMetadataCacheImpl(new \Doctrine\Common\Cache\ArrayCache()); require_once APPPATH . "libraries/UVd/DoctrineFunction/DateFormat.php"; $config->addCustomStringFunction("DATE_FORMAT", "\\UVd\\DoctrineFunction\\DateFormat"); $config->setAutoGenerateProxyClasses(true); $em = EntityManager::create($dbParams, $config); try { // $this->updateSchema($em); } catch (\Exception $e) { echo $e->getMessage(); } return $em; }
public static function _init_manager($connection) { $settings = static::connection_settings($connection); $config = new \Doctrine\ORM\Configuration(); $cache = static::_init_cache($settings); if ($cache) { $config->setMetadataCacheImpl($cache); $config->setQueryCacheImpl($cache); $config->setResultCacheImpl($cache); } $config->setProxyDir($settings['proxy_dir']); $config->setProxyNamespace($settings['proxy_namespace']); $config->setAutoGenerateProxyClasses(\Arr::get($settings, 'auto_generate_proxy_classes', false)); $config->setMetadataDriverImpl(static::_init_metadata($config, $settings)); $EventManager = new \Doctrine\Common\EventManager(); static::$_managers[$connection] = \Doctrine\ORM\EntityManager::create($settings['connection'], $config, $EventManager); if (!empty($settings['profiling'])) { static::$_managers[$connection]->getConnection()->getConfiguration()->setSQLLogger(new Doctrine\Logger($connection)); } // Connection init callback if (!empty($settings['init_callback'])) { // If array merge combined this numeric array, grab last two array elements as the real callback if (is_array($settings['init_callback']) && count($settings['init_callback']) > 2) { $settings['init_callback'] = array_slice($settings['init_callback'], -2); } call_user_func($settings['init_callback'], static::$_managers[$connection], $connection); } }