You are here

Home » API reference » Acquia Cloud Site Factory Connector 8 » AcsfDuplicationScrubCommentStorage.php

class AcsfDuplicationScrubCommentStorage in Acquia Cloud Site Factory Connector 8

Same name and namespace in other branches
  1. 8.2 src/Event/AcsfDuplicationScrubCommentStorage.php \Drupal\acsf\Event\AcsfDuplicationScrubCommentStorage

Comment storage class (using a SQL backend) which ignores load failures.

The idea of this class is to prefer scrubbing over consistency; we don't care much about load failures since the only reason for loading comments is being able to delete them.

Hierarchy

Expanded class hierarchy of AcsfDuplicationScrubCommentStorage

File

src/Event/AcsfDuplicationScrubCommentStorage.php, line 14

Namespace

Drupal\acsf\Event
View source 
class AcsfDuplicationScrubCommentStorage extends CommentStorage {

  /**
   * Invokes hook_entity_storage_load() while catching exceptions thrown.
   *
   * Unlike SqlContentEntityStorage's implementation, this prevents a
   * hook_comment_storage_load() implementation somewhere in contrib from
   * throwing exceptions while loading orphaned comments, and causing
   * Wip failures.
   *
   * Issue https://www.drupal.org/node/2614720 was filed and this method was
   * written assuming that Drupal Core itself was throwing exceptions which
   * should be caught, while loading orphaned comments. Unfortunately that's not
   * the case: RDF module throws a fatal error (not an exception). So now this
   * method does not solve a known problem; it's just a semi random extra
   * precaution in case a contrib module does funny things. This may be deleted
   * if we value minimizing code over supporting random theoretical failures.
   *
   * @param \Drupal\Core\Entity\ContentEntityInterface[] $entities
   *   List of entities, keyed on the entity ID.
   */
  protected function invokeStorageLoadHook(array &$entities) {
    if (!empty($entities)) {

      // Call hook_entity_storage_load().
      foreach ($this
        ->moduleHandler()
        ->getImplementations('entity_storage_load') as $module) {
        $function = $module . '_entity_storage_load';
        try {
          $function($entities, $this->entityTypeId);
        } catch (\Exception $e) {

          // Don't care.
        }
      }

      // Call hook_TYPE_storage_load().
      foreach ($this
        ->moduleHandler()
        ->getImplementations($this->entityTypeId . '_storage_load') as $module) {
        $function = $module . '_' . $this->entityTypeId . '_storage_load';
        try {
          $function($entities);
        } catch (\Exception $e) {

          // Don't care.
        }
      }
    }
  }

  /**
   * Deletes orphaned comments without having to load the full entities first.
   *
   * The regular EntityStorageInterface::delete() expects fully loaded entities
   * as arguments but -because of the above- we cannot load orphaned comments.
   * So we'll query for IDs, and mimic delete-related methods so they need
   * IDs as an argument instead of full entities.
   *
   * @param int $limit
   *   (optional) Maximum number of comments to delete in one go.
   * @param int $already_processed_min_id
   *   (optional) If specified and >0, only delete items with an ID lower than
   *   this. 0 is interpreted as "no deletion is necessary".
   *
   * @return array
   *   The orphaned items that were found, and possibly deleted.
   */
  public function deleteOrphanedItems($limit = 0, $already_processed_min_id = -1) {
    $cids = $this
      ->getOrphanedItems($limit, $already_processed_min_id);
    if ($cids) {

      // First, check if these comments have children which are not orphaned
      // (i.e. the commented node and user do exist; the parent comment is only
      // orphaned because its parent does not exist). If so, add these to the
      // list. (These cannot be loaded without generating fatal errors either,
      // because rdf_comment_storage_load() calls $comment->getParentComment()
      // which tries to load the whole parent comment which recursively etc.
      // until rdf_comment_storage_load() processes the orphaned parent and
      // crashes.)
      $uid_and_entity_ok = array_filter($cids);
      $child_cids = [];
      if ($uid_and_entity_ok) {

        // Database statement copied/changed from $this->getChildCids():
        $child_cids = $this->database
          ->select('comment_field_data', 'c')
          ->fields('c', [
          'cid',
        ])
          ->condition('pid', array_keys($uid_and_entity_ok), 'IN')
          ->condition('default_langcode', 1)
          ->execute()
          ->fetchCol();
      }
      $cids = array_merge(array_keys($cids), $child_cids);

      // Mimic the parts of CommentStorage::delete() that are possible.
      // The call structure:
      // - Comment::preDelete: is empty.
      // - invokeHook('predelete'): needs entity.
      // - doDelete():
      //   - invokeFieldMethod('delete'): needs entity.
      //   - doDeleteFieldItems(): can be mimicked.
      $this
        ->doDeleteFieldItemsById($cids);

      // - resetCache()
      $this
        ->resetCache($cids);

      // - Comment::postDelete:
      //   - deletes child comments: done above.
      //   - deletes statistics: copying CommentStatistics::delete() code here:
      $this->database
        ->delete('comment_entity_statistics')
        ->condition('entity_id', $cids, 'IN')
        ->condition('entity_type', 'comment')
        ->execute();

      // - invokeHook('postdelete'): needs entity.
    }
    return $cids;
  }

