/** * Replaces default DateTime Doctrine types with their _immutable counterparts */ public static function replaceImmutableTypes() { Type::overrideType(Type::DATE, DateTimeImmutable\DateImmutableType::class); Type::overrideType(Type::DATETIME, DateTimeImmutable\DateTimeImmutableType::class); Type::overrideType(Type::DATETIMETZ, DateTimeImmutable\DateTimeTzImmutableType::class); Type::overrideType(Type::TIME, DateTimeImmutable\TimeImmutableType::class); }
/** * @param array $options * @param \Zend_Cache_Core $cache * @param \Enlight_Hook_HookManager $hookManager */ public function __construct($options, \Zend_Cache_Core $cache, \Enlight_Hook_HookManager $hookManager) { $this->setHookManager($hookManager); // Specifies the FQCN of a subclass of the EntityRepository. // That will be available for all entities without a custom repository class. $this->setDefaultRepositoryClassName('Shopware\\Components\\Model\\ModelRepository'); $this->setProxyDir($options['proxyDir']); $this->setProxyNamespace($options['proxyNamespace']); $this->setAutoGenerateProxyClasses(AbstractProxyFactory::AUTOGENERATE_FILE_NOT_EXISTS); $this->setAttributeDir($options['attributeDir']); $this->setFileCacheDir($options['fileCacheDir']); $this->addEntityNamespace('Shopware', 'Shopware\\Models'); $this->addEntityNamespace('Custom', 'Shopware\\CustomModels'); Type::overrideType('datetime', 'Shopware\\Components\\Model\\DBAL\\Types\\DateTimeStringType'); Type::overrideType('date', 'Shopware\\Components\\Model\\DBAL\\Types\\DateStringType'); Type::overrideType('array', 'Shopware\\Components\\Model\\DBAL\\Types\\AllowInvalidArrayType'); $this->addCustomStringFunction('DATE_FORMAT', 'Shopware\\Components\\Model\\Query\\Mysql\\DateFormat'); $this->addCustomStringFunction('IFNULL', 'Shopware\\Components\\Model\\Query\\Mysql\\IfNull'); $this->addCustomStringFunction('RegExp', 'Shopware\\Components\\Model\\Query\\Mysql\\RegExp'); $this->addCustomStringFunction('Replace', 'Shopware\\Components\\Model\\Query\\Mysql\\Replace'); // Load custom namespace for doctrine cache provider, if provided if (isset($options['cacheNamespace'])) { $this->cacheNamespace = $options['cacheNamespace']; } if (isset($options['cacheProvider'])) { $this->setCacheProvider($options['cacheProvider']); } if ($this->getMetadataCacheImpl() === null) { $this->setCacheResource($cache); } }
protected function setUp() { if (Type::hasType(ExtendedDataType::NAME)) { Type::overrideType(ExtendedDataType::NAME, 'JMS\\Payment\\CoreBundle\\Entity\\ExtendedDataType'); } else { Type::addType(ExtendedDataType::NAME, 'JMS\\Payment\\CoreBundle\\Entity\\ExtendedDataType'); } }
public function setUp() { if (Type::hasType('json')) { Type::overrideType('json', 'Sonata\\Doctrine\\Types\\JsonType'); } else { Type::addType('json', 'Sonata\\Doctrine\\Types\\JsonType'); } }
/** * @param $name * @param $class * * @throws \Doctrine\DBAL\DBALException */ public function addType($name, $class) { if (!Type::hasType($name)) { Type::addType($name, $class); } else { Type::overrideType($name, $class); } }
public function setUp() { if (Type::hasType('currency')) { Type::overrideType('currency', 'Sonata\\Component\\Currency\\CurrencyDoctrineType'); } else { Type::addType('currency', 'Sonata\\Component\\Currency\\CurrencyDoctrineType'); } }
protected function setUp() { if (DBALType::hasType('negative_to_positive')) { DBALType::overrideType('negative_to_positive', 'Doctrine\\Tests\\DbalTypes\\NegativeToPositiveType'); } else { DBALType::addType('negative_to_positive', 'Doctrine\\Tests\\DbalTypes\\NegativeToPositiveType'); } $this->_em = $this->_getTestEntityManager(); }
/** * Configures DBAL types required in tests */ protected function setUpDBALTypes() { if (Type::hasType('jsonb')) { Type::overrideType('jsonb', 'Boldtrn\\JsonbBundle\\Types\\JsonbArrayType'); } else { Type::addType('jsonb', 'Boldtrn\\JsonbBundle\\Types\\JsonbArrayType'); } $this->connection->getDatabasePlatform()->registerDoctrineTypeMapping('JSONB', 'jsonb'); }
protected function setUp() { $this->generator = \Mockery::mock(EnumTypeGenerator::class); $this->storage = \Mockery::mock(EnumTypeStorage::class); $this->sut = new EnumTypeRegistry($this->generator, $this->storage); if (Type::hasType('foobar')) { Type::overrideType('foobar', null); } }
public function boot() { // Register custom data types if (!Type::hasType('uniqueidentifier')) { Type::addType('uniqueidentifier', 'Realestate\\MssqlBundle\\Types\\UniqueidentifierType'); } Type::overrideType('date', 'Realestate\\MssqlBundle\\Types\\DateType'); Type::overrideType('datetime', 'Realestate\\MssqlBundle\\Types\\DateTimeType'); }
private function initializeTypes() { foreach ($this->typesConfig as $type => $className) { if (Type::hasType($type)) { Type::overrideType($type, $className); } else { Type::addType($type, $className); } } }
protected function setUp() { if (DBALType::hasType(CustomIdObjectType::NAME)) { DBALType::overrideType(CustomIdObjectType::NAME, CustomIdObjectType::CLASSNAME); } else { DBALType::addType(CustomIdObjectType::NAME, CustomIdObjectType::CLASSNAME); } $this->useModelSet('custom_id_object_type'); parent::setUp(); }
public function setUp() { // Type is a singleton. if (Type::hasType(self::TYPE_NAME)) { // Remove the type so it can be re-instantiated. Type::overrideType(self::TYPE_NAME, null); } Type::addType(self::TYPE_NAME, 'Omeka\\Db\\Type\\IpAddress'); $this->ipAddress = Type::getType(self::TYPE_NAME); $this->platform = $this->getMockForAbstractClass('Doctrine\\DBAL\\Platforms\\AbstractPlatform'); }
/** * {@inheritDoc} */ public function __construct() { parent::__construct(); $this->initializeDoctrineTypeMappings(); if (!Type::hasType(MapType::NAME)) { Type::addType(MapType::NAME, 'Crate\\DBAL\\Types\\MapType'); } if (!Type::hasType(TimestampType::NAME)) { Type::addType(TimestampType::NAME, 'Crate\\DBAL\\Types\\TimestampType'); } Type::overrideType('array', 'Crate\\DBAL\\Types\\ArrayType'); }
public function testSerialization() { $array = array('a' => 'b'); $encoded = base64_encode(serialize($array)); $platform = TestUtil::getEntityManager()->getConnection()->getDatabasePlatform(); Type::overrideType(Type::TARRAY, 'Oro\\DBAL\\Types\\ArrayType'); $type = Type::getType(Type::TARRAY); $actualDbValue = $type->convertToDatabaseValue($array, $platform); $this->assertEquals($encoded, $actualDbValue); $this->assertEquals($array, $type->convertToPHPValue($actualDbValue, $platform)); $this->assertEquals($array, $type->convertToPHPValue($encoded, $platform)); }
/** * initialize the types */ private function initializeTypes() { foreach ($this->typesConfig as $type => $typeConfig) { if (Type::hasType($type)) { Type::overrideType($type, $typeConfig['class']); } else { Type::addType($type, $typeConfig['class']); } if ($typeConfig['commented']) { $this->commentedTypes[] = $type; } } }
/** * @param ServiceLocatorInterface $serviceLocator * @param Configuration $config */ public function setupDBALConfiguration(ServiceLocatorInterface $serviceLocator, Configuration $config) { $options = $this->getOptions($serviceLocator); $config->setResultCacheImpl($serviceLocator->get($options->resultCache)); $config->setSQLLogger($options->sqlLogger); foreach ($options->types as $name => $class) { if (Type::hasType($name)) { Type::overrideType($name, $class); } else { Type::addType($name, $class); } } }
public function testSerialization() { $object = new \stdClass(); $object->a = 'test1'; $encoded = base64_encode(serialize($object)); $platform = TestUtil::getEntityManager()->getConnection()->getDatabasePlatform(); Type::overrideType(Type::OBJECT, 'Oro\\DBAL\\Types\\ObjectType'); $type = Type::getType(Type::OBJECT); $actualDbValue = $type->convertToDatabaseValue($object, $platform); $this->assertEquals($encoded, $actualDbValue); $this->assertEquals($object, $type->convertToPHPValue($actualDbValue, $platform)); $this->assertEquals($object, $type->convertToPHPValue($encoded, $platform)); }
function register_dbal_types() { $types = ['coast_url' => 'Coast\\Doctrine\\DBAL\\Types\\UrlType']; foreach ($types as $name => $class) { \Doctrine\DBAL\Types\Type::addType($name, $class); } if (class_exists('Carbon\\Carbon')) { $types = ['date' => 'Coast\\Doctrine\\DBAL\\Types\\CarbonDateType', 'time' => 'Coast\\Doctrine\\DBAL\\Types\\CarbonTimeType', 'datetime' => 'Coast\\Doctrine\\DBAL\\Types\\CarbonDateTimeType']; foreach ($types as $name => $class) { \Doctrine\DBAL\Types\Type::overrideType($name, $class); } } }
public function boot() { // Register custom data types if (!Type::hasType('uniqueidentifier')) { Type::addType('uniqueidentifier', 'Improvein\\MssqlBundle\\Types\\UniqueidentifierType'); } if (!Type::hasType('geography')) { Type::addType('geography', 'Improvein\\MssqlBundle\\Types\\PointType'); } Type::overrideType(Type::DATE, 'Improvein\\MssqlBundle\\Types\\DateType'); Type::overrideType(Type::DATETIME, 'Improvein\\MssqlBundle\\Types\\DateTimeType'); Type::overrideType(Type::TEXT, 'Improvein\\MssqlBundle\\Types\\TextType'); Type::overrideType(Type::STRING, 'Improvein\\MssqlBundle\\Types\\StringType'); }
/** * @param Configuration $ormConfiguration * @param Config $dbConfig * @return EntityManager */ public static function configure($dbConfig, Configuration $ormConfiguration) { Type::overrideType("datetime", 'Doctrine\\DBAL\\Types\\VarDateTimeType'); //новый биллинг семь знаков после секунды $ormConfiguration->setProxyDir(__DIR__ . '/Proxy'); $ormConfiguration->setProxyNamespace('Billing\\Proxy'); //$config->setSQLLogger(new Core\HtmlSqlLogger()); $eventManager = new \Doctrine\Common\EventManager(); $eventManager->addEventSubscriber(new \Doctrine\DBAL\Event\Listeners\SQLSessionInit('use billing35;')); //?$eventManager->addEventSubscriber($loggableListener); //dblib:host=217.114.191.214;dbname=planneddebtorsrollcall;','obzvon','qwerty123! $dbConfig = array("driver" => "pdo_sqlsrv", "user" => $dbConfig->user, "password" => $dbConfig->password, "host" => strtoupper(substr(PHP_OS, 0, 3)) === 'WIN' ? "217.114.191.214" : "ipsoft", "dbname" => $dbConfig->database, "driverOptions" => array("CharacterSet" => "UTF-8")); self::$_em = EntityManager::create($dbConfig, $ormConfiguration, $eventManager); return self::$_em; }
/** * Add a type. * * @param string $name * @param string $className * @param callable[] $calls an array of - [ methodName, [ methodParams... ] ] */ public function addType($name, $className, array $calls = []) { if (!Type::hasType($name)) { Type::addType($name, $className); } else { Type::overrideType($name, $className); } if (!empty($calls)) { $type = self::getType($name); foreach ($calls as $call) { call_user_func_array([$type, $call[0]], $call[1]); } } $this->entityManager->getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping($name, $name); }
protected function setUp() { if (DBALType::hasType('upper_case_string')) { DBALType::overrideType('upper_case_string', '\\Doctrine\\Tests\\DbalTypes\\UpperCaseStringType'); } else { DBALType::addType('upper_case_string', '\\Doctrine\\Tests\\DbalTypes\\UpperCaseStringType'); } if (DBALType::hasType('negative_to_positive')) { DBALType::overrideType('negative_to_positive', '\\Doctrine\\Tests\\DbalTypes\\NegativeToPositiveType'); } else { DBALType::addType('negative_to_positive', '\\Doctrine\\Tests\\DbalTypes\\NegativeToPositiveType'); } $this->useModelSet('customtype'); parent::setUp(); }
protected function setUp() { parent::setUp(); if (DBALType::hasType('negative_to_positive')) { DBALType::overrideType('negative_to_positive', '\\Doctrine\\Tests\\DbalTypes\\NegativeToPositiveType'); } else { DBALType::addType('negative_to_positive', '\\Doctrine\\Tests\\DbalTypes\\NegativeToPositiveType'); } if (DBALType::hasType('upper_case_string')) { DBALType::overrideType('upper_case_string', '\\Doctrine\\Tests\\DbalTypes\\UpperCaseStringType'); } else { DBALType::addType('upper_case_string', '\\Doctrine\\Tests\\DbalTypes\\UpperCaseStringType'); } $this->_em = $this->_getTestEntityManager(); $this->_persister = new BasicEntityPersister($this->_em, $this->_em->getClassMetadata("Doctrine\\Tests\\Models\\CustomType\\CustomTypeParent")); }
/** * @param ContainerInterface $container * @param Configuration $config */ public function setupDBALConfiguration(ContainerInterface $container, Configuration $config) { $options = $this->getOptions($container); $config->setResultCacheImpl($container->get($options->resultCache)); $sqlLogger = $options->sqlLogger; if (is_string($sqlLogger) and $container->has($sqlLogger)) { $sqlLogger = $container->get($sqlLogger); } $config->setSQLLogger($sqlLogger); foreach ($options->types as $name => $class) { if (Type::hasType($name)) { Type::overrideType($name, $class); } else { Type::addType($name, $class); } } }
/** * Registers all declared typed, if not already done. * * @param ContainerInterface $container */ private function registerTypes(ContainerInterface $container) { if (self::$areTypesRegistered) { return; } $applicationConfig = $container->has('config') ? $container->get('config') : []; $doctrineConfig = array_key_exists('doctrine', $applicationConfig) ? $applicationConfig['doctrine'] : []; $typesConfig = array_key_exists('types', $doctrineConfig) ? $doctrineConfig['types'] : []; foreach ($typesConfig as $name => $className) { if (Type::hasType($name)) { Type::overrideType($name, $className); continue; } Type::addType($name, $className); } self::$areTypesRegistered = true; }
public static function init($options) { if (empty($options)) { return false; } // Register custom data types. Type::addType('json', 'DF\\Doctrine\\Type\\Json'); Type::addType('unixdatetime', 'DF\\Doctrine\\Type\\UnixDateTime'); Type::overrideType('array', 'DF\\Doctrine\\Type\\SoftArray'); Type::overrideType('datetime', 'DF\\Doctrine\\Type\\UTCDateTime'); // Fetch and store entity manager. $em = self::getEntityManager($options); $conn = $em->getConnection(); $platform = $conn->getDatabasePlatform(); $platform->markDoctrineTypeCommented(Type::getType('json')); $platform->markDoctrineTypeCommented(Type::getType('unixdatetime')); return $em; }
public function onBootstrap(Event $e) { $application = $e->getApplication(); $eventManager = $application->getEventManager(); $eventManager->attach(MvcEvent::EVENT_DISPATCH, array($this, 'setApplicationSection')); $eventManager->attach(MvcEvent::EVENT_DISPATCH, array($this, 'setLayout'), 31); $eventManager->attach(MvcEvent::EVENT_DISPATCH_ERROR, array($this, 'setLayout'), 31); $app = $e->getParam('application'); $sm = $app->getServiceManager(); $evm = $sm->get('doctrine.eventmanager.orm_default'); $config = $sm->get('Config'); $tablePrefix = isset($config['doctrine']['connection']['orm_default']['params']['table_prefix']) ? $config['doctrine']['connection']['orm_default']['params']['table_prefix'] : FALSE; if ($tablePrefix) { $tablePrefix = new \Dxapp\Doctrine\Extension\TablePrefix($tablePrefix); $evm->addEventListener(\Doctrine\ORM\Events::loadClassMetadata, $tablePrefix); } $cache = $sm->get('doctrine.cache.memcache'); $annotationReader = new \Doctrine\Common\Annotations\AnnotationReader(); $cachedAnnotationReader = new \Doctrine\Common\Annotations\CachedReader($annotationReader, $cache); $em = $sm->get('doctrine.entitymanager.orm_default'); \Doctrine\DBAL\Types\Type::overrideType('datetime', 'Dxapp\\Doctrine\\Types\\UTCDatetimeType'); // $em->getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping('Datetime', 'datetime'); $sluggableListener = new \Gedmo\Sluggable\SluggableListener(); $sluggableListener->setAnnotationReader($cachedAnnotationReader); $evm->addEventSubscriber($sluggableListener); $treeListener = new \Gedmo\Tree\TreeListener(); $treeListener->setAnnotationReader($cachedAnnotationReader); $evm->addEventSubscriber($treeListener); $timestampableListener = new \Gedmo\Timestampable\TimestampableListener(); $timestampableListener->setAnnotationReader($cachedAnnotationReader); $evm->addEventSubscriber($timestampableListener); $translatableListener = new \Gedmo\Translatable\TranslatableListener(); $translatableListener->setAnnotationReader($cachedAnnotationReader); $translatableListener->setTranslatableLocale('en'); $translatableListener->setDefaultLocale('en'); $evm->addEventSubscriber($translatableListener); }
/** * Connect to the database sets the entity manager. * * @param array $params * @param string $sysPath * @param string $entityRootPath * * @throws \Doctrine\ORM\ORMException */ public function connect($params = array(), $sysPath = '', $entityRootPath = '') { $config = self::getDoctrineConfig($entityRootPath); $config->setAutoGenerateProxyClasses(true); $config->setEntityNamespaces(array('ChamiloUserBundle' => 'Chamilo\\UserBundle\\Entity', 'ChamiloCoreBundle' => 'Chamilo\\CoreBundle\\Entity', 'ChamiloCourseBundle' => 'Chamilo\\CourseBundle\\Entity')); $params['charset'] = 'utf8'; $entityManager = EntityManager::create($params, $config); $sysPath = !empty($sysPath) ? $sysPath : api_get_path(SYS_PATH); // Registering Constraints AnnotationRegistry::registerAutoloadNamespace('Symfony\\Component\\Validator\\Constraint', $sysPath . "vendor/symfony/symfony/src"); AnnotationRegistry::registerFile($sysPath . "vendor/symfony/symfony/src/Symfony/Bridge/Doctrine/Validator/Constraints/UniqueEntity.php"); // Registering gedmo extensions AnnotationRegistry::registerAutoloadNamespace('Gedmo\\Mapping\\Annotation', $sysPath . "vendor/gedmo/doctrine-extensions/lib"); Type::overrideType(Type::DATETIME, self::getUTCDateTimeTypeClass()); $listener = new \Gedmo\Timestampable\TimestampableListener(); $entityManager->getEventManager()->addEventSubscriber($listener); $listener = new \Gedmo\Tree\TreeListener(); $entityManager->getEventManager()->addEventSubscriber($listener); $listener = new \Gedmo\Sortable\SortableListener(); $entityManager->getEventManager()->addEventSubscriber($listener); $connection = $entityManager->getConnection(); $this->setConnection($connection); $this->setManager($entityManager); }
public function testCustomTypeValueSqlForPartialObject() { if (DBALType::hasType('negative_to_positive')) { DBALType::overrideType('negative_to_positive', 'Doctrine\\Tests\\DbalTypes\\NegativeToPositiveType'); } else { DBALType::addType('negative_to_positive', 'Doctrine\\Tests\\DbalTypes\\NegativeToPositiveType'); } $this->assertSqlGeneration('SELECT partial p.{id, customInteger} FROM Doctrine\\Tests\\Models\\CustomType\\CustomTypeParent p', 'SELECT c0_.id AS id0, -(c0_.customInteger) AS customInteger1 FROM customtype_parents c0_'); }