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 setUp() { $this->configuration = new Configuration(); $this->configuration->setMetadataCacheImpl(new ArrayCache()); $this->configuration->setQueryCacheImpl(new ArrayCache()); $this->configuration->setProxyDir(__DIR__ . '/Proxies'); $this->configuration->setProxyNamespace('DoctrineExtensions\\Tests\\Proxies'); $this->configuration->setAutoGenerateProxyClasses(true); $this->configuration->setMetadataDriverImpl($this->configuration->newDefaultAnnotationDriver(__DIR__ . '/../Entities')); $this->entityManager = EntityManager::create(array('driver' => 'pdo_sqlite', 'memory' => true), $this->configuration); }
/** * {@inheritdoc} */ public function register(Container $app) { // @todo crear DoctrineOrmManagerRegistryProvider // o poner en boot estos servicios $app->extend('form.extensions', function ($extensions, $app) { $extensions[] = new DoctrineOrmExtension($app['doctrine']); return $extensions; }); $app['doctrine.orm.validator.unique_validator'] = function ($app) { return new UniqueEntityValidator($app['doctrine']); }; if (!isset($app['validator.validator_service_ids'])) { $app['validator.validator_service_ids'] = []; } $app['validator.validator_service_ids'] = array_merge($app['validator.validator_service_ids'], ['doctrine.orm.validator.unique' => 'doctrine.orm.validator.unique_validator']); $app->extend('validator.object_initializers', function (array $objectInitializers, $app) { $objectInitializers[] = new DoctrineInitializer($app['doctrine']); return $objectInitializers; }); $app['doctrine'] = function ($app) { return new ManagerRegistry($app); }; $app['orm.em'] = function ($app) { $em = EntityManager::create($app['db'], $app['orm.config'], $app['db.event_manager']); return $em; }; // Entity manager alias $app['em'] = function ($app) { return $app['orm.em']; }; $app['orm.config'] = function ($app) { $config = new Configuration(); // @todo path! $config->setProxyDir(sprintf('%s/../../../../../../var/cache/doctrine/proxies', __DIR__)); $config->setProxyNamespace('DoctrineProxies'); $config->setAutoGenerateProxyClasses($app['debug']); // The strongly recommended FALSE in production $chain = new MappingDriverChain(); // Pulsar $path = realpath(sprintf('%s/../Entity', __DIR__)); $driver = $config->newDefaultAnnotationDriver((array) $path, false); $chain->addDriver($driver, 'Pulsar\\Entity'); // App $path = realpath(sprintf('%s/../../../../../../src/App', __DIR__)); $driver = $config->newDefaultAnnotationDriver((array) $path, false); $chain->addDriver($driver, 'App\\Entity'); $config->setMetadataCacheImpl($app['orm.cache']); $config->setMetadataDriverImpl($chain); return $config; }; $app['orm.cache'] = function () { return new ArrayCache(); }; }
public function testNewDefaultAnnotationDriver() { $paths = array(__DIR__); $reflectionClass = new ReflectionClass(__NAMESPACE__ . '\\ConfigurationTestAnnotationReaderChecker'); $annotationDriver = $this->configuration->newDefaultAnnotationDriver($paths, false); $reader = $annotationDriver->getReader(); $annotation = $reader->getMethodAnnotation($reflectionClass->getMethod('namespacedAnnotationMethod'), 'Doctrine\\ORM\\Mapping\\PrePersist'); $this->assertInstanceOf('Doctrine\\ORM\\Mapping\\PrePersist', $annotation); $annotationDriver = $this->configuration->newDefaultAnnotationDriver($paths); $reader = $annotationDriver->getReader(); $annotation = $reader->getMethodAnnotation($reflectionClass->getMethod('simpleAnnotationMethod'), 'Doctrine\\ORM\\Mapping\\PrePersist'); $this->assertInstanceOf('Doctrine\\ORM\\Mapping\\PrePersist', $annotation); }
protected function _initDoctrine() { $config = new Configuration(); switch (APPLICATION_ENV) { case 'production': case 'staging': $cache = new \Doctrine\Common\Cache\ApcCache(); break; // Both development and test environments will use array cache. // Both development and test environments will use array cache. default: $cache = new \Doctrine\Common\Cache\ArrayCache(); break; } $config->setMetadataCacheImpl($cache); $driverImpl = $config->newDefaultAnnotationDriver(APPLICATION_PATH . '/models'); $config->setMetadataDriverImpl($driverImpl); $config->setQueryCacheImpl($cache); $config->setProxyDir(APPLICATION_PATH . '/proxies'); $config->setProxyNamespace('D2Test\\Proxies'); $options = $this->getOption('doctrine'); $config->setAutoGenerateProxyClasses($options['auto_generate_proxy_class']); $em = EntityManager::create($options['db'], $config); Zend_Registry::set('EntityManager', $em); return $em; }
public function __construct() { // load database configuration from CodeIgniter require_once APPPATH . 'config/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'; // We use the Composer Autoloader instead - just set // $config['composer_autoload'] = TRUE; in application/config/config.php //require_once APPPATH.'vendor/autoload.php'; //A Doctrine Autoloader is needed to load the models $entitiesClassLoader = new ClassLoader('Entities', APPPATH . "models"); $entitiesClassLoader->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' => 'dev_pila', 'password' => 'damienludothomas', 'host' => 'localhost', 'dbname' => 'tradr'); // Create EntityManager $this->em = EntityManager::create($connectionOptions, $config); }
/** * @return EntityManager */ protected function getEntityManager() { if (null !== $this->em) { return $this->em; } $config = new Configuration(); $config->setMetadataCacheImpl(new ArrayCache()); $config->setQueryCacheImpl(new ArrayCache()); $config->setProxyDir(__DIR__ . '/Proxies'); $config->setAutoGenerateProxyClasses(ProxyFactory::AUTOGENERATE_EVAL); $config->setProxyNamespace('SimpleThings\\EntityAudit\\Tests\\Proxies'); $config->setMetadataDriverImpl($config->newDefaultAnnotationDriver(array(realpath(__DIR__ . '/Fixtures/Core'), realpath(__DIR__ . '/Fixtures/Issue'), realpath(__DIR__ . '/Fixtures/Relation')), false)); Gedmo\DoctrineExtensions::registerAnnotations(); $connection = $this->_getConnection(); // get rid of more global state $evm = $connection->getEventManager(); foreach ($evm->getListeners() as $event => $listeners) { foreach ($listeners as $listener) { $evm->removeEventListener(array($event), $listener); } } $this->em = EntityManager::create($connection, $config); if (isset($this->customTypes) and is_array($this->customTypes)) { foreach ($this->customTypes as $customTypeName => $customTypeClass) { if (!Type::hasType($customTypeName)) { Type::addType($customTypeName, $customTypeClass); } $this->em->getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping('db_' . $customTypeName, $customTypeName); } } return $this->em; }
public function init() { $dbParams = ['driver' => $this->driver, 'host' => $this->host, 'user' => $this->user, 'password' => $this->password, 'dbname' => $this->dbname, 'charset' => 'utf8mb4']; $this->pathProxy = $this->path . DIRECTORY_SEPARATOR . 'proxy'; if (!is_dir($this->pathCache)) { File::createDirectory($this->pathCache); } if (!is_dir($this->pathProxy)) { File::createDirectory($this->pathProxy); } $config = new Configuration(); $cache = new \Doctrine\Common\Cache\FilesystemCache($this->pathCache); $config->setMetadataCacheImpl($cache); $config->setQueryCacheImpl($cache); $driverImpl = $config->newDefaultAnnotationDriver($this->path); $config->setMetadataDriverImpl($driverImpl); $config->setProxyDir($this->pathProxy); $config->setProxyNamespace('app\\tables\\proxy'); if ($this->applicationMode == "development") { $config->setAutoGenerateProxyClasses(true); } else { $config->setAutoGenerateProxyClasses(false); } $this->doctrine = EntityManager::create($dbParams, $config); }
public function loadDependencyDefaults(ContainerInterface $container) { // logger $container['logger'] = function (ContainerInterface $c) { $settings = $c->get('settings')['logger']; $debug = array_key_exists('debug', $settings) && $settings['debug']; $logger = new Logger($settings['name']); $logger->pushProcessor(new UidProcessor()); $logger->pushHandler(new StreamHandler($settings['path'], $debug ? Logger::DEBUG : Logger::ERROR)); return $logger; }; // entity manager $container['entityManager'] = function (ContainerInterface $c) { $settings = $c->get('settings')['database']; $config = new Configuration(); $config->setMetadataCacheImpl(new ArrayCache()); $driverImpl = $config->newDefaultAnnotationDriver(array(__DIR__ . '/Entity')); $config->setMetadataDriverImpl($driverImpl); $config->setProxyDir(__DIR__ . '/Entity/Proxy'); $config->setProxyNamespace('Proxy'); return EntityManager::create($settings, $config); }; $container['foundHandler'] = function () { return new RequestResponseArgs(); }; $container['dataFormatter'] = function () { return new ResponseDataFormatter(); }; return $container; }
function initDoctrine() { require_once __DIR__ . '/../lib/vendor/doctrine-common/lib/Doctrine/Common/ClassLoader.php'; // Set up class loading. You could use different autoloaders, provided by your favorite framework, // if you want to. $classLoader = new ClassLoader('Doctrine\\ORM', realpath(__DIR__ . '/../lib')); $classLoader->register(); $classLoader = new ClassLoader('Doctrine\\DBAL', realpath(__DIR__ . '/../lib/vendor/doctrine-dbal/lib')); $classLoader->register(); $classLoader = new ClassLoader('Doctrine\\Common', realpath(__DIR__ . '/../lib/vendor/doctrine-common/lib')); $classLoader->register(); $classLoader = new ClassLoader('Symfony', realpath(__DIR__ . '/../lib/vendor')); $classLoader->register(); $classLoader = new ClassLoader('Entities', __DIR__); $classLoader->register(); $classLoader = new ClassLoader('Proxies', __DIR__); $classLoader->register(); // Set up caches $config = new Configuration(); $cache = new ApcCache(); $config->setMetadataCacheImpl($cache); $driverImpl = $config->newDefaultAnnotationDriver(array(__DIR__ . "/Entities")); $config->setMetadataDriverImpl($driverImpl); $config->setQueryCacheImpl($cache); // Proxy configuration $config->setProxyDir(__DIR__ . '/Proxies'); $config->setProxyNamespace('Proxies'); $config->setMetadataCacheImpl(new \Doctrine\Common\Cache\ArrayCache()); // Database connection information $connectionOptions = array('driver' => 'pdo_sqlite', 'path' => __DIR__ . '/database.sqlite'); // Create EntityManager $em = EntityManager::create($connectionOptions, $config); return $em; }
public function __construct() { //cargamos la configuración de base de datos de codeigniter require APPPATH . "config/database.php"; //utilizamos el namespace Entities para mapear el directorio models $entitiesClassLoader = new ClassLoader('Entities', rtrim(APPPATH . "models")); $entitiesClassLoader->register(); //utilizamos el namespace Proxies para mapear el directorio models/proxies $proxiesClassLoader = new ClassLoader('Proxies', APPPATH . 'models/proxies'); $proxiesClassLoader->register(); // Configuración y chaché $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); // Configuración Proxy $config->setProxyDir(APPPATH . '/models/proxies'); $config->setProxyNamespace('Proxies'); // Habilitar el logger para obtener información de cada proceso $logger = new EchoSQLLogger(); //$config->setSQLLogger($logger); $config->setAutoGenerateProxyClasses(TRUE); //configuramos la conexión con la base de datos utilizando las credenciales de nuestra app $connectionOptions = array('driver' => 'pdo_mysql', 'user' => $db["default"]["username"], 'password' => $db["default"]["password"], 'host' => $db["default"]["hostname"], 'dbname' => $db["default"]["database"]); // Creamos el EntityManager $this->em = EntityManager::create($connectionOptions, $config); }
public function __construct() { $this->setRoot("/var/www/html/uan/"); $this->setEntidade(array($this->getRoot() . "models/")); $this->setIsDevMode(true); $mode = "DESENVOLVIMENTO"; $config = Setup::createAnnotationMetadataConfiguration($this->getEntidade(), $this->getIsDevMode(), NULL, NULL, FALSE); if ($mode == "DESENVOLVIMENTO") { $cache = new \Doctrine\Common\Cache\ArrayCache(); } else { $cache = new \Doctrine\Common\Cache\ApcCache(); } $config = new Configuration(); $config->setMetadataCacheImpl($cache); $driverImpl = $config->newDefaultAnnotationDriver($this->getRoot() . 'models/'); $config->setMetadataDriverImpl($driverImpl); $config->setQueryCacheImpl($cache); $config->setProxyDir($this->getRoot() . 'proxies/'); $config->setProxyNamespace('proxies'); if ($mode == "DESENVOLVIMENTO") { $config->setAutoGenerateProxyClasses(true); } else { $config->setAutoGenerateProxyClasses(false); } $config = Setup::createAnnotationMetadataConfiguration($this->getEntidade(), $this->getIsDevMode(), NULL, NULL, FALSE); $dbParams = array('driver' => 'pdo_mysql', 'user' => 'root', 'password' => '', 'dbname' => 'ceafie', 'charset' => 'utf8', 'driverOptions' => array(1002 => 'SET NAMES utf8')); $this->em = EntityManager::create($dbParams, $config); $loader = new ClassLoader('Entity', __DIR__ . '/models'); $loader->register(); }
public function __construct() { if (defined('FCPATH')) { //Get CI instance $this->ci = CI_Controller::get_instance(); //Load database configuration from CodeIgniter $this->db = $this->ci->db; //Database connection information $connectionOptions = array('user' => $this->db->username, 'password' => $this->db->password, 'host' => $this->db->hostname, 'dbname' => $this->db->database); } elseif (ENVIRONMENT === 'development') { include_once str_replace("/", DIRECTORY_SEPARATOR, APPPATH) . 'config' . DIRECTORY_SEPARATOR . 'development' . DIRECTORY_SEPARATOR . 'database.php'; $connectionOptions = array('user' => $db['default']['username'], 'password' => $db['default']['password'], 'host' => $db['default']['hostname'], 'dbname' => $db['default']['database']); } $connectionOptions['driver'] = 'pdo_mysql'; $connectionOptions['charset'] = 'utf8'; $connectionOptions['driverOptions'] = array(1002 => 'SET NAMES utf8'); $config = new Configuration(); //Set up caches $cache = new ArrayCache(); $config->setMetadataCacheImpl($cache); $config->setQueryCacheImpl($cache); //Set up Annotation $driverImpl = $config->newDefaultAnnotationDriver(array(APPPATH . 'models/Entities')); $config->setMetadataDriverImpl($driverImpl); //Proxy configuration $config->setProxyDir(APPPATH . '/models/proxies'); $config->setProxyNamespace('Proxies'); $config->setAutoGenerateProxyClasses(TRUE); // Create EntityManager $this->em = EntityManager::create($connectionOptions, $config); //Fix the problem: "unknown database type enum requested" $platform = $this->em->getConnection()->getDatabasePlatform(); $platform->registerDoctrineTypeMapping('enum', 'string'); }
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; }
public function __construct($config) { if (isset($config["doctrine"])) { $dbParams = $config["doctrine"]["db_params"]; $paths = StringCommon::replaceKeyWords($config["doctrine"]["entity_paths"]); $isDevMode = $config["doctrine"]["is_dev_mode"]; $proxyDir = StringCommon::replaceKeyWords($config["doctrine"]["proxy_dir"]); $proxyNamespace = $config["doctrine"]["proxy_namespace"]; $applicationMode = Game::getInstance()->getApplicationMode(); if ($applicationMode == Game::DEVELOPMENT_MODE) { $cache = new \Doctrine\Common\Cache\ArrayCache(); } else { $cache = new \Doctrine\Common\Cache\ApcCache(); } $doctrineConfig = new Configuration(); $doctrineConfig->setMetadataCacheImpl($cache); $driverImpl = $doctrineConfig->newDefaultAnnotationDriver($paths); $doctrineConfig->setMetadataDriverImpl($driverImpl); $doctrineConfig->setQueryCacheImpl($cache); $doctrineConfig->setProxyDir($proxyDir); $doctrineConfig->setProxyNamespace($proxyNamespace); if ($applicationMode == Game::DEVELOPMENT_MODE) { $doctrineConfig->setAutoGenerateProxyClasses(true); } else { $doctrineConfig->setAutoGenerateProxyClasses(false); } $entityManager = EntityManager::create($dbParams, $doctrineConfig); Game::getInstance()->getContainer()->set("entity_manager", $entityManager); } else { throw new \RuntimeException("You need add Doctrine config in your res/config.yml"); } }
private function loadDoctrine($dbname, $host, $username, $password) { $lib = APPLICATION_PATH . "/doctrine-orm"; Doctrine\ORM\Tools\Setup::registerAutoloadDirectory($lib); if (APPLICATION_ENV == "production") { $cache = new \Doctrine\Common\Cache\ApcCache(); } else { $cache = new \Doctrine\Common\Cache\ArrayCache(); } $config = new Configuration(); $config->setMetadataCacheImpl($cache); $driverImpl = $config->newDefaultAnnotationDriver(APPLICATION_PATH . '/modules/default/models'); $config->setMetadataDriverImpl($driverImpl); $config->setQueryCacheImpl($cache); $config->setProxyDir(APPLICATION_PATH . '/Proxies'); $config->setProxyNamespace('EasyCMS\\Proxies'); if ($applicationMode == "production") { $config->setAutoGenerateProxyClasses(false); } else { $config->setAutoGenerateProxyClasses(true); } $connectionOptions = array('driver' => 'pdo_mysql', 'dbname' => $dbname, 'user' => $username, 'password' => $password, 'host' => $host); $em = EntityManager::create($connectionOptions, $config); Zend_Registry::set('**application_db_connection**', $em); }
/** * Init the doctrine entity manager. * * @return Doctrine\ORM\EntityManager */ private function _initEntityManager() { // New database configuration $config = new Configuration(); $driverImpl = $config->newDefaultAnnotationDriver(); $config->setMetadataDriverImpl($driverImpl); $proxiesPath = $this->_application->getCacheDir() . DIRECTORY_SEPARATOR . 'Proxies'; $config->setProxyDir($proxiesPath); $config->setProxyNamespace('Proxies'); // Create EntityManager $em = EntityManager::create($this->_config, $config); if (isset($this->_config['charset'])) { try { $em->getConnection()->executeUpdate('SET SESSION character_set_client = "' . addslashes($this->_config['charset']) . '";'); $em->getConnection()->executeUpdate('SET SESSION character_set_connection = "' . addslashes($this->_config['charset']) . '";'); $em->getConnection()->executeUpdate('SET SESSION character_set_results = "' . addslashes($this->_config['charset']) . '";'); } catch (\Exception $e) { throw new BBException(sprintf('Invalid database character set `%s`', $this->_config['charset']), BBException::INVALID_ARGUMENT, $e); } } if (isset($this->_config['collation'])) { try { $em->getConnection()->executeUpdate('SET SESSION collation_connection = "' . addslashes($this->_config['collation']) . '";'); } catch (\Exception $e) { throw new BBException(sprintf('Invalid database collation `%s`', $this->_config['collation']), BBException::INVALID_ARGUMENT, $e); } } return $em; }
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; }
public function __construct() { //Set up class loading. You cold use different autoloaders, provider by your //if you want to. require_once APPPATH . 'third_party/DoctrineORM-2.2.2/libraries/Doctrine/Common/ClassLoader.php'; require_once APPPATH . 'third_party/DoctrineORM-2.2.2/libraries/Doctrine/ORM/Tools/Setup.php'; Doctrine\ORM\Tools\Setup::registerAutoloadDirectory(APPPATH . 'third_party/DoctrineORM-2.2.2/libraries/'); $doctrineClassLoader = new ClassLoader('Doctrine', APPPATH . 'third_party/DoctrineORM-2.2.2/libraries'); $doctrineClassLoader->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([APPPATH . 'models/Entities']); $config->setMetadataDriverImpl($driverImpl); $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); include APPPATH . 'config/database.php'; //Database connection information $connectionOptions = ['driver' => 'pdo_mysql', 'user' => $db['default']['username'], 'password' => $db['default']['password'], 'host' => $db['default']['hostname'], 'dbname' => $db['default']['database'], 'charset' => $db['default']['char_set'], 'driverOptions' => [1002 => 'SET NAMES utf8']]; //Enforce connection character set. This is very important if you are //using MySQL and InnoDB tables! //Doctrine_Manager::connection()->setCharset('utf8'); //Doctrine_Manager::connection()->setCollate('utf8_general_ci'); //Create EntityManager $this->em = EntityManager::create($connectionOptions, $config); }
public function __construct() { // load database configuration from CodeIgniter if (!file_exists($file_path = APPPATH . 'config/' . ENVIRONMENT . '/database.php') && !file_exists($file_path = APPPATH . 'config/database.php')) { throw new Exception('The configuration file database.php does not exist.'); } require $file_path; $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 = $this->convertDbConfig($db['default']); // Create EntityManager $this->em = EntityManager::create($connectionOptions, $config); }
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 __construct() { // load database configuration from CodeIgniter require APPPATH . 'config/database.php'; //A Doctrine Autoloader is needed to load the models // first argument of classloader is namespace and second argument is path // setup models/entity namespace $entityLoader = new ClassLoader('models', APPPATH); $entityLoader->register(); foreach (glob(APPPATH . 'modules/*', GLOB_ONLYDIR) as $m) { $module = str_replace(APPPATH . 'modules/', '', $m); $entityLoader = new ClassLoader($module, APPPATH . 'modules'); $entityLoader->register(); } //Register proxies namespace $proxyLoader = new ClassLoader('Proxies', APPPATH . 'Proxies'); $proxyLoader->register(); // Set up caches $config = new Configuration(); $cache = new ArrayCache(); $config->setMetadataCacheImpl($cache); $driverImpl = $config->newDefaultAnnotationDriver(array(APPPATH . 'models')); $config->setMetadataDriverImpl($driverImpl); $config->setQueryCacheImpl($cache); // Set up entity $reader = new AnnotationReader($cache); $models = array(APPPATH . 'models'); foreach (glob(APPPATH . 'modules/*/models', GLOB_ONLYDIR) as $m) { array_push($models, $m); } $driver = new AnnotationDriver($reader, $models); $config->setMetadataDriverImpl($driver); // Setup Gedmo $cachedAnnotationReader = new Doctrine\Common\Annotations\CachedReader($reader, $cache); // create a driver chain for metadata reading $driverChain = new Doctrine\ORM\Mapping\Driver\DriverChain(); // load superclass metadata mapping only, into driver chain // also registers Gedmo annotations.NOTE: you can personalize it Gedmo\DoctrineExtensions::registerAbstractMappingIntoDriverChainORM($driverChain, $cachedAnnotationReader); $event = new EventManager(); $timestampableListener = new TimestampableListener(); $timestampableListener->setAnnotationReader($cachedAnnotationReader); $event->addEventSubscriber($timestampableListener); $slugListener = new SluggableListener(); $slugListener->setAnnotationReader($cachedAnnotationReader); $event->addEventSubscriber($slugListener); // Proxy configuration $config->setProxyDir(APPPATH . '/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, $event); }
/** * Create a mapping driver. * * @param Configuration $configuration * @return \Doctrine\Common\Persistence\Mapping\Driver\MappingDriver */ protected function createOrmMappingDriver(Configuration $configuration) { $entityClasses = $this->getEntityClasses(); $entityClasses[] = $this->getRepositoryObjectClass(); $entityPaths = array_unique(array_map(function ($className) { $info = new \ReflectionClass($className); return dirname($info->getFileName()); }, $entityClasses)); return new StrictEntityDriverDecorator($configuration->newDefaultAnnotationDriver($entityPaths, false), $entityClasses); }
/** * Return's the new driver instance. * * @param Doctrine\ORM\Configuration $configuration The DBAL configuration to create the driver for * @param array $paths The path to the driver configuration * @param array $params The additional configuration params * * @return Doctrine\Common\Persistence\Mapping\Driver\MappingDriver The driver instance */ public static function get(Configuration $configuration, array $paths = array(), array $params = array()) { // query whether or not we want to use the simple annotation reader $useSimpleAnnotationReader = false; if (isset($params[DriverKeys::USE_SIMPLE_ANNOTATION_READER])) { $useSimpleAnnotationReader = $params[DriverKeys::USE_SIMPLE_ANNOTATION_READER]; } // create and return the driver instance return $configuration->newDefaultAnnotationDriver($paths, $useSimpleAnnotationReader); }
/** * Initialize metadata driver from resource options. * * @return void */ protected function _initMetadataDriver() { $options = $this->getOptions(); $mappingPaths = $options['metadata']['mappingPaths']; $driver = $options['metadata']['driver']; switch ($driver) { case 'yaml': $driver = new YamlDriver($mappingPaths); break; case 'xml': $driver = new XmlDriver($mappingPaths); break; case 'php': $driver = new PhpDriver($mappingPaths); break; default: $driver = $this->_config->newDefaultAnnotationDriver($mappingPaths); } $this->_config->setMetadataDriverImpl($driver); }
/** * Entidades::configuracion() * * Genera el proceso de configuracion y preparacion * de los directorios de las entidades * * @return object */ private function configuracion() { $confg = new Configuration(); $confg->setMetadataDriverImpl($confg->newDefaultAnnotationDriver($this->dirEntidades)); $confg->setMetadataCacheImpl(new ArrayCache()); $confg->setProxyDir($this->dirProxy); $confg->setProxyNamespace('Proxy'); $confg->setAutoGenerateProxyClasses(true); $confg->setEntityNamespaces(array('Entidades\\' . $this->conexion . '\\' => $this->dirEntidades)); $this->entityManager($confg); }
public function _getDefaultORMConfig() { $ormConfig = new ORM\Configuration(); $pathToEntities = array(__DIR__ . '/Entities'); $ORMDriver = $ormConfig->newDefaultAnnotationDriver($pathToEntities, false); $ormConfig->setMetadataDriverImpl($ORMDriver); // Do proxy stuff $ormConfig->setProxyDir(__DIR__ . '/Entities/Proxies'); $ormConfig->setProxyNamespace('DrestTests\\Entities\\Proxies'); $ormConfig->setAutoGenerateProxyClasses(true); return $ormConfig; }
/** * @return EntityManager */ protected function getMockEntityManager() { if (isset($this->mockEntityManager)) { return $this->mockEntityManager; } $config = new Configuration(); $config->setMetadataCacheImpl(new ArrayCache()); $config->setProxyDir(__DIR__ . '/Proxies'); $config->setProxyNamespace('CrEOF\\Spatial\\Tests\\Proxies'); $config->setMetadataDriverImpl($config->newDefaultAnnotationDriver(array(realpath(__DIR__ . '/Fixtures')), true)); return EntityManager::create($this->getMockConnection(), $config); }
/** * @return \Doctrine\ORM\EntityManager */ public function createEntityManager($conn, OrmConf $config = null, $eventManager = null) { if (empty($config)) { $config = new OrmConf(); $config->setAutoCommit($this->autoCommit); $annotationDriver = $config->newDefaultAnnotationDriver($this->entitiesPaths); $config->setMetadataDriverImpl($annotationDriver); $config->setProxyDir($this->proxyDir); $config->setProxyNamespace($this->proxyNamespace); } return EntityManager::create($conn, $config, $eventManager); }
protected function setUp() { $configuration = new Configuration(); $driverImpl = $configuration->newDefaultAnnotationDriver(__DIR__ . '/../../../../Model/Doctrine/ORM'); $configuration->setMetadataDriverImpl($driverImpl); $configuration->setProxyDir(__DIR__ . '/../../Model/Doctrine/ORM/Proxy'); $configuration->setProxyNamespace('Proxy'); $configuration->setAutoGenerateProxyClasses(true); $this->entityManager = EntityManager::create(array('driver' => 'pdo_sqlite', 'path' => ':memory:'), $configuration); $schemaTool = new SchemaTool($this->entityManager); $schemaTool->createSchema($this->entityManager->getMetadataFactory()->getAllMetadata()); }