/** * @param ContainerInterface $container * @return EntityManager */ public function __invoke(ContainerInterface $container) { $config = $container->has('config') ? $container->get('config') : []; if (!isset($config['doctrine'])) { throw new ServiceNotCreatedException('Missing Doctrine configuration'); } $config = $config['doctrine']; $proxyDir = isset($config['proxy_dir']) ? $config['proxy_dir'] : 'data/DoctrineORM/Proxy'; $proxyNamespace = isset($config['proxy_namespace']) ? $config['proxy_namespace'] : 'DoctrineORM/Proxy'; $autoGenerateProxyClasses = isset($config['configuration']['auto_generate_proxy_classes']) ? $config['configuration']['auto_generate_proxy_classes'] : false; $underscoreNamingStrategy = isset($config['configuration']['underscore_naming_strategy']) ? $config['configuration']['underscore_naming_strategy'] : false; // Doctrine ORM $doctrine = new Configuration(); $doctrine->setProxyDir($proxyDir); $doctrine->setProxyNamespace($proxyNamespace); $doctrine->setAutoGenerateProxyClasses($autoGenerateProxyClasses); // Naming Strategy if ($underscoreNamingStrategy) { $doctrine->setNamingStrategy(new UnderscoreNamingStrategy()); } // ORM mapping by Annotation //AnnotationRegistry::registerAutoloadNamespace($config['driver']['annotations']['class']); AnnotationRegistry::registerFile('vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php'); $driver = new AnnotationDriver(new AnnotationReader(), $config['driver']['annotations']['paths']); $doctrine->setMetadataDriverImpl($driver); // Cache $cache = $container->get(\Doctrine\Common\Cache\Cache::class); $doctrine->setQueryCacheImpl($cache); $doctrine->setResultCacheImpl($cache); $doctrine->setMetadataCacheImpl($cache); // EntityManager return EntityManager::create($config['connection']['orm_default']['params'], $doctrine); }
/** * Setup doctrine cache * * @return void */ protected function setDoctrineCache() { static::$cacheDriver = static::getCacheDriverByOptions(\XLite::getInstance()->getOptions('cache')); $this->configuration->setMetadataCacheImpl(static::$cacheDriver); $this->configuration->setQueryCacheImpl(static::$cacheDriver); $this->configuration->setResultCacheImpl(static::$cacheDriver); }
/** * Get entity manager. * * @return EntityManagerInterface */ protected function getEntityManager() { if (null === $this->entityManager) { $params = ['driver' => 'pdo_sqlite', 'memory' => true]; $cache = new ArrayCache(); /** @var AnnotationReader $reader */ $reader = new CachedReader(new AnnotationReader(), $cache); $annotationDriver = new AnnotationDriver($reader, [__DIR__ . '/../../../src/ORM']); $driverChain = new MappingDriverChain(); $driverChain->addDriver($annotationDriver, Commander::ENTITY_NAMESPACE); DoctrineExtensions::registerAbstractMappingIntoDriverChainORM($driverChain, $reader); $config = new Configuration(); $config->setAutoGenerateProxyClasses(true); $config->setProxyDir(sys_get_temp_dir()); $config->setProxyNamespace(Commander::ENTITY_NAMESPACE); $config->setMetadataDriverImpl($driverChain); $config->setMetadataCacheImpl($cache); $config->setQueryCacheImpl($cache); $config->setResultCacheImpl($cache); $config->setHydrationCacheImpl($cache); $timestampableListener = new TimestampableListener(); $timestampableListener->setAnnotationReader($annotationDriver->getReader()); $eventManager = new EventManager(); $eventManager->addEventSubscriber($timestampableListener); $entityManager = EntityManager::create($params, $config, $eventManager); $schemaTool = new SchemaTool($entityManager); $schemaTool->createSchema($entityManager->getMetadataFactory()->getAllMetadata()); $this->entityManager = $entityManager; } return $this->entityManager; }
private function obterConfiguracao($dados) { $this->config = new Configuration(); // Definição do driver de mapeamento $metadata_driver = "Doctrine\\ORM\\Mapping\\Driver\\{$dados['metadata_driver']}"; if ($dados['metadata_driver'] == "AnnotationDriver") { $driver = $this->config->newDefaultAnnotationDriver(array(MODELO), true); } else { $driver = new $metadata_driver(CONFIG . DS . 'orm'); } if (!empty($dados['map_paths'])) { $driver->addPaths(preg_split('/, ?/', $dados['map_paths'])); } $this->config->setMetadataDriverImpl($driver); // Configurações de proxies $this->config->setProxyDir(RAIZ . DS . $dados['proxy_dir']); $this->config->setProxyNamespace($dados['proxy_namespace']); $this->config->setAutoGenerateProxyClasses($dados['auto_proxies']); // Definição da estratégia de caches de consultas e metadados $metadata_cache = "Doctrine\\Common\\Cache\\{$dados['metadata_cache']}"; $query_cache = "Doctrine\\Common\\Cache\\{$dados['query_cache']}"; $result_cache = "Doctrine\\Common\\Cache\\{$dados['query_cache']}"; $this->config->setMetadataCacheImpl(new $metadata_cache()); $this->config->setQueryCacheImpl(new $query_cache()); $this->config->setResultCacheImpl(new $result_cache()); // Ferramenta de log de consultas if (!empty($dados['sql_logger'])) { $sql_logger = "Doctrine\\DBAL\\Logging\\{$dados['sql_logger']}"; $logger = new $sql_logger(); $this->config->setSQLLogger($logger); } }
public function createService(ServiceLocatorInterface $serviceLocator) { /** @var $options \DoctrineORMModule\Options\Configuration */ $options = $this->getOptions($serviceLocator); $config = new Configuration(); $config->setAutoGenerateProxyClasses($options->getGenerateProxies()); $config->setProxyDir($options->getProxyDir()); $config->setProxyNamespace($options->getProxyNamespace()); $config->setEntityNamespaces($options->getEntityNamespaces()); $config->setCustomDatetimeFunctions($options->getDatetimeFunctions()); $config->setCustomStringFunctions($options->getStringFunctions()); $config->setCustomNumericFunctions($options->getNumericFunctions()); $config->setClassMetadataFactoryName($options->getClassMetadataFactoryName()); foreach ($options->getNamedQueries() as $name => $query) { $config->addNamedQuery($name, $query); } foreach ($options->getNamedNativeQueries() as $name => $query) { $config->addNamedNativeQuery($name, $query['sql'], new $query['rsm']()); } foreach ($options->getCustomHydrationModes() as $modeName => $hydrator) { $config->addCustomHydrationMode($modeName, $hydrator); } foreach ($options->getFilters() as $name => $class) { $config->addFilter($name, $class); } $config->setMetadataCacheImpl($serviceLocator->get($options->getMetadataCache())); $config->setQueryCacheImpl($serviceLocator->get($options->getQueryCache())); $config->setResultCacheImpl($serviceLocator->get($options->getResultCache())); $config->setHydrationCacheImpl($serviceLocator->get($options->getHydrationCache())); $config->setMetadataDriverImpl($serviceLocator->get($options->getDriver())); if ($namingStrategy = $options->getNamingStrategy()) { if (is_string($namingStrategy)) { if (!$serviceLocator->has($namingStrategy)) { throw new InvalidArgumentException(sprintf('Naming strategy "%s" not found', $namingStrategy)); } $config->setNamingStrategy($serviceLocator->get($namingStrategy)); } else { $config->setNamingStrategy($namingStrategy); } } if ($repositoryFactory = $options->getRepositoryFactory()) { if (is_string($repositoryFactory)) { if (!$serviceLocator->has($repositoryFactory)) { throw new InvalidArgumentException(sprintf('Repository factory "%s" not found', $repositoryFactory)); } $config->setRepositoryFactory($serviceLocator->get($repositoryFactory)); } else { $config->setRepositoryFactory($repositoryFactory); } } if ($entityListenerResolver = $options->getEntityListenerResolver()) { if ($entityListenerResolver instanceof EntityListenerResolver) { $config->setEntityListenerResolver($entityListenerResolver); } else { $config->setEntityListenerResolver($serviceLocator->get($entityListenerResolver)); } } $this->setupDBALConfiguration($serviceLocator, $config); return $config; }
public function _initDoctrineEntityManager() { $this->bootstrap(array('classLoaders', 'doctrineCache')); $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 $driver = new YamlDriver($zendConfig['doctrine']['mappingPath']); $driver->setFileExtension('.yml'); $configuration->setMetadataDriverImpl($driver); // 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; }
/** * Setup doctrine cache * * @return void */ protected function setDoctrineCache() { static::$cacheDriver = new \XLite\Core\Cache(); $driver = static::$cacheDriver->getDriver(); $this->configuration->setMetadataCacheImpl($driver); $this->configuration->setQueryCacheImpl($driver); $this->configuration->setResultCacheImpl($driver); }
public function setUp() { $configuration = new Configuration(); $configuration->setResultCacheImpl(new \Doctrine\Common\Cache\ArrayCache()); $configuration->setMetadataDriverImpl(new \Doctrine\ORM\Mapping\Driver\AnnotationDriver(new AnnotationReader(), realpath(__DIR__ . '/Models/'))); $connection = \Doctrine\DBAL\DriverManager::getConnection(array('driver' => $GLOBALS['db_type'], 'host' => $GLOBALS['db_host'], 'dbname' => $GLOBALS['db_name'], 'user' => $GLOBALS['db_username'], 'password' => $GLOBALS['db_password'])); $configuration->setMetadataCacheImpl(new \Doctrine\Common\Cache\ZendDataCache()); $this->em = new \Lynx\EntityManager($connection, $configuration); }
public function create() { $debug = $this->options['debug']; $doctrineConfig = new Configuration(); $doctrineConfig->setMetadataCacheImpl($this->cache); $doctrineConfig->setMetadataDriverImpl($this->driver); $doctrineConfig->setQueryCacheImpl($this->cache); $doctrineConfig->setResultCacheImpl($this->cache); $doctrineConfig->setProxyDir($this->options['proxy_dir']); $doctrineConfig->setProxyNamespace($this->options['proxy_namespace']); $doctrineConfig->setAutoGenerateProxyClasses($debug); return $doctrineConfig; }
/** * @param ContainerInterface $container * * @return EntityManagerInterface * @throws ORMException */ public function __invoke(ContainerInterface $container) { $config = $container->has('config') ? $container->get('config') : []; $proxyDir = isset($config['doctrine']['orm']['proxy_dir']) ? $config['doctrine']['orm']['proxy_dir'] : 'data/cache/EntityProxy'; $proxyNamespace = isset($config['doctrine']['orm']['proxy_namespace']) ? $config['doctrine']['orm']['proxy_namespace'] : 'EntityProxy'; $autoGenerateProxyClasses = isset($config['doctrine']['orm']['auto_generate_proxy_classes']) ? $config['doctrine']['orm']['auto_generate_proxy_classes'] : false; $underscoreNamingStrategy = isset($config['doctrine']['orm']['underscore_naming_strategy']) ? $config['doctrine']['orm']['underscore_naming_strategy'] : false; $entityPaths = isset($config['doctrine']['orm']['entity_paths']) ? $config['doctrine']['orm']['entity_paths'] : ['src']; // Doctrine ORM $doctrine = new Configuration(); $doctrine->setProxyDir($proxyDir); $doctrine->setProxyNamespace($proxyNamespace); $doctrine->setAutoGenerateProxyClasses($autoGenerateProxyClasses); if ($underscoreNamingStrategy) { $doctrine->setNamingStrategy(new UnderscoreNamingStrategy()); } // Cache $cache = $container->get(Cache::class); $doctrine->setQueryCacheImpl($cache); $doctrine->setResultCacheImpl($cache); $doctrine->setMetadataCacheImpl($cache); // ORM mapping by Annotation AnnotationRegistry::registerFile('vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php'); if (class_exists(DoctrineExtensions::class)) { DoctrineExtensions::registerAnnotations(); } $cachedAnnotationReader = new CachedReader(new AnnotationReader(), $cache); $driver = new AnnotationDriver($cachedAnnotationReader, $entityPaths); $doctrine->setMetadataDriverImpl($driver); $eventManager = new EventManager(); if (isset($config['doctrine']['orm']['event_subscribers'])) { foreach ($config['doctrine']['orm']['event_subscribers'] as $subscriber) { $subscriberInstance = $container->get($subscriber); if ($subscriberInstance instanceof MappedEventSubscriber) { $subscriberInstance->setAnnotationReader($cachedAnnotationReader); } $eventManager->addEventSubscriber($subscriberInstance); } } $entityManager = EntityManager::create($config['doctrine']['connection']['orm_default'], $doctrine, $eventManager); // Types Type::addType('uuid', UuidType::class); $entityManager->getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping('uuid', 'uuid'); if (isset($config['doctrine']['orm']['types'])) { foreach ($config['doctrine']['orm']['types'] as $type => $class) { Type::addType($type, $class); } } return $entityManager; }
/** * Initializes resource * * @return Doctrine\ORM\EntityManager */ public function init() { $options = $this->getOptions(); $config = new Configuration(); if (APPLICATION_ENV == 'production' && function_exists('apc_fetch')) { // @codeCoverageIgnoreStart #extension_loaded() memcache, xcache, redis $cache = new ApcCache(); } else { // @codeCoverageIgnoreEnd $cache = new ArrayCache(); } #$driverImpl = $config->newDefaultAnnotationDriver($options['modelDirectory']); // @todo Temporary(?) fix for using new AnnotationReader $reader = new AnnotationReader(); #$reader->setEnableParsePhpImports(true); $reader = new IndexedReader($reader); $reader = new CachedReader($reader, $cache); $driverImpl = new AnnotationDriver($reader, $options['modelDirectory']); class_exists('Doctrine\\ORM\\Mapping\\Driver\\DoctrineAnnotations'); // Beware cache slams: http://doctrine-orm.readthedocs.org/en/2.0.x/reference/caching.html#cache-slams $config->setMetadataCacheImpl($cache); $config->setQueryCacheImpl($cache); $config->setResultCacheImpl($cache); $config->setProxyDir($options['proxyDirectory']); $config->setProxyNamespace($options['proxyNamespace']); $config->setAutoGenerateProxyClasses($options['autoGenerateProxyClasses']); $config->setMetadataDriverImpl($driverImpl); // @codeCoverageIgnoreStart if (null !== $options['logPath']) { $sqlLogger = new SqlLogger($options['logPath']); $config->setSQLLogger($sqlLogger); Zend_Registry::set('sqlLogger', $sqlLogger); } // @codeCoverageIgnoreEnd $entityManager = EntityManager::create($options['connection'], $config); Service::setEntityManager($entityManager); // Add BLOB data type mapping if (!Type::hasType('gzblob')) { Type::addType('gzblob', 'Rexmac\\Zyndax\\Doctrine\\DBAL\\Type\\GzBlob'); $entityManager->getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping('BLOB', 'gzblob'); } // Add IP data type mapping if (!Type::hasType('ip')) { Type::addType('ip', 'Rexmac\\Zyndax\\Doctrine\\DBAL\\Type\\Ip'); $entityManager->getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping('IP', 'ip'); } return $entityManager; }
public function _initDoctrine() { $classLoader = new ClassLoader('Doctrine'); $classLoader->register(); $config = new Configuration(); $config->setMetadataCacheImpl(new \Doctrine\Common\Cache\ArrayCache()); $config->setResultCacheImpl(new \Doctrine\Common\Cache\ArrayCache()); $driverImpl = $config->newDefaultAnnotationDriver('/home/jsuggs/bbm/BBM'); $config->setMetadataDriverImpl($driverImpl); $config->setProxyDir(PROXYDIR); $config->setProxyNamespace('DoctrineProxies'); $connectionOptions = array('driver' => 'pdo_pgsql', 'user' => 'bbm', 'password' => 'bbm', 'host' => 'localhost', 'dbname' => 'bbm'); $em = EntityManager::create($connectionOptions, $config); return $em; }
/** * @return \Doctrine\ORM\Configuration */ protected function getDoctrine_ConfigService() { $this->services['doctrine.config'] = $instance = new Configuration(); $baseDir = $this->getParameter('app.baseDir'); $cache = $this->get('app.cache'); $instance->setMetadataCacheImpl($cache); $instance->setQueryCacheImpl($cache); $instance->setResultCacheImpl($cache); $instance->setProxyDir($baseDir . $this->getParameter('doctrine.proxy.dir')); $instance->setProxyNamespace($this->getParameter('doctrine.proxy.namespace')); $instance->setAutoGenerateProxyClasses($this->getParameter('app.devmode')); AnnotationRegistry::registerFile($baseDir . 'vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php'); $reader = new SimpleAnnotationReader(); $reader->addNamespace('Doctrine\\ORM\\Mapping'); $instance->setMetadataDriverImpl(new AnnotationDriver(new CachedReader($reader, $cache), array($baseDir . $this->getParameter('doctrine.entity.dir')))); return $instance; }
public function __construct() { $config = ConfigReader::readConfig('doctrine'); $doctrineConfig = new Configuration(); $cache = new Cache(); $doctrineConfig->setQueryCacheImpl($cache); $doctrineConfig->setProxyDir($config['proxyDir']); $doctrineConfig->setProxyNamespace('Proxy'); $doctrineConfig->setAutoGenerateProxyClasses(true); $doctrineConfig->setResultCacheImpl($cache); //mapping (example uses annotations, could be any of XML/YAML or plain PHP) AnnotationRegistry::registerFile(BASE_DIR . '/vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php'); $driver = new \Doctrine\ORM\Mapping\Driver\AnnotationDriver(new \Doctrine\Common\Annotations\AnnotationReader(), array($config['entityDir'])); $doctrineConfig->setMetadataDriverImpl($driver); $doctrineConfig->setMetadataCacheImpl($cache); $em = EntityManager::create($config, $doctrineConfig); $this->setEm($em); }
private function initORM() { $config_pff = ServiceContainer::get('config'); if (true === $config_pff->getConfigData('development_environment')) { $cache = new ArrayCache(); } elseif ($this->redis) { $redis = new \Redis(); if (!$redis->connect($this->redis_host, $this->redis_port)) { throw new PffException("Cannot connect to redis", 500); } if ($this->redis_password != '') { if (!$redis->auth($this->redis_password)) { throw new PffException("Cannot auth to redis", 500); } } $cache = new RedisCache(); $cache->setRedis($redis); $cache->setNamespace($this->_app->getConfig()->getConfigData('app_name')); } else { $cache = new ApcuCache(); $cache->setNamespace($this->_app->getConfig()->getConfigData('app_name')); } $config = new Configuration(); $config->setMetadataCacheImpl($cache); $config->setQueryCacheImpl($cache); $config->setResultCacheImpl($cache); $driverImpl = $config->newDefaultAnnotationDriver(ROOT . DS . 'app' . DS . 'models'); $config->setMetadataDriverImpl($driverImpl); $config->setQueryCacheImpl($cache); $config->setProxyDir(ROOT . DS . 'app' . DS . 'proxies'); $config->setProxyNamespace('pff\\proxies'); if (true === $config_pff->getConfigData('development_environment')) { $config->setAutoGenerateProxyClasses(true); $connectionOptions = $config_pff->getConfigData('databaseConfigDev'); } else { $config->setAutoGenerateProxyClasses(false); $connectionOptions = $config_pff->getConfigData('databaseConfig'); } $this->db = EntityManager::create($connectionOptions, $config); ServiceContainer::set()['dm'] = $this->db; $platform = $this->db->getConnection()->getDatabasePlatform(); $platform->registerDoctrineTypeMapping('enum', 'string'); }
/** * Inits ORM * * @return EntityManager|null * @throws InvalidArgumentException */ private function initORM() { $options = $this->getOptions(); if (isset($options['orm'])) { $ormOptions = $options['orm']; if (!isset($options['dbal'])) { throw new InvalidArgumentException('DBAL must be configured to use ORM'); } $this->assertProxyConfiguration($ormOptions); $config = new ORMConfiguration(); $config->setMetadataCacheImpl($this->getCache($ormOptions, 'metadataCache')); $config->setQueryCacheImpl($this->getCache($ormOptions, 'queryCache')); $config->setResultCacheImpl($this->getCache($ormOptions, 'resultCache')); $config->setMetadataDriverImpl($config->newDefaultAnnotationDriver($this->getAnnotationDirectories($ormOptions))); $config->setProxyDir(realpath($ormOptions['proxyDir'])); $config->setProxyNamespace($ormOptions['proxyNamespace']); $config->setAutoGenerateProxyClasses((bool) isset($ormOptions['autoGenerateProxyClasses']) ? $ormOptions['autoGenerateProxyClasses'] : true); return EntityManager::create($options['dbal'], $config); } }
/** * Factory method which creates an EntityManager. * * @return \Doctrine\ORM\EntityManager */ public function create() { $config = new Configuration(); $config->setClassMetadataFactoryName('TYPO3\\Flow\\Persistence\\Doctrine\\Mapping\\ClassMetadataFactory'); $cache = new \TYPO3\Flow\Persistence\Doctrine\CacheAdapter(); // must use ObjectManager in compile phase... $cache->setCache($this->objectManager->get('TYPO3\\Flow\\Cache\\CacheManager')->getCache('Flow_Persistence_Doctrine')); $config->setMetadataCacheImpl($cache); $config->setQueryCacheImpl($cache); $resultCache = new \TYPO3\Flow\Persistence\Doctrine\CacheAdapter(); // must use ObjectManager in compile phase... $resultCache->setCache($this->objectManager->get('TYPO3\\Flow\\Cache\\CacheManager')->getCache('Flow_Persistence_Doctrine_Results')); $config->setResultCacheImpl($resultCache); if (class_exists($this->settings['doctrine']['sqlLogger'])) { $config->setSQLLogger(new $this->settings['doctrine']['sqlLogger']()); } $eventManager = $this->buildEventManager(); $flowAnnotationDriver = $this->objectManager->get('TYPO3\\Flow\\Persistence\\Doctrine\\Mapping\\Driver\\FlowAnnotationDriver'); $config->setMetadataDriverImpl($flowAnnotationDriver); $proxyDirectory = \TYPO3\Flow\Utility\Files::concatenatePaths(array($this->environment->getPathToTemporaryDirectory(), 'Doctrine/Proxies')); \TYPO3\Flow\Utility\Files::createDirectoryRecursively($proxyDirectory); $config->setProxyDir($proxyDirectory); $config->setProxyNamespace('TYPO3\\Flow\\Persistence\\Doctrine\\Proxies'); $config->setAutoGenerateProxyClasses(FALSE); $entityManager = \Doctrine\ORM\EntityManager::create($this->settings['backendOptions'], $config, $eventManager); $flowAnnotationDriver->setEntityManager($entityManager); \Doctrine\DBAL\Types\Type::addType('objectarray', 'TYPO3\\Flow\\Persistence\\Doctrine\\DataTypes\\ObjectArray'); if (isset($this->settings['doctrine']['filters']) && is_array($this->settings['doctrine']['filters'])) { foreach ($this->settings['doctrine']['filters'] as $filterName => $filterClass) { $config->addFilter($filterName, $filterClass); $entityManager->getFilters()->enable($filterName); } } if (isset($this->settings['doctrine']['dql']) && is_array($this->settings['doctrine']['dql'])) { $this->applyDqlSettingsToConfiguration($this->settings['doctrine']['dql'], $config); } return $entityManager; }
public function register(Application $app) { $app['doctrine_orm.configuration'] = $app->share(function ($app) { $configuration = new Configuration(); if (isset($app['doctrine_orm.metadata_cache'])) { $configuration->setMetadataCacheImpl($app['doctrine_orm.metadata_cache']); } else { $configuration->setMetadataCacheImpl(new ArrayCache()); } $driverImpl = $configuration->newDefaultAnnotationDriver($app['doctrine_orm.entities_path']); $configuration->setMetadataDriverImpl($driverImpl); if (isset($app['doctrine_orm.query_cache'])) { $configuration->setQueryCacheImpl($app['doctrine_orm.query_cache']); } else { $configuration->setQueryCacheImpl(new ArrayCache()); } if (isset($app['doctrine_orm.result_cache'])) { $configuration->setResultCacheImpl($app['doctrine_orm.result_cache']); } $configuration->setProxyDir($app['doctrine_orm.proxies_path']); $configuration->setProxyNamespace($app['doctrine_orm.proxies_namespace']); $configuration->setAutogenerateProxyClasses(false); if (isset($app['doctrine_orm.autogenerate_proxy_classes'])) { $configuration->setAutogenerateProxyClasses($app['doctrine_orm.autogenerate_proxy_classes']); } else { $configuration->setAutogenerateProxyClasses(true); } return $configuration; }); $app['doctrine_orm.connection'] = $app->share(function ($app) { return DriverManager::getConnection($app['doctrine_orm.connection_parameters'], $app['doctrine_orm.configuration'], new EventManager()); }); $app['doctrine_orm.em'] = $app->share(function ($app) { return EntityManager::create($app['doctrine_orm.connection'], $app['doctrine_orm.configuration'], $app['doctrine_orm.connection']->getEventManager()); }); }
/** * @return \Doctrine\ORM\EntityManager */ protected static function getEntityManager() { if (null === self::$em) { // 'path' is commented out but can be very helpful // if used instead of 'memory' for debugging $connection = array('driver' => 'pdo_sqlite', 'memory' => true); $cache = new ArrayCache(); $config = new Configuration(); $config->setMetadataCacheImpl($cache); $config->setQueryCacheImpl($cache); $config->setResultCacheImpl($cache); $config->setProxyDir(sys_get_temp_dir()); $config->setProxyNamespace('DoctrineProxies'); $config->setAutoGenerateProxyClasses(true); $config->setMetadataDriverImpl(new AnnotationDriver(new IndexedReader(new AnnotationReader()), __DIR__)); // $config->setSQLLogger(new EchoSQLLogger()); self::$em = EntityManager::create($connection, $config); $schemaTool = new SchemaTool(self::$em); $cmf = self::$em->getMetadataFactory(); $classes = $cmf->getAllMetadata(); $schemaTool->createSchema($classes); } return static::$em; }
private static function createNewEntityManager() { $config = new Configuration(); $driverImpl = $config->newDefaultAnnotationDriver(APPLICATION_PATH . '/Models/Entities'); $config->setMetadataDriverImpl($driverImpl); // $config->setMetadataCacheImpl(MyCache::getInstance("_doctrine_metadata")->getCacheImplement()); // $config->setQueryCacheImpl(MyCache::getInstance("_doctrine_query_cache")->getCacheImplement()); // $config->setResultCacheImpl(MyCache::getInstance("_doctrine_result_cache")->getCacheImplement()); // $config->setHydrationCacheImpl(MyCache::getInstance("_doctrine_hydration_cache")->getCacheImplement()); $config->setMetadataCacheImpl(MyCache::getInstance("_doctrine_cache")->getCacheImplement()); $config->setQueryCacheImpl(MyCache::getInstance("_doctrine_cache")->getCacheImplement()); $config->setResultCacheImpl(MyCache::getInstance("_doctrine_cache")->getCacheImplement()); $config->setHydrationCacheImpl(MyCache::getInstance("_doctrine_cache")->getCacheImplement()); $config->setProxyDir(APPLICATION_PATH . '/Models/Proxies/__CG__/'); // $config->setProxyDir(APPLICATION_PATH.'/Models/Proxies/__CG__/Models/Entities2'); $config->setAutoGenerateProxyClasses(AbstractProxyFactory::AUTOGENERATE_FILE_NOT_EXISTS); $config->setProxyNamespace('Models\\Proxies\\'); // \My\Doc $config->addCustomNumericFunction('RAND', 'My\\Doctrine\\DqlFunction\\Rand'); // $config->setSQLLogger(new MySQLLogger()); $connectionParams = MyDatabaseConfiguration::getConnectionParam(); $conn = DriverManager::getConnection($connectionParams); return EntityManager::create($conn, $config); }
<?php /* * @description doctrine Doctrine ORM config * @author CawaKharkov */ use Doctrine\ORM\EntityManager, Doctrine\ORM\Configuration, Doctrine\Common\Cache\ArrayCache as Cache, Doctrine\Common\Annotations\AnnotationRegistry; //configuration $doctrineConfig = new Configuration(); $cache = new Cache(); $doctrineConfig->setQueryCacheImpl($cache); $doctrineConfig->setProxyDir(__DIR__ . '/data/Proxy'); $doctrineConfig->setProxyNamespace('Proxy'); $doctrineConfig->setAutoGenerateProxyClasses(true); $doctrineConfig->setResultCacheImpl($cache); //mapping (example uses annotations, could be any of XML/YAML or plain PHP) AnnotationRegistry::registerFile('vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php'); $driver = new \Doctrine\ORM\Mapping\Driver\AnnotationDriver(new \Doctrine\Common\Annotations\AnnotationReader(), array(__DIR__ . '/app/Entity')); $doctrineConfig->setMetadataDriverImpl($driver); $doctrineConfig->setMetadataCacheImpl($cache); //getting the EntityManager $entityManager = EntityManager::create(array('driver' => 'pdo_mysql', 'user' => 'root', 'password' => 'cawa123azs', 'dbname' => 'blog', 'charset' => 'utf8'), $doctrineConfig); $helpers = new Symfony\Component\Console\Helper\HelperSet(array('db' => new \Doctrine\DBAL\Tools\Console\Helper\ConnectionHelper($entityManager->getConnection()), 'em' => new \Doctrine\ORM\Tools\Console\Helper\EntityManagerHelper($entityManager)));
/** * Creates a configuration without a metadata driver. * * @param bool $isDevMode * @param string $proxyDir * @param Cache $cache * * @return Configuration */ public static function createConfiguration($isDevMode = false, $proxyDir = null, Cache $cache = null) { $proxyDir = $proxyDir ?: sys_get_temp_dir(); if ($isDevMode === false && $cache === null) { if (extension_loaded('apc')) { $cache = new \Doctrine\Common\Cache\ApcCache(); } elseif (extension_loaded('xcache')) { $cache = new \Doctrine\Common\Cache\XcacheCache(); } elseif (extension_loaded('memcache')) { $memcache = new \Memcache(); $memcache->connect('127.0.0.1'); $cache = new \Doctrine\Common\Cache\MemcacheCache(); $cache->setMemcache($memcache); } elseif (extension_loaded('redis')) { $redis = new \Redis(); $redis->connect('127.0.0.1'); $cache = new \Doctrine\Common\Cache\RedisCache(); $cache->setRedis($redis); } else { $cache = new ArrayCache(); } } elseif ($cache === null) { $cache = new ArrayCache(); } if ($cache instanceof CacheProvider) { $cache->setNamespace("dc2_" . md5($proxyDir) . "_"); // to avoid collisions } $config = new Configuration(); $config->setMetadataCacheImpl($cache); $config->setQueryCacheImpl($cache); $config->setResultCacheImpl($cache); $config->setProxyDir($proxyDir); $config->setProxyNamespace('DoctrineProxies'); $config->setAutoGenerateProxyClasses($isDevMode); return $config; }
/** * @param Configuration $config * * @throws \ThinFrame\Foundation\Exceptions\RuntimeException */ private function setCacheDrivers(Configuration $config) { if (isset($this->configuration['caching']) && is_array($this->configuration['caching'])) { foreach ($this->configuration['caching'] as $mode => $driver) { if (trim($driver) == '') { continue; } if (is_null($cacheDriver = $this->getCacheDriver($driver))) { throw new RuntimeException('Bad configuration for cache driver: ' . $driver); } switch ($mode) { case 'result': $config->setResultCacheImpl($cacheDriver); break; case 'metadata': $config->setMetadataCacheImpl($cacheDriver); break; case 'query': $config->setQueryCacheImpl($cacheDriver); break; case 'hydration': $config->setHydrationCacheImpl($cacheDriver); break; default: } } } }
/** * Factory method which creates an EntityManager. * * @return EntityManager * @throws \TYPO3\Flow\Configuration\Exception\InvalidConfigurationException */ public function create() { $config = new Configuration(); $config->setClassMetadataFactoryName(Mapping\ClassMetadataFactory::class); $cache = new CacheAdapter(); // must use ObjectManager in compile phase... $cache->setCache($this->objectManager->get(CacheManager::class)->getCache('Flow_Persistence_Doctrine')); $config->setMetadataCacheImpl($cache); $config->setQueryCacheImpl($cache); $resultCache = new CacheAdapter(); // must use ObjectManager in compile phase... $resultCache->setCache($this->objectManager->get(CacheManager::class)->getCache('Flow_Persistence_Doctrine_Results')); $config->setResultCacheImpl($resultCache); if (is_string($this->settings['doctrine']['sqlLogger']) && class_exists($this->settings['doctrine']['sqlLogger'])) { $configuredSqlLogger = $this->settings['doctrine']['sqlLogger']; $sqlLoggerInstance = new $configuredSqlLogger(); if ($sqlLoggerInstance instanceof SQLLogger) { $config->setSQLLogger($sqlLoggerInstance); } else { throw new InvalidConfigurationException(sprintf('TYPO3.Flow.persistence.doctrine.sqlLogger must point to a \\Doctrine\\DBAL\\Logging\\SQLLogger implementation, %s given.', get_class($sqlLoggerInstance)), 1426150388); } } $eventManager = $this->buildEventManager(); $flowAnnotationDriver = $this->objectManager->get(Mapping\Driver\FlowAnnotationDriver::class); $config->setMetadataDriverImpl($flowAnnotationDriver); $proxyDirectory = Files::concatenatePaths(array($this->environment->getPathToTemporaryDirectory(), 'Doctrine/Proxies')); Files::createDirectoryRecursively($proxyDirectory); $config->setProxyDir($proxyDirectory); $config->setProxyNamespace('TYPO3\\Flow\\Persistence\\Doctrine\\Proxies'); $config->setAutoGenerateProxyClasses(false); // Set default host to 127.0.0.1 if there is no host configured but a dbname if (empty($this->settings['backendOptions']['host']) && !empty($this->settings['backendOptions']['dbname'])) { $this->settings['backendOptions']['host'] = '127.0.0.1'; } // The following code tries to connect first, if that succeeds, all is well. If not, the platform is fetched directly from the // driver - without version checks to the database server (to which no connection can be made) - and is added to the config // which is then used to create a new connection. This connection will then return the platform directly, without trying to // detect the version it runs on, which fails if no connection can be made. But the platform is used even if no connection can // be made, which was no problem with Doctrine DBAL 2.3. And then came version-aware drivers and platforms... $connection = DriverManager::getConnection($this->settings['backendOptions'], $config, $eventManager); try { $connection->connect(); } catch (ConnectionException $exception) { $settings = $this->settings['backendOptions']; $settings['platform'] = $connection->getDriver()->getDatabasePlatform(); $connection = DriverManager::getConnection($settings, $config, $eventManager); } $entityManager = EntityManager::create($connection, $config, $eventManager); $flowAnnotationDriver->setEntityManager($entityManager); if (isset($this->settings['doctrine']['dbal']['mappingTypes']) && is_array($this->settings['doctrine']['dbal']['mappingTypes'])) { foreach ($this->settings['doctrine']['dbal']['mappingTypes'] as $typeName => $typeConfiguration) { Type::addType($typeName, $typeConfiguration['className']); $entityManager->getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping($typeConfiguration['dbType'], $typeName); } } if (isset($this->settings['doctrine']['filters']) && is_array($this->settings['doctrine']['filters'])) { foreach ($this->settings['doctrine']['filters'] as $filterName => $filterClass) { $config->addFilter($filterName, $filterClass); $entityManager->getFilters()->enable($filterName); } } if (isset($this->settings['doctrine']['dql']) && is_array($this->settings['doctrine']['dql'])) { $this->applyDqlSettingsToConfiguration($this->settings['doctrine']['dql'], $config); } return $entityManager; }
/* * Copyright 2015 Jack Sleight <http://jacksleight.com/> * This source file is subject to the MIT license that is bundled with this package in the file LICENCE.md. */ use Doctrine\ORM\Configuration; use Doctrine\Common\EventManager; use Doctrine\ORM\EntityManager; use Doctrine\ORM\Proxy\Autoloader; use Chalk\Doctrine\ORM\EntityManager as ChalkEntityManager; use Chalk\Doctrine\NamingStrategy; use Chalk\Listener; \Coast\Doctrine\register_dbal_types(); if (!isset($app->config->database)) { throw new \Chalk\Exception('Database connection details are required'); } $config = new Configuration(); $config->setNamingStrategy(new NamingStrategy()); $config->setMetadataDriverImpl($config->newDefaultAnnotationDriver()); $config->setProxyDir($app->config->dataDir->dir('proxy')); $config->setProxyNamespace('Chalk\\Proxy'); $config->setAutoGenerateProxyClasses(false); $config->setQueryCacheImpl($app->cache->value()); $config->setResultCacheImpl($app->cache->value()); $config->setMetadataCacheImpl($app->cache->value()); Autoloader::register($app->config->dataDir->dir('proxy'), 'Chalk\\Proxy'); $evm = new EventManager(); $evm->addEventSubscriber(new Listener()); $em = new ChalkEntityManager(EntityManager::create($app->config->database + ['driver' => 'pdo_mysql', 'charset' => 'utf8'], $config, $evm)); $em->getConnection()->exec("SET NAMES utf8"); Toast\Wrapper::$em = $em; return $em;
/** * Returns an entity manager * * @param string $name the entity manager configuration name * * @return Doctrine\ORM\EntityManager * @throws CException */ public function getEntityManager($name = 'default') { if (isset($this->_cache['em'][$name]) === true) { return $this->_cache['em'][$name]; } if (isset($this->entityManager[$name]) === false) { throw new \CException(\Yii::t('wk', 'Unknown entity manager configuration "{name}"', array('{name}' => $name))); } $options = $this->entityManager[$name]; $conn = $this->getConnection($options['connection']); $config = new ORM\Configuration(); unset($options['connection']); $driver = $this->_getMappingDriver($options); $config->setMetadataDriverImpl($driver); // set metadata cache if (isset($options['metadataCache']) === true) { $config->setMetadataCacheImpl($this->getCache($options['metadataCache'])); unset($options['metadataCache']); } // set query cache if (isset($options['queryCache']) === true) { $config->setQueryCacheImpl($this->getCache($options['queryCache'])); unset($options['queryCache']); } // set result cache if (isset($options['resultCache']) === true) { $config->setResultCacheImpl($this->getCache($options['resultCache'])); unset($options['resultCache']); } $options['proxyDir'] = \Yii::getPathOfAlias($options['proxyDir']); // loop through setters of remaining options foreach ($options as $key => $value) { $method = 'set' . ucfirst($key); if (method_exists($config, $method) === true) { $config->{$method}($value); } } $em = ORM\EntityManager::create($conn, $config); $this->_cache['em'][$name] = $em; return $em; }
public function register(Application $app) { $app['EM.sql-logger.file'] = $app->share(function (Application $app) { return $app['log.path'] . '/doctrine-log.log'; }); $app['EM.sql-logger.max-files'] = 5; $app['EM.sql-logger'] = $app->share(function (Application $app) { $logger = new $app['monolog.logger.class']('doctrine-logger'); $logger->pushHandler(new RotatingFileHandler($app['EM.sql-logger.file'], $app['EM.sql-logger.max-files'])); return new MonologSQLLogger($logger, 'yaml'); }); $app['EM.driver'] = $app->share(function (Application $app) { AnnotationRegistry::registerFile($app['root.path'] . '/vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php'); $annotationReader = new AnnotationReader(); $fileCacheReader = new FileCacheReader($annotationReader, $app['cache.path'] . '/doctrine', $app['debug']); $driverChain = new MappingDriverChain(); DoctrineExtensions::registerAbstractMappingIntoDriverChainORM($driverChain, $fileCacheReader); $annotationDriver = new AnnotationDriver($annotationReader, [$app['root.path'] . '/lib/Alchemy/Phrasea/Model/Entities']); $driverChain->addDriver($annotationDriver, 'Alchemy\\Phrasea\\Model\\Entities'); return $driverChain; }); $app['EM.config'] = $app->share(function (Application $app) { $config = new ORMConfiguration(); if ($app->getEnvironment() === PhraseaApplication::ENV_DEV) { $config->setSQLLogger($app['EM.sql-logger']); } $config->setMetadataCacheImpl($app['phraseanet.cache-service']->factory('ORMmetadata', $app['EM.opcode-cache-type'], $app['EM.opcode-cache-options'])); $config->setQueryCacheImpl($app['phraseanet.cache-service']->factory('ORMquery', $app['EM.opcode-cache-type'], $app['EM.opcode-cache-options'])); $config->setResultCacheImpl($app['phraseanet.cache-service']->factory('ORMresult', $app['EM.cache-type'], $app['EM.cache-options'])); $config->setAutoGenerateProxyClasses($app['debug']); $config->setMetadataDriverImpl($app['EM.driver']); $config->setProxyDir($app['root.path'] . '/resources/proxies'); $config->setProxyNamespace('Alchemy\\Phrasea\\Model\\Proxies'); $config->setAutoGenerateProxyClasses($app['debug']); $config->addEntityNamespace('Phraseanet', 'Alchemy\\Phrasea\\Model\\Entities'); return $config; }); $app['EM.opcode-cache-type'] = $app->share(function (Application $app) { if ($app['configuration.store']->isSetup()) { return $app['conf']->get(['main', 'opcodecache', 'type']); } return 'ArrayCache'; }); $app['EM.opcode-cache-options'] = $app->share(function (Application $app) { if ($app['configuration.store']->isSetup()) { return $app['conf']->get(['main', 'opcodecache', 'options']); } return []; }); $app['EM.cache-type'] = $app->share(function (Application $app) { if ($app['configuration.store']->isSetup()) { return $app['conf']->get(['main', 'cache', 'type']); } return 'ArrayCache'; }); $app['EM.cache-options'] = $app->share(function (Application $app) { if ($app['configuration.store']->isSetup()) { return $app['conf']->get(['main', 'cache', 'options']); } return []; }); $app['EM.events-manager'] = $app->share(function (Application $app) { $evm = new EventManager(); $evm->addEventSubscriber(new TimestampableListener()); return $evm; }); $app['EM.dbal-conf'] = $app->share(function (Application $app) { if ('test' === $app->getEnvironment()) { return $app['conf']->get(['main', 'database-test']); } return $app['conf']->get(['main', 'database']); }); $app['dbal.provider'] = $app->share(function (Application $app) { return new ConnectionProvider($app['EM.config'], $app['EM.events-manager'], isset($app['task-manager.logger']) ? $app['task-manager.logger'] : $app['monolog']); }); $app['EM'] = $app->share(function (Application $app) { try { $em = EntityManager::create($app['EM.dbal-conf'], $app['EM.config'], $app['EM.events-manager']); } catch (\Exception $e) { throw new RuntimeException("Unable to create database connection", $e->getCode(), $e); } $platform = $em->getConnection()->getDatabasePlatform(); $types = ['blob' => 'Alchemy\\Phrasea\\Model\\Types\\Blob', 'enum' => 'Alchemy\\Phrasea\\Model\\Types\\Blob', 'longblob' => 'Alchemy\\Phrasea\\Model\\Types\\LongBlob', 'varbinary' => 'Alchemy\\Phrasea\\Model\\Types\\VarBinary', 'binary' => 'Alchemy\\Phrasea\\Model\\Types\\Binary', 'binary_string' => 'Alchemy\\Phrasea\\Model\\Types\\BinaryString']; foreach ($types as $type => $class) { if (!Type::hasType($type)) { Type::addType($type, $class); } $platform->registerDoctrineTypeMapping($type, $type); } return $em; }); $app['EM.native-query'] = $app->share(function ($app) { return new NativeQueryProvider($app['EM']); }); }
/** * {@inheritdoc} */ protected function createWithConfig(ContainerInterface $container, $configKey) { $config = $this->retrieveConfig($container, $configKey, 'configuration'); $configuration = new Configuration(); $configuration->setProxyDir($config['proxy_dir']); $configuration->setProxyNamespace($config['proxy_namespace']); $configuration->setAutoGenerateProxyClasses($config['auto_generate_proxy_classes']); $configuration->setEntityNamespaces($config['entity_namespaces']); $configuration->setCustomDatetimeFunctions($config['datetime_functions']); $configuration->setCustomStringFunctions($config['string_functions']); $configuration->setCustomNumericFunctions($config['numeric_functions']); $configuration->setCustomHydrationModes($config['custom_hydration_modes']); $configuration->setClassMetadataFactoryName($config['class_metadata_factory_name']); foreach ($config['named_queries'] as $name => $dql) { $configuration->addNamedQuery($name, $dql); } foreach ($config['named_native_queries'] as $name => $query) { $configuration->addNamedNativeQuery($name, $query['sql'], $query['rsm']); } foreach ($config['filters'] as $name => $className) { $configuration->addFilter($name, $className); } $configuration->setMetadataCacheImpl($this->retrieveDependency($container, $config['metadata_cache'], 'cache', CacheFactory::class)); $configuration->setQueryCacheImpl($this->retrieveDependency($container, $config['query_cache'], 'cache', CacheFactory::class)); $configuration->setResultCacheImpl($this->retrieveDependency($container, $config['result_cache'], 'cache', CacheFactory::class)); $configuration->setHydrationCacheImpl($this->retrieveDependency($container, $config['hydration_cache'], 'cache', CacheFactory::class)); $configuration->setMetadataDriverImpl($this->retrieveDependency($container, $config['driver'], 'driver', DriverFactory::class)); if (is_string($config['naming_strategy'])) { $configuration->setNamingStrategy($container->get($config['naming_strategy'])); } elseif (null !== $config['naming_strategy']) { $configuration->setNamingStrategy($config['naming_strategy']); } if (is_string($config['repository_factory'])) { $configuration->setRepositoryFactory($container->get($config['repository_factory'])); } elseif (null !== $config['repository_factory']) { $configuration->setRepositoryFactory($config['repository_factory']); } if (is_string($config['entity_listener_resolver'])) { $configuration->setEntityListenerResolver($container->get($config['entity_listener_resolver'])); } elseif (null !== $config['entity_listener_resolver']) { $configuration->setEntityListenerResolver($config['entity_listener_resolver']); } if (null !== $config['default_repository_class_name']) { $configuration->setDefaultRepositoryClassName($config['default_repository_class_name']); } if ($config['second_level_cache']['enabled']) { $regionsConfig = new RegionsConfiguration($config['second_level_cache']['default_lifetime'], $config['second_level_cache']['default_lock_lifetime']); foreach ($config['second_level_cache']['regions'] as $regionName => $regionConfig) { if (array_key_exists('lifetime', $regionConfig)) { $regionsConfig->setLifetime($regionName, $regionConfig['lifetime']); } if (array_key_exists('lock_lifetime', $regionConfig)) { $regionsConfig->setLockLifetime($regionName, $regionConfig['lock_lifetime']); } } $cacheFactory = new DefaultCacheFactory($regionsConfig, $configuration->getResultCacheImpl()); $cacheFactory->setFileLockRegionDirectory($config['second_level_cache']['file_lock_region_directory']); $cacheConfiguration = new CacheConfiguration(); $cacheConfiguration->setCacheFactory($cacheFactory); $cacheConfiguration->setRegionsConfiguration($regionsConfig); $configuration->setSecondLevelCacheEnabled(true); $configuration->setSecondLevelCacheConfiguration($cacheConfiguration); } if (is_string($config['sql_logger'])) { $configuration->setSQLLogger($container->get($config['sql_logger'])); } elseif (null !== $config['sql_logger']) { $configuration->setSQLLogger($config['sql_logger']); } return $configuration; }
/** * {@inheritDoc} * * @return Configuration */ public function __invoke(ContainerInterface $container, $requestedName, array $options = null) { /** @var $options \DoctrineORMModule\Options\Configuration */ $options = $this->getOptions($container); $config = new Configuration(); $config->setAutoGenerateProxyClasses($options->getGenerateProxies()); $config->setProxyDir($options->getProxyDir()); $config->setProxyNamespace($options->getProxyNamespace()); $config->setEntityNamespaces($options->getEntityNamespaces()); $config->setCustomDatetimeFunctions($options->getDatetimeFunctions()); $config->setCustomStringFunctions($options->getStringFunctions()); $config->setCustomNumericFunctions($options->getNumericFunctions()); $config->setClassMetadataFactoryName($options->getClassMetadataFactoryName()); foreach ($options->getNamedQueries() as $name => $query) { $config->addNamedQuery($name, $query); } foreach ($options->getNamedNativeQueries() as $name => $query) { $config->addNamedNativeQuery($name, $query['sql'], new $query['rsm']()); } foreach ($options->getCustomHydrationModes() as $modeName => $hydrator) { $config->addCustomHydrationMode($modeName, $hydrator); } foreach ($options->getFilters() as $name => $class) { $config->addFilter($name, $class); } $config->setMetadataCacheImpl($container->get($options->getMetadataCache())); $config->setQueryCacheImpl($container->get($options->getQueryCache())); $config->setResultCacheImpl($container->get($options->getResultCache())); $config->setHydrationCacheImpl($container->get($options->getHydrationCache())); $config->setMetadataDriverImpl($container->get($options->getDriver())); if ($namingStrategy = $options->getNamingStrategy()) { if (is_string($namingStrategy)) { if (!$container->has($namingStrategy)) { throw new InvalidArgumentException(sprintf('Naming strategy "%s" not found', $namingStrategy)); } $config->setNamingStrategy($container->get($namingStrategy)); } else { $config->setNamingStrategy($namingStrategy); } } if ($quoteStrategy = $options->getQuoteStrategy()) { if (is_string($quoteStrategy)) { if (!$container->has($quoteStrategy)) { throw new InvalidArgumentException(sprintf('Quote strategy "%s" not found', $quoteStrategy)); } $config->setQuoteStrategy($container->get($quoteStrategy)); } else { $config->setQuoteStrategy($quoteStrategy); } } if ($repositoryFactory = $options->getRepositoryFactory()) { if (is_string($repositoryFactory)) { if (!$container->has($repositoryFactory)) { throw new InvalidArgumentException(sprintf('Repository factory "%s" not found', $repositoryFactory)); } $config->setRepositoryFactory($container->get($repositoryFactory)); } else { $config->setRepositoryFactory($repositoryFactory); } } if ($entityListenerResolver = $options->getEntityListenerResolver()) { if ($entityListenerResolver instanceof EntityListenerResolver) { $config->setEntityListenerResolver($entityListenerResolver); } else { $config->setEntityListenerResolver($container->get($entityListenerResolver)); } } $secondLevelCache = $options->getSecondLevelCache(); if ($secondLevelCache->isEnabled()) { $regionsConfig = new RegionsConfiguration($secondLevelCache->getDefaultLifetime(), $secondLevelCache->getDefaultLockLifetime()); foreach ($secondLevelCache->getRegions() as $regionName => $regionConfig) { if (isset($regionConfig['lifetime'])) { $regionsConfig->setLifetime($regionName, $regionConfig['lifetime']); } if (isset($regionConfig['lock_lifetime'])) { $regionsConfig->setLockLifetime($regionName, $regionConfig['lock_lifetime']); } } // As Second Level Cache caches queries results, we reuse the result cache impl $cacheFactory = new DefaultCacheFactory($regionsConfig, $config->getResultCacheImpl()); $cacheFactory->setFileLockRegionDirectory($secondLevelCache->getFileLockRegionDirectory()); $cacheConfiguration = new CacheConfiguration(); $cacheConfiguration->setCacheFactory($cacheFactory); $cacheConfiguration->setRegionsConfiguration($regionsConfig); $config->setSecondLevelCacheEnabled(); $config->setSecondLevelCacheConfiguration($cacheConfiguration); } if ($className = $options->getDefaultRepositoryClassName()) { $config->setDefaultRepositoryClassName($className); } $this->setupDBALConfiguration($container, $config); return $config; }
public function register(Container $app) { if (!isset($app['dbs'])) { throw new \LogicException('You must register the DoctrineServiceProvider to use the DoctrineOrmServiceProvider.'); } if (!isset($app['caches'])) { throw new \LogicException('You must register the DoctrineCacheServiceProvider to use the DoctrineOrmServiceProvider.'); } $app['ems.options.initializer'] = $app->protect(function () use($app) { static $initialized = false; if ($initialized) { return; } $initialized = true; if (!isset($app['ems.options'])) { $app['ems.options'] = ['default' => isset($app['orm.options']) ? $app['orm.options'] : []]; } $app['ems.options'] = array_map(function ($options) use($app) { return array_replace($app['orm.default_options'], $options); }, $app['ems.options']); if (!isset($app['ems.default'])) { $app['ems.default'] = array_keys(array_slice($app['ems.options'], 0, 1))[0]; } }); $app['ems'] = function (Container $app) { $app['ems.options.initializer'](); $container = new Container(); foreach ($app['ems.options'] as $name => $options) { if ($app['ems.default'] === $name) { $config = $app['orm.config']; } else { $config = $app['ems.config'][$name]; } $connection = $app['dbs'][$options['connection']]; $manager = $app['dbs.event_manager'][$options['connection']]; $container[$name] = function () use($connection, $config, $manager) { return EntityManager::create($connection, $config, $manager); }; } return $container; }; $app['ems.config'] = function (Container $app) { $app['ems.options.initializer'](); $container = new Container(); foreach ($app['ems.options'] as $name => $options) { $config = new Configuration(); $config->setProxyDir($app['orm.proxy_dir']); $config->setProxyNamespace($app['orm.proxy_namespace']); $config->setAutoGenerateProxyClasses($app['orm.auto_generate_proxy_classes']); $config->setCustomStringFunctions($app['orm.custom_functions_string']); $config->setCustomNumericFunctions($app['orm.custom_functions_numeric']); $config->setCustomDatetimeFunctions($app['orm.custom_functions_datetime']); $config->setMetadataCacheImpl($app['orm.cache.factory']('metadata', $options)); $config->setQueryCacheImpl($app['orm.cache.factory']('query', $options)); $config->setResultCacheImpl($app['orm.cache.factory']('result', $options)); $config->setMetadataDriverImpl($app['orm.mapping.chain']($config, $options['mappings'])); $container[$name] = $config; } return $container; }; $app['orm.cache.factory'] = $app->protect(function ($type, $options) use($app) { $type = $type . '_cache_driver'; if (!isset($options[$type])) { $options[$type] = 'array'; } if (!is_array($options[$type])) { $options[$type] = ['driver' => $options[$type]]; } $driver = $options[$type]['driver']; $namespace = isset($options[$type]['namespace']) ? $options[$type]['namespace'] : null; $cache = $app['cache.factory']($driver, $options); $cache->setNamespace($namespace); return $cache; }); $app['orm.mapping.chain'] = $app->protect(function (Configuration $config, array $mappings) { $chain = new MappingDriverChain(); foreach ($mappings as $mapping) { if (!is_array($mapping)) { throw new \InvalidArgumentException(); } switch ($mapping['type']) { case 'annotation': $useSimpleAnnotationReader = isset($mapping['use_simple_annotation_reader']) ? $mapping['use_simple_annotation_reader'] : true; $driver = $config->newDefaultAnnotationDriver($mapping['path'], $useSimpleAnnotationReader); break; case 'yml': $driver = new YamlDriver($mapping['path']); break; default: throw new \InvalidArgumentException(); break; } $chain->addDriver($driver, $mapping['namespace']); } return $chain; }); $app['orm.proxy_dir'] = null; $app['orm.proxy_namespace'] = 'Proxy'; $app['orm.auto_generate_proxy_classes'] = true; $app['orm.custom_functions_string'] = []; $app['orm.custom_functions_numeric'] = []; $app['orm.custom_functions_datetime'] = []; $app['orm.default_options'] = ['connection' => 'default', 'mappings' => []]; // shortcuts for the "first" ORM $app['orm'] = function (Container $app) { $ems = $app['ems']; return $ems[$app['ems.default']]; }; $app['orm.config'] = function (Container $app) { $ems = $app['ems.config']; return $ems[$app['ems.default']]; }; }