  /**
   * Gets a list of orphaned comment IDs.
   *
   * 'orphaned' means having an invalid user, commented entity, or parent
   * comment. "Commented entity" is only checked for nodes (not other entity
   * types).
   *
   * @param int $limit
   *   (optional) Maximum number of comment IDs to fetch in one go.
   * @param int $already_processed_min_id
   *   (optional) If specified and >0, only fetch IDs lower than this. 0 is
   *   interpreted as "no action is necessary".
   *
   * @return array
   *   An indexed array indexed by the relevant comment IDs, with a value of 1
   *   if the user and commented entity are valid (so only the parent comment
   *   is wrong), and 0 otherwise.
   */
  protected function getOrphanedItems($limit = 0, $already_processed_min_id = -1) {
    if ($already_processed_min_id == 0) {
      return [];
    }
    $where = "u.uid IS NULL OR (n.nid IS NULL and c.entity_type = 'node')\n      OR (pc.cid IS NULL AND c.pid > 0)";
    $args = [];
    if ($already_processed_min_id > 0) {
      $where = "({$where}) AND c.cid < :processed";
      $args[':processed'] = $already_processed_min_id;
    }
    $query = "SELECT c.cid, CASE WHEN u.uid IS NULL OR (n.nid IS NULL and c.entity_type = 'node') THEN 0 ELSE 1 END AS validref\n      FROM {comment_field_data} c\n      LEFT JOIN {users} u ON c.uid = u.uid\n      LEFT JOIN {node} n ON c.entity_id = n.nid\n      LEFT JOIN {comment} pc ON c.pid = pc.cid\n      WHERE {$where} ORDER BY c.cid DESC";
    $statement = $limit ? $this->database
      ->queryRange($query, 0, $limit, $args) : $this->database
      ->query($query, $args);
    return $statement
      ->fetchAllKeyed();
  }

