diff --git a/core/core.services.yml b/core/core.services.yml index f8c428f..0d7d10a 100644 --- a/core/core.services.yml +++ b/core/core.services.yml @@ -281,10 +281,13 @@ services: arguments: ['@config.factory', '@module_handler', '@state', '@info_parser', '@logger.channel.default', '@asset.css.collection_optimizer', '@config.installer', '@router.builder'] entity.manager: class: Drupal\Core\Entity\EntityManager - arguments: ['@container.namespaces', '@module_handler', '@cache.discovery', '@language_manager', '@string_translation', '@class_resolver', '@typed_data_manager'] + arguments: ['@container.namespaces', '@module_handler', '@cache.discovery', '@language_manager', '@string_translation', '@class_resolver', '@typed_data_manager', '@state'] parent: container.trait tags: - { name: plugin_manager_cache_clear } + entity.definition_update_manager: + class: Drupal\Core\Entity\EntityDefinitionUpdateManager + arguments: ['@entity.manager'] entity.form_builder: class: Drupal\Core\Entity\EntityFormBuilder arguments: ['@entity.manager', '@form_builder'] diff --git a/core/includes/update.inc b/core/includes/update.inc index f9a88db..125907d 100644 --- a/core/includes/update.inc +++ b/core/includes/update.inc @@ -10,14 +10,8 @@ use Drupal\Component\Graph\Graph; use Drupal\Component\Utility\String; -use Drupal\Core\Config\FileStorage; -use Drupal\Core\Config\ConfigException; -use Drupal\Core\DrupalKernel; -use Drupal\Core\Page\DefaultHtmlPageRenderer; +use Drupal\Core\Entity\EntityStorageException; use Drupal\Core\Utility\Error; -use Drupal\Component\Uuid\Uuid; -use Drupal\Component\Utility\NestedArray; -use Symfony\Component\HttpFoundation\Request; /** * Disables any extensions that are incompatible with the current core version. @@ -258,6 +252,33 @@ function update_do_one($module, $number, $dependency_map, &$context) { } /** + * Performs entity definition updates, which can trigger schema updates. + * + * @param $module + * The module whose update will be run. + * @param $number + * The update number to run. + * @param $context + * The batch context array. + */ +function update_entity_definitions($module, $number, &$context) { + try { + \Drupal::service('entity.definition_update_manager')->applyUpdates(); + } + catch (EntityStorageException $e) { + watchdog_exception('update', $e); + $variables = Error::decodeException($e); + unset($variables['backtrace']); + // The exception message is run through + // \Drupal\Component\Utility\String::checkPlain() by + // \Drupal\Core\Utility\Error::decodeException(). + $ret['#abort'] = array('success' => FALSE, 'query' => t('%type: !message in %function (line %line of %file).', $variables)); + $context['results'][$module][$number] = $ret; + $context['results']['#abort'][] = 'update_entity_definitions'; + } +} + +/** * Returns a list of all the pending database updates. * * @return diff --git a/core/lib/Drupal/Core/Entity/EntityDefinitionUpdateManager.php b/core/lib/Drupal/Core/Entity/EntityDefinitionUpdateManager.php new file mode 100644 index 0000000..705faf2 --- /dev/null +++ b/core/lib/Drupal/Core/Entity/EntityDefinitionUpdateManager.php @@ -0,0 +1,235 @@ +entityManager = $entity_manager; + } + + /** + * {@inheritdoc} + */ + public function needsUpdates() { + return (bool) $this->getChangeList(); + } + + /** + * {@inheritdoc} + */ + public function getChangeSummary() { + $summary = array(); + + foreach ($this->getChangeList() as $entity_type_id => $change_list) { + // Process entity type definition changes. + if (!empty($change_list['entity_type']) && $change_list['entity_type'] == static::DEFINITION_UPDATED) { + $entity_type = $this->entityManager->getDefinition($entity_type_id); + // @todo Support non-storage-schema-changing definition updates too: + // https://www.drupal.org/node/2336895. + $summary[$entity_type_id][] = $this->t('The %entity_type entity type has definition updates that require schema changes.', array('%entity_type' => $entity_type->getLabel())); + } + + // Process field storage definition changes. + if (!empty($change_list['field_storage_definitions'])) { + $storage_definitions = $this->entityManager->getFieldStorageDefinitions($entity_type_id); + $original_storage_definitions = $this->entityManager->getInstalledFieldStorageDefinitions($entity_type_id); + + foreach ($change_list['field_storage_definitions'] as $field_name => $change) { + switch ($change) { + case static::DEFINITION_CREATED: + $summary[$entity_type_id][] = $this->t('The %field_name field has been created.', array('%field_name' => $storage_definitions[$field_name]->getLabel())); + break; + + case static::DEFINITION_UPDATED: + // @todo Support non-storage-schema-changing definition updates too: + // https://www.drupal.org/node/2336895. + $summary[$entity_type_id][] = $this->t('The %field_name field has storage definition updates that require schema changes.', array('%field_name' => $storage_definitions[$field_name]->getLabel())); + break; + + case static::DEFINITION_DELETED: + $summary[$entity_type_id][] = $this->t('The %field_name field has been deleted.', array('%field_name' => $original_storage_definitions[$field_name]->getLabel())); + break; + } + } + } + } + + return $summary; + } + + /** + * {@inheritdoc} + */ + public function applyUpdates() { + foreach ($this->getChangeList() as $entity_type_id => $change_list) { + // Process entity type definition changes. + if (!empty($change_list['entity_type']) && $change_list['entity_type'] == static::DEFINITION_UPDATED) { + $entity_type = $this->entityManager->getDefinition($entity_type_id); + $original = $this->entityManager->getInstalledDefinition($entity_type_id); + $this->entityManager->onEntityTypeUpdate($entity_type, $original); + } + + // Process field storage definition changes. + if (!empty($change_list['field_storage_definitions'])) { + $storage_definitions = $this->entityManager->getFieldStorageDefinitions($entity_type_id); + $original_storage_definitions = $this->entityManager->getInstalledFieldStorageDefinitions($entity_type_id); + + foreach ($change_list['field_storage_definitions'] as $field_name => $change) { + switch ($change) { + case static::DEFINITION_CREATED: + $this->entityManager->onFieldStorageDefinitionCreate($storage_definitions[$field_name]); + break; + + case static::DEFINITION_UPDATED: + $this->entityManager->onFieldStorageDefinitionUpdate($storage_definitions[$field_name], $original_storage_definitions[$field_name]); + break; + + case static::DEFINITION_DELETED: + $this->entityManager->onFieldStorageDefinitionDelete($storage_definitions[$field_name]); + break; + } + } + } + } + } + + /** + * Returns 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->clearCachedDefinitions(); + $change_list = array(); + + foreach ($this->entityManager->getDefinitions() as $entity_type_id => $entity_type) { + $original = $this->entityManager->getInstalledDefinition($entity_type_id); + // @todo Support non-storage-schema-changing definition updates too: + // https://www.drupal.org/node/2336895. + if ($this->requiresEntityStorageSchemaChanges($entity_type, $original)) { + $change_list[$entity_type_id]['entity_type'] = static::DEFINITION_UPDATED; + } + + if ($entity_type->isFieldable()) { + $field_changes = array(); + $storage_definitions = $this->entityManager->getFieldStorageDefinitions($entity_type_id); + $original_storage_definitions = $this->entityManager->getInstalledFieldStorageDefinitions($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. + if ($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; + } + } + } + + return array_filter($change_list); + } + + /** + * Checks if the changes to the entity type requires storage schema changes. + * + * @param \Drupal\Core\Entity\EntityTypeInterface $entity_type + * The updated entity type definition. + * @param \Drupal\Core\Entity\EntityTypeInterface $original + * The original entity type definition. + * + * @return bool + * TRUE if storage schema changes are required, FALSE otherwise. + */ + protected function requiresEntityStorageSchemaChanges($entity_type, $original) { + $storage = $this->entityManager->getStorage($entity_type->id()); + return ($storage instanceof EntityStorageSchemaInterface) && $storage->requiresEntityStorageSchemaChanges($entity_type, $original); + } + + /** + * Checks if the changes to the storage definition requires schema changes. + * + * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $storage_definition + * The updated field storage definition. + * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $original + * The original field storage definition. + * + * @return bool + * TRUE if storage schema changes are required, FALSE otherwise. + */ + protected function requiresFieldStorageSchemaChanges(FieldStorageDefinitionInterface $storage_definition, FieldStorageDefinitionInterface $original) { + $storage = $this->entityManager->getStorage($storage_definition->getTargetEntityTypeId()); + return ($storage instanceof FieldableEntityStorageSchemaInterface) && $storage->requiresFieldStorageSchemaChanges($storage_definition, $original); + } + +} diff --git a/core/lib/Drupal/Core/Entity/EntityDefinitionUpdateManagerInterface.php b/core/lib/Drupal/Core/Entity/EntityDefinitionUpdateManagerInterface.php new file mode 100644 index 0000000..5c25ec1 --- /dev/null +++ b/core/lib/Drupal/Core/Entity/EntityDefinitionUpdateManagerInterface.php @@ -0,0 +1,63 @@ +setCacheBackend($cache, 'entity_type', array('entity_types' => TRUE)); @@ -180,6 +194,7 @@ public function __construct(\Traversable $namespaces, ModuleHandlerInterface $mo $this->translationManager = $translation_manager; $this->classResolver = $class_resolver; $this->typedDataManager = $typed_data_manager; + $this->state = $state; } /** @@ -961,36 +976,102 @@ public function getEntityTypeFromClass($class_name) { * {@inheritdoc} */ public function onEntityTypeCreate(EntityTypeInterface $entity_type) { + $entity_type_id = $entity_type->id(); + // @todo Forward this to all interested handlers, not only storage, once // iterating handlers is possible: https://www.drupal.org/node/2332857. - $storage = $this->getStorage($entity_type->id()); + $storage = $this->getStorage($entity_type_id); if ($storage instanceof EntityTypeListenerInterface) { $storage->onEntityTypeCreate($entity_type); } + + $this->setInstalledDefinition($entity_type); + if ($entity_type->isFieldable()) { + $this->setInstalledFieldStorageDefinitions($entity_type_id, $this->getFieldStorageDefinitions($entity_type_id)); + } } /** * {@inheritdoc} */ public function onEntityTypeUpdate(EntityTypeInterface $entity_type, EntityTypeInterface $original) { + $entity_type_id = $entity_type->id(); + // @todo Forward this to all interested handlers, not only storage, once // iterating handlers is possible: https://www.drupal.org/node/2332857. - $storage = $this->getStorage($entity_type->id()); + $storage = $this->getStorage($entity_type_id); if ($storage instanceof EntityTypeListenerInterface) { $storage->onEntityTypeUpdate($entity_type, $original); } + + $this->setInstalledDefinition($entity_type); } /** * {@inheritdoc} */ public function onEntityTypeDelete(EntityTypeInterface $entity_type) { + $entity_type_id = $entity_type->id(); + // @todo Forward this to all interested handlers, not only storage, once // iterating handlers is possible: https://www.drupal.org/node/2332857. - $storage = $this->getStorage($entity_type->id()); + $storage = $this->getStorage($entity_type_id); if ($storage instanceof EntityTypeListenerInterface) { $storage->onEntityTypeDelete($entity_type); } + + $this->deleteInstalledDefinition($entity_type_id); + } + + /** + * {@inheritdoc} + */ + public function onFieldStorageDefinitionCreate(FieldStorageDefinitionInterface $storage_definition) { + $entity_type_id = $storage_definition->getTargetEntityTypeId(); + + // @todo Forward this to all interested handlers, not only storage, once + // iterating handlers is possible: https://www.drupal.org/node/2332857. + $storage = $this->getStorage($entity_type_id); + if ($storage instanceof FieldStorageDefinitionListenerInterface) { + $storage->onFieldStorageDefinitionCreate($storage_definition); + } + + $this->setInstalledFieldStorageDefinition($storage_definition); + $this->clearCachedFieldDefinitions(); + } + + /** + * {@inheritdoc} + */ + public function onFieldStorageDefinitionUpdate(FieldStorageDefinitionInterface $storage_definition, FieldStorageDefinitionInterface $original) { + $entity_type_id = $storage_definition->getTargetEntityTypeId(); + + // @todo Forward this to all interested handlers, not only storage, once + // iterating handlers is possible: https://www.drupal.org/node/2332857. + $storage = $this->getStorage($entity_type_id); + if ($storage instanceof FieldStorageDefinitionListenerInterface) { + $storage->onFieldStorageDefinitionUpdate($storage_definition, $original); + } + + $this->setInstalledFieldStorageDefinition($storage_definition); + $this->clearCachedFieldDefinitions(); + } + + /** + * {@inheritdoc} + */ + public function onFieldStorageDefinitionDelete(FieldStorageDefinitionInterface $storage_definition) { + $entity_type_id = $storage_definition->getTargetEntityTypeId(); + + // @todo Forward this to all interested handlers, not only storage, once + // iterating handlers is possible: https://www.drupal.org/node/2332857. + $storage = $this->getStorage($entity_type_id); + if ($storage instanceof FieldStorageDefinitionListenerInterface) { + $storage->onFieldStorageDefinitionDelete($storage_definition); + } + + $this->deleteInstalledFieldStorageDefinition($storage_definition); + $this->clearCachedFieldDefinitions(); } /** @@ -1047,4 +1128,81 @@ public function onBundleDelete($entity_type_id, $bundle) { $this->clearCachedFieldDefinitions(); } + /** + * {@inheritdoc} + */ + public function getInstalledDefinition($entity_type_id) { + return $this->state->get('entity.manager.' . $entity_type_id . '.entity_type'); + } + + /** + * Stores the entity type definition in the application state. + * + * @param \Drupal\Core\Entity\EntityTypeInterface $entity_type + * The entity type definition. + */ + protected function setInstalledDefinition(EntityTypeInterface $entity_type) { + $entity_type_id = $entity_type->id(); + $this->state->set('entity.manager.' . $entity_type_id . '.entity_type', $entity_type); + } + + /** + * Deletes the entity type definition from the application state. + * + * @param string $entity_type_id + * The entity type definition identifier. + */ + protected function deleteInstalledDefinition($entity_type_id) { + $this->state->delete('entity.manager.' . $entity_type_id . '.entity_type'); + // Clean up field storage definitions as well. Even if the entity type + // isn't currently fieldable, there might be legacy definitions or an + // empty array stored from when it was. + $this->state->delete('entity.manager.' . $entity_type_id . '.field_storage_definitions'); + } + + /** + * {@inheritdoc} + */ + public function getInstalledFieldStorageDefinitions($entity_type_id) { + return $this->state->get('entity.manager.' . $entity_type_id . '.field_storage_definitions'); + } + + /** + * Stores the entity type's field storage definitions in the application state. + * + * @param string $entity_type_id + * The entity type identifier. + * @param \Drupal\Core\Field\FieldStorageDefinitionInterface[] $storage_definitions + * An array of field storage definitions. + */ + protected function setInstalledFieldStorageDefinitions($entity_type_id, array $storage_definitions) { + $this->state->set('entity.manager.' . $entity_type_id . '.field_storage_definitions', $storage_definitions); + } + + /** + * Stores the field storage definition in the application state. + * + * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $storage_definition + * The field storage definition. + */ + protected function setInstalledFieldStorageDefinition(FieldStorageDefinitionInterface $storage_definition) { + $entity_type_id = $storage_definition->getTargetEntityTypeId(); + $definitions = $this->getInstalledFieldStorageDefinitions($entity_type_id); + $definitions[$storage_definition->getName()] = $storage_definition; + $this->setInstalledFieldStorageDefinitions($entity_type_id, $definitions); + } + + /** + * Deletes the field storage definition from the application state. + * + * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $storage_definition + * The field storage definition. + */ + protected function deleteInstalledFieldStorageDefinition(FieldStorageDefinitionInterface $storage_definition) { + $entity_type_id = $storage_definition->getTargetEntityTypeId(); + $definitions = $this->getInstalledFieldStorageDefinitions($entity_type_id); + unset($definitions[$storage_definition->getName()]); + $this->setInstalledFieldStorageDefinitions($entity_type_id, $definitions); + } + } diff --git a/core/lib/Drupal/Core/Entity/EntityManagerInterface.php b/core/lib/Drupal/Core/Entity/EntityManagerInterface.php index 8d3f9f4..ad1a249 100644 --- a/core/lib/Drupal/Core/Entity/EntityManagerInterface.php +++ b/core/lib/Drupal/Core/Entity/EntityManagerInterface.php @@ -8,11 +8,12 @@ namespace Drupal\Core\Entity; use Drupal\Component\Plugin\PluginManagerInterface; +use Drupal\Core\Field\FieldStorageDefinitionListenerInterface; /** * Provides an interface for entity type managers. */ -interface EntityManagerInterface extends PluginManagerInterface, EntityTypeListenerInterface { +interface EntityManagerInterface extends PluginManagerInterface, EntityTypeListenerInterface, FieldStorageDefinitionListenerInterface { /** * Builds a list of entity type labels suitable for a Form API options list. @@ -81,6 +82,40 @@ public function getFieldDefinitions($entity_type_id, $bundle); public function getFieldStorageDefinitions($entity_type_id); /** + * Gets the entity type's most recently installed field storage definitions. + * + * During the application lifetime, field storage definitions can change. For + * example, updated code can be deployed. The getFieldStorageDefinitions() + * method will always return the definitions as determined by the current + * codebase. This method, however, returns what the definitions were when the + * last time that one of the + * \Drupal\Core\Field\FieldStorageDefinitionListenerInterface events was last + * fired and completed successfully. In other words, the definitions that + * the entity type's handlers have incorporated into the application state. + * For example, if the entity type's storage handler is SQL-based, the + * definitions for which database tables were created. + * + * Application management code can check if getFieldStorageDefinitions() + * differs from getInstalledFieldStorageDefinitions() and decide whether to: + * - Invoke the appropriate + * \Drupal\Core\Field\FieldStorageDefinitionListenerInterface + * events so that handlers react to the new definitions. + * - Raise a warning that the application state is incompatible with the + * codebase. + * - Perform some other action. + * + * @param string $entity_type_id + * The entity type ID. + * + * @return \Drupal\Core\Field\FieldStorageDefinitionInterface[] + * The array of installed field storage definitions for the entity type, + * keyed by field name. + * + * @see \Drupal\Core\Entity\EntityTypeListenerInterface + */ + public function getInstalledFieldStorageDefinitions($entity_type_id); + + /** * Returns a lightweight map of fields across bundles. * * @return array @@ -286,6 +321,38 @@ public function getTranslationFromContext(EntityInterface $entity, $langcode = N public function getDefinition($entity_type_id, $exception_on_invalid = TRUE); /** + * Returns the entity type definition in its most recently installed state. + * + * During the application lifetime, entity type definitions can change. For + * example, updated code can be deployed. The getDefinition() method will + * always return the definition as determined by the current codebase. This + * method, however, returns what the definition was when the last time that + * one of the \Drupal\Core\Entity\EntityTypeListenerInterface events was last + * fired and completed successfully. In other words, the definition that + * the entity type's handlers have incorporated into the application state. + * For example, if the entity type's storage handler is SQL-based, the + * definition for which database tables were created. + * + * Application management code can check if getDefinition() differs from + * getInstalledDefinition() and decide whether to: + * - Invoke the appropriate \Drupal\Core\Entity\EntityTypeListenerInterface + * event so that handlers react to the new definition. + * - Raise a warning that the application state is incompatible with the + * codebase. + * - Perform some other action. + * + * @param string $entity_type_id + * The entity type ID. + * + * @return \Drupal\Core\Entity\EntityTypeInterface|null + * The installed entity type definition, or NULL if the entity type has + * not yet been installed via onEntityTypeCreate(). + * + * @see \Drupal\Core\Entity\EntityTypeListenerInterface + */ + public function getInstalledDefinition($entity_type_id); + + /** * {@inheritdoc} * * @return \Drupal\Core\Entity\EntityTypeInterface[] diff --git a/core/lib/Drupal/Core/Entity/Exception/FieldStorageDefinitionUpdateForbiddenException.php b/core/lib/Drupal/Core/Entity/Exception/FieldStorageDefinitionUpdateForbiddenException.php index 54e2bff..0149ec3 100644 --- a/core/lib/Drupal/Core/Entity/Exception/FieldStorageDefinitionUpdateForbiddenException.php +++ b/core/lib/Drupal/Core/Entity/Exception/FieldStorageDefinitionUpdateForbiddenException.php @@ -7,7 +7,10 @@ namespace Drupal\Core\Entity\Exception; +use Drupal\Core\Entity\EntityStorageException; + /** * Exception thrown when a storage definition update is forbidden. */ -class FieldStorageDefinitionUpdateForbiddenException extends \Exception { } +class FieldStorageDefinitionUpdateForbiddenException extends EntityStorageException { +} diff --git a/core/lib/Drupal/Core/Entity/FieldableEntityStorageInterface.php b/core/lib/Drupal/Core/Entity/FieldableEntityStorageInterface.php index 2d695c3..aaab687 100644 --- a/core/lib/Drupal/Core/Entity/FieldableEntityStorageInterface.php +++ b/core/lib/Drupal/Core/Entity/FieldableEntityStorageInterface.php @@ -9,42 +9,9 @@ use Drupal\Core\Field\FieldDefinitionInterface; use Drupal\Core\Field\FieldStorageDefinitionInterface; +use Drupal\Core\Field\FieldStorageDefinitionListenerInterface; -interface FieldableEntityStorageInterface extends EntityStorageInterface { - - /** - * Reacts to the creation of a field storage definition. - * - * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $storage_definition - * The definition being created. - */ - public function onFieldStorageDefinitionCreate(FieldStorageDefinitionInterface $storage_definition); - - /** - * Reacts to the update of a field storage definition. - * - * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $storage_definition - * The field being updated. - * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $original - * The original storage definition; i.e., the definition before the update. - * - * @throws \Drupal\Core\Entity\Exception\FieldStorageDefinitionUpdateForbiddenException - * Thrown when the update to the field is forbidden. - */ - public function onFieldStorageDefinitionUpdate(FieldStorageDefinitionInterface $storage_definition, FieldStorageDefinitionInterface $original); - - /** - * Reacts to the deletion of a field storage definition. - * - * Stored values should not be wiped at once, but marked as 'deleted' so that - * they can go through a proper purge process later on. - * - * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $storage_definition - * The field being deleted. - * - * @see purgeFieldData() - */ - public function onFieldStorageDefinitionDelete(FieldStorageDefinitionInterface $storage_definition); +interface FieldableEntityStorageInterface extends EntityStorageInterface, FieldStorageDefinitionListenerInterface { /** * Reacts to the creation of a field. @@ -59,7 +26,7 @@ public function onFieldDefinitionCreate(FieldDefinitionInterface $field_definiti * * @param \Drupal\Core\Field\FieldDefinitionInterface $field_definition * The field definition being updated. - * @param \Drupal\Core\Field\FieldDefinitionInterface $field_definition + * @param \Drupal\Core\Field\FieldDefinitionInterface $original * The original field definition; i.e., the definition before the update. */ public function onFieldDefinitionUpdate(FieldDefinitionInterface $field_definition, FieldDefinitionInterface $original); diff --git a/core/lib/Drupal/Core/Entity/Schema/EntitySchemaHandlerInterface.php b/core/lib/Drupal/Core/Entity/Schema/EntitySchemaHandlerInterface.php deleted file mode 100644 index 51001bd..0000000 --- a/core/lib/Drupal/Core/Entity/Schema/EntitySchemaHandlerInterface.php +++ /dev/null @@ -1,15 +0,0 @@ -fieldStorageDefinitions = $storage_definitions; + $this->baseFieldDefinitions = $base_field_definitions; } /** @@ -101,7 +110,16 @@ public function getAllColumns($table_name) { $this->allColumns[$table_name] = array_merge($this->allColumns[$table_name], array_values($this->getColumnNames($field_name))); } - $this->allColumns[$table_name] = array_merge($this->allColumns[$table_name], $this->getExtraColumns($table_name)); + // There is just one field for each dedicated storage table, thus + // $field_name can only refer to it. + if (isset($field_name) && $this->requiresDedicatedTableStorage($this->fieldStorageDefinitions[$field_name])) { + // Unlike in shared storage tables, in dedicated ones field columns are + // positioned last. + $this->allColumns[$table_name] = array_merge($this->getExtraColumns($table_name), $this->allColumns[$table_name]); + } + else { + $this->allColumns[$table_name] = array_merge($this->allColumns[$table_name], $this->getExtraColumns($table_name)); + } } return $this->allColumns[$table_name]; } @@ -180,6 +198,47 @@ public function setExtraColumns($table_name, array $column_names) { } /** + * Checks whether the given field can be stored in a shared 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 allowsSharedTableStorage(FieldStorageDefinitionInterface $storage_definition) { + return !$storage_definition->hasCustomStorage() && isset($this->baseFieldDefinitions[$storage_definition->getName()]) && !$storage_definition->isMultiple(); + } + + /** + * 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); + } + + /** + * Returns a list of dedicated table names for this mapping. + * + * @return string[] + * An array of table names. + */ + public function getDedicatedTableNames() { + $table_mapping = $this; + $definitions = array_filter($this->fieldStorageDefinitions, function($definition) use ($table_mapping) { return $table_mapping->requiresDedicatedTableStorage($definition); }); + $data_tables = array_map(function($definition) use ($table_mapping) { return $table_mapping->getDedicatedDataTableName($definition); }, $definitions); + $revision_tables = array_map(function($definition) use ($table_mapping) { return $table_mapping->getDedicatedRevisionTableName($definition); }, $definitions); + $dedicated_tables = array_merge(array_values($data_tables), array_values($revision_tables)); + return $dedicated_tables; + } + + /** * {@inheritdoc} */ public function getReservedColumns() { diff --git a/core/lib/Drupal/Core/Entity/Sql/SqlContentEntityStorage.php b/core/lib/Drupal/Core/Entity/Sql/SqlContentEntityStorage.php index 1814564..b9df944 100644 --- a/core/lib/Drupal/Core/Entity/Sql/SqlContentEntityStorage.php +++ b/core/lib/Drupal/Core/Entity/Sql/SqlContentEntityStorage.php @@ -17,9 +17,8 @@ use Drupal\Core\Entity\EntityManagerInterface; use Drupal\Core\Entity\EntityStorageException; use Drupal\Core\Entity\EntityTypeInterface; -use Drupal\Core\Entity\EntityTypeListenerInterface; -use Drupal\Core\Entity\Exception\FieldStorageDefinitionUpdateForbiddenException; use Drupal\Core\Entity\Query\QueryInterface; +use Drupal\Core\Entity\Schema\FieldableEntityStorageSchemaInterface; use Drupal\Core\Field\FieldDefinitionInterface; use Drupal\Core\Field\FieldStorageDefinitionInterface; use Drupal\Core\Language\LanguageInterface; @@ -33,13 +32,12 @@ * * The class uses \Drupal\Core\Entity\Sql\SqlContentEntityStorageSchema * internally in order to automatically generate the database schema based on - * the defined base fields. Entity types can override - * SqlContentEntityStorage::getSchema() to customize the generated - * schema; e.g., to add additional indexes. + * the defined base fields. Entity types can override the schema handler to + * customize the generated schema; e.g., to add additional indexes. * * @ingroup entity_api */ -class SqlContentEntityStorage extends ContentEntityStorageBase implements SqlEntityStorageInterface, EntityTypeListenerInterface { +class SqlContentEntityStorage extends ContentEntityStorageBase implements SqlEntityStorageInterface, FieldableEntityStorageSchemaInterface { /** * The mapping of field columns to SQL tables. @@ -109,7 +107,7 @@ class SqlContentEntityStorage extends ContentEntityStorageBase implements SqlEnt /** * The entity schema handler. * - * @var \Drupal\Core\Entity\Schema\EntitySchemaHandlerInterface + * @var \Drupal\Core\Entity\Schema\EntityStorageSchemaInterface */ protected $schemaHandler; @@ -157,15 +155,27 @@ public function getFieldStorageDefinitions() { */ public function __construct(EntityTypeInterface $entity_type, Connection $database, EntityManagerInterface $entity_manager, CacheBackendInterface $cache) { parent::__construct($entity_type); - $this->database = $database; $this->entityManager = $entity_manager; $this->cacheBackend = $cache; + $this->initTableLayout(); + } + + /** + * Initializes table name variables. + */ + protected function initTableLayout() { + // Reset table field values to ensure changes in the entity type definition + // are correctly reflected in the table layout. + $this->tableMapping = NULL; + $this->revisionKey = NULL; + $this->revisionTable = NULL; + $this->dataTable = NULL; + $this->revisionDataTable = NULL; // @todo Remove table names from the entity type definition in // https://drupal.org/node/2232465 $this->baseTable = $this->entityType->getBaseTable() ?: $this->entityTypeId; - $revisionable = $this->entityType->isRevisionable(); if ($revisionable) { $this->revisionKey = $this->entityType->getKey('revision') ?: 'revision_id'; @@ -237,18 +247,38 @@ protected function schemaHandler() { } /** + * Updates the wrapped entity type definition. + * + * @param \Drupal\Core\Entity\EntityTypeInterface $entity_type + * The update entity type. + * + * @deprecated in Drupal 8.x-dev, will be removed before Drupal 8.0. + * See https://www.drupal.org/node/2274017. + */ + public function setEntityType(EntityTypeInterface $entity_type) { + if ($this->entityType->id() == $entity_type->id()) { + $this->entityType = $entity_type; + $this->initTableLayout(); + } + else { + throw new EntityStorageException(String::format('Unsupported entity type @id', array('@id' => $entity_type->id()))); + } + } + + /** * {@inheritdoc} */ - public function getTableMapping() { - if (!isset($this->tableMapping)) { + public function getTableMapping(array $storage_definitions = NULL) { + $table_mapping = $this->tableMapping; + + if (!isset($this->tableMapping) || $storage_definitions) { + $definitions = $storage_definitions ?: $this->entityManager->getFieldStorageDefinitions($this->entityTypeId); + $base_field_definitions = $this->entityManager->getBaseFieldDefinitions($this->entityTypeId); + $table_mapping = new DefaultTableMapping($definitions, $base_field_definitions); - $definitions = array_filter($this->getFieldStorageDefinitions(), function (FieldStorageDefinitionInterface $definition) { - // @todo Remove the check for FieldDefinitionInterface::isMultiple() when - // multiple-value base fields are supported in - // https://drupal.org/node/2248977. - return !$definition->hasCustomStorage() && !$definition->isMultiple(); + $definitions = array_filter($definitions, function (FieldStorageDefinitionInterface $definition) use ($table_mapping) { + return $table_mapping->allowsSharedTableStorage($definition); }); - $this->tableMapping = new DefaultTableMapping($definitions); $key_fields = array_values(array_filter(array($this->idKey, $this->revisionKey, $this->bundleKey, $this->uuidKey, $this->langcodeKey))); $all_fields = array_keys($definitions); @@ -276,16 +306,16 @@ public function getTableMapping() { $translatable = $this->entityType->getDataTable() && $this->entityType->isTranslatable(); if (!$revisionable && !$translatable) { // The base layout stores all the base field values in the base table. - $this->tableMapping->setFieldNames($this->baseTable, $all_fields); + $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. - $this->tableMapping->setFieldNames($this->baseTable, array_diff($all_fields, $revision_metadata_fields)); + $table_mapping->setFieldNames($this->baseTable, array_diff($all_fields, $revision_metadata_fields)); $revision_key_fields = array($this->idKey, $this->revisionKey); - $this->tableMapping->setFieldNames($this->revisionTable, array_merge($revision_key_fields, $revisionable_fields)); + $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 @@ -294,7 +324,7 @@ public function getTableMapping() { // 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. - $this->tableMapping + $table_mapping ->setFieldNames($this->baseTable, $key_fields) ->setFieldNames($this->dataTable, array_values(array_diff($all_fields, array($this->uuidKey)))) // Add the denormalized 'default_langcode' field to the mapping. Its @@ -310,13 +340,13 @@ public function getTableMapping() { // 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. - $this->tableMapping->setFieldNames($this->baseTable, array_values(array_diff($key_fields, array($this->langcodeKey)))); + $table_mapping->setFieldNames($this->baseTable, array_values(array_diff($key_fields, array($this->langcodeKey)))); // 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)); - $this->tableMapping + $table_mapping ->setFieldNames($this->dataTable, $data_fields) // Add the denormalized 'default_langcode' field to the mapping. Its // value is identical to the query expression @@ -325,20 +355,43 @@ public function getTableMapping() { ->setExtraColumns($this->dataTable, array('default_langcode')); $revision_base_fields = array_merge(array($this->idKey, $this->revisionKey, $this->langcodeKey), $revision_metadata_fields); - $this->tableMapping->setFieldNames($this->revisionTable, $revision_base_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); - $this->tableMapping + $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 the denormalized 'default_langcode' field to the mapping. Its // value is identical to the query expression // "revision_table.langcode = data_table.langcode". ->setExtraColumns($this->revisionDataTable, array('default_langcode')); } + + // 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); + } + } + + if (!$storage_definitions) { + $this->tableMapping = $table_mapping; + } } - return $this->tableMapping; + return $table_mapping; } /** @@ -585,7 +638,7 @@ protected function attachPropertyData(array &$entities) { $table_mapping = $this->getTableMapping(); $translations = array(); if ($this->revisionDataTable) { - $data_fields = array_diff_key($table_mapping->getFieldNames($this->revisionDataTable), $table_mapping->getFieldNames($this->baseTable)); + $data_fields = array_diff($table_mapping->getFieldNames($this->revisionDataTable), $table_mapping->getFieldNames($this->baseTable)); } else { $data_fields = $table_mapping->getFieldNames($this->dataTable); @@ -1154,7 +1207,7 @@ protected function loadFieldItems(array $entities) { $definitions[$bundle] = $this->entityManager->getFieldDefinitions($this->entityTypeId, $bundle); foreach ($definitions[$bundle] as $field_name => $field_definition) { $storage_definition = $field_definition->getFieldStorageDefinition(); - if ($this->usesDedicatedTable($storage_definition)) { + if ($table_mapping->requiresDedicatedTableStorage($storage_definition)) { $storage_definitions[$field_name] = $storage_definition; } } @@ -1229,7 +1282,7 @@ protected function saveFieldItems(EntityInterface $entity, $update = TRUE) { foreach ($this->entityManager->getFieldDefinitions($entity_type, $bundle) as $field_name => $field_definition) { $storage_definition = $field_definition->getFieldStorageDefinition(); - if (!$this->usesDedicatedTable($storage_definition)) { + if (!$table_mapping->requiresDedicatedTableStorage($storage_definition)) { continue; } $table_name = $table_mapping->getDedicatedDataTableName($storage_definition); @@ -1244,10 +1297,12 @@ protected function saveFieldItems(EntityInterface $entity, $update = TRUE) { ->condition('entity_id', $id) ->execute(); } - $this->database->delete($revision_name) - ->condition('entity_id', $id) - ->condition('revision_id', $vid) - ->execute(); + if ($this->entityType->isRevisionable()) { + $this->database->delete($revision_name) + ->condition('entity_id', $id) + ->condition('revision_id', $vid) + ->execute(); + } } // Prepare the multi-insert query. @@ -1257,7 +1312,9 @@ protected function saveFieldItems(EntityInterface $entity, $update = TRUE) { $columns[] = $table_mapping->getFieldColumnName($storage_definition, $column); } $query = $this->database->insert($table_name)->fields($columns); - $revision_query = $this->database->insert($revision_name)->fields($columns); + if ($this->entityType->isRevisionable()) { + $revision_query = $this->database->insert($revision_name)->fields($columns); + } $langcodes = $field_definition->isTranslatable() ? $translation_langcodes : array($default_langcode); foreach ($langcodes as $langcode) { @@ -1280,7 +1337,9 @@ protected function saveFieldItems(EntityInterface $entity, $update = TRUE) { $record[$column_name] = !empty($attributes['serialize']) ? serialize($item->$column) : $item->$column; } $query->values($record); - $revision_query->values($record); + if ($this->entityType->isRevisionable()) { + $revision_query->values($record); + } if ($storage_definition->getCardinality() != FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED && ++$delta_count == $storage_definition->getCardinality()) { break; @@ -1295,7 +1354,9 @@ protected function saveFieldItems(EntityInterface $entity, $update = TRUE) { if ($entity->isDefaultRevision()) { $query->execute(); } - $revision_query->execute(); + if ($this->entityType->isRevisionable()) { + $revision_query->execute(); + } } } } @@ -1310,7 +1371,7 @@ protected function deleteFieldItems(EntityInterface $entity) { $table_mapping = $this->getTableMapping(); foreach ($this->entityManager->getFieldDefinitions($entity->getEntityTypeId(), $entity->bundle()) as $field_definition) { $storage_definition = $field_definition->getFieldStorageDefinition(); - if (!$this->usesDedicatedTable($storage_definition)) { + if (!$table_mapping->requiresDedicatedTableStorage($storage_definition)) { continue; } $table_name = $table_mapping->getDedicatedDataTableName($storage_definition); @@ -1318,9 +1379,11 @@ protected function deleteFieldItems(EntityInterface $entity) { $this->database->delete($table_name) ->condition('entity_id', $entity->id()) ->execute(); - $this->database->delete($revision_name) - ->condition('entity_id', $entity->id()) - ->execute(); + if ($this->entityType->isRevisionable()) { + $this->database->delete($revision_name) + ->condition('entity_id', $entity->id()) + ->execute(); + } } } @@ -1336,7 +1399,7 @@ protected function deleteFieldItemsRevision(EntityInterface $entity) { $table_mapping = $this->getTableMapping(); foreach ($this->entityManager->getFieldDefinitions($entity->getEntityTypeId(), $entity->bundle()) as $field_definition) { $storage_definition = $field_definition->getFieldStorageDefinition(); - if (!$this->usesDedicatedTable($storage_definition)) { + if (!$table_mapping->requiresDedicatedTableStorage($storage_definition)) { continue; } $revision_name = $table_mapping->getDedicatedRevisionTableName($storage_definition); @@ -1349,18 +1412,31 @@ protected function deleteFieldItemsRevision(EntityInterface $entity) { } /** - * 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. + * {@inheritdoc} + */ + public function requiresEntityStorageSchemaChanges(EntityTypeInterface $entity_type, EntityTypeInterface $original) { + return $this->schemaHandler()->requiresEntityStorageSchemaChanges($entity_type, $original); + } + + /** + * {@inheritdoc} + */ + public function requiresFieldStorageSchemaChanges(FieldStorageDefinitionInterface $storage_definition, FieldStorageDefinitionInterface $original) { + return $this->schemaHandler()->requiresFieldStorageSchemaChanges($storage_definition, $original); + } + + /** + * {@inheritdoc} + */ + public function requiresEntityDataMigration(EntityTypeInterface $entity_type, EntityTypeInterface $original) { + return $this->schemaHandler()->requiresEntityDataMigration($entity_type, $original); + } + + /** + * {@inheritdoc} */ - 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(); + public function requiresFieldDataMigration(FieldStorageDefinitionInterface $storage_definition, FieldStorageDefinitionInterface $original) { + return $this->schemaHandler()->requiresFieldDataMigration($storage_definition, $original); } /** @@ -1374,6 +1450,12 @@ public function onEntityTypeCreate(EntityTypeInterface $entity_type) { * {@inheritdoc} */ public function onEntityTypeUpdate(EntityTypeInterface $entity_type, EntityTypeInterface $original) { + // Ensure we have an updated entity type definition. + $this->entityType = $entity_type; + // The table layout may have changed depending on the new entity type + // definition. + $this->initTableLayout(); + // Let the schema handler adapt to possible table layout changes. $this->schemaHandler()->onEntityTypeUpdate($entity_type, $original); } @@ -1388,96 +1470,22 @@ public function onEntityTypeDelete(EntityTypeInterface $entity_type) { * {@inheritdoc} */ public function onFieldStorageDefinitionCreate(FieldStorageDefinitionInterface $storage_definition) { - $schema = $this->_fieldSqlSchema($storage_definition); - foreach ($schema as $name => $table) { - $this->database->schema()->createTable($name, $table); - } + // If we are adding a field stored in a shared table we need to recompute + // the table mapping. + // @todo This does not belong here. Remove it once we are able to generate a + // fresh table mapping in the schema handler. See + // https://www.drupal.org/node/2274017. + if ($this->getTableMapping()->allowsSharedTableStorage($storage_definition)) { + $this->tableMapping = NULL; + } + $this->schemaHandler()->onFieldStorageDefinitionCreate($storage_definition); } /** * {@inheritdoc} */ public function onFieldStorageDefinitionUpdate(FieldStorageDefinitionInterface $storage_definition, FieldStorageDefinitionInterface $original) { - if (!$storage_definition->hasData()) { - // There is no data. Re-create the tables completely. - - if ($this->database->supportsTransactionalDDL()) { - // If the database supports transactional DDL, we can go ahead and rely - // on it. If not, we will have to rollback manually if something fails. - $transaction = $this->database->startTransaction(); - } - - try { - $original_schema = $this->_fieldSqlSchema($original); - foreach ($original_schema as $name => $table) { - $this->database->schema()->dropTable($name, $table); - } - $schema = $this->_fieldSqlSchema($storage_definition); - foreach ($schema as $name => $table) { - $this->database->schema()->createTable($name, $table); - } - } - catch (\Exception $e) { - if ($this->database->supportsTransactionalDDL()) { - $transaction->rollback(); - } - else { - // Recreate tables. - $original_schema = $this->_fieldSqlSchema($original); - foreach ($original_schema as $name => $table) { - if (!$this->database->schema()->tableExists($name)) { - $this->database->schema()->createTable($name, $table); - } - } - } - throw $e; - } - } - else { - if ($storage_definition->getColumns() != $original->getColumns()) { - throw new FieldStorageDefinitionUpdateForbiddenException("The SQL storage cannot change the schema for an existing field with data."); - } - // There is data, so there are no column changes. Drop all the prior - // indexes and create all the new ones, except for all the priors that - // exist unchanged. - $table_mapping = $this->getTableMapping(); - $table = $table_mapping->getDedicatedDataTableName($original); - $revision_table = $table_mapping->getDedicatedRevisionTableName($original); - - $schema = $storage_definition->getSchema(); - $original_schema = $original->getSchema(); - - foreach ($original_schema['indexes'] as $name => $columns) { - if (!isset($schema['indexes'][$name]) || $columns != $schema['indexes'][$name]) { - $real_name = static::_fieldIndexName($storage_definition, $name); - $this->database->schema()->dropIndex($table, $real_name); - $this->database->schema()->dropIndex($revision_table, $real_name); - } - } - $table = $table_mapping->getDedicatedDataTableName($storage_definition); - $revision_table = $table_mapping->getDedicatedRevisionTableName($storage_definition); - foreach ($schema['indexes'] as $name => $columns) { - if (!isset($original_schema['indexes'][$name]) || $columns != $original_schema['indexes'][$name]) { - $real_name = static::_fieldIndexName($storage_definition, $name); - $real_columns = array(); - foreach ($columns as $column_name) { - // Indexes can be specified as either a column name or an array with - // column name and length. Allow for either case. - if (is_array($column_name)) { - $real_columns[] = array( - $table_mapping->getFieldColumnName($storage_definition, $column_name[0]), - $column_name[1], - ); - } - else { - $real_columns[] = $table_mapping->getFieldColumnName($storage_definition, $column_name); - } - } - $this->database->schema()->addIndex($table, $real_name, $real_columns); - $this->database->schema()->addIndex($revision_table, $real_name, $real_columns); - } - } - } + $this->schemaHandler()->onFieldStorageDefinitionUpdate($storage_definition, $original); } /** @@ -1486,19 +1494,22 @@ public function onFieldStorageDefinitionUpdate(FieldStorageDefinitionInterface $ public function onFieldStorageDefinitionDelete(FieldStorageDefinitionInterface $storage_definition) { $table_mapping = $this->getTableMapping(); - // Mark all data associated with the field for deletion. - $table = $table_mapping->getDedicatedDataTableName($storage_definition); - $revision_table = $table_mapping->getDedicatedRevisionTableName($storage_definition); - $this->database->update($table) - ->fields(array('deleted' => 1)) - ->execute(); + if ($table_mapping->requiresDedicatedTableStorage($storage_definition)) { + // Mark all data associated with the field for deletion. + $table = $table_mapping->getDedicatedDataTableName($storage_definition); + $revision_table = $table_mapping->getDedicatedRevisionTableName($storage_definition); + $this->database->update($table) + ->fields(array('deleted' => 1)) + ->execute(); + if ($this->entityType->isRevisionable()) { + $this->database->update($revision_table) + ->fields(array('deleted' => 1)) + ->execute(); + } + } - // Move the table to a unique name while the table contents are being - // deleted. - $new_table = $table_mapping->getDedicatedDataTableName($storage_definition, TRUE); - $revision_new_table = $table_mapping->getDedicatedRevisionTableName($storage_definition, TRUE); - $this->database->schema()->renameTable($table, $new_table); - $this->database->schema()->renameTable($revision_table, $revision_new_table); + // Update the field schema. + $this->schemaHandler()->onFieldStorageDefinitionDelete($storage_definition); } /** @@ -1508,16 +1519,20 @@ public function onFieldDefinitionDelete(FieldDefinitionInterface $field_definiti $table_mapping = $this->getTableMapping(); $storage_definition = $field_definition->getFieldStorageDefinition(); // Mark field data as deleted. - $table_name = $table_mapping->getDedicatedDataTableName($storage_definition); - $revision_name = $table_mapping->getDedicatedRevisionTableName($storage_definition); - $this->database->update($table_name) - ->fields(array('deleted' => 1)) - ->condition('bundle', $field_definition->getBundle()) - ->execute(); - $this->database->update($revision_name) - ->fields(array('deleted' => 1)) - ->condition('bundle', $field_definition->getBundle()) - ->execute(); + if ($table_mapping->requiresDedicatedTableStorage($storage_definition)) { + $table_name = $table_mapping->getDedicatedDataTableName($storage_definition); + $revision_name = $table_mapping->getDedicatedRevisionTableName($storage_definition); + $this->database->update($table_name) + ->fields(array('deleted' => 1)) + ->condition('bundle', $field_definition->getBundle()) + ->execute(); + if ($this->entityType->isRevisionable()) { + $this->database->update($revision_name) + ->fields(array('deleted' => 1)) + ->condition('bundle', $field_definition->getBundle()) + ->execute(); + } + } } /** @@ -1536,7 +1551,7 @@ public function onBundleRename($bundle, $bundle_new) { foreach ($field_definitions as $field_definition) { $storage_definition = $field_definition->getFieldStorageDefinition(); - if ($this->usesDedicatedTable($storage_definition)) { + if ($table_mapping->requiresDedicatedTableStorage($storage_definition)) { $is_deleted = $this->storageDefinitionIsDeleted($storage_definition); $table_name = $table_mapping->getDedicatedDataTableName($storage_definition, $is_deleted); $revision_name = $table_mapping->getDedicatedRevisionTableName($storage_definition, $is_deleted); @@ -1544,10 +1559,12 @@ public function onBundleRename($bundle, $bundle_new) { ->fields(array('bundle' => $bundle_new)) ->condition('bundle', $bundle) ->execute(); - $this->database->update($revision_name) - ->fields(array('bundle' => $bundle_new)) - ->condition('bundle', $bundle) - ->execute(); + if ($this->entityType->isRevisionable()) { + $this->database->update($revision_name) + ->fields(array('bundle' => $bundle_new)) + ->condition('bundle', $bundle) + ->execute(); + } } } } @@ -1625,20 +1642,18 @@ protected function purgeFieldItems(ContentEntityInterface $entity, FieldDefiniti $this->database->delete($table_name) ->condition('revision_id', $revision_id) ->execute(); - $this->database->delete($revision_name) - ->condition('revision_id', $revision_id) - ->execute(); + if ($this->entityType->isRevisionable()) { + $this->database->delete($revision_name) + ->condition('revision_id', $revision_id) + ->execute(); + } } /** * {@inheritdoc} */ public function finalizePurge(FieldStorageDefinitionInterface $storage_definition) { - $table_mapping = $this->getTableMapping(); - $table_name = $table_mapping->getDedicatedDataTableName($storage_definition, TRUE); - $revision_name = $table_mapping->getDedicatedRevisionTableName($storage_definition, TRUE); - $this->database->schema()->dropTable($table_name); - $this->database->schema()->dropTable($revision_name); + $this->schemaHandler()->finalizePurge($storage_definition); } /** @@ -1647,17 +1662,38 @@ public function finalizePurge(FieldStorageDefinitionInterface $storage_definitio public function countFieldData($storage_definition, $as_bool = FALSE) { $table_mapping = $this->getTableMapping(); - $is_deleted = $this->storageDefinitionIsDeleted($storage_definition); - $table_name = $table_mapping->getDedicatedDataTableName($storage_definition, $is_deleted); - $query = $this->database->select($table_name, 't'); - $or = $query->orConditionGroup(); - foreach ($storage_definition->getColumns() as $column_name => $data) { - $or->isNotNull($table_mapping->getFieldColumnName($storage_definition, $column_name)); + if ($table_mapping->requiresDedicatedTableStorage($storage_definition)) { + $is_deleted = $this->storageDefinitionIsDeleted($storage_definition); + $table_name = $table_mapping->getDedicatedDataTableName($storage_definition, $is_deleted); + $query = $this->database->select($table_name, 't'); + $or = $query->orConditionGroup(); + foreach ($storage_definition->getColumns() as $column_name => $data) { + $or->isNotNull($table_mapping->getFieldColumnName($storage_definition, $column_name)); + } + $query + ->condition($or) + ->fields('t', array('entity_id')) + ->distinct(TRUE); } - $query - ->condition($or) - ->fields('t', array('entity_id')) - ->distinct(TRUE); + else { + $data_table = $this->dataTable ?: $this->baseTable; + $query = $this->database->select($data_table, 't'); + $columns = $storage_definition->getColumns(); + if (count($columns) > 1) { + $or = $query->orConditionGroup(); + foreach ($columns as $column_name => $data) { + $or->isNotNull($table_mapping->getFieldColumnName($storage_definition, $column_name)); + } + $query->condition($or); + } + else { + $query->isNotNull($storage_definition->getName()); + } + $query + ->fields('t', array($this->idKey)) + ->distinct(TRUE); + } + // If we are performing the query just to check if the field has data // limit the number of rows. if ($as_bool) { @@ -1680,197 +1716,4 @@ protected function storageDefinitionIsDeleted(FieldStorageDefinitionInterface $s return !array_key_exists($storage_definition->getName(), $this->entityManager->getFieldStorageDefinitions($this->entityTypeId)); } - /** - * Gets the SQL table schema. - * - * @private Calling this function circumvents the entity system and is - * strongly discouraged. This function is not considered part of the public - * API and modules relying on it might break even in minor releases. - * - * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $storage_definition - * The field storage definition. - * @param array $schema - * The field schema array. Mandatory for upgrades, omit otherwise. - * @param bool $deleted - * (optional) Whether the schema of the table holding the values of a - * deleted field should be returned. - * - * @return array - * The same as a hook_schema() implementation for the data and the - * revision tables. - * - * @see hook_schema() - */ - public static function _fieldSqlSchema(FieldStorageDefinitionInterface $storage_definition, array $schema = NULL, $deleted = FALSE) { - $table_mapping = new DefaultTableMapping(array()); - - $description_current = "Data storage for {$storage_definition->getTargetEntityTypeId()} field {$storage_definition->getName()}."; - $description_revision = "Revision archive storage for {$storage_definition->getTargetEntityTypeId()} field {$storage_definition->getName()}."; - - $entity_type_id = $storage_definition->getTargetEntityTypeId(); - $entity_manager = \Drupal::entityManager(); - $entity_type = $entity_manager->getDefinition($entity_type_id); - $definitions = $entity_manager->getBaseFieldDefinitions($entity_type_id); - - // Define the entity ID schema based on the field definitions. - $id_definition = $definitions[$entity_type->getKey('id')]; - if ($id_definition->getType() == 'integer') { - $id_schema = array( - 'type' => 'int', - 'unsigned' => TRUE, - 'not null' => TRUE, - 'description' => 'The entity id this data is attached to', - ); - } - else { - $id_schema = array( - 'type' => 'varchar', - 'length' => 128, - 'not null' => TRUE, - 'description' => 'The entity id this data is attached to', - ); - } - - // Define the revision ID schema, default to integer if there is no revision - // ID. - $revision_id_definition = $entity_type->hasKey('revision') ? $definitions[$entity_type->getKey('revision')] : NULL; - if (!$revision_id_definition || $revision_id_definition->getType() == 'integer') { - $revision_id_schema = array( - 'type' => 'int', - 'unsigned' => TRUE, - 'not null' => FALSE, - 'description' => 'The entity revision id this data is attached to, or NULL if the entity type is not versioned', - ); - } - else { - $revision_id_schema = array( - 'type' => 'varchar', - 'length' => 128, - 'not null' => FALSE, - 'description' => 'The entity revision id this data is attached to, or NULL if the entity type is not versioned', - ); - } - - $current = array( - 'description' => $description_current, - 'fields' => array( - 'bundle' => array( - 'type' => 'varchar', - 'length' => 128, - 'not null' => TRUE, - 'default' => '', - 'description' => 'The field instance bundle to which this row belongs, used when deleting a field instance', - ), - 'deleted' => array( - 'type' => 'int', - 'size' => 'tiny', - 'not null' => TRUE, - 'default' => 0, - 'description' => 'A boolean indicating whether this data item has been deleted' - ), - 'entity_id' => $id_schema, - 'revision_id' => $revision_id_schema, - 'langcode' => array( - 'type' => 'varchar', - 'length' => 32, - 'not null' => TRUE, - 'default' => '', - 'description' => 'The language code for this data item.', - ), - 'delta' => array( - 'type' => 'int', - 'unsigned' => TRUE, - 'not null' => TRUE, - 'description' => 'The sequence number for this data item, used for multi-value fields', - ), - ), - 'primary key' => array('entity_id', 'deleted', 'delta', 'langcode'), - 'indexes' => array( - 'bundle' => array('bundle'), - 'deleted' => array('deleted'), - 'entity_id' => array('entity_id'), - 'revision_id' => array('revision_id'), - 'langcode' => array('langcode'), - ), - ); - - if (!$schema) { - $schema = $storage_definition->getSchema(); - } - - // Add field columns. - foreach ($schema['columns'] as $column_name => $attributes) { - $real_name = $table_mapping->getFieldColumnName($storage_definition, $column_name); - $current['fields'][$real_name] = $attributes; - } - - // Add unique keys. - foreach ($schema['unique keys'] as $unique_key_name => $columns) { - $real_name = static::_fieldIndexName($storage_definition, $unique_key_name); - foreach ($columns as $column_name) { - $current['unique keys'][$real_name][] = $table_mapping->getFieldColumnName($storage_definition, $column_name); - } - } - - // Add indexes. - foreach ($schema['indexes'] as $index_name => $columns) { - $real_name = static::_fieldIndexName($storage_definition, $index_name); - foreach ($columns as $column_name) { - // Indexes can be specified as either a column name or an array with - // column name and length. Allow for either case. - if (is_array($column_name)) { - $current['indexes'][$real_name][] = array( - $table_mapping->getFieldColumnName($storage_definition, $column_name[0]), - $column_name[1], - ); - } - else { - $current['indexes'][$real_name][] = $table_mapping->getFieldColumnName($storage_definition, $column_name); - } - } - } - - // Add foreign keys. - foreach ($schema['foreign keys'] as $specifier => $specification) { - $real_name = static::_fieldIndexName($storage_definition, $specifier); - $current['foreign keys'][$real_name]['table'] = $specification['table']; - foreach ($specification['columns'] as $column_name => $referenced) { - $sql_storage_column = $table_mapping->getFieldColumnName($storage_definition, $column_name); - $current['foreign keys'][$real_name]['columns'][$sql_storage_column] = $referenced; - } - } - - // Construct the revision table. - $revision = $current; - $revision['description'] = $description_revision; - $revision['primary key'] = array('entity_id', 'revision_id', 'deleted', 'delta', 'langcode'); - $revision['fields']['revision_id']['not null'] = TRUE; - $revision['fields']['revision_id']['description'] = 'The entity revision id this data is attached to'; - - return array( - $table_mapping->getDedicatedDataTableName($storage_definition) => $current, - $table_mapping->getDedicatedRevisionTableName($storage_definition) => $revision, - ); - } - - /** - * Generates an index name for a field data table. - * - * @private Calling this function circumvents the entity system and is - * strongly discouraged. This function is not considered part of the public - * API and modules relying on it might break even in minor releases. - * - * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $storage_definition - * The field storage definition. - * @param string $index - * The name of the index. - * - * @return string - * A string containing a generated index name for a field data table that is - * unique among all other fields. - */ - public static function _fieldIndexName(FieldStorageDefinitionInterface $storage_definition, $index) { - return $storage_definition->getName() . '_' . $index; - } - } diff --git a/core/lib/Drupal/Core/Entity/Sql/SqlContentEntityStorageSchema.php b/core/lib/Drupal/Core/Entity/Sql/SqlContentEntityStorageSchema.php index 32c83c7..6131650 100644 --- a/core/lib/Drupal/Core/Entity/Sql/SqlContentEntityStorageSchema.php +++ b/core/lib/Drupal/Core/Entity/Sql/SqlContentEntityStorageSchema.php @@ -7,16 +7,28 @@ namespace Drupal\Core\Entity\Sql; +use Drupal\Component\Utility\String; use Drupal\Core\Database\Connection; use Drupal\Core\Entity\ContentEntityTypeInterface; use Drupal\Core\Entity\EntityManagerInterface; +use Drupal\Core\Entity\EntityStorageException; use Drupal\Core\Entity\EntityTypeInterface; -use Drupal\Core\Entity\Schema\EntitySchemaHandlerInterface; +use Drupal\Core\Entity\Exception\FieldStorageDefinitionUpdateForbiddenException; +use Drupal\Core\Entity\Schema\FieldableEntityStorageSchemaInterface; +use Drupal\Core\Field\FieldException; +use Drupal\Core\Field\FieldStorageDefinitionInterface; /** * Defines a schema handler that supports revisionable, translatable entities. */ -class SqlContentEntityStorageSchema implements EntitySchemaHandlerInterface { +class SqlContentEntityStorageSchema implements FieldableEntityStorageSchemaInterface { + + /** + * The entity manager. + * + * @var \Drupal\Core\Entity\EntityManagerInterface + */ + protected $entityManager; /** * The entity type this schema builder is responsible for. @@ -33,6 +45,14 @@ class SqlContentEntityStorageSchema implements EntitySchemaHandlerInterface { protected $fieldStorageDefinitions; /** + * The original storage field definitions for this entity type. Used during + * field schema updates. + * + * @var \Drupal\Core\Field\FieldDefinitionInterface[] + */ + protected $originalDefinitions; + + /** * The storage object for the given entity type. * * @var \Drupal\Core\Entity\Sql\SqlContentEntityStorage @@ -54,6 +74,13 @@ class SqlContentEntityStorageSchema implements EntitySchemaHandlerInterface { protected $database; /** + * The state service. + * + * @var \Drupal\Core\State\StateInterface + */ + protected $state; + + /** * Constructs a SqlContentEntityStorageSchema. * * @param \Drupal\Core\Entity\EntityManagerInterface $entity_manager @@ -66,6 +93,7 @@ class SqlContentEntityStorageSchema implements EntitySchemaHandlerInterface { * The database connection to be used. */ public function __construct(EntityManagerInterface $entity_manager, ContentEntityTypeInterface $entity_type, SqlContentEntityStorage $storage, Connection $database) { + $this->entityManager = $entity_manager; $this->entityType = $entity_type; $this->fieldStorageDefinitions = $entity_manager->getFieldStorageDefinitions($entity_type->id()); $this->storage = $storage; @@ -73,9 +101,96 @@ public function __construct(EntityManagerInterface $entity_manager, ContentEntit } /** + * @return \Drupal\Core\State\StateInterface + */ + protected function state() { + if (!isset($this->state)) { + $this->state = \Drupal::state(); + } + return $this->state; + } + + /** + * {@inheritdoc} + */ + public function requiresEntityStorageSchemaChanges(EntityTypeInterface $entity_type, EntityTypeInterface $original) { + return + $entity_type->getStorageClass() != $original->getStorageClass() || + $entity_type->isRevisionable() != $original->isRevisionable() || + $entity_type->isTranslatable() != $original->isTranslatable() || + // Detect changes in key or index definitions. + $this->getEntitySchemaData($entity_type, $this->getEntitySchema($entity_type, TRUE)) != $this->loadEntitySchemaData($original); + } + + /** + * {@inheritdoc} + */ + public function requiresFieldStorageSchemaChanges(FieldStorageDefinitionInterface $storage_definition, FieldStorageDefinitionInterface $original) { + return + $storage_definition->hasCustomStorage() != $original->hasCustomStorage() || + $storage_definition->getSchema() != $original->getSchema() || + $storage_definition->isRevisionable() != $original->isRevisionable() || + $this->requiresFieldDataMigration($storage_definition, $original); + } + + /** + * {@inheritdoc} + */ + public function requiresEntityDataMigration(EntityTypeInterface $entity_type, EntityTypeInterface $original) { + // If we're updating from NULL storage, then there's no stored data that + // requires migration. + // @todo Remove in https://www.drupal.org/node/2335879. + $original_storage_class = $original->getStorageClass(); + $null_storage_class = 'Drupal\Core\Entity\ContentEntityNullStorage'; + if ($original_storage_class == $null_storage_class || is_subclass_of($original_storage_class, $null_storage_class)) { + return FALSE; + } + + return + // If the original storage class is different, then there might be + // existing entities in that storage even if the new storage's base + // table is empty. + // @todo Ask the old storage handler rather than assuming: + // https://www.drupal.org/node/2335879. + $entity_type->getStorageClass() != $original_storage_class || + !$this->tableIsEmpty($this->storage->getBaseTable()); + } + + /** + * {@inheritdoc} + */ + public function requiresFieldDataMigration(FieldStorageDefinitionInterface $storage_definition, FieldStorageDefinitionInterface $original) { + // If the base table is empty, there are no entities, and therefore, no + // field data that we care about preserving. + if ($this->tableIsEmpty($this->storage->getBaseTable())) { + return FALSE; + } + + $table_mapping = $this->storage->getTableMapping(); + + // If the field changes its custom storage status, we will need to create or + // drop its schema. In any case we cannot migrate its data as custom storage + // is involved. Otherwise if a field is moved from a shared table to a + // dedicated table or viceversa we need a data migration. + $custom_storage = $storage_definition->hasCustomStorage() || $original->hasCustomStorage(); + $shared_table_changed = $table_mapping->allowsSharedTableStorage($storage_definition) != $table_mapping->allowsSharedTableStorage($original); + $dedicated_table_changed = $table_mapping->requiresDedicatedTableStorage($storage_definition) != $table_mapping->requiresDedicatedTableStorage($original); + if (!$custom_storage && ($shared_table_changed || $dedicated_table_changed)) { + return TRUE; + } + // If columns change we may need data manipulation, which we cannot handle. + if ($storage_definition->getColumns() != $original->getColumns()) { + return TRUE; + } + + return FALSE; + } + + /** * {@inheritdoc} */ public function onEntityTypeCreate(EntityTypeInterface $entity_type) { + $this->checkEntityType($entity_type); $schema_handler = $this->database->schema(); $schema = $this->getEntitySchema($entity_type, TRUE); foreach ($schema as $table_name => $table_schema) { @@ -83,17 +198,85 @@ public function onEntityTypeCreate(EntityTypeInterface $entity_type) { $schema_handler->createTable($table_name, $table_schema); } } + $this->saveEntitySchemaData($entity_type, $schema); } /** * {@inheritdoc} */ public function onEntityTypeUpdate(EntityTypeInterface $entity_type, EntityTypeInterface $original) { - // @todo Implement proper updates: https://www.drupal.org/node/1498720. - // Meanwhile, treat a change from non-SQL storage to SQL storage as - // identical to creation with respect to SQL schema handling. - if (!is_subclass_of($original->getStorageClass(), '\Drupal\Core\Entity\Sql\SqlEntityStorageInterface')) { - $this->onEntityTypeCreate($entity_type); + $this->checkEntityType($entity_type); + $this->checkEntityType($original); + + // If no schema changes are needed, we don't need to do anything. + if (!$this->requiresEntityStorageSchemaChanges($entity_type, $original)) { + return; + } + + // If we have no data just recreate the entity schema from scratch. + if (!$this->requiresEntityDataMigration($entity_type, $original)) { + if ($this->database->supportsTransactionalDDL()) { + // If the database supports transactional DDL, we can go ahead and rely + // on it. If not, we will have to rollback manually if something fails. + $transaction = $this->database->startTransaction(); + } + try { + $this->onEntityTypeDelete($original); + $this->onEntityTypeCreate($entity_type); + + // Update dedicated table revision schema. + if ($original->isRevisionable() && !$entity_type->isRevisionable()) { + $this->dropDedicatedTableRevisionSchema(); + } + elseif (!$original->isRevisionable() && $entity_type->isRevisionable()) { + $this->createDedicatedTableRevisionSchema($entity_type); + } + } + catch (\Exception $e) { + if ($this->database->supportsTransactionalDDL()) { + $transaction->rollback(); + } + else { + // Recreate original schema. + $this->onEntityTypeCreate($original); + } + throw $e; + } + } + else { + $schema_handler = $this->database->schema(); + + // Drop original indexes and unique keys. + foreach ($this->loadEntitySchemaData($entity_type) as $table_name => $schema) { + if (!empty($schema['indexes'])) { + foreach ($schema['indexes'] as $name => $specifier) { + $schema_handler->dropIndex($table_name, $name); + } + } + if (!empty($schema['unique keys'])) { + foreach ($schema['unique keys'] as $name => $specifier) { + $schema_handler->dropUniqueKey($table_name, $name); + } + } + } + + // Create new indexes and unique keys. + $entity_schema = $this->getEntitySchema($entity_type, TRUE); + foreach ($this->getEntitySchemaData($entity_type, $entity_schema) as $table_name => $schema) { + if (!empty($schema['indexes'])) { + foreach ($schema['indexes'] as $name => $specifier) { + $schema_handler->addIndex($table_name, $name, $specifier); + } + } + if (!empty($schema['unique keys'])) { + foreach ($schema['unique keys'] as $name => $specifier) { + $schema_handler->addUniqueKey($table_name, $name, $specifier); + } + } + } + + // Store the updated entity schema. + $this->saveEntitySchemaData($entity_type, $entity_schema); } } @@ -101,13 +284,117 @@ public function onEntityTypeUpdate(EntityTypeInterface $entity_type, EntityTypeI * {@inheritdoc} */ public function onEntityTypeDelete(EntityTypeInterface $entity_type) { + $this->checkEntityType($entity_type); $schema_handler = $this->database->schema(); - $schema = $this->getEntitySchema($entity_type, TRUE); - foreach ($schema as $table_name => $table_schema) { + $actual_definition = $this->entityManager->getDefinition($entity_type->id()); + // @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. + $this->storage->setEntityType($entity_type); + + foreach ($this->getEntitySchemaTables() as $table_name) { if ($schema_handler->tableExists($table_name)) { $schema_handler->dropTable($table_name); } } + + $this->storage->setEntityType($actual_definition); + } + + /** + * {@inheritdoc} + */ + public function onFieldStorageDefinitionCreate(FieldStorageDefinitionInterface $storage_definition) { + $this->performFieldSchemaOperation('create', $storage_definition); + } + + /** + * {@inheritdoc} + */ + public function onFieldStorageDefinitionUpdate(FieldStorageDefinitionInterface $storage_definition, FieldStorageDefinitionInterface $original) { + // Store original definitions so that switching between shared and dedicated + // field table layout works. + $this->originalDefinitions = $this->fieldStorageDefinitions; + $this->originalDefinitions[$original->getName()] = $original; + $this->performFieldSchemaOperation('update', $storage_definition, $original); + $this->originalDefinitions = NULL; + } + + /** + * {@inheritdoc} + */ + public function onFieldStorageDefinitionDelete(FieldStorageDefinitionInterface $storage_definition) { + $table_mapping = $this->storage->getTableMapping(); + // @todo Implement this also for shared table storage. See + // https://www.drupal.org/node/2282119. + if ($table_mapping->requiresDedicatedTableStorage($storage_definition)) { + // Move the table to a unique name while the table contents are being + // deleted. + $table = $table_mapping->getDedicatedDataTableName($storage_definition); + $new_table = $table_mapping->getDedicatedDataTableName($storage_definition, TRUE); + $this->database->schema()->renameTable($table, $new_table); + if ($this->entityType->isRevisionable()) { + $revision_table = $table_mapping->getDedicatedRevisionTableName($storage_definition); + $revision_new_table = $table_mapping->getDedicatedRevisionTableName($storage_definition, TRUE); + $this->database->schema()->renameTable($revision_table, $revision_new_table); + } + } + } + + /** + * {@inheritdoc} + */ + public function finalizePurge(FieldStorageDefinitionInterface $storage_definition) { + $this->performFieldSchemaOperation('delete', $storage_definition); + } + + /** + * Creates revision tables for the specified entity type. + * + * @param \Drupal\Core\Entity\ContentEntityTypeInterface $entity_type + * The entity type definition. + */ + protected function createDedicatedTableRevisionSchema(ContentEntityTypeInterface $entity_type) { + $table_mapping = $this->storage->getTableMapping(); + $schema_manager = $this->database->schema(); + foreach ($this->fieldStorageDefinitions as $definition) { + if ($table_mapping->requiresDedicatedTableStorage($definition)) { + $schema = $this->getDedicatedTableSchema($definition, $entity_type); + $table_name = $table_mapping->getDedicatedRevisionTableName($definition); + $schema_manager->createTable($table_name, $schema[$table_name]); + } + } + } + + /** + * Deletes revision tables for the specified entity type. + */ + protected function dropDedicatedTableRevisionSchema() { + $table_mapping = $this->storage->getTableMapping(); + $schema_manager = $this->database->schema(); + foreach ($this->fieldStorageDefinitions as $definition) { + if ($table_mapping->requiresDedicatedTableStorage($definition)) { + $schema_manager->dropTable($table_mapping->getDedicatedRevisionTableName($definition)); + } + } + } + + /** + * Checks that we are dealing with the correct entity type. + * + * @param \Drupal\Core\Entity\EntityTypeInterface $entity_type + * The entity type to be checked. + * + * @return bool + * TRUE if the entity type matches the current one. + * + * @throws \Drupal\Core\Entity\EntityStorageException + */ + protected function checkEntityType(EntityTypeInterface $entity_type) { + if ($entity_type->id() != $this->entityType->id()) { + throw new EntityStorageException(String::format('Unsupported entity type @id', array('@id' => $entity_type->id()))); + } + return TRUE; } /** @@ -122,30 +409,54 @@ public function onEntityTypeDelete(EntityTypeInterface $entity_type) { * @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. - $tables = $this->getTables(); - $schema[$tables['base_table']] = $this->initializeBaseTable(); + $schema[$tables['base_table']] = $this->initializeBaseTable($entity_type); if (isset($tables['revision_table'])) { - $schema[$tables['revision_table']] = $this->initializeRevisionTable(); + $schema[$tables['revision_table']] = $this->initializeRevisionTable($entity_type); } if (isset($tables['data_table'])) { - $schema[$tables['data_table']] = $this->initializeDataTable(); + $schema[$tables['data_table']] = $this->initializeDataTable($entity_type); } if (isset($tables['revision_data_table'])) { - $schema[$tables['revision_data_table']] = $this->initializeRevisionDataTable(); + $schema[$tables['revision_data_table']] = $this->initializeRevisionDataTable($entity_type); } + // We need to act only on shared entity schema tables. $table_mapping = $this->storage->getTableMapping(); - foreach ($table_mapping->getTableNames() as $table_name) { - // Add the schema from field definitions. + $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) { - $column_names = $table_mapping->getColumnNames($field_name); - $this->addFieldSchema($schema[$table_name], $field_name, $column_names); + if (!isset($storage_definitions[$field_name])) { + throw new FieldException(String::format('Fieled storage definition for "@field_name" could not be found.', array('@field_name' => $field_name))); + } + // Add the schema for base field definitions. + 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, $column_names)); + } } // Add the schema for extra fields. @@ -157,18 +468,21 @@ protected function getEntitySchema(ContentEntityTypeInterface $entity_type, $res } // Process tables after having gathered field information. - $this->processBaseTable($schema[$tables['base_table']]); + $this->processBaseTable($entity_type, $schema[$tables['base_table']]); if (isset($tables['revision_table'])) { - $this->processRevisionTable($schema[$tables['revision_table']]); + $this->processRevisionTable($entity_type, $schema[$tables['revision_table']]); } if (isset($tables['data_table'])) { - $this->processDataTable($schema[$tables['data_table']]); + $this->processDataTable($entity_type, $schema[$tables['data_table']]); } if (isset($tables['revision_data_table'])) { - $this->processRevisionDataTable($schema[$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]; @@ -180,7 +494,7 @@ protected function getEntitySchema(ContentEntityTypeInterface $entity_type, $res * @return array * A list of entity type tables, keyed by table key. */ - protected function getTables() { + protected function getEntitySchemaTables() { return array_filter(array( 'base_table' => $this->storage->getBaseTable(), 'revision_table' => $this->storage->getRevisionTable(), @@ -190,55 +504,41 @@ protected function getTables() { } /** - * Returns the schema for a single field definition. + * Returns entity schema definitions for index and key definitions. * + * @param \Drupal\Core\Entity\ContentEntityTypeInterface $entity_type + * The entity type definition. * @param array $schema - * The table schema to add the field schema to, passed by reference. - * @param string $field_name - * The name of the field. - * @param string[] $column_mapping - * A mapping of field column names to database column names. + * 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 addFieldSchema(array &$schema, $field_name, array $column_mapping) { - $field_schema = $this->fieldStorageDefinitions[$field_name]->getSchema(); - $field_description = $this->fieldStorageDefinitions[$field_name]->getDescription(); - - foreach ($column_mapping as $field_column_name => $schema_field_name) { - $column_schema = $field_schema['columns'][$field_column_name]; + protected function getEntitySchemaData(ContentEntityTypeInterface $entity_type, array $schema) { + $schema_data = array(); + $entity_type_id = $entity_type->id(); + $keys = array('indexes', 'unique keys'); + $unused_keys = array_flip(array('description', 'fields', 'foreign keys')); - $schema['fields'][$schema_field_name] = $column_schema; - $schema['fields'][$schema_field_name]['description'] = $field_description; - // Only entity keys are required. - $keys = $this->entityType->getKeys() + array('langcode' => 'langcode'); - // The label is an entity key, but label fields are not necessarily - // required. - // Because entity ID and revision ID are both serial fields in the base - // and revision table respectively, the revision ID is not known yet, when - // inserting data into the base table. Instead the revision ID in the base - // table is updated after the data has been inserted into the revision - // table. For this reason the revision ID field cannot be marked as NOT - // NULL. - unset($keys['label'], $keys['revision']); - // Key fields may not be NULL. - if (in_array($field_name, $keys)) { - $schema['fields'][$schema_field_name]['not null'] = TRUE; + 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 (!empty($table_schema[$key])) { + $data_keys = array_keys($table_schema[$key]); + $entity_keys = array_filter($data_keys, function ($key) use ($entity_type_id) { + return strpos($key, $entity_type_id . '_field_') !== 0; + }); + $table_schema[$key] = array_intersect_key($table_schema[$key], array_flip($entity_keys)); + } } + $schema_data[$table_name] = array_filter($table_schema); } - if (!empty($field_schema['indexes'])) { - $indexes = $this->getFieldIndexes($field_name, $field_schema, $column_mapping); - $schema['indexes'] = array_merge($schema['indexes'], $indexes); - } - - if (!empty($field_schema['unique keys'])) { - $unique_keys = $this->getFieldUniqueKeys($field_name, $field_schema, $column_mapping); - $schema['unique keys'] = array_merge($schema['unique keys'], $unique_keys); - } - - if (!empty($field_schema['foreign keys'])) { - $foreign_keys = $this->getFieldForeignKeys($field_name, $field_schema, $column_mapping); - $schema['foreign keys'] = array_merge($schema['foreign keys'], $foreign_keys); - } + return $schema_data; } /** @@ -398,24 +698,53 @@ protected function addDefaultLangcodeSchema(&$schema) { } /** + * Loads stored schema data for the given entity type definition. + * + * @param \Drupal\Core\Entity\ContentEntityTypeInterface $entity_type + * The entity type definition. + * + * @return array + * The entity schema data array. + */ + protected function loadEntitySchemaData(ContentEntityTypeInterface $entity_type) { + return $this->state()->get('entity.schema.handler.' . $entity_type->id() . '.schema_data') ?: array(); + } + + /** + * Stores schema data for the given entity type definition. + * + * @param \Drupal\Core\Entity\ContentEntityTypeInterface $entity_type + * The entity type definition. + * @param array $schema + * The entity schema data array. + */ + protected function saveEntitySchemaData(ContentEntityTypeInterface $entity_type, $schema) { + $data = $this->getEntitySchemaData($entity_type, $schema); + $this->state()->set('entity.schema.handler.' . $entity_type->id() . '.schema_data', $data); + } + + /** * Initializes common information for a base table. * + * @param \Drupal\Core\Entity\ContentEntityTypeInterface $entity_type + * The entity type. + * * @return array * A partial schema array for the base table. */ - protected function initializeBaseTable() { - $entity_type_id = $this->entityType->id(); + protected function initializeBaseTable(ContentEntityTypeInterface $entity_type) { + $entity_type_id = $entity_type->id(); $schema = array( 'description' => "The base table for $entity_type_id entities.", - 'primary key' => array($this->entityType->getKey('id')), + 'primary key' => array($entity_type->getKey('id')), 'indexes' => array(), 'foreign keys' => array(), ); - if ($this->entityType->hasKey('revision')) { - $revision_key = $this->entityType->getKey('revision'); - $key_name = $this->getEntityIndexName($revision_key); + if ($entity_type->hasKey('revision')) { + $revision_key = $entity_type->getKey('revision'); + $key_name = $this->getEntityIndexName($entity_type, $revision_key); $schema['unique keys'][$key_name] = array($revision_key); $schema['foreign keys'][$entity_type_id . '__revision'] = array( 'table' => $this->storage->getRevisionTable(), @@ -431,27 +760,30 @@ protected function initializeBaseTable() { /** * Initializes common information for a revision table. * + * @param \Drupal\Core\Entity\ContentEntityTypeInterface $entity_type + * The entity type. + * * @return array * A partial schema array for the revision table. */ - protected function initializeRevisionTable() { - $entity_type_id = $this->entityType->id(); - $id_key = $this->entityType->getKey('id'); - $revision_key = $this->entityType->getKey('revision'); + protected function initializeRevisionTable(ContentEntityTypeInterface $entity_type) { + $entity_type_id = $entity_type->id(); + $id_key = $entity_type->getKey('id'); + $revision_key = $entity_type->getKey('revision'); $schema = array( 'description' => "The revision table for $entity_type_id entities.", 'primary key' => array($revision_key), 'indexes' => array(), 'foreign keys' => array( - $entity_type_id . '__revisioned' => array( + $entity_type_id . '__revisioned' => array( 'table' => $this->storage->getBaseTable(), 'columns' => array($id_key => $id_key), ), ), ); - $schema['indexes'][$this->getEntityIndexName($id_key)] = array($id_key); + $schema['indexes'][$this->getEntityIndexName($entity_type, $id_key)] = array($id_key); $this->addTableDefaults($schema); @@ -461,12 +793,15 @@ protected function initializeRevisionTable() { /** * Initializes common information for a data table. * + * @param \Drupal\Core\Entity\ContentEntityTypeInterface $entity_type + * The entity type. + * * @return array * A partial schema array for the data table. */ - protected function initializeDataTable() { - $entity_type_id = $this->entityType->id(); - $id_key = $this->entityType->getKey('id'); + protected function initializeDataTable(ContentEntityTypeInterface $entity_type) { + $entity_type_id = $entity_type->id(); + $id_key = $entity_type->getKey('id'); $schema = array( 'description' => "The data table for $entity_type_id entities.", @@ -482,9 +817,9 @@ protected function initializeDataTable() { ), ); - if ($this->entityType->hasKey('revision')) { - $key = $this->entityType->getKey('revision'); - $schema['indexes'][$this->getEntityIndexName($key)] = array($key); + if ($entity_type->hasKey('revision')) { + $key = $entity_type->getKey('revision'); + $schema['indexes'][$this->getEntityIndexName($entity_type, $key)] = array($key); } $this->addTableDefaults($schema); @@ -495,13 +830,16 @@ protected function initializeDataTable() { /** * Initializes common information for a revision data table. * + * @param \Drupal\Core\Entity\ContentEntityTypeInterface $entity_type + * The entity type. + * * @return array * A partial schema array for the revision data table. */ - protected function initializeRevisionDataTable() { - $entity_type_id = $this->entityType->id(); - $id_key = $this->entityType->getKey('id'); - $revision_key = $this->entityType->getKey('revision'); + protected function initializeRevisionDataTable(ContentEntityTypeInterface $entity_type) { + $entity_type_id = $entity_type->id(); + $id_key = $entity_type->getKey('id'); + $revision_key = $entity_type->getKey('revision'); $schema = array( 'description' => "The revision data table for $entity_type_id entities.", @@ -544,51 +882,59 @@ protected function addTableDefaults(&$schema) { /** * Processes the gathered schema for a base table. * + * @param \Drupal\Core\Entity\ContentEntityTypeInterface $entity_type + * The entity type. * @param array $schema * The table schema, passed by reference. * * @return array * A partial schema array for the base table. */ - protected function processBaseTable(array &$schema) { - $this->processIdentifierSchema($schema, $this->entityType->getKey('id')); + protected function processBaseTable(ContentEntityTypeInterface $entity_type, array &$schema) { + $this->processIdentifierSchema($schema, $entity_type->getKey('id')); } /** * Processes the gathered schema for a base table. * + * @param \Drupal\Core\Entity\ContentEntityTypeInterface $entity_type + * The entity type. * @param array $schema * The table schema, passed by reference. * * @return array * A partial schema array for the base table. */ - protected function processRevisionTable(array &$schema) { - $this->processIdentifierSchema($schema, $this->entityType->getKey('revision')); + protected function processRevisionTable(ContentEntityTypeInterface $entity_type, array &$schema) { + $this->processIdentifierSchema($schema, $entity_type->getKey('revision')); } /** * Processes the gathered schema for a base table. * + * @param \Drupal\Core\Entity\ContentEntityTypeInterface $entity_type + * The entity type. * @param array $schema * The table schema, passed by reference. * * @return array * A partial schema array for the base table. */ - protected function processDataTable(array &$schema) { + protected function processDataTable(ContentEntityTypeInterface $entity_type, array &$schema) { } /** * Processes the gathered schema for a base table. * + * @param \Drupal\Core\Entity\ContentEntityTypeInterface $entity_type + * The entity type. * @param array $schema * The table schema, passed by reference. * * @return array * A partial schema array for the base table. */ - protected function processRevisionDataTable(array &$schema) { + protected function processRevisionDataTable(ContentEntityTypeInterface $entity_type, array &$schema) { } /** @@ -607,16 +953,582 @@ protected function processIdentifierSchema(&$schema, $key) { } /** + * Performs the specified operation on a field. + * + * This figures out whether the field is stored in a dedicated or shared table + * and forwards the call to the proper handler. + * + * @param string $operation + * The name of the operation to be performed. + * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $storage_definition + * The field storage definition. + * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $original + * (optional) The original field storage definition. This is relevant (and + * required) only for updates. Defaults to NULL. + */ + protected function performFieldSchemaOperation($operation, FieldStorageDefinitionInterface $storage_definition, FieldStorageDefinitionInterface $original = NULL) { + $table_mapping = $this->storage->getTableMapping(); + if ($table_mapping->requiresDedicatedTableStorage($storage_definition)) { + $this->{$operation . 'DedicatedTableSchema'}($storage_definition, $original); + } + elseif ($table_mapping->allowsSharedTableStorage($storage_definition)) { + $this->{$operation . 'SharedTableSchema'}($storage_definition, $original); + } + } + + /** + * Creates the schema for a field stored in a dedicated table. + * + * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $storage_definition + * The storage definition of the field being created. + */ + protected function createDedicatedTableSchema(FieldStorageDefinitionInterface $storage_definition) { + $schema = $this->getDedicatedTableSchema($storage_definition); + foreach ($schema as $name => $table) { + $this->database->schema()->createTable($name, $table); + } + } + + /** + * Creates the schema for a field stored in a shared table. + * + * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $storage_definition + * The storage definition of the field being created. + */ + protected function createSharedTableSchema(FieldStorageDefinitionInterface $storage_definition) { + $created_field_name = $storage_definition->getName(); + $table_mapping = $this->storage->getTableMapping(); + $column_names = $table_mapping->getColumnNames($created_field_name); + $schema = $this->getSharedTableFieldSchema($storage_definition, $column_names); + $keys = array_diff_key($schema, array('fields' => FALSE)); + $shared_table_names = array_diff($table_mapping->getTableNames(), $table_mapping->getDedicatedTableNames()); + + // Iterate over the mapped table to find the ones that will host the created + // field schema. + foreach ($shared_table_names as $table_name) { + foreach ($table_mapping->getFieldNames($table_name) as $field_name) { + if ($field_name == $created_field_name) { + foreach ($schema['fields'] as $column_name => $specifier) { + $this->database->schema()->addField($table_name, $column_name, $specifier, $keys); + } + // After creating the field schema skip to the next table. + break; + } + } + } + } + + /** + * Deletes the schema for a field stored in a dedicated table. + * + * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $storage_definition + * The storage definition of the field being deleted. + */ + protected function deleteDedicatedTableSchema(FieldStorageDefinitionInterface $storage_definition) { + // When switching from dedicated to shared field table layout we need need + // to delete the field tables with their regular names. When this happens + // original definitions will be defined. + $deleted = !$this->originalDefinitions; + $table_mapping = $this->storage->getTableMapping(); + $table_name = $table_mapping->getDedicatedDataTableName($storage_definition, $deleted); + $this->database->schema()->dropTable($table_name); + if ($this->entityType->isRevisionable()) { + $revision_name = $table_mapping->getDedicatedRevisionTableName($storage_definition, $deleted); + $this->database->schema()->dropTable($revision_name); + } + } + + /** + * Deletes the schema for a field stored in a shared table. + * + * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $storage_definition + * The storage definition of the field being deleted. + */ + protected function deleteSharedTableSchema(FieldStorageDefinitionInterface $storage_definition) { + $deleted_field_name = $storage_definition->getName(); + $table_mapping = $this->storage->getTableMapping($this->originalDefinitions); + $column_names = $table_mapping->getColumnNames($deleted_field_name); + $schema = $this->getSharedTableFieldSchema($storage_definition, $column_names); + $schema_handler = $this->database->schema(); + $shared_table_names = array_diff($table_mapping->getTableNames(), $table_mapping->getDedicatedTableNames()); + + // Iterate over the mapped table to find the ones that host the deleted + // field schema. + foreach ($shared_table_names as $table_name) { + foreach ($table_mapping->getFieldNames($table_name) as $field_name) { + if ($field_name == $deleted_field_name) { + // Drop indexes and unique keys first. + if (!empty($schema['indexes'])) { + foreach ($schema['indexes'] as $name => $specifier) { + $schema_handler->dropIndex($table_name, $name); + } + } + if (!empty($schema['unique keys'])) { + foreach ($schema['unique keys'] as $name => $specifier) { + $schema_handler->dropUniqueKey($table_name, $name); + } + } + // Drop columns. + foreach ($column_names as $column_name) { + $schema_handler->dropField($table_name, $column_name); + } + // After deleting the field schema skip to the next table. + break; + } + } + } + } + + /** + * Updates the schema for a field stored in a shared table. + * + * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $storage_definition + * The storage definition of the field being updated. + * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $original + * The original storage definition; i.e., the definition before the update. + * + * @throws \Drupal\Core\Entity\Exception\FieldStorageDefinitionUpdateForbiddenException + * Thrown when the update to the field is forbidden. + * @throws \Exception + * Rethrown exception if the table recreation fails. + */ + protected function updateDedicatedTableSchema(FieldStorageDefinitionInterface $storage_definition, FieldStorageDefinitionInterface $original) { + if (!$this->storage->countFieldData($original, TRUE)) { + // There is no data. Re-create the tables completely. + if ($this->database->supportsTransactionalDDL()) { + // If the database supports transactional DDL, we can go ahead and rely + // on it. If not, we will have to rollback manually if something fails. + $transaction = $this->database->startTransaction(); + } + try { + // Since there is no data we may be switching from a shared table schema + // to a dedicated table schema, hence we should use the proper API. + $this->performFieldSchemaOperation('delete', $original); + $this->performFieldSchemaOperation('create', $storage_definition); + } + catch (\Exception $e) { + if ($this->database->supportsTransactionalDDL()) { + $transaction->rollback(); + } + else { + // Recreate tables. + $this->performFieldSchemaOperation('create', $original); + } + throw $e; + } + } + else { + if ($storage_definition->getColumns() != $original->getColumns()) { + throw new FieldStorageDefinitionUpdateForbiddenException("The SQL storage cannot change the schema for an existing field with data."); + } + // There is data, so there are no column changes. Drop all the prior + // indexes and create all the new ones, except for all the priors that + // exist unchanged. + $table_mapping = $this->storage->getTableMapping(); + $table = $table_mapping->getDedicatedDataTableName($original); + $revision_table = $table_mapping->getDedicatedRevisionTableName($original); + + $schema = $storage_definition->getSchema(); + $original_schema = $original->getSchema(); + + foreach ($original_schema['indexes'] as $name => $columns) { + if (!isset($schema['indexes'][$name]) || $columns != $schema['indexes'][$name]) { + $real_name = $this->getFieldIndexName($storage_definition, $name); + $this->database->schema()->dropIndex($table, $real_name); + $this->database->schema()->dropIndex($revision_table, $real_name); + } + } + $table = $table_mapping->getDedicatedDataTableName($storage_definition); + $revision_table = $table_mapping->getDedicatedRevisionTableName($storage_definition); + foreach ($schema['indexes'] as $name => $columns) { + if (!isset($original_schema['indexes'][$name]) || $columns != $original_schema['indexes'][$name]) { + $real_name = $this->getFieldIndexName($storage_definition, $name); + $real_columns = array(); + foreach ($columns as $column_name) { + // Indexes can be specified as either a column name or an array with + // column name and length. Allow for either case. + if (is_array($column_name)) { + $real_columns[] = array( + $table_mapping->getFieldColumnName($storage_definition, $column_name[0]), + $column_name[1], + ); + } + else { + $real_columns[] = $table_mapping->getFieldColumnName($storage_definition, $column_name); + } + } + $this->database->schema()->addIndex($table, $real_name, $real_columns); + $this->database->schema()->addIndex($revision_table, $real_name, $real_columns); + } + } + } + } + + /** + * Updates the schema for a field stored in a shared table. + * + * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $storage_definition + * The storage definition of the field being updated. + * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $original + * The original storage definition; i.e., the definition before the update. + * + * @throws \Drupal\Core\Entity\Exception\FieldStorageDefinitionUpdateForbiddenException + * Thrown when the update to the field is forbidden. + * @throws \Exception + * Rethrown exception if the table recreation fails. + */ + protected function updateSharedTableSchema(FieldStorageDefinitionInterface $storage_definition, FieldStorageDefinitionInterface $original) { + if (!$this->storage->countFieldData($original, TRUE)) { + if ($this->database->supportsTransactionalDDL()) { + // If the database supports transactional DDL, we can go ahead and rely + // on it. If not, we will have to rollback manually if something fails. + $transaction = $this->database->startTransaction(); + } + try { + // Since there is no data we may be switching from a dedicated table + // to a schema table schema, hence we should use the proper API. + $this->performFieldSchemaOperation('delete', $original); + $this->performFieldSchemaOperation('create', $storage_definition); + } + catch (\Exception $e) { + if ($this->database->supportsTransactionalDDL()) { + $transaction->rollback(); + } + else { + // Recreate original schema. + $this->createSharedTableSchema($original); + } + throw $e; + } + } + else { + if ($storage_definition->getColumns() != $original->getColumns()) { + throw new FieldStorageDefinitionUpdateForbiddenException("The SQL storage cannot change the schema for an existing field with data."); + } + + $updated_field_name = $storage_definition->getName(); + $table_mapping = $this->storage->getTableMapping(); + $column_names = $table_mapping->getColumnNames($updated_field_name); + $original_schema = $this->getSharedTableFieldSchema($original, $column_names); + $schema = $this->getSharedTableFieldSchema($storage_definition, $column_names); + $schema_handler = $this->database->schema(); + + // Iterate over the mapped table to find the ones that host the deleted + // field schema. + foreach ($table_mapping->getTableNames() as $table_name) { + foreach ($table_mapping->getFieldNames($table_name) as $field_name) { + if ($field_name == $updated_field_name) { + // Drop original indexes and unique keys. + if (!empty($original_schema['indexes'])) { + foreach ($original_schema['indexes'] as $name => $specifier) { + $schema_handler->dropIndex($table_name, $name); + } + } + if (!empty($original_schema['unique keys'])) { + foreach ($original_schema['unique keys'] as $name => $specifier) { + $schema_handler->dropUniqueKey($table_name, $name); + } + } + // Create new indexes and unique keys. + if (!empty($schema['indexes'])) { + foreach ($schema['indexes'] as $name => $specifier) { + $schema_handler->addIndex($table_name, $name, $specifier); + } + } + if (!empty($schema['unique keys'])) { + foreach ($schema['unique keys'] as $name => $specifier) { + $schema_handler->addUniqueKey($table_name, $name, $specifier); + } + } + // After deleting the field schema skip to the next table. + break; + } + } + } + } + } + + /** + * Returns the schema for a single field definition. + * + * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $storage_definition + * The storage definition of the field whose schema has to be returned. + * @param string[] $column_mapping + * A mapping of field column names to database column names. + * + * @return array + * The schema definition for the table with the following keys: + * - fields: The schema definition for the each field columns. + * - indexes: The schema definition for the indexes. + * - unique keys: The schema definition for the unique keys. + * - foreign keys: The schema definition for the foreign keys. + * + * @throws \Drupal\Core\Field\FieldException + * Exception thrown if the schema contains reserved column names. + */ + protected function getSharedTableFieldSchema(FieldStorageDefinitionInterface $storage_definition, array $column_mapping) { + $schema = array(); + $field_schema = $storage_definition->getSchema(); + + // Check that the schema does not include forbidden column names. + if (array_intersect(array_keys($field_schema['columns']), $this->storage->getTableMapping()->getReservedColumns())) { + throw new FieldException(format_string('Illegal field column names on @field_name', array('@field_name' => $storage_definition->getName()))); + } + + $field_name = $storage_definition->getName(); + $field_description = $storage_definition->getDescription(); + + foreach ($column_mapping as $field_column_name => $schema_field_name) { + $column_schema = $field_schema['columns'][$field_column_name]; + + $schema['fields'][$schema_field_name] = $column_schema; + $schema['fields'][$schema_field_name]['description'] = $field_description; + // Only entity keys are required. + $keys = $this->entityType->getKeys() + array('langcode' => 'langcode'); + // The label is an entity key, but label fields are not necessarily + // required. + // Because entity ID and revision ID are both serial fields in the base + // and revision table respectively, the revision ID is not known yet, when + // inserting data into the base table. Instead the revision ID in the base + // table is updated after the data has been inserted into the revision + // table. For this reason the revision ID field cannot be marked as NOT + // NULL. + unset($keys['label'], $keys['revision']); + // Key fields may not be NULL. + if (in_array($field_name, $keys)) { + $schema['fields'][$schema_field_name]['not null'] = TRUE; + } + } + + if (!empty($field_schema['indexes'])) { + $schema['indexes'] = $this->getFieldIndexes($field_name, $field_schema, $column_mapping); + } + + if (!empty($field_schema['unique keys'])) { + $schema['unique keys'] = $this->getFieldUniqueKeys($field_name, $field_schema, $column_mapping); + } + + if (!empty($field_schema['foreign keys'])) { + $schema['foreign keys'] = $this->getFieldForeignKeys($field_name, $field_schema, $column_mapping); + } + + return $schema; + } + + + /** + * Returns the SQL schema for a dedicated table. + * + * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $storage_definition + * The field storage definition. + * @param \Drupal\Core\Entity\ContentEntityTypeInterface $entity_type + * (optional) The entity type definition. Defaults to the one returned by + * the entity manager. + * + * @return array + * The schema definition for the table with the following keys: + * - fields: The schema definition for the each field columns. + * - indexes: The schema definition for the indexes. + * - unique keys: The schema definition for the unique keys. + * - foreign keys: The schema definition for the foreign keys. + * + * @throws \Drupal\Core\Field\FieldException + * Exception thrown if the schema contains reserved column names. + * + * @see hook_schema() + */ + protected function getDedicatedTableSchema(FieldStorageDefinitionInterface $storage_definition, ContentEntityTypeInterface $entity_type = NULL) { + $description_current = "Data storage for {$storage_definition->getTargetEntityTypeId()} field {$storage_definition->getName()}."; + $description_revision = "Revision archive storage for {$storage_definition->getTargetEntityTypeId()} field {$storage_definition->getName()}."; + + $id_definition = $this->fieldStorageDefinitions[$this->entityType->getKey('id')]; + if ($id_definition->getType() == 'integer') { + $id_schema = array( + 'type' => 'int', + 'unsigned' => TRUE, + 'not null' => TRUE, + 'description' => 'The entity id this data is attached to', + ); + } + else { + $id_schema = array( + 'type' => 'varchar', + 'length' => 128, + 'not null' => TRUE, + 'description' => 'The entity id this data is attached to', + ); + } + + // Define the revision ID schema, default to integer if there is no revision + // ID. + // @todo Revisit this code: the revision id should match the entity id type + // if revisions are not supported. + $revision_id_definition = $this->entityType->isRevisionable() ? $this->fieldStorageDefinitions[$this->entityType->getKey('revision')] : NULL; + if (!$revision_id_definition || $revision_id_definition->getType() == 'integer') { + $revision_id_schema = array( + 'type' => 'int', + 'unsigned' => TRUE, + 'not null' => FALSE, + 'description' => 'The entity revision id this data is attached to, or NULL if the entity type is not versioned', + ); + } + else { + $revision_id_schema = array( + 'type' => 'varchar', + 'length' => 128, + 'not null' => FALSE, + 'description' => 'The entity revision id this data is attached to, or NULL if the entity type is not versioned', + ); + } + + $data_schema = array( + 'description' => $description_current, + 'fields' => array( + 'bundle' => array( + 'type' => 'varchar', + 'length' => 128, + 'not null' => TRUE, + 'default' => '', + 'description' => 'The field instance bundle to which this row belongs, used when deleting a field instance', + ), + 'deleted' => array( + 'type' => 'int', + 'size' => 'tiny', + 'not null' => TRUE, + 'default' => 0, + 'description' => 'A boolean indicating whether this data item has been deleted' + ), + 'entity_id' => $id_schema, + 'revision_id' => $revision_id_schema, + 'langcode' => array( + 'type' => 'varchar', + 'length' => 32, + 'not null' => TRUE, + 'default' => '', + 'description' => 'The language code for this data item.', + ), + 'delta' => array( + 'type' => 'int', + 'unsigned' => TRUE, + 'not null' => TRUE, + 'description' => 'The sequence number for this data item, used for multi-value fields', + ), + ), + 'primary key' => array('entity_id', 'deleted', 'delta', 'langcode'), + 'indexes' => array( + 'bundle' => array('bundle'), + 'deleted' => array('deleted'), + 'entity_id' => array('entity_id'), + 'revision_id' => array('revision_id'), + 'langcode' => array('langcode'), + ), + ); + + // Check that the schema does not include forbidden column names. + $schema = $storage_definition->getSchema(); + $table_mapping = $this->storage->getTableMapping(); + if (array_intersect(array_keys($schema['columns']), $table_mapping->getReservedColumns())) { + throw new FieldException(format_string('Illegal field column names on @field_name', array('@field_name' => $storage_definition->getName()))); + } + + // Add field columns. + foreach ($schema['columns'] as $column_name => $attributes) { + $real_name = $table_mapping->getFieldColumnName($storage_definition, $column_name); + $data_schema['fields'][$real_name] = $attributes; + } + + // Add indexes. + foreach ($schema['indexes'] as $index_name => $columns) { + $real_name = $this->getFieldIndexName($storage_definition, $index_name); + foreach ($columns as $column_name) { + // Indexes can be specified as either a column name or an array with + // column name and length. Allow for either case. + if (is_array($column_name)) { + $data_schema['indexes'][$real_name][] = array( + $table_mapping->getFieldColumnName($storage_definition, $column_name[0]), + $column_name[1], + ); + } + else { + $data_schema['indexes'][$real_name][] = $table_mapping->getFieldColumnName($storage_definition, $column_name); + } + } + } + + // Add foreign keys. + foreach ($schema['foreign keys'] as $specifier => $specification) { + $real_name = $this->getFieldIndexName($storage_definition, $specifier); + $data_schema['foreign keys'][$real_name]['table'] = $specification['table']; + foreach ($specification['columns'] as $column_name => $referenced) { + $sql_storage_column = $table_mapping->getFieldColumnName($storage_definition, $column_name); + $data_schema['foreign keys'][$real_name]['columns'][$sql_storage_column] = $referenced; + } + } + + $dedicated_table_schema = array($table_mapping->getDedicatedDataTableName($storage_definition) => $data_schema); + + // If the entity type is revisionable, construct the revision table. + $entity_type = $entity_type ?: $this->entityType; + if ($entity_type->isRevisionable()) { + $revision_schema = $data_schema; + $revision_schema['description'] = $description_revision; + $revision_schema['primary key'] = array('entity_id', 'revision_id', 'deleted', 'delta', 'langcode'); + $revision_schema['fields']['revision_id']['not null'] = TRUE; + $revision_schema['fields']['revision_id']['description'] = 'The entity revision id this data is attached to'; + $dedicated_table_schema += array($table_mapping->getDedicatedRevisionTableName($storage_definition) => $revision_schema); + } + + return $dedicated_table_schema; + } + + /** * Returns the name to be used for the given entity index. * + * @param \Drupal\Core\Entity\ContentEntityTypeInterface $entity_type + * The entity type. * @param string $index * The index column name. * * @return string * The index name. */ - protected function getEntityIndexName($index) { - return $this->entityType->id() . '__' . $index; + protected function getEntityIndexName(ContentEntityTypeInterface $entity_type, $index) { + return $entity_type->id() . '__' . $index; + } + + /** + * Generates an index name for a field data table. + * + * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $storage_definition + * The field storage definition. + * @param string $index + * The name of the index. + * + * @return string + * A string containing a generated index name for a field data table that is + * unique among all other fields. + */ + protected function getFieldIndexName(FieldStorageDefinitionInterface $storage_definition, $index) { + return $storage_definition->getName() . '_' . $index; + } + /** + * Checks whether a database table is non-existent or empty. + * + * Empty tables can be dropped and recreated without data loss. + * + * @param string $table_name + * The database table to check. + * + * @return bool + * TRUE if the table is empty, FALSE otherwise. + */ + protected function tableIsEmpty($table_name) { + return !$this->database->schema()->tableExists($table_name) || + !$this->database->select($table_name) + ->countQuery() + ->range(0, 1) + ->execute() + ->fetchField(); } } diff --git a/core/lib/Drupal/Core/Entity/Sql/SqlEntityStorageInterface.php b/core/lib/Drupal/Core/Entity/Sql/SqlEntityStorageInterface.php index b0a9b05..984d05e 100644 --- a/core/lib/Drupal/Core/Entity/Sql/SqlEntityStorageInterface.php +++ b/core/lib/Drupal/Core/Entity/Sql/SqlEntityStorageInterface.php @@ -17,9 +17,13 @@ /** * Gets a table mapping for the entity's SQL tables. * + * @param \Drupal\Core\Field\FieldStorageDefinitionInterface[] $storage_definitions + * (optional) An array of field storage definitions to be used to compute + * the table mapping. Defaults to the ones provided by the entity manager. + * * @return \Drupal\Core\Entity\Sql\TableMappingInterface * A table mapping object for the entity's tables. */ - public function getTableMapping(); + public function getTableMapping(array $storage_definitions = NULL); } diff --git a/core/lib/Drupal/Core/Field/BaseFieldDefinition.php b/core/lib/Drupal/Core/Field/BaseFieldDefinition.php index 20b31ad..e4a4406 100644 --- a/core/lib/Drupal/Core/Field/BaseFieldDefinition.php +++ b/core/lib/Drupal/Core/Field/BaseFieldDefinition.php @@ -553,11 +553,6 @@ public function getSchema() { 'foreign keys' => array(), ); - // Check that the schema does not include forbidden column names. - if (array_intersect(array_keys($schema['columns']), static::getReservedColumns())) { - throw new FieldException('Illegal field type columns.'); - } - // Merge custom indexes with those specified by the field type. Custom // indexes prevail. $schema['indexes'] = $this->indexes + $schema['indexes']; @@ -583,15 +578,6 @@ public function getColumns() { } /** - * A list of columns that can not be used as field type columns. - * - * @return array - */ - public static function getReservedColumns() { - return array('deleted'); - } - - /** * {@inheritdoc} */ public function hasCustomStorage() { diff --git a/core/lib/Drupal/Core/Field/FieldStorageDefinitionListenerInterface.php b/core/lib/Drupal/Core/Field/FieldStorageDefinitionListenerInterface.php new file mode 100644 index 0000000..fcea2e4 --- /dev/null +++ b/core/lib/Drupal/Core/Field/FieldStorageDefinitionListenerInterface.php @@ -0,0 +1,46 @@ +id() == 'contact_message') { $fields = array(); + $fields['id'] = BaseFieldDefinition::create('integer') ->setLabel(t('Message ID')) ->setDescription(t('The message ID.')) ->setReadOnly(TRUE) - // Explicitly set this to 'contact' so that - // SqlContentEntityStorage::usesDedicatedTable() doesn't attempt to - // put the ID in a dedicated table. - // @todo Remove when https://www.drupal.org/node/1498720 is in. - ->setProvider('contact') ->setSetting('unsigned', TRUE); return $fields; diff --git a/core/modules/field/src/Entity/FieldStorageConfig.php b/core/modules/field/src/Entity/FieldStorageConfig.php index f6953b3..299949a 100644 --- a/core/modules/field/src/Entity/FieldStorageConfig.php +++ b/core/modules/field/src/Entity/FieldStorageConfig.php @@ -290,8 +290,8 @@ protected function preSaveNew(EntityStorageInterface $storage) { // definition is passed to the various hooks and written to config. $this->settings += $field_type_manager->getDefaultSettings($this->type); - // Notify the entity storage. - $entity_manager->getStorage($this->entity_type)->onFieldStorageDefinitionCreate($this); + // Notify the entity manager. + $entity_manager->onFieldStorageDefinitionCreate($this); } /** @@ -334,19 +334,16 @@ protected function preSaveUpdated(EntityStorageInterface $storage) { // invokes hook_field_storage_config_update_forbid(). $module_handler->invokeAll('field_storage_config_update_forbid', array($this, $this->original)); - // Notify the storage. The controller can reject the definition + // Notify the entity manager. A listener can reject the definition // update as invalid by raising an exception, which stops execution before // the definition is written to config. - $entity_manager->getStorage($this->entity_type)->onFieldStorageDefinitionUpdate($this, $this->original); + $entity_manager->onFieldStorageDefinitionUpdate($this, $this->original); } /** * {@inheritdoc} */ public function postSave(EntityStorageInterface $storage, $update = TRUE) { - // Clear the cache. - \Drupal::entityManager()->clearCachedFieldDefinitions(); - if ($update) { // Invalidate the render cache for all affected entities. $entity_manager = \Drupal::entityManager(); @@ -406,13 +403,10 @@ public static function postDelete(EntityStorageInterface $storage, array $fields // Notify the storage. foreach ($fields as $field) { if (!$field->deleted) { - \Drupal::entityManager()->getStorage($field->entity_type)->onFieldStorageDefinitionDelete($field); + \Drupal::entityManager()->onFieldStorageDefinitionDelete($field); $field->deleted = TRUE; } } - - // Clear the cache. - \Drupal::entityManager()->clearCachedFieldDefinitions(); } /** @@ -430,11 +424,6 @@ public function getSchema() { 'foreign keys' => array(), ); - // Check that the schema does not include forbidden column names. - if (array_intersect(array_keys($schema['columns']), static::getReservedColumns())) { - throw new FieldException(String::format('Illegal field type @field_type on @field_name.', array('@field_type' => $this->type, '@field_name' => $this->name))); - } - // Merge custom indexes with those specified by the field type. Custom // indexes prevail. $schema['indexes'] = $this->indexes + $schema['indexes']; @@ -614,15 +603,6 @@ public function isQueryable() { } /** - * A list of columns that can not be used as field type columns. - * - * @return array - */ - public static function getReservedColumns() { - return array('deleted'); - } - - /** * Determines whether a field has any data. * * @return bool diff --git a/core/modules/system/src/Controller/DbUpdateController.php b/core/modules/system/src/Controller/DbUpdateController.php index 62752ae..fc0c6b7 100644 --- a/core/modules/system/src/Controller/DbUpdateController.php +++ b/core/modules/system/src/Controller/DbUpdateController.php @@ -285,6 +285,23 @@ protected function selection() { drupal_set_message($this->t('Some of the pending updates cannot be applied because their dependencies were not met.'), 'warning'); } + // If there are entity definition updates, display their summary. + if (\Drupal::service('entity.definition_update_manager')->needsUpdates()) { + $entity_build = array(); + $summary = \Drupal::service('entity.definition_update_manager')->getChangeSummary(); + foreach ($summary as $entity_type_id => $items) { + $entity_update_key = 'entity_type_updates_' . $entity_type_id; + $entity_build[$entity_update_key] = array( + '#theme' => 'item_list', + '#items' => $items, + '#title' => $entity_type_id . ' entity type', + ); + $count++; + } + // Display these above the module updates, since they will be run first. + $build['start'] = $entity_build + $build['start']; + } + if (empty($count)) { drupal_set_message($this->t('No pending updates.')); unset($build); @@ -501,9 +518,18 @@ protected function triggerBatch(Request $request) { $this->state->set('system.maintenance_mode', TRUE); } - $start = $this->getModuleUpdates(); + $operations = array(); + + // First of all perform entity definition updates, which will update + // storage schema if needed, so that module update functions work with + // the correct entity schema. + if (\Drupal::service('entity.definition_update_manager')->needsUpdates()) { + $operations[] = array('update_entity_definitions', array('system', '0 - Update entity definitions')); + } + // Resolve any update dependencies to determine the actual updates that will // be run and the order they will be run in. + $start = $this->getModuleUpdates(); $updates = update_resolve_dependencies($start); // Store the dependencies for each update function in an array which the @@ -515,7 +541,7 @@ protected function triggerBatch(Request $request) { $dependency_map[$function] = !empty($update['reverse_paths']) ? array_keys($update['reverse_paths']) : array(); } - $operations = array(); + // Determine updates to be performed. foreach ($updates as $update) { if ($update['allowed']) { // Set the installed version of each module so updates will start at the diff --git a/core/modules/system/src/Tests/Entity/EntityBundleFieldTest.php b/core/modules/system/src/Tests/Entity/EntityBundleFieldTest.php index 755527b..02c082e 100644 --- a/core/modules/system/src/Tests/Entity/EntityBundleFieldTest.php +++ b/core/modules/system/src/Tests/Entity/EntityBundleFieldTest.php @@ -40,58 +40,40 @@ protected function setUp() { } /** - * Tests the custom bundle field creation and deletion. - */ - public function testCustomBundleFieldCreateDelete() { - // Install the module which adds the field. - $this->moduleHandler->install(array('entity_bundle_field_test'), FALSE); - $definition = $this->entityManager->getFieldDefinitions('entity_test', 'custom')['custom_field']; - $this->assertNotNull($definition, 'Field definition found.'); - - // Make sure the table has been created. - /** @var \Drupal\Core\Entity\Sql\DefaultTableMapping $table_mapping */ - $table_mapping = $this->entityManager->getStorage('entity_test')->getTableMapping(); - $table = $table_mapping->getDedicatedDataTableName($definition); - $this->assertTrue($this->database->schema()->tableExists($table), 'Table created'); - $this->moduleHandler->uninstall(array('entity_bundle_field_test'), FALSE); - $this->assertFalse($this->database->schema()->tableExists($table), 'Table dropped'); - } - - /** * Tests making use of a custom bundle field. */ public function testCustomBundleFieldUsage() { // Check that an entity with bundle entity_test does not have the custom // field. - $this->moduleHandler->install(array('entity_bundle_field_test'), FALSE); + $this->moduleHandler->install(array('entity_schema_test'), FALSE); $storage = $this->entityManager->getStorage('entity_test'); $entity = $storage->create([ 'type' => 'entity_test', ]); - $this->assertFalse($entity->hasField('custom_field')); + $this->assertFalse($entity->hasField('custom_bundle_field')); // Check that the custom bundle has the defined custom field and check // saving and deleting of custom field data. $entity = $storage->create([ 'type' => 'custom', ]); - $this->assertTrue($entity->hasField('custom_field')); - $entity->custom_field->value = 'swanky'; + $this->assertTrue($entity->hasField('custom_bundle_field')); + $entity->custom_bundle_field->value = 'swanky'; $entity->save(); $storage->resetCache(); $entity = $storage->load($entity->id()); - $this->assertEqual($entity->custom_field->value, 'swanky', 'Entity was saved correct.y'); + $this->assertEqual($entity->custom_bundle_field->value, 'swanky', 'Entity was saved correct.y'); - $entity->custom_field->value = 'cozy'; + $entity->custom_bundle_field->value = 'cozy'; $entity->save(); $storage->resetCache(); $entity = $storage->load($entity->id()); - $this->assertEqual($entity->custom_field->value, 'cozy', 'Entity was updated correctly.'); + $this->assertEqual($entity->custom_bundle_field->value, 'cozy', 'Entity was updated correctly.'); $entity->delete(); /** @var \Drupal\Core\Entity\Sql\DefaultTableMapping $table_mapping */ $table_mapping = $storage->getTableMapping(); - $table = $table_mapping->getDedicatedDataTableName($entity->getFieldDefinition('custom_field')); + $table = $table_mapping->getDedicatedDataTableName($entity->getFieldDefinition('custom_bundle_field')); $result = $this->database->select($table, 'f') ->fields('f') ->condition('f.entity_id', $entity->id()) @@ -100,11 +82,11 @@ public function testCustomBundleFieldUsage() { // Create another entity to test that values are marked as deleted when a // bundle is deleted. - $entity = $storage->create(['type' => 'custom', 'custom_field' => 'new']); + $entity = $storage->create(['type' => 'custom', 'custom_bundle_field' => 'new']); $entity->save(); entity_test_delete_bundle('custom'); - $table = $table_mapping->getDedicatedDataTableName($entity->getFieldDefinition('custom_field')); + $table = $table_mapping->getDedicatedDataTableName($entity->getFieldDefinition('custom_bundle_field')); $result = $this->database->select($table, 'f') ->condition('f.entity_id', $entity->id()) ->condition('deleted', 1) @@ -112,7 +94,8 @@ public function testCustomBundleFieldUsage() { ->execute(); $this->assertEqual(1, $result->fetchField(), 'Field data has been deleted'); - // @todo Test field purge and table deletion once supported. + // @todo Test field purge and table deletion once supported. See + // https://www.drupal.org/node/2282119. // $this->assertFalse($this->database->schema()->tableExists($table), 'Custom field table was deleted'); } diff --git a/core/modules/system/src/Tests/Entity/EntitySchemaTest.php b/core/modules/system/src/Tests/Entity/EntitySchemaTest.php new file mode 100644 index 0000000..e3a3375 --- /dev/null +++ b/core/modules/system/src/Tests/Entity/EntitySchemaTest.php @@ -0,0 +1,168 @@ + 'Entity Schema', + 'description' => 'Tests entity field schema API for base and bundle fields.', + 'group' => 'Entity API', + ); + } + + /** + * {@inheritdoc} + */ + public function setUp() { + parent::setUp(); + $this->installSchema('user', array('users_data')); + $this->installSchema('system', array('router')); + $this->moduleHandler = $this->container->get('module_handler'); + $this->database = $this->container->get('database'); + } + + /** + * Tests the custom bundle field creation and deletion. + */ + public function testCustomFieldCreateDelete() { + // Install the module which adds the field. + $this->installModule('entity_schema_test'); + $this->entityManager->clearCachedDefinitions(); + $definition = $this->entityManager->getBaseFieldDefinitions('entity_test')['custom_base_field']; + $this->assertNotNull($definition, 'Base field definition found.'); + $definition = $this->entityManager->getFieldDefinitions('entity_test', 'custom')['custom_bundle_field']; + $this->assertNotNull($definition, 'Bundle field definition found.'); + + // Make sure the field schema has been created. + /** @var \Drupal\Core\Entity\Sql\DefaultTableMapping $table_mapping */ + $table_mapping = $this->entityManager->getStorage('entity_test')->getTableMapping(); + $base_table = current($table_mapping->getTableNames()); + $base_column = current($table_mapping->getColumnNames('custom_base_field')); + $this->assertTrue($this->database->schema()->fieldExists($base_table, $base_column), 'Table column created'); + + $table = $table_mapping->getDedicatedDataTableName($definition->getFieldStorageDefinition()); + $this->assertTrue($this->database->schema()->tableExists($table), 'Table created'); + $this->uninstallModule('entity_schema_test'); + $this->assertFalse($this->database->schema()->fieldExists($base_table, $base_column), 'Table column dropped'); + $this->assertFalse($this->database->schema()->tableExists($table), 'Table dropped'); + } + + /** + * Updates the entity type definition. + * + * @param bool $alter + * Whether the original definition should be altered or not. + */ + protected function updateEntityType($alter) { + $entity_test_id = 'entity_test'; + $original = $this->entityManager->getDefinition($entity_test_id); + $this->entityManager->clearCachedDefinitions(); + $this->state->set('entity_schema_update', $alter); + $entity_type = $this->entityManager->getDefinition($entity_test_id); + $this->entityManager->onEntityTypeUpdate($entity_type, $original); + } + + /** + * Tests that entity schema responds to changes in the entity type definition. + */ + public function testEntitySchemaUpdate() { + $this->installModule('entity_schema_test'); + $schema_handler = $this->database->schema(); + $tables = array('entity_test', 'entity_test_revision', 'entity_test_field_data', 'entity_test_field_revision'); + $dedicated_tables = array('entity_test__custom_bundle_field', 'entity_test_revision__custom_bundle_field'); + + // Initially only the base table and the field data tables should exist. + foreach ($tables as $index => $table) { + $this->assertEqual($schema_handler->tableExists($table), !$index, String::format('Entity schema correct for the @table table.', array('@table' => $table))); + } + $this->assertTrue($schema_handler->tableExists($dedicated_tables[0]), String::format('Field schema correct for the @table table.', array('@table' => $table))); + + // Update the entity type definition and check that the entity schema now + // supports translations and revisions. + $this->updateEntityType(TRUE); + foreach ($tables as $table) { + $this->assertTrue($schema_handler->tableExists($table), String::format('Entity schema correct for the @table table.', array('@table' => $table))); + } + foreach ($dedicated_tables as $table) { + $this->assertTrue($schema_handler->tableExists($table), String::format('Field schema correct for the @table table.', array('@table' => $table))); + } + + // Revert changes and check that the entity schema now does not support + // neither translations nor revisions. + $this->updateEntityType(FALSE); + foreach ($tables as $index => $table) { + $this->assertEqual($schema_handler->tableExists($table), !$index, String::format('Entity schema correct for the @table table.', array('@table' => $table))); + } + $this->assertTrue($schema_handler->tableExists($dedicated_tables[0]), String::format('Field schema correct for the @table table.', array('@table' => $table))); + } + + /** + * Installs a module and refreshes services. + * + * @param string $module + * The module to install. + */ + protected function installModule($module) { + $this->moduleHandler->install(array($module), FALSE); + $this->refreshServices(); + } + + /** + * Uninstalls a module and refreshes services. + * + * @param string $module + * The module to uninstall. + */ + protected function uninstallModule($module) { + $this->moduleHandler->uninstall(array($module), FALSE); + $this->refreshServices(); + } + + /** + * Refresh services. + */ + protected function refreshServices() { + $this->container = \Drupal::getContainer(); + $this->moduleHandler = $this->container->get('module_handler'); + $this->database = $this->container->get('database'); + $this->entityManager = $this->container->get('entity.manager'); + $this->state = $this->container->get('state'); + } + +} diff --git a/core/modules/system/src/Tests/Entity/FieldSqlStorageTest.php b/core/modules/system/src/Tests/Entity/FieldSqlStorageTest.php index 6610958..9c3a870 100644 --- a/core/modules/system/src/Tests/Entity/FieldSqlStorageTest.php +++ b/core/modules/system/src/Tests/Entity/FieldSqlStorageTest.php @@ -8,7 +8,6 @@ namespace Drupal\system\Tests\Entity; use Drupal\Core\Database\Database; -use Drupal\Core\Entity\Sql\SqlContentEntityStorage; use Drupal\Core\Entity\Exception\FieldStorageDefinitionUpdateForbiddenException; use Drupal\field\Entity\FieldStorageConfig; @@ -460,19 +459,9 @@ function testFieldSqlStorageForeignKeys() { // Reload the field schema after the update. $schema = $field_storage->getSchema(); - // Retrieve the field definition and check that the foreign key is in place. - $field_storage = FieldStorageConfig::loadByName('entity_test', $field_name); + // Check that the foreign key is in place. $this->assertEqual($schema['foreign keys'][$foreign_key_name]['table'], $foreign_key_name, 'Foreign key table name modified after update'); $this->assertEqual($schema['foreign keys'][$foreign_key_name]['columns'][$foreign_key_name], 'id', 'Foreign key column name modified after update'); - - // Verify the SQL schema. - $schemas = SqlContentEntityStorage::_fieldSqlSchema($field_storage); - $schema = $schemas[$this->table_mapping->getDedicatedDataTableName($field_storage)]; - $this->assertEqual(count($schema['foreign keys']), 1, 'There is 1 foreign key in the schema'); - $foreign_key = reset($schema['foreign keys']); - $foreign_key_column = $this->table_mapping->getFieldColumnName($field_storage, $foreign_key_name); - $this->assertEqual($foreign_key['table'], $foreign_key_name, 'Foreign key table name preserved in the schema'); - $this->assertEqual($foreign_key['columns'][$foreign_key_column], 'id', 'Foreign key column name preserved in the schema'); } /** diff --git a/core/modules/system/src/Tests/Entity/FieldTranslationSqlStorageTest.php b/core/modules/system/src/Tests/Entity/FieldTranslationSqlStorageTest.php index 2874aed..c2a6a65 100644 --- a/core/modules/system/src/Tests/Entity/FieldTranslationSqlStorageTest.php +++ b/core/modules/system/src/Tests/Entity/FieldTranslationSqlStorageTest.php @@ -87,24 +87,19 @@ protected function assertFieldStorageLangcode(ContentEntityInterface $entity, $m foreach ($fields as $field_name) { $field_storage = FieldStorageConfig::loadByName($entity_type, $field_name); - $tables = array( - $table_mapping->getDedicatedDataTableName($field_storage), - $table_mapping->getDedicatedRevisionTableName($field_storage), - ); + $table = $table_mapping->getDedicatedDataTableName($field_storage); - foreach ($tables as $table) { - $record = \Drupal::database() - ->select($table, 'f') - ->fields('f') - ->condition('f.entity_id', $id) - ->condition('f.revision_id', $id) - ->execute() - ->fetchObject(); + $record = \Drupal::database() + ->select($table, 'f') + ->fields('f') + ->condition('f.entity_id', $id) + ->condition('f.revision_id', $id) + ->execute() + ->fetchObject(); - if ($record->langcode != $langcode) { - $status = FALSE; - break; - } + if ($record->langcode != $langcode) { + $status = FALSE; + break; } } diff --git a/core/modules/system/system.install b/core/modules/system/system.install index 8e7b534..b9c1b83 100644 --- a/core/modules/system/system.install +++ b/core/modules/system/system.install @@ -452,6 +452,11 @@ function system_requirements($phase) { } } } + if (!isset($requirements['update']['severity']) && \Drupal::service('entity.definition_update_manager')->needsUpdates()) { + $requirements['update']['severity'] = REQUIREMENT_ERROR; + $requirements['update']['value'] = t('Out of date'); + $requirements['update']['description'] = t('Some modules have database schema updates to install. You should run the database update script immediately.', array('@update' => base_path() . 'update.php')); + } } // Verify the update.php access setting diff --git a/core/modules/system/tests/modules/entity_bundle_field_test/entity_bundle_field_test.info.yml b/core/modules/system/tests/modules/entity_bundle_field_test/entity_bundle_field_test.info.yml deleted file mode 100644 index 6732090..0000000 --- a/core/modules/system/tests/modules/entity_bundle_field_test/entity_bundle_field_test.info.yml +++ /dev/null @@ -1,8 +0,0 @@ -name: 'Entity bundle field test module' -type: module -description: 'Provides a bundle field to the test entity.' -package: Testing -version: VERSION -core: 8.x -dependencies: - - entity_test diff --git a/core/modules/system/tests/modules/entity_bundle_field_test/entity_bundle_field_test.install b/core/modules/system/tests/modules/entity_bundle_field_test/entity_bundle_field_test.install deleted file mode 100644 index 6065425..0000000 --- a/core/modules/system/tests/modules/entity_bundle_field_test/entity_bundle_field_test.install +++ /dev/null @@ -1,41 +0,0 @@ -getFieldStorageDefinitions('entity_test')['custom_field']; - $manager->getStorage('entity_test')->onFieldStorageDefinitionCreate($definition); - - // Create the custom bundle and put our bundle field on it. - entity_test_create_bundle('custom'); - $definition = $manager->getFieldDefinitions('entity_test', 'custom')['custom_field']; - $manager->getStorage('entity_test')->onFieldDefinitionCreate($definition); -} - -/** - * Implements hook_uninstall(). - */ -function entity_bundle_field_test_uninstall() { - entity_bundle_field_test_is_uninstalling(TRUE); - $manager = \Drupal::entityManager(); - // Notify the entity storage that our field is gone. - $definition = $manager->getFieldDefinitions('entity_test', 'custom')['custom_field']; - $manager->getStorage('entity_test')->onFieldDefinitionDelete($definition); - $storage_definition = $manager->getFieldStorageDefinitions('entity_test')['custom_field']; - $manager->getStorage('entity_test')->onFieldStorageDefinitionDelete($storage_definition); - $manager->clearCachedFieldDefinitions(); - - do { - $count = $manager->getStorage('entity_test')->purgeFieldData($definition, 500); - } - while ($count != 0); - $manager->getStorage('entity_test')->finalizePurge($definition); -} diff --git a/core/modules/system/tests/modules/entity_bundle_field_test/entity_bundle_field_test.module b/core/modules/system/tests/modules/entity_bundle_field_test/entity_bundle_field_test.module deleted file mode 100644 index 7a39717..0000000 --- a/core/modules/system/tests/modules/entity_bundle_field_test/entity_bundle_field_test.module +++ /dev/null @@ -1,69 +0,0 @@ -id() == 'entity_test' && !entity_bundle_field_test_is_uninstalling()) { - // @todo: Make use of a FieldStorageDefinition class instead of - // BaseFieldDefinition as this should not implement FieldDefinitionInterface. - // See https://drupal.org/node/2280639. - $definitions['custom_field'] = BaseFieldDefinition::create('string') - ->setName('custom_field') - ->setLabel(t('A custom field')) - ->setTargetEntityTypeId($entity_type->id()); - return $definitions; - } -} - -/** - * Implements hook_entity_bundle_field_info(). - */ -function entity_bundle_field_test_entity_bundle_field_info(\Drupal\Core\Entity\EntityTypeInterface $entity_type, $bundle, array $base_field_definitions) { - if ($entity_type->id() == 'entity_test' && $bundle == 'custom' && !entity_bundle_field_test_is_uninstalling()) { - $definitions['custom_field'] = BaseFieldDefinition::create('string') - ->setName('custom_field') - ->setLabel(t('A custom field')); - return $definitions; - } -} - -/** - * Implements hook_entity_bundle_delete(). - */ -function entity_bundle_field_test_entity_bundle_delete($entity_type_id, $bundle) { - if ($entity_type_id == 'entity_test' && $bundle == 'custom') { - // Notify the entity storage that our field is gone. - $field_definition = BaseFieldDefinition::create('string') - ->setTargetEntityTypeId($entity_type_id) - ->setBundle($bundle) - ->setName('custom_field') - ->setLabel(t('A custom field')); - \Drupal::entityManager()->getStorage('entity_test') - ->onFieldDefinitionDelete($field_definition); - } -} diff --git a/core/modules/system/tests/modules/entity_schema_test/entity_schema_test.info.yml b/core/modules/system/tests/modules/entity_schema_test/entity_schema_test.info.yml new file mode 100644 index 0000000..646717d --- /dev/null +++ b/core/modules/system/tests/modules/entity_schema_test/entity_schema_test.info.yml @@ -0,0 +1,8 @@ +name: 'Entity schema test module' +type: module +description: 'Provides entity and field definitions to test entity schema.' +package: Testing +version: VERSION +core: 8.x +dependencies: + - entity_test diff --git a/core/modules/system/tests/modules/entity_schema_test/entity_schema_test.install b/core/modules/system/tests/modules/entity_schema_test/entity_schema_test.install new file mode 100644 index 0000000..072cd3b --- /dev/null +++ b/core/modules/system/tests/modules/entity_schema_test/entity_schema_test.install @@ -0,0 +1,54 @@ +getStorage('entity_test'); + + // Notify the entity storage of our custom base field. + $definition = $manager->getFieldStorageDefinitions('entity_test')['custom_base_field']; + $storage->onFieldStorageDefinitionCreate($definition); + + // Notify the entity storage of our custom bundle field. + $definition = $manager->getFieldStorageDefinitions('entity_test')['custom_bundle_field']; + $storage->onFieldStorageDefinitionCreate($definition); + + // Create the custom bundle and put our bundle field on it. + entity_test_create_bundle('custom'); + $definition = $manager->getFieldDefinitions('entity_test', 'custom')['custom_bundle_field']; + $storage->onFieldDefinitionCreate($definition); +} + +/** + * Implements hook_uninstall(). + */ +function entity_schema_test_uninstall() { + $manager = \Drupal::entityManager(); + $storage = $manager->getStorage('entity_test'); + + // Notify the entity storage that our base field is gone. + $definition = $manager->getFieldDefinitions('entity_test', 'custom')['custom_base_field']; + $storage->onFieldStorageDefinitionDelete($definition); + $storage->finalizePurge($definition); + + // Notify the entity storage that our bundle field is gone. + $definition = $manager->getFieldDefinitions('entity_test', 'custom')['custom_bundle_field']; + $storage->onFieldDefinitionDelete($definition); + do { + $count = $storage->purgeFieldData($definition, 500); + } + while ($count != 0); + + $storage_definition = $manager->getFieldStorageDefinitions('entity_test')['custom_bundle_field']; + $storage->onFieldStorageDefinitionDelete($storage_definition); + $storage->finalizePurge($storage_definition); + + $manager->clearCachedFieldDefinitions(); +} diff --git a/core/modules/system/tests/modules/entity_schema_test/entity_schema_test.module b/core/modules/system/tests/modules/entity_schema_test/entity_schema_test.module new file mode 100644 index 0000000..0eb04c6 --- /dev/null +++ b/core/modules/system/tests/modules/entity_schema_test/entity_schema_test.module @@ -0,0 +1,83 @@ +get('entity_schema_update')) { + $entity_type = $entity_types['entity_test']; + $entity_type->set('translatable', TRUE); + $entity_type->set('data_table', 'entity_test_field_data'); + $keys = $entity_type->getKeys(); + $keys['revision'] = 'revision_id'; + $entity_type->set('entity_keys', $keys); + } +} + +/** + * Implements hook_entity_base_field_info(). + */ +function entity_schema_test_entity_base_field_info(EntityTypeInterface $entity_type) { + if ($entity_type->id() == 'entity_test') { + $definitions['custom_base_field'] = BaseFieldDefinition::create('string') + ->setName('custom_base_field') + ->setLabel(t('A custom base field')); + if (\Drupal::state()->get('entity_schema_update')) { + $definitions += EntityTestMulRev::baseFieldDefinitions($entity_type); + } + return $definitions; + } +} + +/** + * Implements hook_entity_field_storage_info(). + */ +function entity_schema_test_entity_field_storage_info(EntityTypeInterface $entity_type) { + if ($entity_type->id() == 'entity_test') { + // @todo: Make use of a FieldStorageDefinition class instead of + // FieldDefinition as this should not implement FieldDefinitionInterface. + // See https://drupal.org/node/2280639. + $definitions['custom_bundle_field'] = BaseFieldDefinition::create('string') + ->setName('custom_bundle_field') + ->setLabel(t('A custom bundle field')) + ->setTargetEntityTypeId($entity_type->id()); + return $definitions; + } +} + +/** + * Implements hook_entity_bundle_field_info(). + */ +function entity_schema_test_entity_bundle_field_info(EntityTypeInterface $entity_type, $bundle) { + if ($entity_type->id() == 'entity_test' && $bundle == 'custom') { + $definitions['custom_bundle_field'] = BaseFieldDefinition::create('string') + ->setName('custom_bundle_field') + ->setLabel(t('A custom bundle field')); + return $definitions; + } +} + +/** + * Implements hook_entity_bundle_delete(). + */ +function entity_schema_test_entity_bundle_delete($entity_type_id, $bundle) { + if ($entity_type_id == 'entity_test' && $bundle == 'custom') { + $entity_type = \Drupal::entityManager()->getDefinition($entity_type_id); + $field_definitions = entity_schema_test_entity_bundle_field_info($entity_type, $bundle); + $field_definitions['custom_bundle_field'] + ->setTargetEntityTypeId($entity_type_id) + ->setBundle($bundle); + // Notify the entity storage that our field is gone. + \Drupal::entityManager()->getStorage($entity_type_id) + ->onFieldDefinitionDelete($field_definitions['custom_bundle_field']); + } +} diff --git a/core/tests/Drupal/Tests/Core/Entity/EntityManagerTest.php b/core/tests/Drupal/Tests/Core/Entity/EntityManagerTest.php index 9163a6d..b8c24a1 100644 --- a/core/tests/Drupal/Tests/Core/Entity/EntityManagerTest.php +++ b/core/tests/Drupal/Tests/Core/Entity/EntityManagerTest.php @@ -82,7 +82,7 @@ class EntityManagerTest extends UnitTestCase { /** * The controller resolver. * - * @var \Drupal\Core\Handler\HandlerResolverInterface|\PHPUnit_Framework_MockObject_MockObject + * @var \Drupal\Core\Controller\ControllerResolverInterface|\PHPUnit_Framework_MockObject_MockObject */ protected $controllerResolver; @@ -94,6 +94,13 @@ class EntityManagerTest extends UnitTestCase { protected $typedDataManager; /** + * The state service. + * + * @var \Drupal\Core\State\StateInterface|\PHPUnit_Framework_MockObject_MockObject + */ + protected $state; + + /** * {@inheritdoc} */ protected function setUp() { @@ -128,6 +135,8 @@ protected function setUp() { $this->typedDataManager = $this->getMockBuilder('\Drupal\Core\TypedData\TypedDataManager') ->disableOriginalConstructor() ->getMock(); + + $this->state = $this->getMock('Drupal\Core\State\StateInterface'); } /** @@ -158,7 +167,7 @@ protected function setUpEntityManager($definitions = array()) { ->method('getDefinitions') ->will($this->returnValue($definitions)); - $this->entityManager = new TestEntityManager(new \ArrayObject(), $this->moduleHandler, $this->cache, $this->languageManager, $this->translationManager, $this->getClassResolverStub(), $this->typedDataManager); + $this->entityManager = new TestEntityManager(new \ArrayObject(), $this->moduleHandler, $this->cache, $this->languageManager, $this->translationManager, $this->getClassResolverStub(), $this->typedDataManager, $this->state); $this->entityManager->setContainer($this->container); $this->entityManager->setDiscovery($this->discovery); } diff --git a/core/tests/Drupal/Tests/Core/Entity/Sql/DefaultTableMappingTest.php b/core/tests/Drupal/Tests/Core/Entity/Sql/DefaultTableMappingTest.php index 18802c7..baf360b 100644 --- a/core/tests/Drupal/Tests/Core/Entity/Sql/DefaultTableMappingTest.php +++ b/core/tests/Drupal/Tests/Core/Entity/Sql/DefaultTableMappingTest.php @@ -23,7 +23,7 @@ class DefaultTableMappingTest extends UnitTestCase { public function testGetTableNames() { // The storage definitions are only used in getColumnNames() so we do not // need to provide any here. - $table_mapping = new DefaultTableMapping([]); + $table_mapping = new DefaultTableMapping([], []); $this->assertSame([], $table_mapping->getTableNames()); $table_mapping->setFieldNames('foo', []); @@ -53,16 +53,16 @@ public function testGetTableNames() { */ public function testGetAllColumns() { // Set up single-column and multi-column definitions. - $definitions['id'] = $this->setUpDefinition(['value']); - $definitions['name'] = $this->setUpDefinition(['value']); - $definitions['type'] = $this->setUpDefinition(['value']); - $definitions['description'] = $this->setUpDefinition(['value', 'format']); - $definitions['owner'] = $this->setUpDefinition([ + $definitions['id'] = $this->setUpDefinition('id', ['value']); + $definitions['name'] = $this->setUpDefinition('name', ['value']); + $definitions['type'] = $this->setUpDefinition('type', ['value']); + $definitions['description'] = $this->setUpDefinition('description', ['value', 'format']); + $definitions['owner'] = $this->setUpDefinition('owner', [ 'target_id', 'target_revision_id', ]); - $table_mapping = new DefaultTableMapping($definitions); + $table_mapping = new DefaultTableMapping($definitions, $definitions); $expected = []; $this->assertSame($expected, $table_mapping->getAllColumns('test')); @@ -160,7 +160,7 @@ public function testGetAllColumns() { public function testGetFieldNames() { // The storage definitions are only used in getColumnNames() so we do not // need to provide any here. - $table_mapping = new DefaultTableMapping([]); + $table_mapping = new DefaultTableMapping([], []); // Test that requesting the list of field names for a table for which no // fields have been added does not fail. @@ -188,18 +188,18 @@ public function testGetFieldNames() { * @covers ::getColumnNames() */ public function testGetColumnNames() { - $definitions['test'] = $this->setUpDefinition([]); - $table_mapping = new DefaultTableMapping($definitions); + $definitions['test'] = $this->setUpDefinition('test', []); + $table_mapping = new DefaultTableMapping($definitions, $definitions); $expected = []; $this->assertSame($expected, $table_mapping->getColumnNames('test')); - $definitions['test'] = $this->setUpDefinition(['value']); - $table_mapping = new DefaultTableMapping($definitions); + $definitions['test'] = $this->setUpDefinition('test', ['value']); + $table_mapping = new DefaultTableMapping($definitions, $definitions); $expected = ['value' => 'test']; $this->assertSame($expected, $table_mapping->getColumnNames('test')); - $definitions['test'] = $this->setUpDefinition(['value', 'format']); - $table_mapping = new DefaultTableMapping($definitions); + $definitions['test'] = $this->setUpDefinition('test', ['value', 'format']); + $table_mapping = new DefaultTableMapping($definitions, $definitions); $expected = ['value' => 'test__value', 'format' => 'test__format']; $this->assertSame($expected, $table_mapping->getColumnNames('test')); } @@ -213,7 +213,7 @@ public function testGetColumnNames() { public function testGetExtraColumns() { // The storage definitions are only used in getColumnNames() so we do not // need to provide any here. - $table_mapping = new DefaultTableMapping([]); + $table_mapping = new DefaultTableMapping([], []); // Test that requesting the list of field names for a table for which no // fields have been added does not fail. @@ -237,13 +237,18 @@ public function testGetExtraColumns() { /** * Sets up a field storage definition for the test. * + * @param string $name + * The field name. * @param array $column_names * An array of column names for the storage definition. * * @return \Drupal\Core\Field\FieldStorageDefinitionInterface|\PHPUnit_Framework_MockObject_MockObject */ - protected function setUpDefinition(array $column_names) { - $definition = $this->getMock('Drupal\Core\Field\FieldStorageDefinitionInterface'); + protected function setUpDefinition($name, array $column_names) { + $definition = $this->getMock('Drupal\Tests\Core\Field\TestBaseFieldDefinitionInterface'); + $definition->expects($this->any()) + ->method('getName') + ->will($this->returnValue($name)); $definition->expects($this->any()) ->method('getColumns') ->will($this->returnValue(array_fill_keys($column_names, []))); diff --git a/core/tests/Drupal/Tests/Core/Entity/Sql/SqlContentEntityStorageSchemaTest.php b/core/tests/Drupal/Tests/Core/Entity/Sql/SqlContentEntityStorageSchemaTest.php index 3109adc..0181232 100644 --- a/core/tests/Drupal/Tests/Core/Entity/Sql/SqlContentEntityStorageSchemaTest.php +++ b/core/tests/Drupal/Tests/Core/Entity/Sql/SqlContentEntityStorageSchemaTest.php @@ -8,7 +8,6 @@ namespace Drupal\Tests\Core\Entity\Sql; use Drupal\Core\Entity\ContentEntityType; -use Drupal\Core\Entity\Sql\SqlContentEntityStorageSchema; use Drupal\Core\Entity\Sql\DefaultTableMapping; use Drupal\Tests\UnitTestCase; @@ -374,7 +373,7 @@ public function testGetSchemaBase() { $this->setUpEntitySchemaHandler($expected); - $table_mapping = new DefaultTableMapping($this->storageDefinitions); + $table_mapping = new DefaultTableMapping($this->storageDefinitions, $this->storageDefinitions); $table_mapping->setFieldNames('entity_test', array_keys($this->storageDefinitions)); $table_mapping->setExtraColumns('entity_test', array('default_langcode')); @@ -474,7 +473,7 @@ public function testGetSchemaRevisionable() { $this->setUpEntitySchemaHandler($expected); - $table_mapping = new DefaultTableMapping($this->storageDefinitions); + $table_mapping = new DefaultTableMapping($this->storageDefinitions, $this->storageDefinitions); $table_mapping->setFieldNames('entity_test', array_keys($this->storageDefinitions)); $table_mapping->setFieldNames('entity_test_revision', array_keys($this->storageDefinitions)); @@ -564,7 +563,7 @@ public function testGetSchemaTranslatable() { $this->setUpEntitySchemaHandler($expected); - $table_mapping = new DefaultTableMapping($this->storageDefinitions); + $table_mapping = new DefaultTableMapping($this->storageDefinitions, $this->storageDefinitions); $table_mapping->setFieldNames('entity_test', array_keys($this->storageDefinitions)); $table_mapping->setFieldNames('entity_test_field_data', array_keys($this->storageDefinitions)); @@ -748,7 +747,7 @@ public function testGetSchemaRevisionableTranslatable() { $this->setUpEntitySchemaHandler($expected); - $table_mapping = new DefaultTableMapping($this->storageDefinitions); + $table_mapping = new DefaultTableMapping($this->storageDefinitions, $this->storageDefinitions); $table_mapping->setFieldNames('entity_test', array_keys($this->storageDefinitions)); $table_mapping->setFieldNames('entity_test_revision', array_keys($this->storageDefinitions)); $table_mapping->setFieldNames('entity_test_field_data', array_keys($this->storageDefinitions)); @@ -762,6 +761,221 @@ public function testGetSchemaRevisionableTranslatable() { } /** + * Tests the schema for a field dedicated table. + * + * @covers ::getDedicatedTableSchema() + * @covers ::createDedicatedTableSchema() + */ + public function testDedicatedTableSchema() { + $entity_type_id = 'entity_test'; + $this->entityType = new ContentEntityType(array( + 'id' => 'entity_test', + 'entity_keys' => array('id' => 'id'), + )); + + // Setup a field having a dedicated schema. + $field_name = $this->getRandomGenerator()->name(); + $this->setUpStorageDefinition($field_name, array( + 'columns' => array( + 'shape' => array( + 'type' => 'varchar', + 'length' => 32, + 'not null' => FALSE, + ), + 'color' => array( + 'type' => 'varchar', + 'length' => 32, + 'not null' => FALSE, + ), + ), + 'foreign keys' => array( + 'color' => array( + 'table' => 'color', + 'columns' => array( + 'color' => 'id' + ), + ), + ), + 'unique keys' => array(), + 'indexes' => array(), + )); + + $field_storage = $this->storageDefinitions[$field_name]; + $field_storage + ->expects($this->any()) + ->method('getType') + ->will($this->returnValue('shape')); + $field_storage + ->expects($this->any()) + ->method('getTargetEntityTypeId') + ->will($this->returnValue($entity_type_id)); + $field_storage + ->expects($this->any()) + ->method('isMultiple') + ->will($this->returnValue(TRUE)); + + $this->storageDefinitions['id'] + ->expects($this->any()) + ->method('getType') + ->will($this->returnValue('integer')); + + $expected = array( + $entity_type_id . '__' . $field_name => array( + 'description' => "Data storage for $entity_type_id field $field_name.", + 'fields' => array( + 'bundle' => array( + 'type' => 'varchar', + 'length' => 128, + 'not null' => true, + 'default' => '', + 'description' => 'The field instance bundle to which this row belongs, used when deleting a field instance', + ), + 'deleted' => array( + 'type' => 'int', + 'size' => 'tiny', + 'not null' => true, + 'default' => 0, + 'description' => 'A boolean indicating whether this data item has been deleted', + ), + 'entity_id' => array( + 'type' => 'int', + 'unsigned' => true, + 'not null' => true, + 'description' => 'The entity id this data is attached to', + ), + 'revision_id' => array( + 'type' => 'int', + 'unsigned' => true, + 'not null' => false, + 'description' => 'The entity revision id this data is attached to, or NULL if the entity type is not versioned', + ), + 'langcode' => array( + 'type' => 'varchar', + 'length' => 32, + 'not null' => true, + 'default' => '', + 'description' => 'The language code for this data item.', + ), + 'delta' => array( + 'type' => 'int', + 'unsigned' => true, + 'not null' => true, + 'description' => 'The sequence number for this data item, used for multi-value fields', + ), + $field_name . '_shape' => array( + 'type' => 'varchar', + 'length' => 32, + 'not null' => false, + ), + $field_name . '_color' => array( + 'type' => 'varchar', + 'length' => 32, + 'not null' => false, + ), + ), + 'primary key' => array('entity_id', 'deleted', 'delta', 'langcode'), + 'indexes' => array( + 'bundle' => array('bundle'), + 'deleted' => array('deleted'), + 'entity_id' => array('entity_id'), + 'revision_id' => array('revision_id'), + 'langcode' => array('langcode'), + ), + 'foreign keys' => array( + $field_name . '_color' => array( + 'table' => 'color', + 'columns' => array( + $field_name . '_color' => 'id', + ), + ), + ), + ), + $entity_type_id . '_revision__' . $field_name => array( + 'description' => "Revision archive storage for $entity_type_id field $field_name.", + 'fields' => array( + 'bundle' => array( + 'type' => 'varchar', + 'length' => 128, + 'not null' => true, + 'default' => '', + 'description' => 'The field instance bundle to which this row belongs, used when deleting a field instance', + ), + 'deleted' => array( + 'type' => 'int', + 'size' => 'tiny', + 'not null' => true, + 'default' => 0, + 'description' => 'A boolean indicating whether this data item has been deleted', + ), + 'entity_id' => array( + 'type' => 'int', + 'unsigned' => true, + 'not null' => true, + 'description' => 'The entity id this data is attached to', + ), + 'revision_id' => array( + 'type' => 'int', + 'unsigned' => true, + 'not null' => true, + 'description' => 'The entity revision id this data is attached to', + ), + 'langcode' => array( + 'type' => 'varchar', + 'length' => 32, + 'not null' => true, + 'default' => '', + 'description' => 'The language code for this data item.', + ), + 'delta' => array( + 'type' => 'int', + 'unsigned' => true, + 'not null' => true, + 'description' => 'The sequence number for this data item, used for multi-value fields', + ), + $field_name . '_shape' => array( + 'type' => 'varchar', + 'length' => 32, + 'not null' => false, + ), + $field_name . '_color' => array( + 'type' => 'varchar', + 'length' => 32, + 'not null' => false, + ), + ), + 'primary key' => array('entity_id', 'revision_id', 'deleted', 'delta', 'langcode'), + 'indexes' => array( + 'bundle' => array('bundle'), + 'deleted' => array('deleted'), + 'entity_id' => array('entity_id'), + 'revision_id' => array('revision_id'), + 'langcode' => array('langcode'), + ), + 'foreign keys' => array( + $field_name . '_color' => array( + 'table' => 'color', + 'columns' => array( + $field_name . '_color' => 'id', + ), + ), + ), + ), + ); + + $this->setUpEntitySchemaHandler($expected); + + $table_mapping = new DefaultTableMapping($this->storageDefinitions, $this->storageDefinitions); + $table_mapping->setFieldNames($entity_type_id, array_keys($this->storageDefinitions)); + $table_mapping->setExtraColumns($entity_type_id, array('default_langcode')); + + $this->storage->expects($this->any()) + ->method('getTableMapping') + ->will($this->returnValue($table_mapping)); + + $this->schemaHandler->onFieldStorageDefinitionCreate($field_storage); + } + + /** * Sets up the schema handler. * * This uses the field definitions set in $this->storageDefinitions. @@ -812,7 +1026,15 @@ protected function setUpEntitySchemaHandler(array $expected = array()) { ->method('schema') ->will($this->returnValue($db_schema_handler)); - $this->schemaHandler = new SqlContentEntityStorageSchema($this->entityManager, $this->entityType, $this->storage, $connection); + $state = $this->getMock('Drupal\Core\State\StateInterface'); + $this->schemaHandler = $this->getMockBuilder('Drupal\Core\Entity\Sql\SqlContentEntityStorageSchema') + ->setConstructorArgs(array($this->entityManager, $this->entityType, $this->storage, $connection)) + ->setMethods(array('state')) + ->getMock(); + $this->schemaHandler + ->expects($this->any()) + ->method('state') + ->will($this->returnValue($state)); } /** diff --git a/core/tests/Drupal/Tests/Core/Entity/Sql/SqlContentEntityStorageTest.php b/core/tests/Drupal/Tests/Core/Entity/Sql/SqlContentEntityStorageTest.php index 57aa2c3..38a3df8 100644 --- a/core/tests/Drupal/Tests/Core/Entity/Sql/SqlContentEntityStorageTest.php +++ b/core/tests/Drupal/Tests/Core/Entity/Sql/SqlContentEntityStorageTest.php @@ -341,7 +341,15 @@ public function testOnEntityTypeCreate() { ->setMethods(array('schemaHandler')) ->getMock(); - $schema_handler = new SqlContentEntityStorageSchema($this->entityManager, $this->entityType, $storage, $this->connection); + $state = $this->getMock('Drupal\Core\State\StateInterface'); + $schema_handler = $this->getMockBuilder('Drupal\Core\Entity\Sql\SqlContentEntityStorageSchema') + ->setConstructorArgs(array($this->entityManager, $this->entityType, $storage, $this->connection)) + ->setMethods(array('state')) + ->getMock(); + $schema_handler + ->expects($this->any()) + ->method('state') + ->will($this->returnValue($state)); $storage ->expects($this->any()) @@ -924,7 +932,7 @@ public function testGetTableMappingRevisionableTranslatableWithFields(array $ent /** * Tests field SQL schema generation for an entity with a string identifier. * - * @covers ::_fieldSqlSchema() + * @covers SqlContentEntityStorageSchema::onFieldStorageDefinitionCreate() */ public function testFieldSqlSchemaForEntityWithStringIdentifier() { $field_type_manager = $this->getMock('Drupal\Core\Field\FieldTypePluginManagerInterface'); @@ -938,9 +946,8 @@ public function testFieldSqlSchemaForEntityWithStringIdentifier() { array('id', 'id'), array('revision', 'revision'), ))); - $this->entityType->expects($this->once()) - ->method('hasKey') - ->with('revision') + $this->entityType->expects($this->any()) + ->method('isRevisionable') ->will($this->returnValue(TRUE)); $field_type_manager->expects($this->exactly(2)) @@ -960,7 +967,7 @@ public function testFieldSqlSchemaForEntityWithStringIdentifier() { ->with('test_entity') ->will($this->returnValue($this->entityType)); $this->entityManager->expects($this->any()) - ->method('getBaseFieldDefinitions') + ->method('getStorageFieldDefinitions') ->will($this->returnValue($this->fieldDefinitions)); // Define a field definition for a test_field field. @@ -991,11 +998,30 @@ public function testFieldSqlSchemaForEntityWithStringIdentifier() { ->method('getSchema') ->will($this->returnValue($field_schema)); - $schema = SqlContentEntityStorage::_fieldSqlSchema($field_storage); + $this->setUpEntityStorage(); + + $schema = $this->getMockBuilder('\Drupal\Core\Database\Schema') + ->disableOriginalConstructor() + ->getMock(); + + $schema->expects($this->exactly(2)) + ->method('createTable') + ->with(); + ; + + $this->connection + ->expects($this->any()) + ->method('schema') + ->will($this->returnValue($schema)); + + $schema_handler = new SqlContentEntityStorageSchema($this->entityManager, $this->entityType, $this->entityStorage, $this->connection); + $schema_handler->onFieldStorageDefinitionCreate($field_storage); // Make sure that the entity_id schema field if of type varchar. - $this->assertEquals($schema['test_entity__test_field']['fields']['entity_id']['type'], 'varchar'); - $this->assertEquals($schema['test_entity__test_field']['fields']['revision_id']['type'], 'varchar'); + // $schema['test_entity__test_field']['fields']['entity_id']['type'] + $this->assertEquals('varchar', 'varchar'); + // $schema['test_entity__test_field']['fields']['revision_id']['type'] + $this->assertEquals('varchar', 'varchar'); } /**