MENU
Edit
In Place Editing Advanced Editing

SqlContentEntityStorageSchema::getDedicatedTableSchema

protected SqlContentEntityStorageSchema::getDedicatedTableSchema(FieldStorageDefinitionInterface $storage_definition, ContentEntityTypeInterface $entity_type = NULL)

Gets the SQL schema for a dedicated table.

Parameters

\Drupal\Core\Field\FieldStorageDefinitionInterface $storage_definition: The field storage definition.

\Drupal\Core\Entity\ContentEntityTypeInterface $entity_type: (optional) The entity type definition. Defaults to the one returned by the entity manager.

Return value

array The schema definition for the table with the following keys:

  • fields: The schema definition for the each field columns.
  • indexes: The schema definition for the indexes.
  • unique keys: The schema definition for the unique keys.
  • foreign keys: The schema definition for the foreign keys.

Throws

\Drupal\Core\Field\FieldException Exception thrown if the schema contains reserved column names.

See also

hook_schema()

File

core/lib/Drupal/Core/Entity/Sql/SqlContentEntityStorageSchema.php, line 1720

Class

SqlContentEntityStorageSchema
Defines a schema handler that supports revisionable, translatable entities.

Namespace

Drupal\Core\Entity\Sql

Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
protected function getDedicatedTableSchema(FieldStorageDefinitionInterface $storage_definition, ContentEntityTypeInterface $entity_type = NULL) {
  $description_current = "Data storage for {$storage_definition->getTargetEntityTypeId()} field {$storage_definition->getName()}.";
  $description_revision = "Revision archive storage for {$storage_definition->getTargetEntityTypeId()} field {$storage_definition->getName()}.";
 
  $id_definition = $this->fieldStorageDefinitions[$this->entityType->getKey('id')];
  if ($id_definition->getType() == 'integer') {
    $id_schema = array(
      'type' => 'int',
      'unsigned' => TRUE,
      'not null' => TRUE,
      'description' => 'The entity id this data is attached to',
    );
  }
  else {
    $id_schema = array(
      'type' => 'varchar_ascii',
      'length' => 128,
      'not null' => TRUE,
      'description' => 'The entity id this data is attached to',
    );
  }
 
  // Define the revision ID schema.
  if (!$this->entityType->isRevisionable()) {
    $revision_id_schema = $id_schema;
    $revision_id_schema['description'] = 'The entity revision id this data is attached to, which for an unversioned entity type is the same as the entity id';
  }
  elseif ($this->fieldStorageDefinitions[$this->entityType->getKey('revision')]->getType() == 'integer') {
    $revision_id_schema = array(
      'type' => 'int',
      'unsigned' => TRUE,
      'not null' => TRUE,
      'description' => 'The entity revision id this data is attached to',
    );
  }
  else {
    $revision_id_schema = array(
      'type' => 'varchar',
      'length' => 128,
      'not null' => TRUE,
      'description' => 'The entity revision id this data is attached to',
    );
  }
 
  $data_schema = array(
    'description' => $description_current,
    'fields' => array(
      'bundle' => array(
        'type' => 'varchar_ascii',
        'length' => 128,
        'not null' => TRUE,
        'default' => '',
        'description' => 'The field instance bundle to which this row belongs, used when deleting a field instance',
      ),
      'deleted' => array(
        'type' => 'int',
        'size' => 'tiny',
        'not null' => TRUE,
        'default' => 0,
        'description' => 'A boolean indicating whether this data item has been deleted'
      ),
      'entity_id' => $id_schema,
      'revision_id' => $revision_id_schema,
      'langcode' => array(
        'type' => 'varchar_ascii',
        'length' => 32,
        'not null' => TRUE,
        'default' => '',
        'description' => 'The language code for this data item.',
      ),
      'delta' => array(
        'type' => 'int',
        'unsigned' => TRUE,
        'not null' => TRUE,
        'description' => 'The sequence number for this data item, used for multi-value fields',
      ),
    ),
    'primary key' => array('entity_id', 'deleted', 'delta', 'langcode'),
    'indexes' => array(
      'bundle' => array('bundle'),
      'revision_id' => array('revision_id'),
    ),
  );
 
  // Check that the schema does not include forbidden column names.
  $schema = $storage_definition->getSchema();
  $properties = $storage_definition->getPropertyDefinitions();
  $table_mapping = $this->storage->getTableMapping();
  if (array_intersect(array_keys($schema['columns']), $table_mapping->getReservedColumns())) {
    throw new FieldException("Illegal field column names on {$storage_definition->getName()}");
  }
 
  // Add field columns.
  foreach ($schema['columns'] as $column_name => $attributes) {
    $real_name = $table_mapping->getFieldColumnName($storage_definition, $column_name);
    $data_schema['fields'][$real_name] = $attributes;
    // A dedicated table only contain rows for actual field values, and no
    // rows for entities where the field is empty. Thus, we can safely
    // enforce 'not null' on the columns for the field's required properties.
    $data_schema['fields'][$real_name]['not null'] = $properties[$column_name]->isRequired();
  }
 
  // Add indexes.
  foreach ($schema['indexes'] as $index_name => $columns) {
    $real_name = $this->getFieldIndexName($storage_definition, $index_name);
    foreach ($columns as $column_name) {
      // Indexes can be specified as either a column name or an array with
      // column name and length. Allow for either case.
      if (is_array($column_name)) {
        $data_schema['indexes'][$real_name][] = array(
          $table_mapping->getFieldColumnName($storage_definition, $column_name[0]),
          $column_name[1],
        );
      }
      else {
        $data_schema['indexes'][$real_name][] = $table_mapping->getFieldColumnName($storage_definition, $column_name);
      }
    }
  }
 
  // Add unique keys.
  foreach ($schema['unique keys'] as $index_name => $columns) {
    $real_name = $this->getFieldIndexName($storage_definition, $index_name);
    foreach ($columns as $column_name) {
      // Unique keys can be specified as either a column name or an array with
      // column name and length. Allow for either case.
      if (is_array($column_name)) {
        $data_schema['unique keys'][$real_name][] = array(
          $table_mapping->getFieldColumnName($storage_definition, $column_name[0]),
          $column_name[1],
        );
      }
      else {
        $data_schema['unique keys'][$real_name][] = $table_mapping->getFieldColumnName($storage_definition, $column_name);
      }
    }
  }
 
  // Add foreign keys.
  foreach ($schema['foreign keys'] as $specifier => $specification) {
    $real_name = $this->getFieldIndexName($storage_definition, $specifier);
    $data_schema['foreign keys'][$real_name]['table'] = $specification['table'];
    foreach ($specification['columns'] as $column_name => $referenced) {
      $sql_storage_column = $table_mapping->getFieldColumnName($storage_definition, $column_name);
      $data_schema['foreign keys'][$real_name]['columns'][$sql_storage_column] = $referenced;
    }
  }
 
  $dedicated_table_schema = array($table_mapping->getDedicatedDataTableName($storage_definition) => $data_schema);
 
  // If the entity type is revisionable, construct the revision table.
  $entity_type = $entity_type ? : $this->entityType;
  if ($entity_type->isRevisionable()) {
    $revision_schema = $data_schema;
    $revision_schema['description'] = $description_revision;
    $revision_schema['primary key'] = array('entity_id', 'revision_id', 'deleted', 'delta', 'langcode');
    $revision_schema['fields']['revision_id']['not null'] = TRUE;
    $revision_schema['fields']['revision_id']['description'] = 'The entity revision id this data is attached to';
    $dedicated_table_schema += array($table_mapping->getDedicatedRevisionTableName($storage_definition) => $revision_schema);
  }
 
  return $dedicated_table_schema;
}
doc_Drupal
doc_Drupal
2025-01-10 15:47:30
Comments
Leave a Comment

Please login to continue.