class CommentStorage
Same name in other branches
- 8.9.x core/modules/comment/src/CommentStorage.php \Drupal\comment\CommentStorage
- 10 core/modules/comment/src/CommentStorage.php \Drupal\comment\CommentStorage
- 11.x core/modules/comment/src/CommentStorage.php \Drupal\comment\CommentStorage
Defines the storage handler class for comments.
This extends the Drupal\Core\Entity\Sql\SqlContentEntityStorage class, adding required special handling for comment entities.
Hierarchy
- class \Drupal\Core\Entity\EntityHandlerBase uses \Drupal\Core\StringTranslation\StringTranslationTrait, \Drupal\Core\DependencyInjection\DependencySerializationTrait
- class \Drupal\Core\Entity\EntityStorageBase extends \Drupal\Core\Entity\EntityHandlerBase implements \Drupal\Core\Entity\EntityStorageInterface, \Drupal\Core\Entity\EntityHandlerInterface
- class \Drupal\Core\Entity\ContentEntityStorageBase extends \Drupal\Core\Entity\EntityStorageBase implements \Drupal\Core\Entity\ContentEntityStorageInterface, \Drupal\Core\Entity\DynamicallyFieldableEntityStorageInterface, \Drupal\Core\Entity\BundleEntityStorageInterface
- class \Drupal\Core\Entity\Sql\SqlContentEntityStorage extends \Drupal\Core\Entity\ContentEntityStorageBase implements \Drupal\Core\Entity\Sql\SqlEntityStorageInterface, \Drupal\Core\Entity\Schema\DynamicallyFieldableEntityStorageSchemaInterface, \Drupal\Core\Entity\EntityBundleListenerInterface
- class \Drupal\comment\CommentStorage extends \Drupal\Core\Entity\Sql\SqlContentEntityStorage implements \Drupal\comment\CommentStorageInterface
- class \Drupal\Core\Entity\Sql\SqlContentEntityStorage extends \Drupal\Core\Entity\ContentEntityStorageBase implements \Drupal\Core\Entity\Sql\SqlEntityStorageInterface, \Drupal\Core\Entity\Schema\DynamicallyFieldableEntityStorageSchemaInterface, \Drupal\Core\Entity\EntityBundleListenerInterface
- class \Drupal\Core\Entity\ContentEntityStorageBase extends \Drupal\Core\Entity\EntityStorageBase implements \Drupal\Core\Entity\ContentEntityStorageInterface, \Drupal\Core\Entity\DynamicallyFieldableEntityStorageInterface, \Drupal\Core\Entity\BundleEntityStorageInterface
- class \Drupal\Core\Entity\EntityStorageBase extends \Drupal\Core\Entity\EntityHandlerBase implements \Drupal\Core\Entity\EntityStorageInterface, \Drupal\Core\Entity\EntityHandlerInterface
Expanded class hierarchy of CommentStorage
File
-
core/
modules/ comment/ src/ CommentStorage.php, line 26
Namespace
Drupal\commentView source
class CommentStorage extends SqlContentEntityStorage implements CommentStorageInterface {
/**
* The current user.
*
* @var \Drupal\Core\Session\AccountInterface
*/
protected $currentUser;
/**
* Constructs a CommentStorage object.
*
* @param \Drupal\Core\Entity\EntityTypeInterface $entity_info
* An array of entity info for the entity type.
* @param \Drupal\Core\Database\Connection $database
* The database connection to be used.
* @param \Drupal\Core\Entity\EntityFieldManagerInterface $entity_field_manager
* The entity field manager.
* @param \Drupal\Core\Session\AccountInterface $current_user
* The current user.
* @param \Drupal\Core\Cache\CacheBackendInterface $cache
* Cache backend instance to use.
* @param \Drupal\Core\Language\LanguageManagerInterface $language_manager
* The language manager.
* @param \Drupal\Core\Cache\MemoryCache\MemoryCacheInterface $memory_cache
* The memory cache.
* @param \Drupal\Core\Entity\EntityTypeBundleInfoInterface $entity_type_bundle_info
* The entity type bundle info.
* @param \Drupal\Core\Entity\EntityTypeManagerInterface $entity_type_manager
* The entity type manager.
*/
public function __construct(EntityTypeInterface $entity_info, Connection $database, EntityFieldManagerInterface $entity_field_manager, AccountInterface $current_user, CacheBackendInterface $cache, LanguageManagerInterface $language_manager, MemoryCacheInterface $memory_cache, EntityTypeBundleInfoInterface $entity_type_bundle_info, EntityTypeManagerInterface $entity_type_manager) {
parent::__construct($entity_info, $database, $entity_field_manager, $cache, $language_manager, $memory_cache, $entity_type_bundle_info, $entity_type_manager);
$this->currentUser = $current_user;
}
/**
* {@inheritdoc}
*/
public static function createInstance(ContainerInterface $container, EntityTypeInterface $entity_info) {
return new static($entity_info, $container->get('database'), $container->get('entity_field.manager'), $container->get('current_user'), $container->get('cache.entity'), $container->get('language_manager'), $container->get('entity.memory_cache'), $container->get('entity_type.bundle.info'), $container->get('entity_type.manager'));
}
/**
* {@inheritdoc}
*/
public function getMaxThread(CommentInterface $comment) {
$query = $this->database
->select($this->getDataTable(), 'c')
->condition('entity_id', $comment->getCommentedEntityId())
->condition('field_name', $comment->getFieldName())
->condition('entity_type', $comment->getCommentedEntityTypeId())
->condition('default_langcode', 1);
$query->addExpression('MAX([thread])', 'thread');
return $query->execute()
->fetchField();
}
/**
* {@inheritdoc}
*/
public function getMaxThreadPerThread(CommentInterface $comment) {
$query = $this->database
->select($this->getDataTable(), 'c')
->condition('entity_id', $comment->getCommentedEntityId())
->condition('field_name', $comment->getFieldName())
->condition('entity_type', $comment->getCommentedEntityTypeId())
->condition('thread', $comment->getParentComment()
->getThread() . '.%', 'LIKE')
->condition('default_langcode', 1);
$query->addExpression('MAX([thread])', 'thread');
return $query->execute()
->fetchField();
}
/**
* {@inheritdoc}
*/
public function getDisplayOrdinal(CommentInterface $comment, $comment_mode, $divisor = 1) {
// Count how many comments (c1) are before $comment (c2) in display order.
// This is the 0-based display ordinal.
$data_table = $this->getDataTable();
$query = $this->database
->select($data_table, 'c1');
$query->innerJoin($data_table, 'c2', '[c2].[entity_id] = [c1].[entity_id] AND [c2].[entity_type] = [c1].[entity_type] AND [c2].[field_name] = [c1].[field_name]');
$query->addExpression('COUNT(*)', 'count');
$query->condition('c2.cid', $comment->id());
if (!$this->currentUser
->hasPermission('administer comments')) {
$query->condition('c1.status', CommentInterface::PUBLISHED);
}
if ($comment_mode == CommentManagerInterface::COMMENT_MODE_FLAT) {
// For rendering flat comments, cid is used for ordering comments due to
// unpredictable behavior with timestamp, so we make the same assumption
// here.
$query->condition('c1.cid', $comment->id(), '<');
}
else {
// For threaded comments, the c.thread column is used for ordering. We can
// use the sorting code for comparison, but must remove the trailing
// slash.
$query->where('SUBSTRING([c1].[thread], 1, (LENGTH([c1].[thread]) - 1)) < SUBSTRING([c2].[thread], 1, (LENGTH([c2].[thread]) - 1))');
}
$query->condition('c1.default_langcode', 1);
$query->condition('c2.default_langcode', 1);
$ordinal = $query->execute()
->fetchField();
return $divisor > 1 ? floor($ordinal / $divisor) : $ordinal;
}
/**
* {@inheritdoc}
*/
public function getNewCommentPageNumber($total_comments, $new_comments, FieldableEntityInterface $entity, $field_name) {
$field = $entity->getFieldDefinition($field_name);
$comments_per_page = $field->getSetting('per_page');
$data_table = $this->getDataTable();
if ($total_comments <= $comments_per_page) {
// Only one page of comments.
$count = 0;
}
elseif ($field->getSetting('default_mode') == CommentManagerInterface::COMMENT_MODE_FLAT) {
// Flat comments.
$count = $total_comments - $new_comments;
}
else {
// Threaded comments.
// 1. Find all the threads with a new comment.
$unread_threads_query = $this->database
->select($data_table, 'comment')
->fields('comment', [
'thread',
])
->condition('entity_id', $entity->id())
->condition('entity_type', $entity->getEntityTypeId())
->condition('field_name', $field_name)
->condition('status', CommentInterface::PUBLISHED)
->condition('default_langcode', 1)
->orderBy('created', 'DESC')
->orderBy('cid', 'DESC')
->range(0, $new_comments);
// 2. Find the first thread.
$first_thread_query = $this->database
->select($unread_threads_query, 'thread');
$first_thread_query->addExpression('SUBSTRING([thread], 1, (LENGTH([thread]) - 1))', 'torder');
$first_thread = $first_thread_query->fields('thread', [
'thread',
])
->orderBy('torder')
->range(0, 1)
->execute()
->fetchField();
// Remove the final '/'.
$first_thread = substr($first_thread, 0, -1);
// Find the number of the first comment of the first unread thread.
$count = $this->database
->query('SELECT COUNT(*) FROM {' . $data_table . '} WHERE [entity_id] = :entity_id
AND [entity_type] = :entity_type
AND [field_name] = :field_name
AND [status] = :status
AND SUBSTRING([thread], 1, (LENGTH([thread]) - 1)) < :thread
AND [default_langcode] = 1', [
':status' => CommentInterface::PUBLISHED,
':entity_id' => $entity->id(),
':field_name' => $field_name,
':entity_type' => $entity->getEntityTypeId(),
':thread' => $first_thread,
])
->fetchField();
}
return $comments_per_page > 0 ? (int) ($count / $comments_per_page) : 0;
}
/**
* {@inheritdoc}
*/
public function getChildCids(array $comments) {
return $this->database
->select($this->getDataTable(), 'c')
->fields('c', [
'cid',
])
->condition('pid', array_keys($comments), 'IN')
->condition('default_langcode', 1)
->execute()
->fetchCol();
}
/**
* {@inheritdoc}
*
* 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.
*
* A "thread" value starts at "1". If we add a child (A) to this comment,
* we assign it a "thread" = "1.1". A child of (A) will have "1.1.1". Next
* brother of (A) will get "1.2". Next brother of the parent of (A) will get
* "2" and so on.
*
* First of all note that the thread field stores the depth of the comment:
* depth 0 will be "X", depth 1 "X.X", depth 2 "X.X.X", etc.
*
* Now to get the ordering right, consider this example:
*
* 1
* 1.1
* 1.1.1
* 1.2
* 2
*
* If we "ORDER BY thread ASC" we get the above result, and this is the
* natural order sorted by time. However, if we "ORDER BY thread DESC"
* we get:
*
* 2
* 1.2
* 1.1.1
* 1.1
* 1
*
* Clearly, this is not a natural way to see a thread, and users will get
* confused. The natural order to show a thread by time desc would be:
*
* 2
* 1
* 1.2
* 1.1
* 1.1.1
*
* which is what we already did before the standard pager patch. To achieve
* this we simply add a "/" at the end of each "thread" value. This way, the
* thread fields will look like this:
*
* 1/
* 1.1/
* 1.1.1/
* 1.2/
* 2/
*
* we add "/" since this char is, in ASCII, higher than every number, so if
* now we "ORDER BY thread DESC" we get the correct order. However this would
* spoil the reverse ordering, "ORDER BY thread ASC" -- here, we do not need
* to consider the trailing "/" so we use a substring only.
*/
public function loadThread(EntityInterface $entity, $field_name, $mode, $comments_per_page = 0, $pager_id = 0) {
$data_table = $this->getDataTable();
$query = $this->database
->select($data_table, 'c');
$query->addField('c', 'cid');
$query->condition('c.entity_id', $entity->id())
->condition('c.entity_type', $entity->getEntityTypeId())
->condition('c.field_name', $field_name)
->condition('c.default_langcode', 1)
->addTag('entity_access')
->addTag('comment_filter')
->addMetaData('base_table', 'comment')
->addMetaData('entity', $entity)
->addMetaData('field_name', $field_name);
if ($comments_per_page) {
$query = $query->extend(PagerSelectExtender::class)
->limit($comments_per_page);
if ($pager_id) {
$query->element($pager_id);
}
$count_query = $this->database
->select($data_table, 'c');
$count_query->addExpression('COUNT(*)');
$count_query->condition('c.entity_id', $entity->id())
->condition('c.entity_type', $entity->getEntityTypeId())
->condition('c.field_name', $field_name)
->condition('c.default_langcode', 1)
->addTag('entity_access')
->addTag('comment_filter')
->addMetaData('base_table', 'comment')
->addMetaData('entity', $entity)
->addMetaData('field_name', $field_name);
$query->setCountQuery($count_query);
}
if (!$this->currentUser
->hasPermission('administer comments')) {
$query->condition('c.status', CommentInterface::PUBLISHED);
if ($comments_per_page) {
$count_query->condition('c.status', CommentInterface::PUBLISHED);
}
}
if ($mode == CommentManagerInterface::COMMENT_MODE_FLAT) {
$query->orderBy('c.cid', 'ASC');
}
else {
// See comment above. Analysis reveals that this doesn't cost too much. It
// scales much better than having the whole comment structure.
$query->addExpression('SUBSTRING([c].[thread], 1, (LENGTH([c].[thread]) - 1))', 'torder');
$query->orderBy('torder', 'ASC');
}
$cids = $query->execute()
->fetchCol();
$comments = [];
if ($cids) {
$comments = $this->loadMultiple($cids);
}
return $comments;
}
/**
* {@inheritdoc}
*/
public function getUnapprovedCount() {
return $this->database
->select($this->getDataTable(), 'c')
->condition('status', CommentInterface::NOT_PUBLISHED, '=')
->condition('default_langcode', 1)
->countQuery()
->execute()
->fetchField();
}
}
Members
Title Sort descending | Modifiers | Object type | Summary | Overriden Title | Overrides |
---|---|---|---|---|---|
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::$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::create | public | function | Constructs a new entity object, without permanently saving it. | Overrides EntityStorageBase::create | 1 |
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::getBundleFromClass | public | function | Retrieves the bundle name for a provided class name. | Overrides BundleEntityStorageInterface::getBundleFromClass | |
ContentEntityStorageBase::getBundleFromValues | protected | function | Retrieves the bundle from an array of values. | ||
ContentEntityStorageBase::getEntityClass | public | function | Retrieves the class name used to create the entity. | Overrides EntityStorageBase::getEntityClass | |
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 | |
ContentEntityStorageBase::invokeStorageLoadHook | protected | function | Invokes hook_entity_storage_load(). | ||
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 | |||
ContentEntityStorageBase::onFieldDefinitionUpdate | public | function | |||
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 | |||
ContentEntityStorageBase::resetCache | public | function | Resets the entity cache. | Overrides EntityStorageBase::resetCache | 1 |
ContentEntityStorageBase::setPersistentCache | protected | function | Stores entities in the persistent cache backend. | ||
DependencySerializationTrait::$_entityStorages | protected | property | |||
DependencySerializationTrait::$_serviceIds | protected | property | |||
DependencySerializationTrait::__sleep | public | function | 1 | ||
DependencySerializationTrait::__wakeup | public | function | 2 | ||
EntityHandlerBase::$moduleHandler | protected | property | The module handler to invoke hooks on. | 5 | |
EntityHandlerBase::moduleHandler | protected | function | Gets the module handler. | 5 | |
EntityHandlerBase::setModuleHandler | public | function | Sets the module handler for this handler. | ||
EntityStorageBase::$baseEntityClass | private | property | Name of the base 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 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::getAggregateQuery | public | function | Gets an aggregated query instance. | Overrides EntityStorageInterface::getAggregateQuery | |
EntityStorageBase::getEntitiesByClass | protected | function | Indexes the given array of entities by their class name and ID. | ||
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 without any access checks. | 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. | ||
EntityStorageBase::__get | public | function | Warns subclasses not to directly access the deprecated entityClass property. | ||
EntityStorageBase::__set | public | function | Warns subclasses not to directly set the deprecated entityClass property. | ||
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 | |||
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::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::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. | ||
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 | 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::wrapSchemaException | protected | function | Wraps a database schema exception into an entity storage exception. | ||
StringTranslationTrait::$stringTranslation | protected | property | The string translation service. | 3 | |
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. |
Buggy or inaccurate documentation? Please file an issue. Need support? Need help programming? Connect with the Drupal community.