PHP Types\Type类代码示例

 /**
  * {@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 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]);
     }
 }