function 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.

File

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

Class

ViewsQueryAlter

Defines a class for altering views queries.

Namespace

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.
}