public function Tables::addField in Drupal 9
Same name in this branch
- 9 core/modules/workspaces/src/EntityQuery/Tables.php \Drupal\workspaces\EntityQuery\Tables::addField()
- 9 core/lib/Drupal/Core/Entity/Query/Sql/Tables.php \Drupal\Core\Entity\Query\Sql\Tables::addField()
Same name and namespace in other branches
- 8 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 doesn't contain a dot, then an entity base field name. If it contains a dot, then either field name dot field column or field name dot delta dot field column. Delta can be a numeric value or a "%delta" for any value.
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
1 call to Tables::addField()
- Tables::addField in core/
modules/ workspaces/ src/ EntityQuery/ Tables.php - Adds a field to a database query.
1 method overrides Tables::addField()
- Tables::addField in core/
modules/ workspaces/ src/ EntityQuery/ Tables.php - Adds a field to a database query.
File
- core/
lib/ Drupal/ Core/ Entity/ Query/ Sql/ Tables.php, line 79
Class
- Tables
- Adds tables and fields to the SQL entity query.
Namespace
Drupal\Core\Entity\Query\SqlCode
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 = [];
$entity_type = $this->entityTypeManager
->getActiveDefinition($entity_type_id);
$field_storage_definitions = $this->entityFieldManager
->getActiveFieldStorageDefinitions($entity_type_id);
for ($key = 0; $key <= $count; $key++) {
// 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];
$column = $field_storage
->getMainPropertyName();
}
else {
$field_storage = FALSE;
$column = NULL;
}
// If there is revision support, all the revisions are being queried, and
// the field is revisionable or the revision ID field itself, then use the
// revision ID. Otherwise, the entity ID will do.
$query_revisions = $all_revisions && $field_storage && ($field_storage
->isRevisionable() || $field_storage
->getName() === $entity_type
->getKey('revision'));
if ($query_revisions) {
// This contains the relevant SQL field to be used when joining entity
// tables.
$entity_id_field = $entity_type
->getKey('revision');
// 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';
}
/** @var \Drupal\Core\Entity\Sql\DefaultTableMapping $table_mapping */
$table_mapping = $this->entityTypeManager
->getStorage($entity_type_id)
->getTableMapping();
// Check whether this field is stored in a dedicated table.
if ($field_storage && $table_mapping
->requiresDedicatedTableStorage($field_storage)) {
$delta = NULL;
if ($key < $count) {
$next = $specifiers[$key + 1];
// If this is a numeric specifier we're adding a condition on the
// specific delta.
if (is_numeric($next)) {
$delta = $next;
$index_prefix .= ".{$delta}";
// Do not process it again.
$key++;
$next = $specifiers[$key + 1];
}
elseif ($next == TableMappingInterface::DELTA) {
$index_prefix .= TableMappingInterface::DELTA;
// Do not process it again.
$key++;
// If there are more specifiers to work with then continue
// processing. If this is the last specifier then use the reserved
// keyword as a column name.
if ($key < $count) {
$next = $specifiers[$key + 1];
}
else {
$column = TableMappingInterface::DELTA;
}
}
// 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, $delta);
$sql_column = $table_mapping
->getFieldColumnName($field_storage, $column);
}
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 = [];
$revision_table = NULL;
if ($query_revisions) {
$data_table = $entity_type
->getRevisionDataTable();
$entity_base_table = $entity_type
->getRevisionTable();
}
else {
$data_table = $entity_type
->getDataTable();
$entity_base_table = $entity_type
->getBaseTable();
if ($field_storage && $field_storage
->isRevisionable() && in_array($field_storage
->getName(), $entity_type
->getRevisionMetadataKeys())) {
$revision_table = $entity_type
->getRevisionTable();
}
}
if ($data_table) {
$this->sqlQuery
->addMetaData('simple_query', FALSE);
$entity_tables[$data_table] = $this
->getTableMapping($data_table, $entity_type_id);
}
if ($revision_table) {
$entity_tables[$revision_table] = $this
->getTableMapping($revision_table, $entity_type_id);
}
$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];
// If this specifier is the reserved keyword "%delta" we're adding a
// condition on a delta range.
if ($next == TableMappingInterface::DELTA) {
$key++;
if ($key < $count) {
$next = $specifiers[$key + 1];
}
else {
return 0;
}
}
// If this is a numeric specifier we're adding a condition on the
// specific delta. Since we know that this is a single value base
// field no other value than 0 makes sense.
if (is_numeric($next)) {
if ($next > 0) {
$this->sqlQuery
->alwaysFalse();
}
$key++;
$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++;
}
}
elseif ($field_storage && $column) {
$columns = $field_storage
->getColumns();
if (isset($columns[$column])) {
$sql_column = $table_mapping
->getFieldColumnName($field_storage, $column);
}
}
$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) and a field
// column, check for case sensitivity.
if ($field_storage && $column) {
$property_definitions = $field_storage
->getPropertyDefinitions();
if (isset($property_definitions[$column])) {
$this->caseSensitiveFields[$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;
}
$entity_type_id = NULL;
// Relationship specifier can also contain the entity type ID, i.e.
// entity:node, entity:user or entity:taxonomy.
if (strpos($relationship_specifier, ':') !== FALSE) {
list($relationship_specifier, $entity_type_id) = explode(':', $relationship_specifier, 2);
}
// Check for a valid relationship.
if (isset($propertyDefinitions[$relationship_specifier]) && $propertyDefinitions[$relationship_specifier] instanceof DataReferenceDefinitionInterface) {
// If it is, use the entity type if specified already, otherwise use
// the definition.
$target_definition = $propertyDefinitions[$relationship_specifier]
->getTargetDefinition();
if (!$entity_type_id && $target_definition instanceof EntityDataDefinitionInterface) {
$entity_type_id = $target_definition
->getEntityTypeId();
}
$entity_type = $this->entityTypeManager
->getActiveDefinition($entity_type_id);
$field_storage_definitions = $this->entityFieldManager
->getActiveFieldStorageDefinitions($entity_type_id);
// Add the new entity base table using the table and sql column.
$base_table = $this
->addNextBaseTable($entity_type, $table, $sql_column, $field_storage);
$propertyDefinitions = [];
$key++;
$index_prefix .= "{$next_index_prefix}.";
}
else {
throw new QueryException("Invalid specifier '{$relationship_specifier}'");
}
}
}
return "{$table}.{$sql_column}";
}