/**
* {@inheritdoc}
*/
public function setType(Type $type)
{
if ($this->constructed) {
$this->setOptions([OroOptions::KEY => [ExtendOptionsManager::TYPE_OPTION => $type->getName()]]);
}
return parent::setType($type);
}
public static function getTypeByDoctrineType(Type $type)
{
$mapping = array_flip(self::$mapping);
if (isset($mapping[$type->getName()])) {
return $mapping[$type->getName()];
} else {
return TableInterface::TYPE_VARCHAR;
}
}
/**
* {@inheritdoc}
*/
public function isCommentedDoctrineType(Type $doctrineType)
{
if ($doctrineType->getName() === Type::BOOLEAN) {
// We require a commented boolean type in order to distinguish between boolean and smallint
// as both (have to) map to the same native type.
return true;
}
return parent::isCommentedDoctrineType($doctrineType);
}
public function testArray()
{
$photo = new Photo();
$photo->setNom('wohoo');
$serialized = $this->type->convertToDatabaseValue([$photo], $this->plateform);
$unserialized = $this->type->convertToPHPValue($serialized, $this->plateform);
$this->assertInstanceOf(Photo::class, $unserialized[0]);
/** @var Photo $var */
$var = $unserialized[0];
$this->assertEquals('wohoo', $var->getNom());
}
public function doctrineColumnLookup($col_lookup)
{
if (isset($this->options['expr']) && isset($col_lookup[$this->options['expr']])) {
/**
* @var $col Column
*/
$col = $col_lookup[$this->options['expr']];
$this->type = $col->getType();
$this->typeName = self::simplifyTypeName($this->type->getName());
}
}
/**
* @param Schema $schema
* @param QueryBag $queries
* @param string $tableName
* @param string $columnName
* @param string $type
*
* @throws \Exception
*/
public function changePrimaryKeyType(Schema $schema, QueryBag $queries, $tableName, $columnName, $type)
{
$targetColumn = $schema->getTable($tableName)->getColumn($columnName);
$type = Type::getType($type);
if ($targetColumn->getType() === $type) {
return;
}
/** @var ForeignKeyConstraint[] $foreignKeys */
$foreignKeys = [];
foreach ($schema->getTables() as $table) {
/** @var ForeignKeyConstraint[] $tableForeignKeys */
$tableForeignKeys = array_filter($table->getForeignKeys(), function (ForeignKeyConstraint $tableForeignKey) use($tableName, $columnName) {
if ($tableForeignKey->getForeignTableName() !== $tableName) {
return false;
}
return $tableForeignKey->getForeignColumns() === [$columnName];
});
foreach ($tableForeignKeys as $tableForeignKey) {
$foreignKeys[$tableForeignKey->getName()] = $tableForeignKey;
$foreignKeyTableName = $tableForeignKey->getLocalTable()->getName();
$foreignKeyColumnNames = $tableForeignKey->getLocalColumns();
$queries->addPreQuery($this->platform->getDropForeignKeySQL($tableForeignKey, $foreignKeyTableName));
$column = $schema->getTable($foreignKeyTableName)->getColumn(reset($foreignKeyColumnNames));
if ($column instanceof ExtendColumn) {
$column->disableExtendOptions()->setType($type)->enableExtendOptions();
} else {
$column->setType($type);
}
}
}
$targetColumn->setType($type);
foreach ($foreignKeys as $foreignKey) {
$queries->addPostQuery($this->platform->getCreateForeignKeySQL($foreignKey, $foreignKey->getLocalTable()));
}
}
/**
* 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);
}
protected function convertResultsInternal($results, AbstractPlatform $platform, CaseSensor $sensor)
{
if (is_array($results)) {
$results = current($results);
}
return Type::getType($this->type)->convertToPHPValue($results, $platform);
}
/**
* {@inheritdoc}
*/
protected function _getPortableTableColumnDefinition($tableColumn)
{
$tableColumn = array_change_key_case($tableColumn, \CASE_LOWER);
$length = null;
$fixed = null;
$unsigned = false;
$scale = false;
$precision = false;
$type = $this->_platform->getDoctrineTypeMapping($tableColumn['typename']);
switch (strtolower($tableColumn['typename'])) {
case 'varchar':
$length = $tableColumn['length'];
$fixed = false;
break;
case 'character':
$length = $tableColumn['length'];
$fixed = true;
break;
case 'clob':
$length = $tableColumn['length'];
break;
case 'decimal':
case 'double':
case 'real':
$scale = $tableColumn['scale'];
$precision = $tableColumn['length'];
break;
}
$options = array('length' => $length, 'unsigned' => (bool) $unsigned, 'fixed' => (bool) $fixed, 'default' => $tableColumn['default'] == "NULL" ? null : $tableColumn['default'], 'notnull' => (bool) ($tableColumn['nulls'] == 'N'), 'scale' => null, 'precision' => null, 'platformOptions' => array());
if ($scale !== null && $precision !== null) {
$options['scale'] = $scale;
$options['precision'] = $precision;
}
return new Column($tableColumn['colname'], \Doctrine\DBAL\Types\Type::getType($type), $options);
}
public function buildForm(FormBuilderInterface $builder, array $options)
{
$schemaManager = $this->container['db']->getSchemaManager();
foreach ($schemaManager->listTableColumns($this->table) as $column) {
// here we try to display nicely database relations w/ foreign keys
if (false !== strpos($column->getName(), '_id')) {
$table = str_replace('_id', '', $column->getName());
$dataMap = new DataMap($this->container['db'], $schemaManager);
$choices = $dataMap->mapForeignKeys($table, $column);
if (is_array($choices)) {
$column->setType(Type::getType('array'));
}
}
switch ($column->getType()) {
case 'Integer':
$builder->add($column->getName(), 'integer', array('read_only' => $column->getName() === 'id' ? true : false, 'required' => $column->getNotNull()));
break;
case 'Array':
$builder->add($column->getName(), 'choice', array('choices' => $choices, 'required' => $column->getNotNull()));
break;
case 'Boolean':
$builder->add($column->getName(), 'checkbox', array('required' => false));
break;
case 'String':
$builder->add($column->getName(), 'text', array('required' => $column->getNotNull()));
break;
case 'Text':
$builder->add($column->getName(), 'textarea', array('required' => $column->getNotNull()));
break;
}
}
}
protected function setUp()
{
parent::setUp();
DDC2494TinyIntType::$calls = array();
Type::addType('ddc2494_tinyint', __NAMESPACE__ . '\\DDC2494TinyIntType');
$this->_schemaTool->createSchema(array($this->_em->getClassMetadata(DDC2494Currency::CLASSNAME), $this->_em->getClassMetadata(DDC2494Campaign::CLASSNAME)));
}
protected function setUp()
{
parent::setUp();
Type::addType(DDC2012TsVectorType::MYTYPE, __NAMESPACE__ . '\\DDC2012TsVectorType');
DDC2012TsVectorType::$calls = array();
$this->_schemaTool->createSchema(array($this->_em->getClassMetadata(__NAMESPACE__ . '\\DDC2012Item'), $this->_em->getClassMetadata(__NAMESPACE__ . '\\DDC2012ItemPerson')));
}
/**
* Create service
*
* @param ServiceLocatorInterface $validators
* @return mixed
*/
public function createService(ServiceLocatorInterface $validators)
{
if (isset($this->options['enum'])) {
$this->options['enum'] = DoctrineType::getType($this->options['enum']);
}
return new EnumValidator($this->options);
}
public function boot()
{
if (!Type::hasType('branch_logo')) {
Type::addType('branch_logo', 'Diamante\\DeskBundle\\Infrastructure\\Persistence\\Doctrine\\DBAL\\Types\\BranchLogoType');
}
if (!Type::hasType('priority')) {
Type::addType('priority', 'Diamante\\DeskBundle\\Infrastructure\\Persistence\\Doctrine\\DBAL\\Types\\TicketPriorityType');
}
if (!Type::hasType('file')) {
Type::addType('file', 'Diamante\\DeskBundle\\Infrastructure\\Persistence\\Doctrine\\DBAL\\Types\\AttachmentFileType');
}
if (!Type::hasType('status')) {
Type::addType('status', 'Diamante\\DeskBundle\\Infrastructure\\Persistence\\Doctrine\\DBAL\\Types\\TicketStatusType');
}
if (!Type::hasType('source')) {
Type::addType('source', 'Diamante\\DeskBundle\\Infrastructure\\Persistence\\Doctrine\\DBAL\\Types\\TicketSourceType');
}
if (!Type::hasType('ticket_sequence_number')) {
Type::addType('ticket_sequence_number', 'Diamante\\DeskBundle\\Infrastructure\\Persistence\\Doctrine\\DBAL\\Types\\TicketSequenceNumberType');
}
if (!Type::hasType('ticket_unique_id')) {
Type::addType('ticket_unique_id', 'Diamante\\DeskBundle\\Infrastructure\\Persistence\\Doctrine\\DBAL\\Types\\TicketUniqueIdType');
}
foreach ($this->dataAuditTypes as $type) {
if (!AuditFieldTypeRegistry::hasType($type)) {
AuditFieldTypeRegistry::addType($type, $type);
}
}
$em = $this->container->get('doctrine.orm.default_entity_manager');
$conn = $em->getConnection();
$conn->getDatabasePlatform()->registerDoctrineTypeMapping('FILE', 'string');
}
public static function getEntityManager($smart = FALSE, $path_to_entity = null, $proxyPath = null, $proxyNamespace = null)
{
if (empty(self::$em)) {
if ($path_to_entity === NULL) {
//$path_to_entity = PATH_ROOT . '/' . Sokol::getApp()->name . '/Entity';
$path_to_entity = PATH_ROOT . '/Entity';
}
$isDev = Sokol::getApp()->isDev;
$connectionParams = Sokol::getConfig('db');
//---Table Prefix---
$tablePrefix = !empty($connectionParams['tablePrefix']) ? $connectionParams['tablePrefix'] : null;
if ($tablePrefix) {
$evm = new EventManager();
$tablePrefix = new TablePrefix($tablePrefix);
$evm->addEventListener(Events::loadClassMetadata, $tablePrefix);
}
//---/Table Prefix---
if ($smart) {
self::$em = self::getEmSmart($path_to_entity, $isDev, $connectionParams, $evm);
} else {
if ($proxyPath === NULL) {
$proxyPath = PATH_ROOT . '/' . Sokol::getApp()->name . '/Proxy';
}
if ($proxyNamespace === NULL) {
$proxyNamespace = Sokol::getApp()->getNamespace() . '\\Proxy';
}
self::$em = self::getEm($path_to_entity, $isDev, $connectionParams, $evm, $proxyPath, $proxyNamespace);
}
//подключаем тип данных "html"
Type::addType('html', 'Sokol\\Doctrine\\Extension\\HtmlType');
self::$em->getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping('db_html', 'html');
}
return self::$em;
}
/**
* Adds doctrine point type
*
* @param LoadClassMetadataEventArgs $eventArgs
*/
public function loadClassMetadata(LoadClassMetadataEventArgs $eventArgs)
{
$classMetadata = $eventArgs->getClassMetadata();
if (null === $classMetadata->reflClass) {
return;
}
if ($this->isGeocodable($classMetadata)) {
if (!Type::hasType('point')) {
Type::addType('point', 'Knp\\DoctrineBehaviors\\DBAL\\Types\\PointType');
}
$em = $eventArgs->getEntityManager();
$con = $em->getConnection();
// skip non-postgres platforms
if (!$con->getDatabasePlatform() instanceof PostgreSqlPlatform && !$con->getDatabasePlatform() instanceof MySqlPlatform) {
return;
}
// skip platforms with registerd stuff
if (!$con->getDatabasePlatform()->hasDoctrineTypeMappingFor('point')) {
$con->getDatabasePlatform()->registerDoctrineTypeMapping('point', 'point');
if ($con->getDatabasePlatform() instanceof PostgreSqlPlatform) {
$em->getConfiguration()->addCustomNumericFunction('DISTANCE', 'Knp\\DoctrineBehaviors\\ORM\\Geocodable\\Query\\AST\\Functions\\DistanceFunction');
}
}
$classMetadata->mapField(['fieldName' => 'location', 'type' => 'point', 'nullable' => true]);
}
}
public function __construct(Connection $con)
{
$this->con = $con;
$this->platform = $con->getDatabasePlatform();
$this->phpType = Type::getType(PhpTypeType::NAME);
$this->insertStmt = $con->prepare(self::INSERT_SQL);
}
/**
* Boots the bundle
*
* @return void
*/
public function boot()
{
if ($this->container->has('doctrine')) {
Type::addType(MbStringType::TYPE_NAME, MbStringType::class);
Type::addType(StdStringType::TYPE_NAME, StdStringType::class);
Type::addType(DateTimeType::TYPE_NAME, DateTimeType::class);
Type::addType(DateType::TYPE_NAME, DateType::class);
Type::addType(TimeType::TYPE_NAME, TimeType::class);
Type::addType(TimezoneType::TYPE_NAME, TimezoneType::class);
Type::addType(UuidType::TYPE_NAME, UuidType::class);
Type::addType(CurrencyType::TYPE_NAME, CurrencyType::class);
Type::addType(MoneyType::TYPE_NAME, MoneyType::class);
Type::addType(UriType::TYPE_NAME, UriType::class);
Type::addType(UrlType::TYPE_NAME, UrlType::class);
/** @var EntityManager $entityManager */
$entityManager = $this->container->get('doctrine')->getManager();
/** @var AbstractPlatform $platform */
$platform = $entityManager->getConnection()->getDatabasePlatform();
$platform->registerDoctrineTypeMapping('db_' . MbStringType::TYPE_NAME, MbStringType::TYPE_NAME);
$platform->registerDoctrineTypeMapping('db_' . StdStringType::TYPE_NAME, StdStringType::TYPE_NAME);
$platform->registerDoctrineTypeMapping('db_' . DateTimeType::TYPE_NAME, DateTimeType::TYPE_NAME);
$platform->registerDoctrineTypeMapping('db_' . DateType::TYPE_NAME, DateType::TYPE_NAME);
$platform->registerDoctrineTypeMapping('db_' . TimeType::TYPE_NAME, TimeType::TYPE_NAME);
$platform->registerDoctrineTypeMapping('db_' . TimezoneType::TYPE_NAME, TimezoneType::TYPE_NAME);
$platform->registerDoctrineTypeMapping('db_' . UuidType::TYPE_NAME, UuidType::TYPE_NAME);
$platform->registerDoctrineTypeMapping('db_' . CurrencyType::TYPE_NAME, CurrencyType::TYPE_NAME);
$platform->registerDoctrineTypeMapping('db_' . MoneyType::TYPE_NAME, MoneyType::TYPE_NAME);
$platform->registerDoctrineTypeMapping('db_' . UriType::TYPE_NAME, UriType::TYPE_NAME);
$platform->registerDoctrineTypeMapping('db_' . UrlType::TYPE_NAME, UrlType::TYPE_NAME);
}
}
protected function setUp()
{
$this->platform = $this->getMockBuilder('Doctrine\\DBAL\\Platforms\\AbstractPlatform')->setMethods(array('getVarcharTypeDeclarationSQL'))->getMockForAbstractClass();
$this->platform->expects($this->any())->method('getVarcharTypeDeclarationSQL')->will($this->returnValue('DUMMYVARCHAR()'));
$this->type = Type::getType('phone_number');
$this->phoneNumberUtil = PhoneNumberUtil::getInstance();
}
public function __construct($setConfigFiles = true)
{
if ($setConfigFiles) {
$this->configFile = __DIR__ . '/../../../config.php';
$this->localConfigFile = __DIR__ . '/../../../config.local.php';
}
parent::__construct();
$isDevMode = false;
$cache = new \Doctrine\Common\Cache\FilesystemCache(__DIR__ . '/../../tmp');
$config = Setup::createConfiguration($isDevMode, __DIR__ . '/../../tmp', $cache);
$config->setProxyDir(__DIR__ . '/../../tmp');
$config->setProxyNamespace('MyProject\\Proxies');
$config->setAutoGenerateProxyClasses(true);
$paths = [__DIR__ . '/../Entity'];
$driver = new \Doctrine\ORM\Mapping\Driver\AnnotationDriver(new AnnotationReader(), $paths);
\Doctrine\Common\Annotations\AnnotationRegistry::registerLoader('class_exists');
$config->setMetadataDriverImpl($driver);
//$config->setSQLLogger(new \Doctrine\DBAL\Logging\EchoSQLLogger());
$conn = ['driver' => 'mysqli', 'host' => '127.0.0.1', 'user' => $this->databaseFactory->getUserName(), 'password' => $this->databaseFactory->getPassword(), 'dbname' => $this->databaseFactory->getDatabaseName()];
$this->entityManager = EntityManager::create($conn, $config);
$this->entityManager->getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping('enum', 'string');
\Doctrine\DBAL\Types\Type::addType('enum', StringType::class);
$this->entityManager->getConfiguration()->addCustomStringFunction('DATE', DateFunction::class);
$this->user = $this->entityManager->createQueryBuilder()->select('u')->from(Sources\Tests\Entity\User::class, 'u');
}
/**
* @param array $column
*
* @return Column
*/
protected function _getPortableTableColumnDefinition($column)
{
$type = $this->orient2Doctrine[$column['type']];
$type = $this->_platform->getDoctrineTypeMapping($type);
$options = array('default' => isset($column['defaultValue']) ? $column['defaultValue'] : null, 'notnull' => isset($column['notNull']) ? $column['notNull'] : null, 'collate' => isset($column['collate']) ? $column['collate'] : null, 'length' => null, 'unsigned' => false, 'fixed' => false, 'scale' => null, 'precision' => null, 'autoincrement' => false, 'comment' => null);
return new Column($column['name'], Type::getType($type), $options);
}
/**
* {@inheritdoc}
*/
public function convertValue($value, array $options, ConversionHints $hints)
{
if (2 === $hints->conversionStrategy || 3 === $hints->conversionStrategy) {
return DBALType::getType('date')->convertToDatabaseValue($value, $hints->connection->getDatabasePlatform());
}
return (int) $value;
}
public function test_importSchemaArray()
{
$instance = new Xoops\Core\Database\Schema\ExportVisitor();
$table = new Doctrine\DBAL\Schema\Table('system_group');
$type = Type::getType(Type::INTEGER);
$col_name = 'groupid';
$column = new Doctrine\DBAL\Schema\Column($col_name, $type);
$instance->acceptColumn($table, $column);
$columns = array('groupid');
$fk_table = 'system_permission';
$fk_name = 'fk_name';
$fk_options = array('o' => 'o1');
$fk_columns = array('system_permission');
$fk_constraint = new Doctrine\DBAL\Schema\ForeignKeyConstraint($columns, $fk_table, $fk_columns, $fk_name, $fk_options);
$instance->acceptForeignKey($table, $fk_constraint);
$name = 'index_name';
$columns = array('name', 'description');
$unique = true;
$primary = true;
$index = new Doctrine\DBAL\Schema\Index($name, $columns, $unique, $primary);
$instance->acceptIndex($table, $index);
$name = 'sequence_name';
$alloc_size = 10;
$initial_value = 11;
$sequence = new Doctrine\DBAL\Schema\Sequence($name, $alloc_size, $initial_value);
$instance->acceptSequence($sequence);
$schema = $instance->getSchemaArray();
$import = new $this->myClass();
$value = $import->importSchemaArray($schema);
$this->assertInstanceOf('Doctrine\\DBAL\\Schema\\Schema', $value);
}
/**
* Walks down a SelectStatement AST node, modifying it to retrieve DISTINCT ids
* of the root Entity
*
* @param SelectStatement $AST
* @return void
*/
public function walkSelectStatement(SelectStatement $AST)
{
$parent = null;
$parentName = null;
$selectExpressions = array();
foreach ($this->_getQueryComponents() as $dqlAlias => $qComp) {
// preserve mixed data in query for ordering
if (isset($qComp['resultVariable'])) {
$selectExpressions[] = new SelectExpression($qComp['resultVariable'], $dqlAlias);
continue;
}
if ($qComp['parent'] === null && $qComp['nestingLevel'] == 0) {
$parent = $qComp;
$parentName = $dqlAlias;
continue;
}
}
$identifier = $parent['metadata']->getSingleIdentifierFieldName();
$this->_getQuery()->setHint(self::IDENTIFIER_TYPE, Type::getType($parent['metadata']->getTypeOfField($identifier)));
$pathExpression = new PathExpression(PathExpression::TYPE_STATE_FIELD | PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION, $parentName, $identifier);
$pathExpression->type = PathExpression::TYPE_STATE_FIELD;
array_unshift($selectExpressions, new SelectExpression($pathExpression, '_dctrn_id'));
$AST->selectClause->selectExpressions = $selectExpressions;
if (isset($AST->orderByClause)) {
foreach ($AST->orderByClause->orderByItems as $item) {
if ($item->expression instanceof PathExpression) {
$pathExpression = new PathExpression(PathExpression::TYPE_STATE_FIELD | PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION, $item->expression->identificationVariable, $item->expression->field);
$pathExpression->type = PathExpression::TYPE_STATE_FIELD;
$AST->selectClause->selectExpressions[] = new SelectExpression($pathExpression, '_dctrn_ord' . $this->_aliasCounter++);
}
}
}
$AST->selectClause->isDistinct = true;
}
/**
* @group DDC-1337
* @return void
*/
public function testCreateTemporaryTableNotAutoCommitTransaction()
{
if ($this->_conn->getDatabasePlatform()->getName() == 'sqlanywhere' || $this->_conn->getDatabasePlatform()->getName() == 'oracle') {
$this->markTestSkipped("Test does not work on Oracle and SQL Anywhere.");
}
$platform = $this->_conn->getDatabasePlatform();
$columnDefinitions = array("id" => array("type" => Type::getType("integer"), "notnull" => true));
$tempTable = $platform->getTemporaryTableName("my_temporary");
$createTempTableSQL = $platform->getCreateTemporaryTableSnippetSQL() . ' ' . $tempTable . ' (' . $platform->getColumnDeclarationListSQL($columnDefinitions) . ')';
$table = new Table("nontemporary");
$table->addColumn("id", "integer");
$table->setPrimaryKey(array('id'));
foreach ($platform->getCreateTableSQL($table) as $sql) {
$this->_conn->executeQuery($sql);
}
$this->_conn->beginTransaction();
$this->_conn->insert("nontemporary", array("id" => 1));
$this->_conn->exec($createTempTableSQL);
$this->_conn->insert("nontemporary", array("id" => 2));
$this->_conn->rollback();
try {
$this->_conn->exec($platform->getDropTemporaryTableSQL($tempTable));
} catch (\Exception $e) {
}
$rows = $this->_conn->fetchAll('SELECT * FROM nontemporary');
$this->assertEquals(array(), $rows, "In an event of an error this result has one row, because of an implicit commit.");
}
protected function setUp()
{
if (!Type::hasType(PercentType::TYPE)) {
Type::addType(PercentType::TYPE, 'Oro\\DBAL\\Types\\PercentType');
}
$this->percentType = Type::getType(PercentType::TYPE);
}
function let()
{
if (!Type::hasType(GeographicLocationType::NAME)) {
Type::addType(GeographicLocationType::NAME, 'DoctrineExt\\DBAL\\Types\\GeographicLocationType');
}
$this->beConstructedThrough('getType', [GeographicLocationType::NAME]);
}
public function boot()
{
if (!Type::hasType('string_simple_array')) {
// this should be optional if using a different ORM
Type::addType('string_simple_array', 'Giosh94mhz\\GeonamesBundle\\Doctrine\\Types\\StringSimpleArrayType');
}
}
public function testContainer()
{
$container = $this->createYamlBundleTestContainer();
$this->assertInstanceOf('Symfony\\Bridge\\Doctrine\\Logger\\DbalLogger', $container->get('doctrine.dbal.logger'));
$this->assertInstanceOf('Symfony\\Bridge\\Doctrine\\DataCollector\\DoctrineDataCollector', $container->get('data_collector.doctrine'));
$this->assertInstanceOf('Doctrine\\DBAL\\Configuration', $container->get('doctrine.dbal.default_connection.configuration'));
$this->assertInstanceOf('Doctrine\\Common\\EventManager', $container->get('doctrine.dbal.default_connection.event_manager'));
$this->assertInstanceOf('Doctrine\\DBAL\\Connection', $container->get('doctrine.dbal.default_connection'));
$this->assertInstanceOf('Doctrine\\Common\\Annotations\\Reader', $container->get('doctrine.orm.metadata.annotation_reader'));
$this->assertInstanceOf('Doctrine\\ORM\\Configuration', $container->get('doctrine.orm.default_configuration'));
$this->assertInstanceOf('Doctrine\\ORM\\Mapping\\Driver\\DriverChain', $container->get('doctrine.orm.default_metadata_driver'));
$this->assertInstanceOf('Doctrine\\Common\\Cache\\ArrayCache', $container->get('doctrine.orm.default_metadata_cache'));
$this->assertInstanceOf('Doctrine\\Common\\Cache\\ArrayCache', $container->get('doctrine.orm.default_query_cache'));
$this->assertInstanceOf('Doctrine\\Common\\Cache\\ArrayCache', $container->get('doctrine.orm.default_result_cache'));
$this->assertInstanceOf('Doctrine\\ORM\\EntityManager', $container->get('doctrine.orm.default_entity_manager'));
$this->assertInstanceOf('Doctrine\\DBAL\\Connection', $container->get('database_connection'));
$this->assertInstanceOf('Doctrine\\ORM\\EntityManager', $container->get('doctrine.orm.entity_manager'));
$this->assertInstanceOf('Doctrine\\Common\\EventManager', $container->get('doctrine.orm.default_entity_manager.event_manager'));
$this->assertInstanceOf('Doctrine\\Common\\EventManager', $container->get('doctrine.dbal.event_manager'));
$this->assertInstanceOf('Symfony\\Bridge\\Doctrine\\CacheWarmer\\ProxyCacheWarmer', $container->get('doctrine.orm.proxy_cache_warmer'));
$this->assertInstanceOf('Doctrine\\Common\\Persistence\\ManagerRegistry', $container->get('doctrine'));
$this->assertInstanceOf('Symfony\\Bridge\\Doctrine\\Validator\\Constraints\\UniqueEntityValidator', $container->get('doctrine.orm.validator.unique'));
$this->assertSame($container->get('my.platform'), $container->get('doctrine.dbal.default_connection')->getDatabasePlatform());
$this->assertTrue(Type::hasType('test'));
if (version_compare(PHP_VERSION, '5.3.6', '<')) {
$this->assertInstanceOf('Doctrine\\DBAL\\Event\\Listeners\\MysqlSessionInit', $container->get('doctrine.dbal.default_connection.events.mysqlsessioninit'));
} else {
$this->assertFalse($container->has('doctrine.dbal.default_connection.events.mysqlsessioninit'));
}
}
/**
* @return Schema[]
*/
protected function prepareSchemas()
{
Type::addType('int', 'Doctrine\\DBAL\\Types\\IntegerType');
$fromSchema = new Schema();
$table = $fromSchema->createTable('oro_entity_extend_test_table');
$table->addColumn('id', 'integer', ['autoincrement' => true]);
$table->addColumn('someExternalColumn', 'string');
$table->addColumn('relation_id', 'int');
$table->addIndex(['someExternalColumn'], 'some_external_index_name');
$table->setPrimaryKey(['id']);
$tableRelation = $fromSchema->createTable('oro_entity_extend_test_relation');
$tableRelation->addColumn('id', 'integer', ['autoincrement' => true]);
$tableRelation->addColumn('someExtendColumn', 'string');
$tableRelation->addIndex(['someExtendColumn'], 'oro_idx_index_name');
$tableRelation->setPrimaryKey(['id']);
$table->addForeignKeyConstraint($tableRelation, ['relation_id'], ['id']);
$toSchema = new Schema();
$table = $toSchema->createTable('oro_entity_extend_test_table');
$table->addColumn('id', 'integer', ['autoincrement' => true]);
$table->setPrimaryKey(['id']);
$tableRelation = $toSchema->createTable('oro_entity_extend_test_relation');
$tableRelation->addColumn('id', 'integer', ['autoincrement' => true]);
$tableRelation->setPrimaryKey(['id']);
return [$fromSchema, $toSchema];
}
