MENU
Edit
In Place Editing Advanced Editing

SqlContentEntityStorage::saveToDedicatedTables

protected SqlContentEntityStorage::saveToDedicatedTables(ContentEntityInterface $entity, $update = TRUE, $names = array())

Saves values of fields that use dedicated tables.

Parameters

\Drupal\Core\Entity\ContentEntityInterface $entity: The entity.

bool $update: TRUE if the entity is being updated, FALSE if it is being inserted.

string[] $names: (optional) The names of the fields to be stored. Defaults to all the available fields.

File

core/lib/Drupal/Core/Entity/Sql/SqlContentEntityStorage.php, line 1178

Class

SqlContentEntityStorage
A content entity database storage implementation.

Namespace

Drupal\Core\Entity\Sql

Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
protected function saveToDedicatedTables(ContentEntityInterface $entity, $update = TRUE, $names = array()) {
  $vid = $entity->getRevisionId();
  $id = $entity->id();
  $bundle = $entity->bundle();
  $entity_type = $entity->getEntityTypeId();
  $default_langcode = $entity->getUntranslated()->language()->getId();
  $translation_langcodes = array_keys($entity->getTranslationLanguages());
  $table_mapping = $this->getTableMapping();
 
  if (!isset($vid)) {
    $vid = $id;
  }
 
  $original = !empty($entity->original) ? $entity->original : NULL;
 
  // Determine which fields should be actually stored.
  $definitions = $this->entityManager->getFieldDefinitions($entity_type, $bundle);
  if ($names) {
    $definitions = array_intersect_key($definitions, array_flip($names));
  }
 
  foreach ($definitions as $field_name => $field_definition) {
    $storage_definition = $field_definition->getFieldStorageDefinition();
    if (!$table_mapping->requiresDedicatedTableStorage($storage_definition)) {
      continue;
    }
 
    // When updating an existing revision, keep the existing records if the
    // field values did not change.
    if (!$entity->isNewRevision() && $original && !$this->hasFieldValueChanged($field_definition, $entity, $original)) {
      continue;
    }
 
    $table_name = $table_mapping->getDedicatedDataTableName($storage_definition);
    $revision_name = $table_mapping->getDedicatedRevisionTableName($storage_definition);
 
    // Delete and insert, rather than update, in case a value was added.
    if ($update) {
      // Only overwrite the field's base table if saving the default revision
      // of an entity.
      if ($entity->isDefaultRevision()) {
        $this->database->delete($table_name)
          ->condition('entity_id', $id)
          ->execute();
      }
      if ($this->entityType->isRevisionable()) {
        $this->database->delete($revision_name)
          ->condition('entity_id', $id)
          ->condition('revision_id', $vid)
          ->execute();
      }
    }
 
    // Prepare the multi-insert query.
    $do_insert = FALSE;
    $columns = array('entity_id', 'revision_id', 'bundle', 'delta', 'langcode');
    foreach ($storage_definition->getColumns() as $column => $attributes) {
      $columns[] = $table_mapping->getFieldColumnName($storage_definition, $column);
    }
    $query = $this->database->insert($table_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) {
      $delta_count = 0;
      $items = $entity->getTranslation($langcode)->get($field_name);
      $items->filterEmptyItems();
      foreach ($items as $delta => $item) {
        // We now know we have something to insert.
        $do_insert = TRUE;
        $record = array(
          'entity_id' => $id,
          'revision_id' => $vid,
          'bundle' => $bundle,
          'delta' => $delta,
          'langcode' => $langcode,
        );
        foreach ($storage_definition->getColumns() as $column => $attributes) {
          $column_name = $table_mapping->getFieldColumnName($storage_definition, $column);
          // Serialize the value if specified in the column schema.
          $record[$column_name] = !empty($attributes['serialize']) ? serialize($item->$column) : $item->$column;
        }
        $query->values($record);
        if ($this->entityType->isRevisionable()) {
          $revision_query->values($record);
        }
 
        if ($storage_definition->getCardinality() != FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED && ++$delta_count == $storage_definition->getCardinality()) {
          break;
        }
      }
    }
 
    // Execute the query if we have values to insert.
    if ($do_insert) {
      // Only overwrite the field's base table if saving the default revision
      // of an entity.
      if ($entity->isDefaultRevision()) {
        $query->execute();
      }
      if ($this->entityType->isRevisionable()) {
        $revision_query->execute();
      }
    }
  }
}
doc_Drupal
doc_Drupal
2025-01-10 15:47:30
Comments
Leave a Comment

Please login to continue.