PHP FieldStorageDefinitionInterface::hasCustomStorage方法代码示例

 /**
  * Compares schemas to check for changes in the column definitions.
  *
  * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $storage_definition
  *   Current field storage definition.
  * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $original
  *   The original field storage definition.
  *
  * @return bool
  *   Returns TRUE if there are schema changes in the column definitions.
  */
 protected function hasColumnChanges(FieldStorageDefinitionInterface $storage_definition, FieldStorageDefinitionInterface $original)
 {
     if ($storage_definition->getColumns() != $original->getColumns()) {
         // Base field definitions have schema data stored in the original
         // definition.
         return TRUE;
     }
     if (!$storage_definition->hasCustomStorage()) {
         $keys = array_flip($this->getColumnSchemaRelevantKeys());
         $definition_schema = $this->getSchemaFromStorageDefinition($storage_definition);
         foreach ($this->loadFieldSchemaData($original) as $table => $table_schema) {
             foreach ($table_schema['fields'] as $name => $spec) {
                 $definition_spec = array_intersect_key($definition_schema[$table]['fields'][$name], $keys);
                 $stored_spec = array_intersect_key($spec, $keys);
                 if ($definition_spec != $stored_spec) {
                     return TRUE;
                 }
             }
         }
     }
     return FALSE;
 }

 /**
  * Checks whether the given field has to be stored in a dedicated table.
  *
  * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $storage_definition
  *   The field storage definition.
  *
  * @return bool
  *   TRUE if the field can be stored in a dedicated table, FALSE otherwise.
  */
 public function requiresDedicatedTableStorage(FieldStorageDefinitionInterface $storage_definition)
 {
     return !$storage_definition->hasCustomStorage() && !$this->allowsSharedTableStorage($storage_definition);
 }

 /**
  * Creates a new field definition based upon a field storage definition.
  *
  * In cases where one needs a field storage definitions to act like full
  * field definitions, this creates a new field definition based upon the
  * (limited) information available. That way it is possible to use the field
  * definition in places where a full field definition is required; e.g., with
  * widgets or formatters.
  *
  * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $definition
  *   The field storage definition to base the new field definition upon.
  *
  * @return $this
  */
 public static function createFromFieldStorageDefinition(FieldStorageDefinitionInterface $definition)
 {
     return static::create($definition->getType())->setCardinality($definition->getCardinality())->setConstraints($definition->getConstraints())->setCustomStorage($definition->hasCustomStorage())->setDescription($definition->getDescription())->setLabel($definition->getLabel())->setName($definition->getName())->setProvider($definition->getProvider())->setQueryable($definition->isQueryable())->setRequired($definition->isRequired())->setRevisionable($definition->isRevisionable())->setSettings($definition->getSettings())->setTargetEntityTypeId($definition->getTargetEntityTypeId())->setTranslatable($definition->isTranslatable());
 }

 /**
  * Returns whether the field uses a dedicated table for storage.
  *
  * @param FieldStorageDefinitionInterface $definition
  *   The field storage definition.
  *
  * @return bool
  *   Whether the field uses a dedicated table for storage.
  */
 protected function usesDedicatedTable(FieldStorageDefinitionInterface $definition)
 {
     // Everything that is not provided by the entity type is stored in a
     // dedicated table.
     return $definition->getProvider() != $this->entityType->getProvider() && !$definition->hasCustomStorage();
 }

 /**
  * {@inheritdoc}
  */
 public function requiresFieldStorageSchemaChanges(FieldStorageDefinitionInterface $storage_definition, FieldStorageDefinitionInterface $original)
 {
     $table_mapping = $this->storage->getTableMapping();
     if ($storage_definition->hasCustomStorage() != $original->hasCustomStorage() || $storage_definition->getSchema() != $original->getSchema() || $storage_definition->isRevisionable() != $original->isRevisionable() || $table_mapping->allowsSharedTableStorage($storage_definition) != $table_mapping->allowsSharedTableStorage($original) || $table_mapping->requiresDedicatedTableStorage($storage_definition) != $table_mapping->requiresDedicatedTableStorage($original)) {
         return TRUE;
     }
     if ($table_mapping->requiresDedicatedTableStorage($storage_definition)) {
         return $this->getDedicatedTableSchema($storage_definition) != $this->loadFieldSchemaData($original);
     } elseif ($table_mapping->allowsSharedTableStorage($storage_definition)) {
         $field_name = $storage_definition->getName();
         $schema = array();
         foreach (array_diff($table_mapping->getTableNames(), $table_mapping->getDedicatedTableNames()) as $table_name) {
             if (in_array($field_name, $table_mapping->getFieldNames($table_name))) {
                 $column_names = $table_mapping->getColumnNames($storage_definition->getName());
                 $schema[$table_name] = $this->getSharedTableFieldSchema($storage_definition, $table_name, $column_names);
             }
         }
         return $schema != $this->loadFieldSchemaData($original);
     } else {
         // The field has custom storage, so we don't know if a schema change is
         // needed or not, but since per the initial checks earlier in this
         // function, nothing about the definition changed that we manage, we
         // return FALSE.
         return FALSE;
     }
 }

 /**
  * Compares schemas to check for changes in the column definitions.
  *
  * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $storage_definition
  *   Current field storage definition.
  * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $original
  *   The original field storage definition.
  *
  * @return bool
  *   Returns TRUE if there are schema changes in the column definitions.
  */
 protected function hasColumnChanges(FieldStorageDefinitionInterface $storage_definition, FieldStorageDefinitionInterface $original)
 {
     if ($storage_definition->getColumns() != $original->getColumns()) {
         // Base field definitions have schema data stored in the original
         // definition.
         return TRUE;
     }
     if (!$storage_definition->hasCustomStorage()) {
         $schema = $this->getSchemaFromStorageDefinition($storage_definition);
         foreach ($this->loadFieldSchemaData($original) as $table => $spec) {
             if ($spec['fields'] != $schema[$table]['fields']) {
                 return TRUE;
             }
         }
     }
     return FALSE;
 }