public function hydrateEntity($entity, array $values) { $classMetadata = $this->em->getClassMetadata(get_class($entity)); foreach ($values as $fieldName => $value) { if ($classMetadata->hasField($fieldName)) { $fieldMappping = $classMetadata->getFieldMapping($fieldName); if (null === $fieldMappping) { throw new HydrationException($fieldName); } $type = Type::getType($classMetadata->fieldMappings[$fieldName]['type']); $value = $type->convertToPHPValue($value, $this->em->getConnection()->getDatabasePlatform()); $classMetadata->setFieldValue($entity, $fieldName, $value); } elseif (isset($classMetadata->associationMappings[$fieldName])) { $fieldMapping = $classMetadata->associationMappings[$fieldName]; if (ClassMetadataInfo::MANY_TO_MANY === $fieldMapping['type']) { // expecting an array of ids in $value if (1 === count($fieldMapping['relationToTargetKeyColumns'])) { $columnName = array_pop($fieldMapping['relationToTargetKeyColumns']); $otherSideMapping = $this->em->getClassMetadata($fieldMapping['targetEntity']); $value = $this->em->getRepository($fieldMapping['targetEntity'])->findBy(array($otherSideMapping->fieldNames[$columnName] => $value)); } $classMetadata->setFieldValue($entity, $fieldName, $value); } elseif (ClassMetadataInfo::MANY_TO_ONE === $fieldMapping['type']) { // expecting an array of ids in $value $value = $this->em->getRepository($fieldMapping['targetEntity'])->find($value); $classMetadata->setFieldValue($entity, $fieldName, $value); } } else { throw new HydrationException($fieldName); } } }
private function getFieldByTagVaule($tag_value) { $value_and_params = $this->parseTagValueAndParameters($tag_value); $type = trim($value_and_params['value']); $params = $value_and_params['parameters']; return new \Hitar\FieldType($params, \Doctrine\DBAL\Types\Type::getType($type)); }
/** * @test */ public function table_should_contain_binary_uuid_column() { $uuidColumn = $this->table->getColumn('uuid'); $this->assertEquals(16, $uuidColumn->getLength()); $this->assertEquals(Type::getType(Type::BINARY), $uuidColumn->getType()); $this->assertTrue($uuidColumn->getFixed()); }
protected function convertResultsInternal($results, AbstractPlatform $platform, CaseSensor $sensor) { if (is_array($results)) { $results = current($results); } return Type::getType($this->type)->convertToPHPValue($results, $platform); }
/** * 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; }
/** * @inheritdoc */ public function up(Schema $schema, QueryBag $queries) { $table = $schema->getTable('orocrm_sales_opportunity'); $table->getColumn('probability')->setType(Type::getType('percent')); $table->getColumn('budget_amount')->setType(Type::getType('money')); $table->getColumn('close_revenue')->setType(Type::getType('money')); }
/** * {@inheritdoc} */ public function up(Schema $schema, QueryBag $queries) { $table = $schema->getTable('orocrm_magento_cart'); $table->getColumn('items_qty')->setType(Type::getType('float')); $table = $schema->getTable('orocrm_magento_order_items'); $table->getColumn('qty')->setType(Type::getType('float')); }
/** * 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 testAlterTableSql() { $changes = array('name' => 'userlist', 'add' => array('quota' => array('type' => Type::getType('integer')))); $sql = $this->_platform->getAlterTableSql('mytable', $changes); $this->assertEquals('ALTER TABLE mytable ADD quota INT DEFAULT NULL', $sql[0]); $this->assertEquals('ALTER TABLE mytable RENAME TO userlist', $sql[1]); }
/** * @test */ public function I_can_register_all_codes_at_once() { $typeName = $this->getExpectedTypeName(); self::assertFalse(Type::hasType($typeName), "Type of name '{$typeName}' should not be registered yet"); /** @var ScalarEnumType $typeClass */ $typeClass = $this->getTypeClass(); foreach ($this->getRelatedCodeClasses() as $relatedCodeClass) { self::assertFalse($typeClass::hasSubTypeEnum($relatedCodeClass), "Sub-type enum of a class '{$relatedCodeClass}' should not be registered yet"); } $typeClass::registerSelf(); self::assertTrue(Type::hasType($typeName), "Type of name '{$typeName}' is not registered"); $testedType = Type::getType($typeName); $platform = $this->createPlatform(); foreach ($this->getRelatedCodeClasses() as $relatedCodeClass) { self::assertTrue($typeClass::hasSubTypeEnum($relatedCodeClass), "Sub-type enum of a class '{$relatedCodeClass}' is not registered"); foreach ($relatedCodeClass::getPossibleValues() as $possibleValue) { $asPhp = $testedType->convertToPHPValue($relatedCodeClass . '::' . $possibleValue, $platform); self::assertInstanceOf($relatedCodeClass, $asPhp); /** @var AbstractCode $asPhp */ self::assertSame($possibleValue, $asPhp->getValue()); } } $typeClass::registerSelf(); // test if can call registering repeatedly }
/** * Walks down a SelectStatement AST node, modifying it to retrieve DISTINCT ids * of the root Entity. * * @param SelectStatement $AST * * @return void * * @throws \RuntimeException */ public function walkSelectStatement(SelectStatement $AST) { $queryComponents = $this->_getQueryComponents(); // Get the root entity and alias from the AST fromClause $from = $AST->fromClause->identificationVariableDeclarations; $fromRoot = reset($from); $rootAlias = $fromRoot->rangeVariableDeclaration->aliasIdentificationVariable; $rootClass = $queryComponents[$rootAlias]['metadata']; $selectExpressions = array(); foreach ($queryComponents as $dqlAlias => $qComp) { // Preserve mixed data in query for ordering. if (isset($qComp['resultVariable'])) { $selectExpressions[] = new SelectExpression($qComp['resultVariable'], $dqlAlias); continue; } } $identifier = $rootClass->getSingleIdentifierFieldName(); if (isset($rootClass->associationMappings[$identifier])) { throw new \RuntimeException("Paginating an entity with foreign key as identifier only works when using the Output Walkers. Call Paginator#setUseOutputWalkers(true) before iterating the paginator."); } $this->_getQuery()->setHint(self::IDENTIFIER_TYPE, Type::getType($rootClass->getTypeOfField($identifier))); $pathExpression = new PathExpression(PathExpression::TYPE_STATE_FIELD | PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION, $rootAlias, $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) { continue; } $AST->selectClause->selectExpressions[] = new SelectExpression($this->createSelectExpressionItem($item->expression), '_dctrn_ord' . $this->_aliasCounter++); } } $AST->selectClause->isDistinct = true; }
/** * {@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; }
/** * @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."); }
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); }
/** * @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())); } }
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 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; } } }
/** * @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} */ 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 __construct(Connection $con) { $this->con = $con; $this->platform = $con->getDatabasePlatform(); $this->phpType = Type::getType(PhpTypeType::NAME); $this->insertStmt = $con->prepare(self::INSERT_SQL); }
/** * {@inheritdoc} */ protected function _processSQLResult(array $sqlResult) { $data = array(); $discrColumnName = $this->_platform->getSQLResultCasing($this->_class->discriminatorColumn['name']); $entityName = $this->_class->discriminatorMap[$sqlResult[$discrColumnName]]; unset($sqlResult[$discrColumnName]); foreach ($sqlResult as $column => $value) { $realColumnName = $this->_resultColumnNames[$column]; if (isset($this->declaringClassMap[$column])) { $class = $this->declaringClassMap[$column]; if ($class->name == $entityName || is_subclass_of($entityName, $class->name)) { $field = $class->fieldNames[$realColumnName]; if (isset($data[$field])) { $data[$realColumnName] = $value; } else { $data[$field] = Type::getType($class->fieldMappings[$field]['type'])->convertToPHPValue($value, $this->_platform); } } } else { if (isset($this->declaringJoinColumnMap[$column])) { if ($this->declaringJoinColumnMap[$column] == $entityName || is_subclass_of($entityName, $this->declaringJoinColumnMap[$column])) { $data[$realColumnName] = $value; } } else { $data[$realColumnName] = $value; } } } return array($entityName, $data); }
protected function setUp() { if (!Type::hasType(PercentType::TYPE)) { Type::addType(PercentType::TYPE, 'Oro\\DBAL\\Types\\PercentType'); } $this->percentType = Type::getType(PercentType::TYPE); }
private function getType($value) { try { return Type::getType(gettype($value))->getName(); } catch (\Exception $e) { return 'text'; } }
protected function setUp() { $this->_platform = new MockPlatform(); if (!Type::hasType('vardatetime')) { Type::addType('vardatetime', 'Doctrine\\DBAL\\Types\\VarDateTimeType'); } $this->_type = Type::getType('vardatetime'); }
protected function setUp() { if (!Type::hasType($this->typeName)) { Type::addType($this->typeName, $this->typeClass); } $this->type = Type::getType($this->typeName); $this->platform = new PostgreSqlPlatform(); }
public function setUp() { if (!Type::hasType('url')) { Type::addType('url', '\\LonelyPullRequests\\Infrastructure\\Symfony\\LonelyPullRequestsBundle\\Type\\UrlType'); } $this->type = Type::getType('url'); $this->platform = Mockery::mock('\\Doctrine\\DBAL\\Platforms\\AbstractPlatform'); }
/** * @test */ public function I_can_convert_it_to_name() { NameType::registerSelf(); $nameType = Type::getType($this->getExpectedTypeName()); $phpValue = $nameType->convertToPHPValue($value = 'some string', $this->getPlatform()); self::assertInstanceOf(Name::class, $phpValue); self::assertEquals($value, "{$phpValue}"); }
protected function setUp() { $this->skipIfNoDoctrineDbal(); $this->skip64BitTest(); $this->platform = $this->getPlatformMock(); $this->platform->expects($this->any())->method('getGuidTypeDeclarationSQL')->will($this->returnValue('DUMMYVARCHAR()')); $this->type = Type::getType('uuid'); }
public function testSchemaConstructor() { $table1 = new Table('table1', [new Column('column1', Type::getType('string'), ['comment' => 'test'])]); $schema = new ExtendSchema($this->extendOptionsManager, $this->nameGenerator, [$table1]); $this->assertSchemaTypes($schema); $this->assertSchemaSql($schema, ['CREATE TABLE table1 (column1 VARCHAR(255) NOT NULL COMMENT \'test\')']); $this->assertExtendOptions($schema, []); }
protected function setUp() { $this->platform = m::mock(AbstractPlatform::class); if (!Type::hasType('json')) { Type::addType('json', Json::class); } $this->type = Type::getType('json'); }