Same name and namespace in other branches

1. main core/lib/Drupal/Core/Entity/Sql/SqlContentEntityStorage.php \Drupal\Core\Entity\Sql\SqlContentEntityStorage::loadMultipleCardinalityFields()

Load multiple cardinality fields.

Parameters

array &$values: The entity values populated so far.

\Drupal\Core\Database\Query\SelectInterface $base_query: The base database query.

string $base_table: The base table used in the query.

string $id_key: The ID key depending on whether regular entities or revisions are being loaded.

string $base_id_key: The base ID key depending on whether regular entities or revisions are being loaded.

string $base_langcode_alias: The base langcode alias.

bool $load_from_revision: Whether we're loading from revisions.

array $multiple_cardinality_fields: The multiple cardinality fields to load.

array $definitions: The field definitions.

array $field_columns: The field columns.

array $field_definition_columns: The field definition columns.

array $default_langcodes: The default langcodes.

1 call to SqlContentEntityStorage::loadMultipleCardinalityFields()

SqlContentEntityStorage::loadFromDedicatedTables in core/lib/Drupal/Core/Entity/Sql/SqlContentEntityStorage.php

Loads values of fields stored in dedicated tables for a group of entities.

File

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

Class

SqlContentEntityStorage

A content entity database storage implementation.

Namespace

Drupal\Core\Entity\Sql

Code

private function loadMultipleCardinalityFields(array &$values, SelectInterface $base_query, string $base_table, string $id_key, string $base_id_key, string $base_langcode_alias, bool $load_from_revision, array $multiple_cardinality_fields, array $definitions, array $field_columns, array $field_definition_columns, array $default_langcodes) : void {
  $table_mapping = $this->getTableMapping();
  $query = clone $base_query;
  $delta_keys = [];
  foreach ($multiple_cardinality_fields as $field_name => $storage_definition) {
    $table = !$load_from_revision ? $table_mapping->getDedicatedDataTableName($storage_definition) : $table_mapping->getDedicatedRevisionTableName($storage_definition);
    // If the entity is translatable, add the langcode to the join and
    // a condition on valid langcodes.
    if ($this->langcodeKey) {
      $query->leftJoin($table, $table, "[{$table}].[{$id_key}] = [{$base_table}].[{$base_id_key}] AND [{$table}].[langcode] = [{$base_table}].[{$this->langcodeKey}] AND [{$table}].[deleted] = 0");
    }
    else {
      $query->leftJoin($table, $table, "[{$table}].[{$id_key}] = [{$base_table}].[{$base_id_key}] AND [{$table}].[deleted] = 0");
    }
    $query->fields($table, $field_columns[$field_name]);
    $delta_keys[$field_name] = $query->addField($table, 'delta', $field_name . '_delta');
  }
  $results = $query->execute();
  foreach ($results as $row) {
    $row = (array) $row;
    $value_key = $row[$base_id_key];
    // Field values in default language are stored with
    // LanguageInterface::LANGCODE_DEFAULT as key.
    $langcode = LanguageInterface::LANGCODE_DEFAULT;
    if ($this->langcodeKey && isset($default_langcodes[$value_key]) && $row[$base_langcode_alias] != $default_langcodes[$value_key]) {
      $langcode = $row[$base_langcode_alias];
    }
    foreach ($multiple_cardinality_fields as $field_name => $storage_definition) {
      $delta_key = $delta_keys[$field_name];
      $bundle = $this->bundleKey ? $values[$value_key][$this->bundleKey][LanguageInterface::LANGCODE_DEFAULT] : $this->entityTypeId;
      // If the delta is null then there are no values at this delta for
      // this field.
      if (!isset($row[$delta_key])) {
        continue;
      }
      if (!isset($values[$value_key][$field_name][$langcode])) {
        $values[$value_key][$field_name][$langcode] = [];
      }
      // Ensure that records for non-translatable fields having invalid
      // languages are skipped.
      if ($langcode == LanguageInterface::LANGCODE_DEFAULT || $definitions[$bundle][$field_name]->isTranslatable()) {
        if ($storage_definition->getCardinality() === FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED || $row[$delta_key] < $storage_definition->getCardinality()) {
          $item = [];
          // For each column declared by the field, populate the item from
          // the prefixed database column.
          foreach ($field_definition_columns[$field_name] as $column => $attributes) {
            $column_name = $table_mapping->getFieldColumnName($storage_definition, $column);
            // Unserialize the value if specified in the column schema.
            $item[$column] = !empty($attributes['serialize']) ? $this->handleNullableFieldUnserialize($row[$column_name]) : $row[$column_name];
          }
          // Add the item to the field values for the entity.
          $values[$value_key][$field_name][$langcode][(int) $row[$delta_key]] = $item;
        }
      }
    }
  }
}

---