public function Tables::addField in Zircon Profile 8

Same name and namespace in other branches

1. 8.0 core/lib/Drupal/Core/Entity/Query/Sql/Tables.php \Drupal\Core\Entity\Query\Sql\Tables::addField()

Adds a field to a database query.

Parameters

string $field: If it contains a dot, then field name dot field column. If it doesn't then entity property name.

string $type: Join type, can either be INNER or LEFT.

string $langcode: The language code the field values are to be queried in.

Return value

string The return value is a string containing the alias of the table, a dot and the appropriate SQL column as passed in. This allows the direct use of this in a query for a condition or sort.

Throws

\Drupal\Core\Entity\Query\QueryException If $field specifies an invalid relationship.

Overrides TablesInterface::addField

File

core/lib/Drupal/Core/Entity/Query/Sql/Tables.php, line 68

Contains \Drupal\Core\Entity\Query\Sql\Tables.

Class

Tables

Adds tables and fields to the SQL entity query.

Namespace

Drupal\Core\Entity\Query\Sql

Code

public function addField($field, $type, $langcode) {
  $entity_type_id = $this->sqlQuery
    ->getMetaData('entity_type');
  $all_revisions = $this->sqlQuery
    ->getMetaData('all_revisions');

  // This variable ensures grouping works correctly. For example:
  // ->condition('tags', 2, '>')
  // ->condition('tags', 20, '<')
  // ->condition('node_reference.nid.entity.tags', 2)
  // The first two should use the same table but the last one needs to be a
  // new table. So for the first two, the table array index will be 'tags'
  // while the third will be 'node_reference.nid.tags'.
  $index_prefix = '';
  $specifiers = explode('.', $field);
  $base_table = 'base_table';
  $count = count($specifiers) - 1;

  // This will contain the definitions of the last specifier seen by the
  // system.
  $propertyDefinitions = array();
  $entity_type = $this->entityManager
    ->getDefinition($entity_type_id);
  $field_storage_definitions = $this->entityManager
    ->getFieldStorageDefinitions($entity_type_id);
  for ($key = 0; $key <= $count; $key++) {

    // If there is revision support and only the current revision is being
    // queried then use the revision id. Otherwise, the entity id will do.
    if (($revision_key = $entity_type
      ->getKey('revision')) && $all_revisions) {

      // This contains the relevant SQL field to be used when joining entity
      // tables.
      $entity_id_field = $revision_key;

      // This contains the relevant SQL field to be used when joining field
      // tables.
      $field_id_field = 'revision_id';
    }
    else {
      $entity_id_field = $entity_type
        ->getKey('id');
      $field_id_field = 'entity_id';
    }

    // This can either be the name of an entity base field or a configurable
    // field.
    $specifier = $specifiers[$key];
    if (isset($field_storage_definitions[$specifier])) {
      $field_storage = $field_storage_definitions[$specifier];
    }
    else {
      $field_storage = FALSE;
    }

    /** @var \Drupal\Core\Entity\Sql\DefaultTableMapping $table_mapping */
    $table_mapping = $this->entityManager
      ->getStorage($entity_type_id)
      ->getTableMapping();

    // Check whether this field is stored in a dedicated table.
    if ($field_storage && $table_mapping
      ->requiresDedicatedTableStorage($field_storage)) {

      // Find the field column.
      $column = $field_storage
        ->getMainPropertyName();
      if ($key < $count) {
        $next = $specifiers[$key + 1];

        // Is this a field column?
        $columns = $field_storage
          ->getColumns();
        if (isset($columns[$next]) || in_array($next, $table_mapping
          ->getReservedColumns())) {

          // Use it.
          $column = $next;

          // Do not process it again.
          $key++;
        }

        // If there are more specifiers, the next one must be a
        // relationship. Either the field name followed by a relationship
        // specifier, for example $node->field_image->entity. Or a field
        // column followed by a relationship specifier, for example
        // $node->field_image->fid->entity. In both cases, prepare the
        // property definitions for the relationship. In the first case,
        // also use the property definitions for column.
        if ($key < $count) {
          $relationship_specifier = $specifiers[$key + 1];
          $propertyDefinitions = $field_storage
            ->getPropertyDefinitions();

          // Prepare the next index prefix.
          $next_index_prefix = "{$relationship_specifier}.{$column}";
        }
      }
      $table = $this
        ->ensureFieldTable($index_prefix, $field_storage, $type, $langcode, $base_table, $entity_id_field, $field_id_field);
      $sql_column = $table_mapping
        ->getFieldColumnName($field_storage, $column);
      $property_definitions = $field_storage
        ->getPropertyDefinitions();
      if (isset($property_definitions[$column])) {
        $this->caseSensitiveFields[$field] = $property_definitions[$column]
          ->getSetting('case_sensitive');
      }
    }
    else {

      // ensureEntityTable() decides whether an entity property will be
      // queried from the data table or the base table based on where it
      // finds the property first. The data table is preferred, which is why
      // it gets added before the base table.
      $entity_tables = array();
      if ($data_table = $all_revisions ? $entity_type
        ->getRevisionDataTable() : $entity_type
        ->getDataTable()) {
        $this->sqlQuery
          ->addMetaData('simple_query', FALSE);
        $entity_tables[$data_table] = $this
          ->getTableMapping($data_table, $entity_type_id);
      }
      $entity_base_table = $all_revisions ? $entity_type
        ->getRevisionTable() : $entity_type
        ->getBaseTable();
      $entity_tables[$entity_base_table] = $this
        ->getTableMapping($entity_base_table, $entity_type_id);
      $sql_column = $specifier;

      // If there are more specifiers, get the right sql column name if the
      // next one is a column of this field.
      if ($key < $count) {
        $next = $specifiers[$key + 1];

        // Is this a field column?
        $columns = $field_storage
          ->getColumns();
        if (isset($columns[$next]) || in_array($next, $table_mapping
          ->getReservedColumns())) {

          // Use it.
          $sql_column = $table_mapping
            ->getFieldColumnName($field_storage, $next);

          // Do not process it again.
          $key++;
        }
      }
      $table = $this
        ->ensureEntityTable($index_prefix, $sql_column, $type, $langcode, $base_table, $entity_id_field, $entity_tables);

      // If there is a field storage (some specifiers are not), check for case
      // sensitivity.
      if ($field_storage) {
        $column = $field_storage
          ->getMainPropertyName();
        $base_field_property_definitions = $field_storage
          ->getPropertyDefinitions();
        if (isset($base_field_property_definitions[$column])) {
          $this->caseSensitiveFields[$field] = $base_field_property_definitions[$column]
            ->getSetting('case_sensitive');
        }
      }
    }

    // If there are more specifiers to come, it's a relationship.
    if ($field_storage && $key < $count) {

      // Computed fields have prepared their property definition already, do
      // it for properties as well.
      if (!$propertyDefinitions) {
        $propertyDefinitions = $field_storage
          ->getPropertyDefinitions();
        $relationship_specifier = $specifiers[$key + 1];
        $next_index_prefix = $relationship_specifier;
      }

      // Check for a valid relationship.
      if (isset($propertyDefinitions[$relationship_specifier]) && $field_storage
        ->getPropertyDefinition('entity')
        ->getDataType() == 'entity_reference') {

        // If it is, use the entity type.
        $entity_type_id = $propertyDefinitions[$relationship_specifier]
          ->getTargetDefinition()
          ->getEntityTypeId();
        $entity_type = $this->entityManager
          ->getDefinition($entity_type_id);
        $field_storage_definitions = $this->entityManager
          ->getFieldStorageDefinitions($entity_type_id);

        // Add the new entity base table using the table and sql column.
        $join_condition = '%alias.' . $entity_type
          ->getKey('id') . " = {$table}.{$sql_column}";
        $base_table = $this->sqlQuery
          ->leftJoin($entity_type
          ->getBaseTable(), NULL, $join_condition);
        $propertyDefinitions = array();
        $key++;
        $index_prefix .= "{$next_index_prefix}.";
      }
      else {
        throw new QueryException("Invalid specifier '{$relationship_specifier}'");
      }
    }
  }
  return "{$table}.{$sql_column}";
}