www.aleph1.co.uk Git - yaffs-website/blob - web/core/lib/Drupal/Core/Entity/Query/Sql/Tables.php

   1 <?php
   2
   3 namespace Drupal\Core\Entity\Query\Sql;
   4
   5 use Drupal\Core\Database\Query\SelectInterface;
   6 use Drupal\Core\Entity\EntityType;
   7 use Drupal\Core\Entity\Query\QueryException;
   8 use Drupal\Core\Entity\Sql\SqlEntityStorageInterface;
   9 use Drupal\Core\Entity\Sql\TableMappingInterface;
  10 use Drupal\Core\Entity\TypedData\EntityDataDefinitionInterface;
  11 use Drupal\Core\Field\FieldStorageDefinitionInterface;
  12 use Drupal\Core\TypedData\DataReferenceDefinitionInterface;
  13
  14 /**
  15  * Adds tables and fields to the SQL entity query.
  16  */
  17 class Tables implements TablesInterface {
  18
  19   /**
  20    * @var \Drupal\Core\Database\Query\SelectInterface
  21    */
  22   protected $sqlQuery;
  23
  24   /**
  25    * Entity table array.
  26    *
  27    * This array contains at most two entries: one for the data, one for the
  28    * properties. Its keys are unique references to the tables, values are
  29    * aliases.
  30    *
  31    * @see \Drupal\Core\Entity\Query\Sql\Tables::ensureEntityTable().
  32    *
  33    * @var array
  34    */
  35   protected $entityTables = [];
  36
  37   /**
  38    * Field table array, key is table name, value is alias.
  39    *
  40    * This array contains one entry per field table.
  41    *
  42    * @var array
  43    */
  44   protected $fieldTables = [];
  45
  46   /**
  47    * The entity manager.
  48    *
  49    * @var \Drupal\Core\Entity\EntityManager
  50    */
  51   protected $entityManager;
  52
  53   /**
  54    * List of case sensitive fields.
  55    *
  56    * @var array
  57    */
  58   protected $caseSensitiveFields = [];
  59
  60   /**
  61    * @param \Drupal\Core\Database\Query\SelectInterface $sql_query
  62    */
  63   public function __construct(SelectInterface $sql_query) {
  64     $this->sqlQuery = $sql_query;
  65     $this->entityManager = \Drupal::entityManager();
  66   }
  67
  68   /**
  69    * {@inheritdoc}
  70    */
  71   public function addField($field, $type, $langcode) {
  72     $entity_type_id = $this->sqlQuery->getMetaData('entity_type');
  73     $all_revisions = $this->sqlQuery->getMetaData('all_revisions');
  74     // This variable ensures grouping works correctly. For example:
  75     // ->condition('tags', 2, '>')
  76     // ->condition('tags', 20, '<')
  77     // ->condition('node_reference.nid.entity.tags', 2)
  78     // The first two should use the same table but the last one needs to be a
  79     // new table. So for the first two, the table array index will be 'tags'
  80     // while the third will be 'node_reference.nid.tags'.
  81     $index_prefix = '';
  82     $specifiers = explode('.', $field);
  83     $base_table = 'base_table';
  84     $count = count($specifiers) - 1;
  85     // This will contain the definitions of the last specifier seen by the
  86     // system.
  87     $propertyDefinitions = [];
  88     $entity_type = $this->entityManager->getDefinition($entity_type_id);
  89
  90     $field_storage_definitions = $this->entityManager->getFieldStorageDefinitions($entity_type_id);
  91     for ($key = 0; $key <= $count; $key++) {
  92       // This can either be the name of an entity base field or a configurable
  93       // field.
  94       $specifier = $specifiers[$key];
  95       if (isset($field_storage_definitions[$specifier])) {
  96         $field_storage = $field_storage_definitions[$specifier];
  97         $column = $field_storage->getMainPropertyName();
  98       }
  99       else {
 100         $field_storage = FALSE;
 101         $column = NULL;
 102       }
 103
 104       // If there is revision support, only the current revisions are being
 105       // queried, and the field is revisionable then use the revision id.
 106       // Otherwise, the entity id will do.
 107       if (($revision_key = $entity_type->getKey('revision')) && $all_revisions && $field_storage && $field_storage->isRevisionable()) {
 108         // This contains the relevant SQL field to be used when joining entity
 109         // tables.
 110         $entity_id_field = $revision_key;
 111         // This contains the relevant SQL field to be used when joining field
 112         // tables.
 113         $field_id_field = 'revision_id';
 114       }
 115       else {
 116         $entity_id_field = $entity_type->getKey('id');
 117         $field_id_field = 'entity_id';
 118       }
 119
 120       /** @var \Drupal\Core\Entity\Sql\DefaultTableMapping $table_mapping */
 121       $table_mapping = $this->entityManager->getStorage($entity_type_id)->getTableMapping();
 122
 123       // Check whether this field is stored in a dedicated table.
 124       if ($field_storage && $table_mapping->requiresDedicatedTableStorage($field_storage)) {
 125         $delta = NULL;
 126
 127         if ($key < $count) {
 128           $next = $specifiers[$key + 1];
 129           // If this is a numeric specifier we're adding a condition on the
 130           // specific delta.
 131           if (is_numeric($next)) {
 132             $delta = $next;
 133             $index_prefix .= ".$delta";
 134             // Do not process it again.
 135             $key++;
 136             $next = $specifiers[$key + 1];
 137           }
 138           // If this specifier is the reserved keyword "%delta" we're adding a
 139           // condition on a delta range.
 140           elseif ($next == TableMappingInterface::DELTA) {
 141             $index_prefix .= TableMappingInterface::DELTA;
 142             // Do not process it again.
 143             $key++;
 144             // If there are more specifiers to work with then continue
 145             // processing. If this is the last specifier then use the reserved
 146             // keyword as a column name.
 147             if ($key < $count) {
 148               $next = $specifiers[$key + 1];
 149             }
 150             else {
 151               $column = TableMappingInterface::DELTA;
 152             }
 153           }
 154           // Is this a field column?
 155           $columns = $field_storage->getColumns();
 156           if (isset($columns[$next]) || in_array($next, $table_mapping->getReservedColumns())) {
 157             // Use it.
 158             $column = $next;
 159             // Do not process it again.
 160             $key++;
 161           }
 162           // If there are more specifiers, the next one must be a
 163           // relationship. Either the field name followed by a relationship
 164           // specifier, for example $node->field_image->entity. Or a field
 165           // column followed by a relationship specifier, for example
 166           // $node->field_image->fid->entity. In both cases, prepare the
 167           // property definitions for the relationship. In the first case,
 168           // also use the property definitions for column.
 169           if ($key < $count) {
 170             $relationship_specifier = $specifiers[$key + 1];
 171             $propertyDefinitions = $field_storage->getPropertyDefinitions();
 172
 173             // Prepare the next index prefix.
 174             $next_index_prefix = "$relationship_specifier.$column";
 175           }
 176         }
 177         $table = $this->ensureFieldTable($index_prefix, $field_storage, $type, $langcode, $base_table, $entity_id_field, $field_id_field, $delta);
 178         $sql_column = $table_mapping->getFieldColumnName($field_storage, $column);
 179       }
 180       // The field is stored in a shared table.
 181       else {
 182         // ensureEntityTable() decides whether an entity property will be
 183         // queried from the data table or the base table based on where it
 184         // finds the property first. The data table is preferred, which is why
 185         // it gets added before the base table.
 186         $entity_tables = [];
 187         if ($all_revisions && $field_storage && $field_storage->isRevisionable()) {
 188           $data_table = $entity_type->getRevisionDataTable();
 189           $entity_base_table = $entity_type->getRevisionTable();
 190         }
 191         else {
 192           $data_table = $entity_type->getDataTable();
 193           $entity_base_table = $entity_type->getBaseTable();
 194         }
 195         if ($data_table) {
 196           $this->sqlQuery->addMetaData('simple_query', FALSE);
 197           $entity_tables[$data_table] = $this->getTableMapping($data_table, $entity_type_id);
 198         }
 199         $entity_tables[$entity_base_table] = $this->getTableMapping($entity_base_table, $entity_type_id);
 200         $sql_column = $specifier;
 201
 202         // If there are more specifiers, get the right sql column name if the
 203         // next one is a column of this field.
 204         if ($key < $count) {
 205           $next = $specifiers[$key + 1];
 206           // If this specifier is the reserved keyword "%delta" we're adding a
 207           // condition on a delta range.
 208           if ($next == TableMappingInterface::DELTA) {
 209             $key++;
 210             if ($key < $count) {
 211               $next = $specifiers[$key + 1];
 212             }
 213             else {
 214               return 0;
 215             }
 216           }
 217           // If this is a numeric specifier we're adding a condition on the
 218           // specific delta. Since we know that this is a single value base
 219           // field no other value than 0 makes sense.
 220           if (is_numeric($next)) {
 221             if ($next > 0) {
 222               $this->sqlQuery->condition('1 <> 1');
 223             }
 224             $key++;
 225             $next = $specifiers[$key + 1];
 226           }
 227           // Is this a field column?
 228           $columns = $field_storage->getColumns();
 229           if (isset($columns[$next]) || in_array($next, $table_mapping->getReservedColumns())) {
 230             // Use it.
 231             $sql_column = $table_mapping->getFieldColumnName($field_storage, $next);
 232             // Do not process it again.
 233             $key++;
 234           }
 235         }
 236
 237         $table = $this->ensureEntityTable($index_prefix, $sql_column, $type, $langcode, $base_table, $entity_id_field, $entity_tables);
 238       }
 239
 240       // If there is a field storage (some specifiers are not) and a field
 241       // column, check for case sensitivity.
 242       if ($field_storage && $column) {
 243         $property_definitions = $field_storage->getPropertyDefinitions();
 244         if (isset($property_definitions[$column])) {
 245           $this->caseSensitiveFields[$field] = $property_definitions[$column]->getSetting('case_sensitive');
 246         }
 247       }
 248
 249       // If there are more specifiers to come, it's a relationship.
 250       if ($field_storage && $key < $count) {
 251         // Computed fields have prepared their property definition already, do
 252         // it for properties as well.
 253         if (!$propertyDefinitions) {
 254           $propertyDefinitions = $field_storage->getPropertyDefinitions();
 255           $relationship_specifier = $specifiers[$key + 1];
 256           $next_index_prefix = $relationship_specifier;
 257         }
 258         $entity_type_id = NULL;
 259         // Relationship specifier can also contain the entity type ID, i.e.
 260         // entity:node, entity:user or entity:taxonomy.
 261         if (strpos($relationship_specifier, ':') !== FALSE) {
 262           list($relationship_specifier, $entity_type_id) = explode(':', $relationship_specifier, 2);
 263         }
 264         // Check for a valid relationship.
 265         if (isset($propertyDefinitions[$relationship_specifier]) && $propertyDefinitions[$relationship_specifier] instanceof DataReferenceDefinitionInterface) {
 266           // If it is, use the entity type if specified already, otherwise use
 267           // the definition.
 268           $target_definition = $propertyDefinitions[$relationship_specifier]->getTargetDefinition();
 269           if (!$entity_type_id && $target_definition instanceof EntityDataDefinitionInterface) {
 270             $entity_type_id = $target_definition->getEntityTypeId();
 271           }
 272           $entity_type = $this->entityManager->getDefinition($entity_type_id);
 273           $field_storage_definitions = $this->entityManager->getFieldStorageDefinitions($entity_type_id);
 274           // Add the new entity base table using the table and sql column.
 275           $base_table = $this->addNextBaseTable($entity_type, $table, $sql_column, $field_storage);
 276           $propertyDefinitions = [];
 277           $key++;
 278           $index_prefix .= "$next_index_prefix.";
 279         }
 280         else {
 281           throw new QueryException("Invalid specifier '$relationship_specifier'");
 282         }
 283       }
 284     }
 285     return "$table.$sql_column";
 286   }
 287
 288   /**
 289    * {@inheritdoc}
 290    */
 291   public function isFieldCaseSensitive($field_name) {
 292     if (isset($this->caseSensitiveFields[$field_name])) {
 293       return $this->caseSensitiveFields[$field_name];
 294     }
 295   }
 296
 297   /**
 298    * Joins the entity table, if necessary, and returns the alias for it.
 299    *
 300    * @param string $index_prefix
 301    *   The table array index prefix. For a base table this will be empty,
 302    *   for a target entity reference like 'field_tags.entity:taxonomy_term.name'
 303    *   this will be 'entity:taxonomy_term.target_id.'.
 304    * @param string $property
 305    *   The field property/column.
 306    * @param string $type
 307    *   The join type, can either be INNER or LEFT.
 308    * @param string $langcode
 309    *   The langcode we use on the join.
 310    * @param string $base_table
 311    *   The table to join to. It can be either the table name, its alias or the
 312    *   'base_table' placeholder.
 313    * @param string $id_field
 314    *   The name of the ID field/property for the current entity. For instance:
 315    *   tid, nid, etc.
 316    * @param array $entity_tables
 317    *   Array of entity tables (data and base tables) where decide the entity
 318    *   property will be queried from. The first table containing the property
 319    *   will be used, so the order is important and the data table is always
 320    *   preferred.
 321    *
 322    * @return string
 323    *   The alias of the joined table.
 324    *
 325    * @throws \Drupal\Core\Entity\Query\QueryException
 326    *   When an invalid property has been passed.
 327    */
 328   protected function ensureEntityTable($index_prefix, $property, $type, $langcode, $base_table, $id_field, $entity_tables) {
 329     foreach ($entity_tables as $table => $mapping) {
 330       if (isset($mapping[$property])) {
 331         // Ensure a table joined multiple times through different index prefixes
 332         // has unique entityTables entries by concatenating the index prefix
 333         // and the base table alias. In this way i.e. if we join to the same
 334         // entity table several times for different entity reference fields,
 335         // each join gets a separate alias.
 336         $key = $index_prefix . ($base_table === 'base_table' ? $table : $base_table);
 337         if (!isset($this->entityTables[$key])) {
 338           $this->entityTables[$key] = $this->addJoin($type, $table, "%alias.$id_field = $base_table.$id_field", $langcode);
 339         }
 340         return $this->entityTables[$key];
 341       }
 342     }
 343     throw new QueryException("'$property' not found");
 344   }
 345
 346   /**
 347    * Join field table if necessary.
 348    *
 349    * @param $field_name
 350    *   Name of the field.
 351    * @return string
 352    * @throws \Drupal\Core\Entity\Query\QueryException
 353    */
 354   protected function ensureFieldTable($index_prefix, &$field, $type, $langcode, $base_table, $entity_id_field, $field_id_field, $delta) {
 355     $field_name = $field->getName();
 356     if (!isset($this->fieldTables[$index_prefix . $field_name])) {
 357       $entity_type_id = $this->sqlQuery->getMetaData('entity_type');
 358       /** @var \Drupal\Core\Entity\Sql\DefaultTableMapping $table_mapping */
 359       $table_mapping = $this->entityManager->getStorage($entity_type_id)->getTableMapping();
 360       $table = !$this->sqlQuery->getMetaData('all_revisions') ? $table_mapping->getDedicatedDataTableName($field) : $table_mapping->getDedicatedRevisionTableName($field);
 361       if ($field->getCardinality() != 1) {
 362         $this->sqlQuery->addMetaData('simple_query', FALSE);
 363       }
 364       $this->fieldTables[$index_prefix . $field_name] = $this->addJoin($type, $table, "%alias.$field_id_field = $base_table.$entity_id_field", $langcode, $delta);
 365     }
 366     return $this->fieldTables[$index_prefix . $field_name];
 367   }
 368
 369   /**
 370    * Adds a join to a given table.
 371    *
 372    * @param string $type
 373    *   The join type.
 374    * @param string $table
 375    *   The table to join to.
 376    * @param string $join_condition
 377    *   The condition on which to join to.
 378    * @param string $langcode
 379    *   The langcode we use on the join.
 380    * @param string|null $delta
 381    *   (optional) A delta which should be used as additional condition.
 382    *
 383    * @return string
 384    *   Returns the alias of the joined table.
 385    */
 386   protected function addJoin($type, $table, $join_condition, $langcode, $delta = NULL) {
 387     $arguments = [];
 388     if ($langcode) {
 389       $entity_type_id = $this->sqlQuery->getMetaData('entity_type');
 390       $entity_type = $this->entityManager->getDefinition($entity_type_id);
 391       // Only the data table follows the entity language key, dedicated field
 392       // tables have an hard-coded 'langcode' column.
 393       $langcode_key = $entity_type->getDataTable() == $table ? $entity_type->getKey('langcode') : 'langcode';
 394       $placeholder = ':langcode' . $this->sqlQuery->nextPlaceholder();
 395       $join_condition .= ' AND %alias.' . $langcode_key . ' = ' . $placeholder;
 396       $arguments[$placeholder] = $langcode;
 397     }
 398     if (isset($delta)) {
 399       $placeholder = ':delta' . $this->sqlQuery->nextPlaceholder();
 400       $join_condition .= ' AND %alias.delta = ' . $placeholder;
 401       $arguments[$placeholder] = $delta;
 402     }
 403     return $this->sqlQuery->addJoin($type, $table, NULL, $join_condition, $arguments);
 404   }
 405
 406   /**
 407    * Gets the schema for the given table.
 408    *
 409    * @param string $table
 410    *   The table name.
 411    *
 412    * @return array|false
 413    *   An associative array of table field mapping for the given table, keyed by
 414    *   columns name and values are just incrementing integers. If the table
 415    *   mapping is not available, FALSE is returned.
 416    */
 417   protected function getTableMapping($table, $entity_type_id) {
 418     $storage = $this->entityManager->getStorage($entity_type_id);
 419     if ($storage instanceof SqlEntityStorageInterface) {
 420       $mapping = $storage->getTableMapping()->getAllColumns($table);
 421     }
 422     else {
 423       return FALSE;
 424     }
 425     return array_flip($mapping);
 426   }
 427
 428   /**
 429    * Add the next entity base table.
 430    *
 431    * For example, when building the SQL query for
 432    * @code
 433    * condition('uid.entity.name', 'foo', 'CONTAINS')
 434    * @endcode
 435    *
 436    * this adds the users table.
 437    *
 438    * @param \Drupal\Core\Entity\EntityType $entity_type
 439    *   The entity type being joined, in the above example, User.
 440    * @param string $table
 441    *   This is the table being joined, in the above example, {users}.
 442    * @param string $sql_column
 443    *   This is the SQL column in the existing table being joined to.
 444    * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $field_storage
 445    *   The field storage definition for the field referencing this column.
 446    *
 447    * @return string
 448    *   The alias of the next entity table joined in.
 449    */
 450   protected function addNextBaseTable(EntityType $entity_type, $table, $sql_column, FieldStorageDefinitionInterface $field_storage) {
 451     $join_condition = '%alias.' . $entity_type->getKey('id') . " = $table.$sql_column";
 452     return $this->sqlQuery->leftJoin($entity_type->getBaseTable(), NULL, $join_condition);
 453   }
 454
 455 }