PHP EntityManagerInterface::getFieldStorageDefinitions方法代码示例

 /**
  * Gets the field storage definitions.
  *
  * @return \Drupal\Core\Field\FieldStorageDefinitionInterface[]
  */
 protected function getFieldStorageDefinitions()
 {
     if (!isset($this->fieldStorageDefinitions)) {
         $this->fieldStorageDefinitions = $this->entityManager->getFieldStorageDefinitions($this->entityType->id());
     }
     return $this->fieldStorageDefinitions;
 }

 /**
  * Retrieves suggestions for taxonomy term autocompletion.
  *
  * This function outputs term name suggestions in response to Ajax requests
  * made by the taxonomy autocomplete widget for taxonomy term reference
  * fields. The output is a JSON object of plain-text term suggestions, keyed
  * by the user-entered value with the completed term name appended.
  * Term names containing commas are wrapped in quotes.
  *
  * For example, suppose the user has entered the string 'red fish, blue' in
  * the field, and there are two taxonomy terms, 'blue fish' and 'blue moon'.
  * The JSON output would have the following structure:
  * @code
  *   {
  *     "red fish, blue fish": "blue fish",
  *     "red fish, blue moon": "blue moon",
  *   };
  * @endcode
  *
  * @param \Symfony\Component\HttpFoundation\Request $request
  *   The request object.
  * @param string $entity_type
  *   The entity_type.
  * @param string $field_name
  *   The name of the term reference field.
  *
  * @return \Symfony\Component\HttpFoundation\JsonResponse|\Symfony\Component\HttpFoundation\Response
  *   When valid field name is specified, a JSON response containing the
  *   autocomplete suggestions for taxonomy terms. Otherwise a normal response
  *   containing an error message.
  */
 public function autocomplete(Request $request, $entity_type, $field_name)
 {
     // A comma-separated list of term names entered in the autocomplete form
     // element. Only the last term is used for autocompletion.
     $tags_typed = $request->query->get('q');
     // Make sure the field exists and is a taxonomy field.
     $field_storage_definitions = $this->entityManager->getFieldStorageDefinitions($entity_type);
     if (!isset($field_storage_definitions[$field_name]) || $field_storage_definitions[$field_name]->getType() !== 'taxonomy_term_reference') {
         // Error string. The JavaScript handler will realize this is not JSON and
         // will display it as debugging information.
         return new Response(t('Taxonomy field @field_name not found.', array('@field_name' => $field_name)), 403);
     }
     $field_storage = $field_storage_definitions[$field_name];
     // The user enters a comma-separated list of tags. We only autocomplete the
     // last tag.
     $tags_typed = Tags::explode($tags_typed);
     $tag_last = Unicode::strtolower(array_pop($tags_typed));
     $matches = array();
     if ($tag_last != '') {
         // Part of the criteria for the query come from the field's own settings.
         $vids = array();
         foreach ($field_storage->getSetting('allowed_values') as $tree) {
             $vids[] = $tree['vocabulary'];
         }
         $matches = $this->getMatchingTerms($tags_typed, $vids, $tag_last);
     }
     return new JsonResponse($matches);
 }

 /**
  * Gets the entity schema for the specified entity type.
  *
  * Entity types may override this method in order to optimize the generated
  * schema of the entity tables. However, only cross-field optimizations should
  * be added here; e.g., an index spanning multiple fields. Optimizations that
  * apply to a single field have to be added via
  * SqlContentEntityStorageSchema::getSharedTableFieldSchema() instead.
  *
  * @param \Drupal\Core\Entity\ContentEntityTypeInterface $entity_type
  *   The entity type definition.
  * @param bool $reset
  *   (optional) If set to TRUE static cache will be ignored and a new schema
  *   array generation will be performed. Defaults to FALSE.
  *
  * @return array
  *   A Schema API array describing the entity schema, excluding dedicated
  *   field tables.
  *
  * @throws \Drupal\Core\Field\FieldException
  */
 protected function getEntitySchema(ContentEntityTypeInterface $entity_type, $reset = FALSE)
 {
     $this->checkEntityType($entity_type);
     $entity_type_id = $entity_type->id();
     if (!isset($this->schema[$entity_type_id]) || $reset) {
         // Back up the storage definition and replace it with the passed one.
         // @todo Instead of switching the wrapped entity type, we should be able
         //   to instantiate a new table mapping for each entity type definition.
         //   See https://www.drupal.org/node/2274017.
         $actual_definition = $this->entityManager->getDefinition($entity_type_id);
         $this->storage->setEntityType($entity_type);
         // Prepare basic information about the entity type.
         $tables = $this->getEntitySchemaTables();
         // Initialize the table schema.
         $schema[$tables['base_table']] = $this->initializeBaseTable($entity_type);
         if (isset($tables['revision_table'])) {
             $schema[$tables['revision_table']] = $this->initializeRevisionTable($entity_type);
         }
         if (isset($tables['data_table'])) {
             $schema[$tables['data_table']] = $this->initializeDataTable($entity_type);
         }
         if (isset($tables['revision_data_table'])) {
             $schema[$tables['revision_data_table']] = $this->initializeRevisionDataTable($entity_type);
         }
         // We need to act only on shared entity schema tables.
         $table_mapping = $this->storage->getTableMapping();
         $table_names = array_diff($table_mapping->getTableNames(), $table_mapping->getDedicatedTableNames());
         $storage_definitions = $this->entityManager->getFieldStorageDefinitions($entity_type_id);
         foreach ($table_names as $table_name) {
             if (!isset($schema[$table_name])) {
                 $schema[$table_name] = array();
             }
             foreach ($table_mapping->getFieldNames($table_name) as $field_name) {
                 if (!isset($storage_definitions[$field_name])) {
                     throw new FieldException(SafeMarkup::format('Field storage definition for "@field_name" could not be found.', array('@field_name' => $field_name)));
                 } elseif ($table_mapping->allowsSharedTableStorage($storage_definitions[$field_name])) {
                     $column_names = $table_mapping->getColumnNames($field_name);
                     $storage_definition = $storage_definitions[$field_name];
                     $schema[$table_name] = array_merge_recursive($schema[$table_name], $this->getSharedTableFieldSchema($storage_definition, $table_name, $column_names));
                 }
             }
         }
         // Process tables after having gathered field information.
         $this->processBaseTable($entity_type, $schema[$tables['base_table']]);
         if (isset($tables['revision_table'])) {
             $this->processRevisionTable($entity_type, $schema[$tables['revision_table']]);
         }
         if (isset($tables['data_table'])) {
             $this->processDataTable($entity_type, $schema[$tables['data_table']]);
         }
         if (isset($tables['revision_data_table'])) {
             $this->processRevisionDataTable($entity_type, $schema[$tables['revision_data_table']]);
         }
         $this->schema[$entity_type_id] = $schema;
         // Restore the actual definition.
         $this->storage->setEntityType($actual_definition);
     }
     return $this->schema[$entity_type_id];
 }

 /**
  * Gets the type of the ID key for a given entity type.
  *
  * @param \Drupal\Core\Entity\EntityTypeInterface $entity_type
  *   An entity type.
  *
  * @return string|null
  *   The type of the ID key for a given entity type, or NULL if the entity
  *   type does not support fields.
  */
 protected function getEntityTypeIdKeyType(EntityTypeInterface $entity_type)
 {
     if (!$entity_type->isSubclassOf(FieldableEntityInterface::class)) {
         return NULL;
     }
     $field_storage_definitions = $this->entityManager->getFieldStorageDefinitions($entity_type->id());
     return $field_storage_definitions[$entity_type->getKey('id')]->getType();
 }

 /**
  * Executes field storage definition updates if needed.
  *
  * @param array $entity_types
  *   A list of entity type definitions to be processed.
  */
 public function updateDefinitions(array $entity_types)
 {
     // Handle field storage definition creation, if needed.
     // @todo Generalize this code in https://www.drupal.org/node/2346013.
     // @todo Handle initial values in https://www.drupal.org/node/2346019.
     if ($this->updateManager->needsUpdates()) {
         foreach ($entity_types as $entity_type_id => $entity_type) {
             $storage_definitions = $this->entityManager->getFieldStorageDefinitions($entity_type_id);
             $installed_storage_definitions = $this->entityManager->getLastInstalledFieldStorageDefinitions($entity_type_id);
             foreach (array_diff_key($storage_definitions, $installed_storage_definitions) as $storage_definition) {
                 /** @var $storage_definition \Drupal\Core\Field\FieldStorageDefinitionInterface */
                 if ($storage_definition->getProvider() == 'content_translation') {
                     $this->updateManager->installFieldStorageDefinition($storage_definition->getName(), $entity_type_id, 'content_translation', $storage_definition);
                 }
             }
         }
     }
 }

 /**
  * Gets a list of changes to entity type and field storage definitions.
  *
  * @return array
  *   An associative array keyed by entity type id of change descriptors. Every
  *   entry is an associative array with the following optional keys:
  *   - entity_type: a scalar having only the DEFINITION_UPDATED value.
  *   - field_storage_definitions: an associative array keyed by field name of
  *     scalars having one value among:
  *     - DEFINITION_CREATED
  *     - DEFINITION_UPDATED
  *     - DEFINITION_DELETED
  */
 protected function getChangeList()
 {
     $this->entityManager->useCaches(FALSE);
     $change_list = array();
     foreach ($this->entityManager->getDefinitions() as $entity_type_id => $entity_type) {
         $original = $this->entityManager->getLastInstalledDefinition($entity_type_id);
         // @todo Support non-storage-schema-changing definition updates too:
         //   https://www.drupal.org/node/2336895.
         if (!$original) {
             $change_list[$entity_type_id]['entity_type'] = static::DEFINITION_CREATED;
         } else {
             if ($this->requiresEntityStorageSchemaChanges($entity_type, $original)) {
                 $change_list[$entity_type_id]['entity_type'] = static::DEFINITION_UPDATED;
             }
             if ($this->entityManager->getStorage($entity_type_id) instanceof DynamicallyFieldableEntityStorageInterface) {
                 $field_changes = array();
                 $storage_definitions = $this->entityManager->getFieldStorageDefinitions($entity_type_id);
                 $original_storage_definitions = $this->entityManager->getLastInstalledFieldStorageDefinitions($entity_type_id);
                 // Detect created field storage definitions.
                 foreach (array_diff_key($storage_definitions, $original_storage_definitions) as $field_name => $storage_definition) {
                     $field_changes[$field_name] = static::DEFINITION_CREATED;
                 }
                 // Detect deleted field storage definitions.
                 foreach (array_diff_key($original_storage_definitions, $storage_definitions) as $field_name => $original_storage_definition) {
                     $field_changes[$field_name] = static::DEFINITION_DELETED;
                 }
                 // Detect updated field storage definitions.
                 foreach (array_intersect_key($storage_definitions, $original_storage_definitions) as $field_name => $storage_definition) {
                     // @todo Support non-storage-schema-changing definition updates too:
                     //   https://www.drupal.org/node/2336895. So long as we're checking
                     //   based on schema change requirements rather than definition
                     //   equality, skip the check if the entity type itself needs to be
                     //   updated, since that can affect the schema of all fields, so we
                     //   want to process that update first without reporting false
                     //   positives here.
                     if (!isset($change_list[$entity_type_id]['entity_type']) && $this->requiresFieldStorageSchemaChanges($storage_definition, $original_storage_definitions[$field_name])) {
                         $field_changes[$field_name] = static::DEFINITION_UPDATED;
                     }
                 }
                 if ($field_changes) {
                     $change_list[$entity_type_id]['field_storage_definitions'] = $field_changes;
                 }
             }
         }
     }
     // @todo Support deleting entity definitions when we support base field
     //   purging. See https://www.drupal.org/node/2282119.
     $this->entityManager->useCaches(TRUE);
     return array_filter($change_list);
 }

 /**
  * Gets the field storage of the used field.
  *
  * @return \Drupal\Core\Field\FieldStorageDefinitionInterface
  */
 protected function getFieldStorageDefinition()
 {
     $entity_type_id = $this->definition['entity_type'];
     $field_storage_definitions = $this->entityManager->getFieldStorageDefinitions($entity_type_id);
     $field_storage = NULL;
     // @todo Unify 'entity field'/'field_name' instead of converting back and
     //   forth. https://www.drupal.org/node/2410779
     if (isset($this->definition['field_name'])) {
         $field_storage = $field_storage_definitions[$this->definition['field_name']];
     } elseif (isset($this->definition['entity field'])) {
         $field_storage = $field_storage_definitions[$this->definition['entity field']];
     }
     return $field_storage;
 }

 /**
  * Gets entity schema definitions for index and key definitions.
  *
  * @param \Drupal\Core\Entity\ContentEntityTypeInterface $entity_type
  *   The entity type definition.
  * @param array $schema
  *   The entity schema array.
  *
  * @return array
  *   A stripped down version of the $schema Schema API array containing, for
  *   each table, only the key and index definitions not derived from field
  *   storage definitions.
  */
 protected function getEntitySchemaData(ContentEntityTypeInterface $entity_type, array $schema)
 {
     $entity_type_id = $entity_type->id();
     // Collect all possible field schema identifiers for shared table fields.
     // These will be used to detect entity schema data in the subsequent loop.
     $field_schema_identifiers = [];
     $storage_definitions = $this->entityManager->getFieldStorageDefinitions($entity_type_id);
     $table_mapping = $this->storage->getTableMapping($storage_definitions);
     foreach ($storage_definitions as $field_name => $storage_definition) {
         if ($table_mapping->allowsSharedTableStorage($storage_definition)) {
             // Make sure both base identifier names and suffixed names are listed.
             $name = $this->getFieldSchemaIdentifierName($entity_type_id, $field_name);
             $field_schema_identifiers[$name] = $name;
             foreach ($storage_definition->getColumns() as $key => $columns) {
                 $name = $this->getFieldSchemaIdentifierName($entity_type_id, $field_name, $key);
                 $field_schema_identifiers[$name] = $name;
             }
         }
     }
     // Extract entity schema data from the Schema API definition.
     $schema_data = [];
     $keys = ['indexes', 'unique keys'];
     $unused_keys = array_flip(['description', 'fields', 'foreign keys']);
     foreach ($schema as $table_name => $table_schema) {
         $table_schema = array_diff_key($table_schema, $unused_keys);
         foreach ($keys as $key) {
             // Exclude data generated from field storage definitions, we will check
             // that separately.
             if ($field_schema_identifiers && !empty($table_schema[$key])) {
                 $table_schema[$key] = array_diff_key($table_schema[$key], $field_schema_identifiers);
             }
         }
         $schema_data[$table_name] = array_filter($table_schema);
     }
     return $schema_data;
 }

 /**
  * Returns whether the passed field has been already deleted.
  *
  * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $storage_definition
  *   The field storage definition.
  *
  * @return bool
  *   Whether the field has been already deleted.
  */
 protected function storageDefinitionIsDeleted(FieldStorageDefinitionInterface $storage_definition)
 {
     return !array_key_exists($storage_definition->getName(), $this->entityManager->getFieldStorageDefinitions($this->entityTypeId));
 }

 /**
  * {@inheritdoc}
  */
 public function getTableMapping(array $storage_definitions = NULL)
 {
     $table_mapping = $this->tableMapping;
     // If we are using our internal storage definitions, which is our main use
     // case, we can statically cache the computed table mapping. If a new set
     // of field storage definitions is passed, for instance when comparing old
     // and new storage schema, we compute the table mapping without caching.
     // @todo Clean-up this in https://www.drupal.org/node/2274017 so we can
     //   easily instantiate a new table mapping whenever needed.
     if (!isset($this->tableMapping) || $storage_definitions) {
         $definitions = $storage_definitions ?: $this->entityManager->getFieldStorageDefinitions($this->entityTypeId);
         $table_mapping = new DefaultTableMapping($this->entityType, $definitions);
         $definitions = array_filter($definitions, function (FieldStorageDefinitionInterface $definition) use($table_mapping) {
             return $table_mapping->allowsSharedTableStorage($definition);
         });
         $key_fields = array_values(array_filter(array($this->idKey, $this->revisionKey, $this->bundleKey, $this->uuidKey, $this->langcodeKey)));
         $all_fields = array_keys($definitions);
         $revisionable_fields = array_keys(array_filter($definitions, function (FieldStorageDefinitionInterface $definition) {
             return $definition->isRevisionable();
         }));
         // Make sure the key fields come first in the list of fields.
         $all_fields = array_merge($key_fields, array_diff($all_fields, $key_fields));
         // Nodes have all three of these fields, while custom blocks only have
         // log.
         // @todo Provide automatic definitions for revision metadata fields in
         //   https://www.drupal.org/node/2248983.
         $revision_metadata_fields = array_intersect(array('revision_timestamp', 'revision_uid', 'revision_log'), $all_fields);
         $revisionable = $this->entityType->isRevisionable();
         $translatable = $this->entityType->isTranslatable();
         if (!$revisionable && !$translatable) {
             // The base layout stores all the base field values in the base table.
             $table_mapping->setFieldNames($this->baseTable, $all_fields);
         } elseif ($revisionable && !$translatable) {
             // The revisionable layout stores all the base field values in the base
             // table, except for revision metadata fields. Revisionable fields
             // denormalized in the base table but also stored in the revision table
             // together with the entity ID and the revision ID as identifiers.
             $table_mapping->setFieldNames($this->baseTable, array_diff($all_fields, $revision_metadata_fields));
             $revision_key_fields = array($this->idKey, $this->revisionKey);
             $table_mapping->setFieldNames($this->revisionTable, array_merge($revision_key_fields, $revisionable_fields));
         } elseif (!$revisionable && $translatable) {
             // Multilingual layouts store key field values in the base table. The
             // other base field values are stored in the data table, no matter
             // whether they are translatable or not. The data table holds also a
             // denormalized copy of the bundle field value to allow for more
             // performant queries. This means that only the UUID is not stored on
             // the data table.
             $table_mapping->setFieldNames($this->baseTable, $key_fields)->setFieldNames($this->dataTable, array_values(array_diff($all_fields, array($this->uuidKey))));
         } elseif ($revisionable && $translatable) {
             // The revisionable multilingual layout stores key field values in the
             // base table, except for language, which is stored in the revision
             // table along with revision metadata. The revision data table holds
             // data field values for all the revisionable fields and the data table
             // holds the data field values for all non-revisionable fields. The data
             // field values of revisionable fields are denormalized in the data
             // table, as well.
             $table_mapping->setFieldNames($this->baseTable, array_values($key_fields));
             // Like in the multilingual, non-revisionable case the UUID is not
             // in the data table. Additionally, do not store revision metadata
             // fields in the data table.
             $data_fields = array_values(array_diff($all_fields, array($this->uuidKey), $revision_metadata_fields));
             $table_mapping->setFieldNames($this->dataTable, $data_fields);
             $revision_base_fields = array_merge(array($this->idKey, $this->revisionKey, $this->langcodeKey), $revision_metadata_fields);
             $table_mapping->setFieldNames($this->revisionTable, $revision_base_fields);
             $revision_data_key_fields = array($this->idKey, $this->revisionKey, $this->langcodeKey);
             $revision_data_fields = array_diff($revisionable_fields, $revision_metadata_fields, array($this->langcodeKey));
             $table_mapping->setFieldNames($this->revisionDataTable, array_merge($revision_data_key_fields, $revision_data_fields));
         }
         // Add dedicated tables.
         $definitions = array_filter($definitions, function (FieldStorageDefinitionInterface $definition) use($table_mapping) {
             return $table_mapping->requiresDedicatedTableStorage($definition);
         });
         $extra_columns = array('bundle', 'deleted', 'entity_id', 'revision_id', 'langcode', 'delta');
         foreach ($definitions as $field_name => $definition) {
             foreach (array($table_mapping->getDedicatedDataTableName($definition), $table_mapping->getDedicatedRevisionTableName($definition)) as $table_name) {
                 $table_mapping->setFieldNames($table_name, array($field_name));
                 $table_mapping->setExtraColumns($table_name, $extra_columns);
             }
         }
         // Cache the computed table mapping only if we are using our internal
         // storage definitions.
         if (!$storage_definitions) {
             $this->tableMapping = $table_mapping;
         }
     }
     return $table_mapping;
 }

 /**
  * {@inheritdoc}
  */
 public function getFieldStorageDefinitions($entity_type_id)
 {
     return $this->entityManager->getFieldStorageDefinitions($entity_type_id);
 }

 protected function defineOptions()
 {
     $options = parent::defineOptions();
     $field_storage_definitions = $this->entityManager->getFieldStorageDefinitions($this->definition['entity_type']);
     $field_storage = $field_storage_definitions[$this->definition['field_name']];
     $field_type = \Drupal::service('plugin.manager.field.field_type')->getDefinition($field_storage->getType());
     $column_names = array_keys($field_storage->getColumns());
     $default_column = '';
     // Try to determine a sensible default.
     if (count($column_names) == 1) {
         $default_column = $column_names[0];
     } elseif (in_array('value', $column_names)) {
         $default_column = 'value';
     }
     // If the field has a "value" column, we probably need that one.
     $options['click_sort_column'] = array('default' => $default_column);
     $options['type'] = array('default' => $field_type['default_formatter']);
     $options['settings'] = array('default' => array());
     $options['group_column'] = array('default' => $default_column);
     $options['group_columns'] = array('default' => array());
     // Options used for multiple value fields.
     $options['group_rows'] = array('default' => TRUE, 'bool' => TRUE);
     // If we know the exact number of allowed values, then that can be
     // the default. Otherwise, default to 'all'.
     $options['delta_limit'] = array('default' => $field_storage->getCardinality() > 1 ? $field_storage->getCardinality() : 'all');
     $options['delta_offset'] = array('default' => 0);
     $options['delta_reversed'] = array('default' => FALSE, 'bool' => TRUE);
     $options['delta_first_last'] = array('default' => FALSE, 'bool' => TRUE);
     $options['multi_type'] = array('default' => 'separator');
     $options['separator'] = array('default' => ', ');
     $options['field_api_classes'] = array('default' => FALSE, 'bool' => TRUE);
     return $options;
 }

 /**
  * Constructs a ContentEntitySchemaHandler.
  *
  * @param \Drupal\Core\Entity\EntityManagerInterface $entity_manager
  *   The entity manager.
  * @param \Drupal\Core\Entity\ContentEntityTypeInterface $entity_type
  *   The entity type.
  * @param \Drupal\Core\Entity\ContentEntityDatabaseStorage $storage
  *   The storage of the entity type. This must be an SQL-based storage.
  */
 public function __construct(EntityManagerInterface $entity_manager, ContentEntityTypeInterface $entity_type, ContentEntityDatabaseStorage $storage)
 {
     $this->entityType = $entity_type;
     $this->fieldStorageDefinitions = $entity_manager->getFieldStorageDefinitions($entity_type->id());
     $this->storage = $storage;
 }