PHP ClassMetadata::getTypeOfColumn方法代码示例

 /**
  * @param FormBuilder $form
  * @param ClassMetadata $metaData
  * @param string $fieldName
  * @throws DoctrineTypeNotSupportedException
  */
 public function createField($form, $metaData, $fieldName)
 {
     $type = $metaData->getTypeOfColumn($fieldName);
     switch ($type) {
         case 'string':
             $formField = $this->createFieldString();
             break;
         case 'text':
             $formField = $this->createFieldText();
             break;
         case 'bigint':
         case 'integer':
             $formField = $this->createFieldInteger($metaData, $fieldName);
             break;
         case 'boolean':
             $formField = $this->createFieldBoolean();
             break;
         case 'datetime':
             $formField = $this->createFieldDateTime();
             break;
         case 'decimal':
             $formField = $this->createFieldDecimal();
             break;
         default:
             throw new DoctrineTypeNotSupportedException($type);
     }
     $formField->setLabel($this->translateName($fieldName));
     $formField->setName($fieldName);
     if (!$metaData->isNullable($fieldName)) {
         $formField->setRequired(true);
     }
     $form->addField($formField);
 }

 /**
  * @param object $entity
  * @return int
  * @throws \Doctrine\ORM\Mapping\MappingException
  */
 public function update($entity)
 {
     $identifiers = [];
     $types = ['id' => \PDO::PARAM_INT];
     foreach ($this->metaData->getIdentifierColumnNames() as $columnName) {
         $fieldName = $this->metaData->getFieldForColumn($columnName);
         $value = $this->metaData->getFieldValue($entity, $fieldName);
         $identifiers[$columnName] = $value;
     }
     $updateSet = [];
     foreach ($this->metaData->getColumnNames() as $columnName) {
         if (isset($identifiers[$columnName])) {
             continue;
         }
         $fieldName = $this->metaData->getFieldForColumn($columnName);
         $typeName = $this->metaData->getTypeOfColumn($fieldName);
         $type = \Doctrine\DBAL\Types\Type::getType($typeName);
         $value = $type->convertToDatabaseValue($entity->{$fieldName}, $this->em->getConnection()->getDatabasePlatform());
         $types[$columnName] = $type->getBindingType();
         $updateSet[$columnName] = $value;
     }
     return $this->em->getConnection()->update($this->metaData->getTableName(), $updateSet, $identifiers, $types);
 }

 /**
  * Gather columns and fk constraints that are required for one part of relationship.
  *
  * @param array $joinColumns
  * @param \Doctrine\DBAL\Schema\Table $theJoinTable
  * @param ClassMetadata $class
  * @param \Doctrine\ORM\Mapping\AssociationMapping $mapping
  * @param array $primaryKeyColumns
  * @param array $uniqueConstraints
  */
 private function _gatherRelationJoinColumns($joinColumns, $theJoinTable, $class, $mapping, &$primaryKeyColumns, &$uniqueConstraints)
 {
     $localColumns = array();
     $foreignColumns = array();
     $fkOptions = array();
     foreach ($joinColumns as $joinColumn) {
         $columnName = $joinColumn['name'];
         $referencedFieldName = $class->getFieldName($joinColumn['referencedColumnName']);
         if (!$class->hasField($referencedFieldName)) {
             throw new \Doctrine\ORM\ORMException("Column name `" . $joinColumn['referencedColumnName'] . "` referenced for relation from " . $mapping['sourceEntity'] . " towards " . $mapping['targetEntity'] . " does not exist.");
         }
         $primaryKeyColumns[] = $columnName;
         $localColumns[] = $columnName;
         $foreignColumns[] = $joinColumn['referencedColumnName'];
         if (!$theJoinTable->hasColumn($joinColumn['name'])) {
             // Only add the column to the table if it does not exist already.
             // It might exist already if the foreign key is mapped into a regular
             // property as well.
             $fieldMapping = $class->getFieldMapping($referencedFieldName);
             $columnDef = null;
             if (isset($joinColumn['columnDefinition'])) {
                 $columnDef = $joinColumn['columnDefinition'];
             } else {
                 if (isset($fieldMapping['columnDefinition'])) {
                     $columnDef = $fieldMapping['columnDefinition'];
                 }
             }
             $columnOptions = array('notnull' => false, 'columnDefinition' => $columnDef);
             if (isset($joinColumn['nullable'])) {
                 $columnOptions['notnull'] = !$joinColumn['nullable'];
             }
             if ($fieldMapping['type'] == "string") {
                 $columnOptions['length'] = $fieldMapping['length'];
             } else {
                 if ($fieldMapping['type'] == "decimal") {
                     $columnOptions['scale'] = $fieldMapping['scale'];
                     $columnOptions['precision'] = $fieldMapping['precision'];
                 }
             }
             $theJoinTable->addColumn($columnName, $class->getTypeOfColumn($joinColumn['referencedColumnName']), $columnOptions);
         }
         if (isset($joinColumn['unique']) && $joinColumn['unique'] == true) {
             $uniqueConstraints[] = array('columns' => array($columnName));
         }
         if (isset($joinColumn['onUpdate'])) {
             $fkOptions['onUpdate'] = $joinColumn['onUpdate'];
         }
         if (isset($joinColumn['onDelete'])) {
             $fkOptions['onDelete'] = $joinColumn['onDelete'];
         }
     }
     $theJoinTable->addUnnamedForeignKeyConstraint($class->getTableName(), $localColumns, $foreignColumns, $fkOptions);
 }