protected function ViewsQueryAlter::alterQueryForEntityType in Drupal 8

Same name and namespace in other branches

1. 9 core/modules/workspaces/src/ViewsQueryAlter.php \Drupal\workspaces\ViewsQueryAlter::alterQueryForEntityType()

Alters the entity type tables for a Views query.

This should only be called after determining that this entity type is involved in the query, and that a non-default workspace is in use.

Parameters

\Drupal\views\Plugin\views\query\Sql $query: The query plugin object for the query.

\Drupal\Core\Entity\EntityTypeInterface $entity_type: The entity type definition.

1 call to ViewsQueryAlter::alterQueryForEntityType()

ViewsQueryAlter::alterQuery in core/modules/workspaces/src/ViewsQueryAlter.php

Implements a hook bridge for hook_views_query_alter().

File

core/modules/workspaces/src/ViewsQueryAlter.php, line 152

Class

ViewsQueryAlter

Defines a class for altering views queries.

Namespace

Drupal\workspaces

Code

protected function alterQueryForEntityType(Sql $query, EntityTypeInterface $entity_type) {

  /** @var \Drupal\Core\Entity\Sql\DefaultTableMapping $table_mapping */
  $table_mapping = $this->entityTypeManager
    ->getStorage($entity_type
    ->id())
    ->getTableMapping();
  $field_storage_definitions = $this->entityFieldManager
    ->getFieldStorageDefinitions($entity_type
    ->id());
  $dedicated_field_storage_definitions = array_filter($field_storage_definitions, function ($definition) use ($table_mapping) {
    return $table_mapping
      ->requiresDedicatedTableStorage($definition);
  });
  $dedicated_field_data_tables = array_map(function ($definition) use ($table_mapping) {
    return $table_mapping
      ->getDedicatedDataTableName($definition);
  }, $dedicated_field_storage_definitions);
  $move_workspace_tables = [];
  $table_queue =& $query
    ->getTableQueue();
  foreach ($table_queue as $alias => &$table_info) {

    // If we reach the workspace_association array item before any candidates,
    // then we do not need to move it.
    if ($table_info['table'] == 'workspace_association') {
      break;
    }

    // Any dedicated field table is a candidate.
    if ($field_name = array_search($table_info['table'], $dedicated_field_data_tables, TRUE)) {
      $relationship = $table_info['relationship'];

      // There can be reverse relationships used. If so, Workspaces can't do
      // anything with them. Detect this and skip.
      if ($table_info['join']->field != 'entity_id') {
        continue;
      }

      // Get the dedicated revision table name.
      $new_table_name = $table_mapping
        ->getDedicatedRevisionTableName($field_storage_definitions[$field_name]);

      // Now add the workspace_association table.
      $workspace_association_table = $this
        ->ensureWorkspaceAssociationTable($entity_type
        ->id(), $query, $relationship);

      // Update the join to use our COALESCE.
      $revision_field = $entity_type
        ->getKey('revision');
      $table_info['join']->leftFormula = "COALESCE({$workspace_association_table}.target_entity_revision_id, {$relationship}.{$revision_field})";

      // Update the join and the table info to our new table name, and to join
      // on the revision key.
      $table_info['table'] = $new_table_name;
      $table_info['join']->table = $new_table_name;
      $table_info['join']->field = 'revision_id';

      // Finally, if we added the workspace_association table we have to move
      // it in the table queue so that it comes before this field.
      if (empty($move_workspace_tables[$workspace_association_table])) {
        $move_workspace_tables[$workspace_association_table] = $alias;
      }
    }
  }

  // JOINs must be in order. i.e, any tables you mention in the ON clause of a
  // JOIN must appear prior to that JOIN. Since we're modifying a JOIN in
  // place, and adding a new table, we must ensure that the new table appears
  // prior to this one. So we recorded at what index we saw that table, and
  // then use array_splice() to move the workspace_association table join to
  // the correct position.
  foreach ($move_workspace_tables as $workspace_association_table => $alias) {
    $this
      ->moveEntityTable($query, $workspace_association_table, $alias);
  }
  $base_entity_table = $entity_type
    ->isTranslatable() ? $entity_type
    ->getDataTable() : $entity_type
    ->getBaseTable();
  $base_fields = array_diff($table_mapping
    ->getFieldNames($entity_type
    ->getBaseTable()), [
    $entity_type
      ->getKey('langcode'),
  ]);
  $revisionable_fields = array_diff($table_mapping
    ->getFieldNames($entity_type
    ->getRevisionDataTable()), $base_fields);

  // Go through and look to see if we have to modify fields and filters.
  foreach ($query->fields as &$field_info) {

    // Some fields don't actually have tables, meaning they're formulae and
    // whatnot. At this time we are going to ignore those.
    if (empty($field_info['table'])) {
      continue;
    }

    // Dereference the alias into the actual table.
    $table = $table_queue[$field_info['table']]['table'];
    if ($table == $base_entity_table && in_array($field_info['field'], $revisionable_fields)) {
      $relationship = $table_queue[$field_info['table']]['alias'];
      $alias = $this
        ->ensureRevisionTable($entity_type, $query, $relationship);
      if ($alias) {

        // Change the base table to use the revision table instead.
        $field_info['table'] = $alias;
      }
    }
  }
  $relationships = [];

  // Build a list of all relationships that might be for our table.
  foreach ($query->relationships as $relationship => $info) {
    if ($info['base'] == $base_entity_table) {
      $relationships[] = $relationship;
    }
  }

  // Now we have to go through our where clauses and modify any of our fields.
  foreach ($query->where as &$clauses) {
    foreach ($clauses['conditions'] as &$where_info) {

      // Build a matrix of our possible relationships against fields we need
      // to switch.
      foreach ($relationships as $relationship) {
        foreach ($revisionable_fields as $field) {
          if (is_string($where_info['field']) && $where_info['field'] == "{$relationship}.{$field}") {
            $alias = $this
              ->ensureRevisionTable($entity_type, $query, $relationship);
            if ($alias) {

              // Change the base table to use the revision table instead.
              $where_info['field'] = "{$alias}.{$field}";
            }
          }
        }
      }
    }
  }

  // @todo Handle $query->orderby, $query->groupby, $query->having and
  //   $query->count_field in https://www.drupal.org/node/2968165.
}