  /**
   * Deletes entity field values from the storage.
   *
   * This is a near copy of SqlContentEntityStorage::doDeleteFieldItems() except
   * it takes ids as argument instead of entities.
   *
   * @param array $ids
   *   The entity ids.
   */
  protected function doDeleteFieldItemsById(array $ids) {
    $this->database
      ->delete($this->entityType
      ->getBaseTable())
      ->condition($this->idKey, $ids, 'IN')
      ->execute();
    if ($this->revisionTable) {
      $this->database
        ->delete($this->revisionTable)
        ->condition($this->idKey, $ids, 'IN')
        ->execute();
    }
    if ($this->dataTable) {
      $this->database
        ->delete($this->dataTable)
        ->condition($this->idKey, $ids, 'IN')
        ->execute();
    }
    if ($this->revisionDataTable) {
      $this->database
        ->delete($this->revisionDataTable)
        ->condition($this->idKey, $ids, 'IN')
        ->execute();
    }

    // For backwards compatibility (Drupal >=8.5.0 and <8.7.0).
    // This class extends CommentStorage which extends SqlContentEntityStorage
    // which extends ContentEntityStorageBase:
    // - before Drupal 8.7, ->getBundleInfo() is reachable through
    //   ContentEntityStorageBase -> entityManager -> entityTypeBundleInfo;
    // - starting with Drupal 8.7 ->getBundleInfo() is reachable through
    //   ContentEntityStorageBase -> entityTypeBundleInfo.
    // The EntityManager class is deprecated; lately the purpose of this class
    // was only to delegate all method calls to the appropriate service.
    //
    // The complete removal of the EntityManager class will happen before
    // Drupal 9.0.0.
    // Although we noticed that in Drupal 8.7.0, core developers started ripping
    // off the usage of EntityManager from various entity classes, like:
    // -- CommentStorage.php
    // -- SqlContentEntityStorage.php
    // -- ContentEntityStorageBase.php
    // which, starting from Drupal 8.7.0 have the necessary service classes
    // properly injected.
    // @see https://www.drupal.org/project/drupal/issues/3025427
    // @see https://git.drupalcode.org/project/drupal/commit/81915a9
    // - the core commit which contains these changes.
    // Keep using EntityManager is not an option since it is deprecated, and for
    // Drupal versions >=8.5.0 and <8.7.0 we need to pull in the service in the
    // non-elegant way.
    $entityTypeBundleInfo = $this->entityTypeBundleInfo ?: \Drupal::service('entity_type.bundle.info');

    // Delete as many dedicated field tables as we can find. This is slightly
    // different from the original: since we don't know the original entities'
    // bundles, we loop through all bundles that exist for a comment.
    foreach (array_keys($entityTypeBundleInfo
      ->getBundleInfo('comment')) as $bundle) {
      $this
        ->deleteFromDedicatedTablesById($ids, $bundle);
    }
  }

  /**
   * Deletes values of fields in dedicated tables for all revisions.
   *
   * This is a lookalike of SqlContentEntityStorage::deleteFromDedicatedTables()
   * which takes an array of ids + a bundle as arguments, instead of a single
   * entity.
   *
   * @param array $ids
   *   The entity ids.
   * @param string $bundle
   *   A bundle id; must be an existing bundle for 'comment'.
   */
  protected function deleteFromDedicatedTablesById(array $ids, $bundle) {
    $table_mapping = $this
      ->getTableMapping();

    // For backwards compatibility (Drupal >=8.5.0 and <8.7.0).
    // This class extends CommentStorage which extends SqlContentEntityStorage
    // which extends ContentEntityStorageBase:
    // - before Drupal 8.7.0, ->getFieldDefinitions() is reachable through
    //   ContentEntityStorageBase -> entityManager -> entityFieldManager;
    // - starting with Drupal 8.7.0 ->getFieldDefinitions() is reachable through
    //   ContentEntityStorageBase -> entityFieldManager.
    // The EntityManager class is deprecated; lately the purpose of this class
    // was only to delegate all method calls to the appropriate service.
    //
    // The complete removal of the EntityManager class will happen before
    // Drupal 9.0.0.
    // Although we noticed that in Drupal 8.7.0, core developers started ripping
    // off the usage of EntityManager from various entity classes, like:
    // -- CommentStorage.php
    // -- SqlContentEntityStorage.php
    // -- ContentEntityStorageBase.php
    // which, starting from Drupal 8.7.0 have the necessary service classes
    // properly injected.
    // @see https://www.drupal.org/project/drupal/issues/3025427
    // @see https://git.drupalcode.org/project/drupal/commit/81915a9
    // - the core commit which contains these changes.
    // Keep using EntityManager is not an option since it is deprecated, and for
    // Drupal versions >=8.5.0 and <8.7.0 we need to pull in the service in the
    // non-elegant way.
    $entityFieldManager = $this->entityFieldManager ?: \Drupal::service('entity_field.manager');
    foreach ($entityFieldManager
      ->getFieldDefinitions('comment', $bundle) as $field_definition) {

      /** @var \Drupal\Core\Field\FieldStorageDefinitionInterface $field_definition */
      $storage_definition = $field_definition
        ->getFieldStorageDefinition();
      if (!$table_mapping
        ->requiresDedicatedTableStorage($storage_definition)) {
        continue;
      }
      $table_name = $table_mapping
        ->getDedicatedDataTableName($storage_definition);
      $revision_name = $table_mapping
        ->getDedicatedRevisionTableName($storage_definition);
      $this->database
        ->delete($table_name)
        ->condition('entity_id', $ids, 'IN')
        ->execute();
      if ($this->entityType
        ->isRevisionable()) {
        $this->database
          ->delete($revision_name)
          ->condition('entity_id', $ids, 'IN')
          ->execute();
      }
    }
  }

}

