PHP ClassMetadata::getIdentifierFieldNames方法代码示例

 /**
  * @param ClassMetadata $classMetadata
  *
  * @return EntityMetadata
  */
 public function createEntityMetadata(ClassMetadata $classMetadata)
 {
     $entityMetadata = new EntityMetadata();
     $entityMetadata->setClassName($classMetadata->name);
     $entityMetadata->setIdentifierFieldNames($classMetadata->getIdentifierFieldNames());
     return $entityMetadata;
 }

 /**
  * @param AbstractFile     $file
  * @param ClassMetadata $metadata
  * @param object        $entity
  * @param array         $properties
  */
 protected function writeClearedProperties(AbstractFile $file, ClassMetadata $metadata, $entity, array $properties)
 {
     $cleared = $this->entityToArray($entity, $properties);
     if ($cleared) {
         $file->writeObject(['identifiers' => $this->entityToArray($entity, $metadata->getIdentifierFieldNames()), 'cleared' => $cleared]);
     }
 }

 /**
  * @param EntityMetadata $entityMetadata
  * @param ClassMetadata $classMetadata
  */
 protected function addDoctrineFields(EntityMetadata $entityMetadata, ClassMetadata $classMetadata)
 {
     $fields = array_diff($classMetadata->getFieldNames(), $classMetadata->getIdentifierFieldNames(), $this->getDeletedFields($classMetadata->name));
     foreach ($fields as $fieldName) {
         $fieldMetadata = $this->metadataFactory->createFieldMetadata(array('field_name' => $fieldName), $classMetadata->getFieldMapping($fieldName));
         $entityMetadata->addFieldMetadata($fieldMetadata);
     }
 }

 /**
  * @param ClassMetadata $metadata
  * @return mixed
  */
 public function getNamePrimaryKeyField(ClassMetadata $metadata)
 {
     $idNames = $metadata->getIdentifierFieldNames();
     if (count($idNames) !== 1) {
         throw new Exception('Primary key for this entity is absent or contains few fields');
     }
     return $idNames[0];
 }

 /**
  * @param ClassMetadata $classMetadata
  *
  * @return EntityMetadata
  */
 public function createEntityMetadata(ClassMetadata $classMetadata)
 {
     $entityMetadata = new EntityMetadata();
     $entityMetadata->setClassName($classMetadata->name);
     $entityMetadata->setIdentifierFieldNames($classMetadata->getIdentifierFieldNames());
     $entityMetadata->setInheritedType($classMetadata->inheritanceType !== ClassMetadata::INHERITANCE_TYPE_NONE);
     return $entityMetadata;
 }

 /**
  * @param ClassMetadata $metadata
  * @return mixed
  */
 public function getNamePrimaryKeyField(ClassMetadata $metadata)
 {
     $idNames = $metadata->getIdentifierFieldNames();
     if (count($idNames) !== 1) {
         throw new RuntimeException(sprintf('Primary key for entity %s is absent or contains more than one field', $metadata->getName()));
     }
     return $idNames[0];
 }

 /**
  * @param EntityMetadata $entityMetadata
  * @param ClassMetadata $classMetadata
  */
 protected function addDoctrineFields(EntityMetadata $entityMetadata, ClassMetadata $classMetadata)
 {
     $identifierFields = $classMetadata->getIdentifierFieldNames();
     foreach ($classMetadata->getFieldNames() as $fieldName) {
         if (in_array($fieldName, $identifierFields)) {
             continue;
         }
         $fieldMetadata = $this->metadataFactory->createFieldMetadata(array('field_name' => $fieldName), $classMetadata->getFieldMapping($fieldName));
         $entityMetadata->addFieldMetadata($fieldMetadata);
     }
 }

 /**
  * @param ClassMetadata $classMetaData
  * @param array $data
  * @return $this
  */
 protected function dispatchPostCreateEntityEvent(ClassMetadata $classMetaData, array $data)
 {
     $identifiers = [];
     foreach ($classMetaData->getIdentifierFieldNames() as $identifier) {
         if (array_key_exists($identifier, $data)) {
             $identifiers[$identifier] = $data[$identifier];
         }
     }
     $eventArgs = new PostCreateEntityEventArgs(get_class($this), $classMetaData->name, $identifiers);
     $this->getEntityManager()->getEventManager()->dispatchEvent(PostCreateEntityEventArgs::EVENT_NAME, $eventArgs);
     return $this;
 }

 /**
  * Get the class metadata that is responsible for the definition of the referenced column name.
  *
  * Previously this was a simple task, but with DDC-117 this problem is actually recursive. If its
  * not a simple field, go through all identifier field names that are associations recursivly and
  * find that referenced column name.
  *
  * TODO: Is there any way to make this code more pleasing?
  *
  * @param ClassMetadata $class
  * @param string $referencedColumnName
  * @return array(ClassMetadata, referencedFieldName)
  */
 private function getDefiningClass($class, $referencedColumnName)
 {
     $referencedFieldName = $class->getFieldName($referencedColumnName);
     if ($class->hasField($referencedFieldName)) {
         return array($class, $referencedFieldName);
     } else {
         if (in_array($referencedColumnName, $class->getIdentifierColumnNames())) {
             // it seems to be an entity as foreign key
             foreach ($class->getIdentifierFieldNames() as $fieldName) {
                 if ($class->hasAssociation($fieldName) && $class->getSingleAssociationJoinColumnName($fieldName) == $referencedColumnName) {
                     return $this->getDefiningClass($this->em->getClassMetadata($class->associationMappings[$fieldName]['targetEntity']), $class->getSingleAssociationReferencedJoinColumnName($fieldName));
                 }
             }
         }
     }
     return null;
 }

 /**
  * Deletes an entity.
  *
  * @param object $entity The entity to delete.
  */
 public function delete($entity)
 {
     $id = array_combine($this->_class->getIdentifierFieldNames(), $this->_em->getUnitOfWork()->getEntityIdentifier($entity));
     $this->_conn->delete($this->_class->primaryTable['name'], $id);
 }

 /**
  * @param $field
  * @param $meta
  * @return bool
  */
 protected function isAutogeneratedIdField($field, ClassMetadata $meta)
 {
     $isIdentifierField = in_array($field, $meta->getIdentifierFieldNames());
     $isAutoGenerated = $meta->generatorType !== ClassMetadata::GENERATOR_TYPE_NONE;
     return $isIdentifierField && $isAutoGenerated;
 }

 /**
  * Get identifier.
  *
  * @param ClassMetadata $metadata
  *
  * @return mixed
  */
 private function getIdentifier(ClassMetadata $metadata)
 {
     $identifiers = $metadata->getIdentifierFieldNames();
     return array_shift($identifiers);
 }

 /**
  * Returns names of entity identifier fields
  *
  * @return string[]
  */
 public function getIdentifierFieldNames()
 {
     return $this->metadata->getIdentifierFieldNames();
 }

 /**
  * Creates a column definition as required by the DBAL from an ORM field mapping definition.
  *
  * @param ClassMetadata $class The class that owns the field mapping.
  * @param array $mapping The field mapping.
  * @param Table $table
  * @return array The portable column definition as required by the DBAL.
  */
 private function _gatherColumn($class, array $mapping, $table)
 {
     $columnName = $class->getQuotedColumnName($mapping['fieldName'], $this->_platform);
     $columnType = $mapping['type'];
     $options = array();
     $options['length'] = isset($mapping['length']) ? $mapping['length'] : null;
     $options['notnull'] = isset($mapping['nullable']) ? !$mapping['nullable'] : true;
     if ($class->isInheritanceTypeSingleTable() && count($class->parentClasses) > 0) {
         $options['notnull'] = false;
     }
     $options['platformOptions'] = array();
     $options['platformOptions']['version'] = $class->isVersioned && $class->versionField == $mapping['fieldName'] ? true : false;
     if (strtolower($columnType) == 'string' && $options['length'] === null) {
         $options['length'] = 255;
     }
     if (isset($mapping['precision'])) {
         $options['precision'] = $mapping['precision'];
     }
     if (isset($mapping['scale'])) {
         $options['scale'] = $mapping['scale'];
     }
     if (isset($mapping['default'])) {
         $options['default'] = $mapping['default'];
     }
     if (isset($mapping['columnDefinition'])) {
         $options['columnDefinition'] = $mapping['columnDefinition'];
     }
     if ($class->isIdGeneratorIdentity() && $class->getIdentifierFieldNames() == array($mapping['fieldName'])) {
         $options['autoincrement'] = true;
     }
     if ($class->isInheritanceTypeJoined() && $class->name != $class->rootEntityName) {
         $options['autoincrement'] = false;
     }
     if ($table->hasColumn($columnName)) {
         // required in some inheritance scenarios
         $table->changeColumn($columnName, $options);
     } else {
         $table->addColumn($columnName, $columnType, $options);
     }
     $isUnique = isset($mapping['unique']) ? $mapping['unique'] : false;
     if ($isUnique) {
         $table->addUniqueIndex(array($columnName));
     }
 }

 /**
  * Gets a list of all indexed fields
  *
  * @param ClassMetadata $metadata
  *
  * @return array [field name => field data-type, ...]
  */
 public function getIndexedFields(ClassMetadata $metadata)
 {
     $indexedColumns = [];
     $idFieldNames = $metadata->getIdentifierFieldNames();
     if (count($idFieldNames) > 0) {
         $indexedColumns[reset($idFieldNames)] = true;
     }
     if (isset($metadata->table['indexes'])) {
         foreach ($metadata->table['indexes'] as $index) {
             $firstFieldName = reset($index['columns']);
             if (!isset($indexedColumns[$firstFieldName])) {
                 $indexedColumns[$firstFieldName] = true;
             }
         }
     }
     $fields = [];
     $fieldNames = $metadata->getFieldNames();
     foreach ($fieldNames as $fieldName) {
         $mapping = $metadata->getFieldMapping($fieldName);
         $hasIndex = false;
         if (isset($mapping['unique']) && true === $mapping['unique']) {
             $hasIndex = true;
         } elseif (array_key_exists($mapping['columnName'], $indexedColumns)) {
             $hasIndex = true;
         }
         if ($hasIndex) {
             $fields[$fieldName] = $mapping['type'];
         }
     }
     return $fields;
 }