Members

Namesort descending Modifiers Type Description Overrides
AcsfDuplicationScrubCommentStorage::deleteFromDedicatedTablesById protected function Deletes values of fields in dedicated tables for all revisions.
AcsfDuplicationScrubCommentStorage::deleteOrphanedItems public function Deletes orphaned comments without having to load the full entities first.
AcsfDuplicationScrubCommentStorage::doDeleteFieldItemsById protected function Deletes entity field values from the storage.
AcsfDuplicationScrubCommentStorage::getOrphanedItems protected function Gets a list of orphaned comment IDs.
AcsfDuplicationScrubCommentStorage::invokeStorageLoadHook protected function Invokes hook_entity_storage_load() while catching exceptions thrown. Overrides ContentEntityStorageBase::invokeStorageLoadHook
CommentStorage::$currentUser protected property The current user.
CommentStorage::createInstance public static function Instantiates a new instance of this entity handler. Overrides SqlContentEntityStorage::createInstance
CommentStorage::getChildCids public function Gets the comment ids of the passed comment entities' children. Overrides CommentStorageInterface::getChildCids
CommentStorage::getDisplayOrdinal public function Gets the display ordinal or page number for a comment. Overrides CommentStorageInterface::getDisplayOrdinal
CommentStorage::getMaxThread public function Gets the maximum encoded thread value for the top level comments. Overrides CommentStorageInterface::getMaxThread
CommentStorage::getMaxThreadPerThread public function Gets the maximum encoded thread value for the children of this comment. Overrides CommentStorageInterface::getMaxThreadPerThread
CommentStorage::getNewCommentPageNumber public function Calculates the page number for the first new comment. Overrides CommentStorageInterface::getNewCommentPageNumber
CommentStorage::getUnapprovedCount public function Returns the number of unapproved comments. Overrides CommentStorageInterface::getUnapprovedCount
CommentStorage::loadThread public function To display threaded comments in the correct order we keep a 'thread' field and order by that value. This field keeps this data in a way which is easy to update and convenient to use. Overrides CommentStorageInterface::loadThread
CommentStorage::__construct public function Constructs a CommentStorage object. Overrides SqlContentEntityStorage::__construct
ContentEntityStorageBase::$bundleKey protected property The entity bundle key.
ContentEntityStorageBase::$cacheBackend protected property Cache backend.
ContentEntityStorageBase::$deprecatedProperties protected property
ContentEntityStorageBase::$entityFieldManager protected property The entity field manager service.
ContentEntityStorageBase::$entityTypeBundleInfo protected property The entity bundle info.
ContentEntityStorageBase::$latestRevisionIds protected property Stores the latest revision IDs for entities.
ContentEntityStorageBase::cleanIds protected function Ensures integer entity key values are valid.
ContentEntityStorageBase::createRevision public function Creates a new revision starting off from the specified entity object. Overrides TranslatableRevisionableStorageInterface::createRevision
ContentEntityStorageBase::createTranslation public function Constructs a new entity translation object, without permanently saving it. Overrides TranslatableStorageInterface::createTranslation
ContentEntityStorageBase::createWithSampleValues public function Creates an entity with sample field values. Overrides ContentEntityStorageInterface::createWithSampleValues 1
ContentEntityStorageBase::deleteRevision public function Delete a specific entity revision. Overrides EntityStorageInterface::deleteRevision 1
ContentEntityStorageBase::doCreate protected function Performs storage-specific creation of entities. Overrides EntityStorageBase::doCreate
ContentEntityStorageBase::doDelete protected function Performs storage-specific entity deletion. Overrides EntityStorageBase::doDelete 1
ContentEntityStorageBase::doPostSave protected function Performs post save entity processing. Overrides EntityStorageBase::doPostSave
ContentEntityStorageBase::doPreSave protected function Performs presave entity processing. Overrides EntityStorageBase::doPreSave
ContentEntityStorageBase::doSave protected function Performs storage-specific saving of the entity. Overrides EntityStorageBase::doSave 1
ContentEntityStorageBase::getFromPersistentCache protected function Gets entities from the persistent cache backend.
ContentEntityStorageBase::getLatestRevisionId public function Returns the latest revision identifier for an entity. Overrides RevisionableStorageInterface::getLatestRevisionId
ContentEntityStorageBase::getLatestTranslationAffectedRevisionId public function Returns the latest revision affecting the specified translation. Overrides TranslatableRevisionableStorageInterface::getLatestTranslationAffectedRevisionId
ContentEntityStorageBase::getRevisionTranslationMergeSkippedFieldNames protected function Returns an array of field names to skip when merging revision translations.
ContentEntityStorageBase::hasFieldValueChanged protected function Checks whether the field values changed compared to the original entity.
ContentEntityStorageBase::initFieldValues protected function Initializes field values.
ContentEntityStorageBase::invokeFieldMethod protected function Invokes a method on the Field objects within an entity.
ContentEntityStorageBase::invokeFieldPostSave protected function Invokes the post save method on the Field objects within an entity.
ContentEntityStorageBase::invokeHook protected function Invokes a hook on behalf of the entity. Overrides EntityStorageBase::invokeHook 1
ContentEntityStorageBase::invokeTranslationHooks protected function Checks translation statuses and invoke the related hooks if needed.
ContentEntityStorageBase::isAnyRevisionTranslated protected function Checks whether any entity revision is translated.
ContentEntityStorageBase::isAnyStoredRevisionTranslated protected function Checks whether any stored entity revision is translated.
ContentEntityStorageBase::loadMultipleRevisions public function Loads multiple entity revisions. Overrides RevisionableStorageInterface::loadMultipleRevisions 1
ContentEntityStorageBase::loadRevision public function Load a specific entity revision. Overrides EntityStorageInterface::loadRevision 1
ContentEntityStorageBase::loadUnchanged public function Loads an unchanged entity from the database. Overrides EntityStorageBase::loadUnchanged
ContentEntityStorageBase::onFieldDefinitionCreate public function Reacts to the creation of a field. Overrides FieldDefinitionListenerInterface::onFieldDefinitionCreate
ContentEntityStorageBase::onFieldDefinitionUpdate public function Reacts to the update of a field. Overrides FieldDefinitionListenerInterface::onFieldDefinitionUpdate
ContentEntityStorageBase::populateAffectedRevisionTranslations protected function Populates the affected flag for all the revision translations.
ContentEntityStorageBase::preLoad protected function Gathers entities from a 'preload' step. Overrides EntityStorageBase::preLoad
ContentEntityStorageBase::purgeFieldData public function Purges a batch of field data. Overrides FieldableEntityStorageInterface::purgeFieldData
ContentEntityStorageBase::resetCache public function Resets the internal, static entity cache. Overrides EntityStorageBase::resetCache 1
ContentEntityStorageBase::setPersistentCache protected function Stores entities in the persistent cache backend.
DependencySerializationTrait::$_entityStorages protected property An array of entity type IDs keyed by the property name of their storages.
DependencySerializationTrait::$_serviceIds protected property An array of service IDs keyed by property name used for serialization.
DependencySerializationTrait::__sleep public function 1
DependencySerializationTrait::__wakeup public function 2
DeprecatedServicePropertyTrait::__get public function Allows to access deprecated/removed properties.
EntityHandlerBase::$moduleHandler protected property The module handler to invoke hooks on. 2
EntityHandlerBase::moduleHandler protected function Gets the module handler. 2
EntityHandlerBase::setModuleHandler public function Sets the module handler for this handler.
EntityStorageBase::$entityClass protected property Name of the entity class.
EntityStorageBase::$entityType protected property Information about the entity type.
EntityStorageBase::$entityTypeId protected property Entity type ID for this storage.
EntityStorageBase::$idKey protected property Name of the entity's ID field in the entity database table.
EntityStorageBase::$memoryCache protected property The memory cache.
EntityStorageBase::$memoryCacheTag protected property The memory cache cache tag.
EntityStorageBase::$uuidKey protected property Name of entity's UUID database table field, if it supports UUIDs. 1
EntityStorageBase::$uuidService protected property The UUID service. 1
EntityStorageBase::buildCacheId protected function Builds the cache ID for the passed in entity ID. 1
EntityStorageBase::create public function Constructs a new entity object, without permanently saving it. Overrides EntityStorageInterface::create 1
EntityStorageBase::getAggregateQuery public function Gets an aggregated query instance. Overrides EntityStorageInterface::getAggregateQuery
EntityStorageBase::getEntityType public function Gets the entity type definition. Overrides EntityStorageInterface::getEntityType
EntityStorageBase::getEntityTypeId public function Gets the entity type ID. Overrides EntityStorageInterface::getEntityTypeId
EntityStorageBase::getFromStaticCache protected function Gets entities from the static cache.
EntityStorageBase::getQuery public function Gets an entity query instance. Overrides EntityStorageInterface::getQuery
EntityStorageBase::hasData public function Determines if the storage contains any data. Overrides EntityStorageInterface::hasData 3
EntityStorageBase::load public function Loads one entity. Overrides EntityStorageInterface::load 2
EntityStorageBase::loadByProperties public function Load entities by their property values. Overrides EntityStorageInterface::loadByProperties 3
EntityStorageBase::loadMultiple public function Loads one or more entities. Overrides EntityStorageInterface::loadMultiple 1
EntityStorageBase::postLoad protected function Attaches data to entities upon loading.
EntityStorageBase::setStaticCache protected function Stores entities in the static entity cache.
EntityStorageInterface::FIELD_LOAD_CURRENT constant Load the most recent version of an entity's field data.
EntityStorageInterface::FIELD_LOAD_REVISION constant Load the version of an entity's field data specified in the entity.
SqlContentEntityStorage::$baseTable protected property The base table of the entity.
SqlContentEntityStorage::$database protected property Active database connection.
SqlContentEntityStorage::$dataTable protected property The table that stores properties, if the entity has multilingual support.
SqlContentEntityStorage::$defaultLangcodeKey protected property The default language entity key.
SqlContentEntityStorage::$entityTypeManager protected property The entity type manager.
SqlContentEntityStorage::$fieldStorageDefinitions protected property The entity type's field storage definitions.
SqlContentEntityStorage::$langcodeKey protected property The entity langcode key. Overrides EntityStorageBase::$langcodeKey
SqlContentEntityStorage::$languageManager protected property The language manager.
SqlContentEntityStorage::$revisionDataTable protected property The table that stores revision field data if the entity supports revisions.
SqlContentEntityStorage::$revisionKey protected property Name of entity's revision database table field, if it supports revisions.
SqlContentEntityStorage::$revisionTable protected property The table that stores revisions, if the entity supports revisions.
SqlContentEntityStorage::$storageSchema protected property The entity type's storage schema object.
SqlContentEntityStorage::$tableMapping protected property The mapping of field columns to SQL tables.
SqlContentEntityStorage::$temporary protected property Whether this storage should use the temporary table mapping.
SqlContentEntityStorage::buildPropertyQuery protected function Builds an entity query. Overrides EntityStorageBase::buildPropertyQuery
SqlContentEntityStorage::buildQuery protected function Builds the query to load the entity.
SqlContentEntityStorage::countFieldData public function Determines the number of entities with values for a given field. Overrides FieldableEntityStorageInterface::countFieldData
SqlContentEntityStorage::delete public function Deletes permanently saved entities. Overrides EntityStorageBase::delete
SqlContentEntityStorage::deleteFromDedicatedTables protected function Deletes values of fields in dedicated tables for all revisions.
SqlContentEntityStorage::deleteRevisionFromDedicatedTables protected function Deletes values of fields in dedicated tables for all revisions.
SqlContentEntityStorage::doDeleteFieldItems protected function Deletes entity field values from the storage. Overrides ContentEntityStorageBase::doDeleteFieldItems
SqlContentEntityStorage::doDeleteRevisionFieldItems protected function Deletes field values of an entity revision from the storage. Overrides ContentEntityStorageBase::doDeleteRevisionFieldItems
SqlContentEntityStorage::doLoadMultiple protected function Performs storage-specific loading of entities. Overrides EntityStorageBase::doLoadMultiple
SqlContentEntityStorage::doLoadMultipleRevisionsFieldItems protected function Actually loads revision field item values from the storage. Overrides ContentEntityStorageBase::doLoadMultipleRevisionsFieldItems
SqlContentEntityStorage::doLoadRevisionFieldItems protected function Actually loads revision field item values from the storage. Overrides ContentEntityStorageBase::doLoadRevisionFieldItems
SqlContentEntityStorage::doSaveFieldItems protected function Writes entity field values to the storage. Overrides ContentEntityStorageBase::doSaveFieldItems 1
SqlContentEntityStorage::finalizePurge public function Performs final cleanup after all data of a field has been purged. Overrides ContentEntityStorageBase::finalizePurge
SqlContentEntityStorage::getBaseTable public function Gets the base table name.
SqlContentEntityStorage::getCustomTableMapping public function Gets a table mapping for the specified entity type and storage definitions.
SqlContentEntityStorage::getDataTable public function Gets the data table name.
SqlContentEntityStorage::getFieldStorageDefinitions Deprecated public function Gets the base field definitions for a content entity type.
SqlContentEntityStorage::getFromStorage protected function Gets entities from the storage.
SqlContentEntityStorage::getQueryServiceName protected function Gets the name of the service for the query for this entity storage. Overrides EntityStorageBase::getQueryServiceName
SqlContentEntityStorage::getRevisionDataTable public function Gets the revision data table name.
SqlContentEntityStorage::getRevisionTable public function Gets the revision table name.
SqlContentEntityStorage::getStorageSchema protected function Gets the entity type's storage schema object.
SqlContentEntityStorage::getTableMapping public function Gets a table mapping for the entity's SQL tables. Overrides SqlEntityStorageInterface::getTableMapping
SqlContentEntityStorage::has protected function Determines if this entity already exists in storage. Overrides EntityStorageBase::has
SqlContentEntityStorage::initTableLayout protected function Initializes table name variables.
SqlContentEntityStorage::isColumnSerial protected function Checks whether a field column should be treated as serial. 1
SqlContentEntityStorage::loadFromDedicatedTables protected function Loads values of fields stored in dedicated tables for a group of entities.
SqlContentEntityStorage::loadFromSharedTables protected function Loads values for fields stored in the shared data tables.
SqlContentEntityStorage::mapFromStorageRecords protected function Maps from storage records to entity objects, and attaches fields. Overrides EntityStorageBase::mapFromStorageRecords
SqlContentEntityStorage::mapToDataStorageRecord protected function Maps from an entity object to the storage record of the field data.
SqlContentEntityStorage::mapToStorageRecord protected function Maps from an entity object to the storage record.
SqlContentEntityStorage::onBundleCreate public function Reacts to a bundle being created. Overrides EntityBundleListenerInterface::onBundleCreate
SqlContentEntityStorage::onBundleDelete public function Reacts to a bundle being deleted. Overrides EntityBundleListenerInterface::onBundleDelete
SqlContentEntityStorage::onEntityTypeCreate public function Reacts to the creation of the entity type. Overrides EntityTypeListenerInterface::onEntityTypeCreate
SqlContentEntityStorage::onEntityTypeDelete public function Reacts to the deletion of the entity type. Overrides EntityTypeListenerInterface::onEntityTypeDelete
SqlContentEntityStorage::onEntityTypeUpdate public function Reacts to the update of the entity type. Overrides EntityTypeListenerInterface::onEntityTypeUpdate
SqlContentEntityStorage::onFieldableEntityTypeCreate public function Reacts to the creation of the fieldable entity type. Overrides EntityTypeListenerInterface::onFieldableEntityTypeCreate
SqlContentEntityStorage::onFieldableEntityTypeUpdate public function Reacts to the update of a fieldable entity type. Overrides EntityTypeListenerInterface::onFieldableEntityTypeUpdate
SqlContentEntityStorage::onFieldDefinitionDelete public function Reacts to the deletion of a field. Overrides ContentEntityStorageBase::onFieldDefinitionDelete
SqlContentEntityStorage::onFieldStorageDefinitionCreate public function Reacts to the creation of a field storage definition. Overrides ContentEntityStorageBase::onFieldStorageDefinitionCreate
SqlContentEntityStorage::onFieldStorageDefinitionDelete public function Reacts to the deletion of a field storage definition. Overrides ContentEntityStorageBase::onFieldStorageDefinitionDelete
SqlContentEntityStorage::onFieldStorageDefinitionUpdate public function Reacts to the update of a field storage definition. Overrides ContentEntityStorageBase::onFieldStorageDefinitionUpdate
SqlContentEntityStorage::purgeFieldItems protected function Removes field items from storage per entity during purge. Overrides ContentEntityStorageBase::purgeFieldItems
SqlContentEntityStorage::readFieldItemsToPurge protected function Reads values to be purged for a single field. Overrides ContentEntityStorageBase::readFieldItemsToPurge
SqlContentEntityStorage::requiresEntityDataMigration public function Checks if existing data would be lost if the schema changes were applied. Overrides EntityStorageSchemaInterface::requiresEntityDataMigration
SqlContentEntityStorage::requiresEntityStorageSchemaChanges public function Checks if the changes to the entity type requires storage schema changes. Overrides EntityStorageSchemaInterface::requiresEntityStorageSchemaChanges
SqlContentEntityStorage::requiresFieldDataMigration public function Checks if existing data would be lost if the schema changes were applied. Overrides DynamicallyFieldableEntityStorageSchemaInterface::requiresFieldDataMigration
SqlContentEntityStorage::requiresFieldStorageSchemaChanges public function Checks if the changes to the storage definition requires schema changes. Overrides DynamicallyFieldableEntityStorageSchemaInterface::requiresFieldStorageSchemaChanges
SqlContentEntityStorage::restore public function Restores a previously saved entity. Overrides EntityStorageBase::restore
SqlContentEntityStorage::save public function Saves the entity permanently. Overrides EntityStorageBase::save 1
SqlContentEntityStorage::saveRevision protected function Saves an entity revision.
SqlContentEntityStorage::saveToDedicatedTables protected function Saves values of fields that use dedicated tables. 1
SqlContentEntityStorage::saveToSharedTables protected function Saves fields that use the shared tables.
SqlContentEntityStorage::setEntityType public function Updates the wrapped entity type definition.
SqlContentEntityStorage::setFieldStorageDefinitions public function Updates the internal list of field storage definitions.
SqlContentEntityStorage::setTableMapping public function Sets the wrapped table mapping definition.
SqlContentEntityStorage::setTemporary public function Changes the temporary state of the storage.
SqlContentEntityStorage::storageDefinitionIsDeleted Deprecated protected function Determines whether the passed field has been already deleted.
SqlContentEntityStorage::wrapSchemaException protected function Wraps a database schema exception into an entity storage exception.
StringTranslationTrait::$stringTranslation protected property The string translation service. 1
StringTranslationTrait::formatPlural protected function Formats a string containing a count of items.
StringTranslationTrait::getNumberOfPlurals protected function Returns the number of plurals supported by a given language.
StringTranslationTrait::getStringTranslation protected function Gets the string translation service.
StringTranslationTrait::setStringTranslation public function Sets the string translation service to use. 2
StringTranslationTrait::t protected function Translates a string to the current language or to a given language.